Add files using upload-large-folder tool

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

@@ -0,0 +1,111 @@
+"""A functions module, includes all the standard functions.
+
+Combinatorial - factorial, fibonacci, harmonic, bernoulli...
+Elementary - hyperbolic, trigonometric, exponential, floor and ceiling, sqrt...
+Special - gamma, zeta,spherical harmonics...
+"""
+
+from sympy.functions.combinatorial.factorials import (factorial, factorial2,
+        rf, ff, binomial, RisingFactorial, FallingFactorial, subfactorial)
+from sympy.functions.combinatorial.numbers import (carmichael, fibonacci, lucas, tribonacci,
+        harmonic, bernoulli, bell, euler, catalan, genocchi, andre, partition, motzkin)
+from sympy.functions.elementary.miscellaneous import (sqrt, root, Min, Max,
+        Id, real_root, cbrt, Rem)
+from sympy.functions.elementary.complexes import (re, im, sign, Abs,
+        conjugate, arg, polar_lift, periodic_argument, unbranched_argument,
+        principal_branch, transpose, adjoint, polarify, unpolarify)
+from sympy.functions.elementary.trigonometric import (sin, cos, tan,
+        sec, csc, cot, sinc, asin, acos, atan, asec, acsc, acot, atan2)
+from sympy.functions.elementary.exponential import (exp_polar, exp, log,
+        LambertW)
+from sympy.functions.elementary.hyperbolic import (sinh, cosh, tanh, coth,
+        sech, csch, asinh, acosh, atanh, acoth, asech, acsch)
+from sympy.functions.elementary.integers import floor, ceiling, frac
+from sympy.functions.elementary.piecewise import (Piecewise, piecewise_fold,
+                                                  piecewise_exclusive)
+from sympy.functions.special.error_functions import (erf, erfc, erfi, erf2,
+        erfinv, erfcinv, erf2inv, Ei, expint, E1, li, Li, Si, Ci, Shi, Chi,
+        fresnels, fresnelc)
+from sympy.functions.special.gamma_functions import (gamma, lowergamma,
+        uppergamma, polygamma, loggamma, digamma, trigamma, multigamma)
+from sympy.functions.special.zeta_functions import (dirichlet_eta, zeta,
+        lerchphi, polylog, stieltjes, riemann_xi)
+from sympy.functions.special.tensor_functions import (Eijk, LeviCivita,
+        KroneckerDelta)
+from sympy.functions.special.singularity_functions import SingularityFunction
+from sympy.functions.special.delta_functions import DiracDelta, Heaviside
+from sympy.functions.special.bsplines import bspline_basis, bspline_basis_set, interpolating_spline
+from sympy.functions.special.bessel import (besselj, bessely, besseli, besselk,
+        hankel1, hankel2, jn, yn, jn_zeros, hn1, hn2, airyai, airybi, airyaiprime, airybiprime, marcumq)
+from sympy.functions.special.hyper import hyper, meijerg, appellf1
+from sympy.functions.special.polynomials import (legendre, assoc_legendre,
+        hermite, hermite_prob, chebyshevt, chebyshevu, chebyshevu_root,
+        chebyshevt_root, laguerre, assoc_laguerre, gegenbauer, jacobi, jacobi_normalized)
+from sympy.functions.special.spherical_harmonics import Ynm, Ynm_c, Znm
+from sympy.functions.special.elliptic_integrals import (elliptic_k,
+        elliptic_f, elliptic_e, elliptic_pi)
+from sympy.functions.special.beta_functions import beta, betainc, betainc_regularized
+from sympy.functions.special.mathieu_functions import (mathieus, mathieuc,
+        mathieusprime, mathieucprime)
+ln = log
+
+__all__ = [
+    'factorial', 'factorial2', 'rf', 'ff', 'binomial', 'RisingFactorial',
+    'FallingFactorial', 'subfactorial',
+
+    'carmichael', 'fibonacci', 'lucas', 'motzkin', 'tribonacci', 'harmonic',
+    'bernoulli', 'bell', 'euler', 'catalan', 'genocchi', 'andre', 'partition',
+
+    'sqrt', 'root', 'Min', 'Max', 'Id', 'real_root', 'cbrt', 'Rem',
+
+    're', 'im', 'sign', 'Abs', 'conjugate', 'arg', 'polar_lift',
+    'periodic_argument', 'unbranched_argument', 'principal_branch',
+    'transpose', 'adjoint', 'polarify', 'unpolarify',
+
+    'sin', 'cos', 'tan', 'sec', 'csc', 'cot', 'sinc', 'asin', 'acos', 'atan',
+    'asec', 'acsc', 'acot', 'atan2',
+
+    'exp_polar', 'exp', 'ln', 'log', 'LambertW',
+
+    'sinh', 'cosh', 'tanh', 'coth', 'sech', 'csch', 'asinh', 'acosh', 'atanh',
+    'acoth', 'asech', 'acsch',
+
+    'floor', 'ceiling', 'frac',
+
+    'Piecewise', 'piecewise_fold', 'piecewise_exclusive',
+
+    'erf', 'erfc', 'erfi', 'erf2', 'erfinv', 'erfcinv', 'erf2inv', 'Ei',
+    'expint', 'E1', 'li', 'Li', 'Si', 'Ci', 'Shi', 'Chi', 'fresnels',
+    'fresnelc',
+
+    'gamma', 'lowergamma', 'uppergamma', 'polygamma', 'loggamma', 'digamma',
+    'trigamma', 'multigamma',
+
+    'dirichlet_eta', 'zeta', 'lerchphi', 'polylog', 'stieltjes', 'riemann_xi',
+
+    'Eijk', 'LeviCivita', 'KroneckerDelta',
+
+    'SingularityFunction',
+
+    'DiracDelta', 'Heaviside',
+
+    'bspline_basis', 'bspline_basis_set', 'interpolating_spline',
+
+    'besselj', 'bessely', 'besseli', 'besselk', 'hankel1', 'hankel2', 'jn',
+    'yn', 'jn_zeros', 'hn1', 'hn2', 'airyai', 'airybi', 'airyaiprime',
+    'airybiprime', 'marcumq',
+
+    'hyper', 'meijerg', 'appellf1',
+
+    'legendre', 'assoc_legendre', 'hermite', 'hermite_prob', 'chebyshevt',
+    'chebyshevu', 'chebyshevu_root', 'chebyshevt_root', 'laguerre',
+    'assoc_laguerre', 'gegenbauer', 'jacobi', 'jacobi_normalized',
+
+    'Ynm', 'Ynm_c', 'Znm',
+
+    'elliptic_k', 'elliptic_f', 'elliptic_e', 'elliptic_pi',
+
+    'beta', 'betainc', 'betainc_regularized',
+
+    'mathieus', 'mathieuc', 'mathieusprime', 'mathieucprime',
+]

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

@@ -0,0 +1 @@
+# Stub __init__.py for sympy.functions.elementary

llmeval-env/lib/python3.10/site-packages/sympy/functions/elementary/_trigonometric_special.py

@@ -0,0 +1,260 @@
+r"""A module for special angle forumlas for trigonometric functions
+
+TODO
+====
+
+This module should be developed in the future to contain direct squrae root
+representation of
+
+.. math
+    F(\frac{n}{m} \pi)
+
+for every
+
+- $m \in \{ 3, 5, 17, 257, 65537 \}$
+- $n \in \mathbb{N}$, $0 \le n < m$
+- $F \in \{\sin, \cos, \tan, \csc, \sec, \cot\}$
+
+Without multi-step rewrites
+(e.g. $\tan \to \cos/\sin \to \cos/\sqrt \to \ sqrt$)
+or using chebyshev identities
+(e.g. $\cos \to \cos + \cos^2 + \cdots \to \sqrt{} + \sqrt{}^2 + \cdots $),
+which are trivial to implement in sympy,
+and had used to give overly complicated expressions.
+
+The reference can be found below, if anyone may need help implementing them.
+
+References
+==========
+
+.. [*] Gottlieb, Christian. (1999). The Simple and straightforward construction
+   of the regular 257-gon. The Mathematical Intelligencer. 21. 31-37.
+   10.1007/BF03024829.
+.. [*] https://resources.wolframcloud.com/FunctionRepository/resources/Cos2PiOverFermatPrime
+"""
+from __future__ import annotations
+from typing import Callable
+from functools import reduce
+from sympy.core.expr import Expr
+from sympy.core.singleton import S
+from sympy.core.numbers import igcdex, Integer
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core.cache import cacheit
+
+
+def migcdex(*x: int) -> tuple[tuple[int, ...], int]:
+    r"""Compute extended gcd for multiple integers.
+
+    Explanation
+    ===========
+
+    Given the integers $x_1, \cdots, x_n$ and
+    an extended gcd for multiple arguments are defined as a solution
+    $(y_1, \cdots, y_n), g$ for the diophantine equation
+    $x_1 y_1 + \cdots + x_n y_n = g$ such that
+    $g = \gcd(x_1, \cdots, x_n)$.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary._trigonometric_special import migcdex
+    >>> migcdex()
+    ((), 0)
+    >>> migcdex(4)
+    ((1,), 4)
+    >>> migcdex(4, 6)
+    ((-1, 1), 2)
+    >>> migcdex(6, 10, 15)
+    ((1, 1, -1), 1)
+    """
+    if not x:
+        return (), 0
+
+    if len(x) == 1:
+        return (1,), x[0]
+
+    if len(x) == 2:
+        u, v, h = igcdex(x[0], x[1])
+        return (u, v), h
+
+    y, g = migcdex(*x[1:])
+    u, v, h = igcdex(x[0], g)
+    return (u, *(v * i for i in y)), h
+
+
+def ipartfrac(*denoms: int) -> tuple[int, ...]:
+    r"""Compute the the partial fraction decomposition.
+
+    Explanation
+    ===========
+
+    Given a rational number $\frac{1}{q_1 \cdots q_n}$ where all
+    $q_1, \cdots, q_n$ are pairwise coprime,
+
+    A partial fraction decomposition is defined as
+
+    .. math::
+        \frac{1}{q_1 \cdots q_n} = \frac{p_1}{q_1} + \cdots + \frac{p_n}{q_n}
+
+    And it can be derived from solving the following diophantine equation for
+    the $p_1, \cdots, p_n$
+
+    .. math::
+        1 = p_1 \prod_{i \ne 1}q_i + \cdots + p_n \prod_{i \ne n}q_i
+
+    Where $q_1, \cdots, q_n$ being pairwise coprime implies
+    $\gcd(\prod_{i \ne 1}q_i, \cdots, \prod_{i \ne n}q_i) = 1$,
+    which guarantees the existance of the solution.
+
+    It is sufficient to compute partial fraction decomposition only
+    for numerator $1$ because partial fraction decomposition for any
+    $\frac{n}{q_1 \cdots q_n}$ can be easily computed by multiplying
+    the result by $n$ afterwards.
+
+    Parameters
+    ==========
+
+    denoms : int
+        The pairwise coprime integer denominators $q_i$ which defines the
+        rational number $\frac{1}{q_1 \cdots q_n}$
+
+    Returns
+    =======
+
+    tuple[int, ...]
+        The list of numerators which semantically corresponds to $p_i$ of the
+        partial fraction decomposition
+        $\frac{1}{q_1 \cdots q_n} = \frac{p_1}{q_1} + \cdots + \frac{p_n}{q_n}$
+
+    Examples
+    ========
+
+    >>> from sympy import Rational, Mul
+    >>> from sympy.functions.elementary._trigonometric_special import ipartfrac
+
+    >>> denoms = 2, 3, 5
+    >>> numers = ipartfrac(2, 3, 5)
+    >>> numers
+    (1, 7, -14)
+
+    >>> Rational(1, Mul(*denoms))
+    1/30
+    >>> out = 0
+    >>> for n, d in zip(numers, denoms):
+    ...    out += Rational(n, d)
+    >>> out
+    1/30
+    """
+    if not denoms:
+        return ()
+
+    def mul(x: int, y: int) -> int:
+        return x * y
+
+    denom = reduce(mul, denoms)
+    a = [denom // x for x in denoms]
+    h, _ = migcdex(*a)
+    return h
+
+
+def fermat_coords(n: int) -> list[int] | None:
+    """If n can be factored in terms of Fermat primes with
+    multiplicity of each being 1, return those primes, else
+    None
+    """
+    primes = []
+    for p in [3, 5, 17, 257, 65537]:
+        quotient, remainder = divmod(n, p)
+        if remainder == 0:
+            n = quotient
+            primes.append(p)
+            if n == 1:
+                return primes
+    return None
+
+
+@cacheit
+def cos_3() -> Expr:
+    r"""Computes $\cos \frac{\pi}{3}$ in square roots"""
+    return S.Half
+
+
+@cacheit
+def cos_5() -> Expr:
+    r"""Computes $\cos \frac{\pi}{5}$ in square roots"""
+    return (sqrt(5) + 1) / 4
+
+
+@cacheit
+def cos_17() -> Expr:
+    r"""Computes $\cos \frac{\pi}{17}$ in square roots"""
+    return sqrt(
+        (15 + sqrt(17)) / 32 + sqrt(2) * (sqrt(17 - sqrt(17)) +
+        sqrt(sqrt(2) * (-8 * sqrt(17 + sqrt(17)) - (1 - sqrt(17))
+        * sqrt(17 - sqrt(17))) + 6 * sqrt(17) + 34)) / 32)
+
+
+@cacheit
+def cos_257() -> Expr:
+    r"""Computes $\cos \frac{\pi}{257}$ in square roots
+
+    References
+    ==========
+
+    .. [*] https://math.stackexchange.com/questions/516142/how-does-cos2-pi-257-look-like-in-real-radicals
+    .. [*] https://r-knott.surrey.ac.uk/Fibonacci/simpleTrig.html
+    """
+    def f1(a: Expr, b: Expr) -> tuple[Expr, Expr]:
+        return (a + sqrt(a**2 + b)) / 2, (a - sqrt(a**2 + b)) / 2
+
+    def f2(a: Expr, b: Expr) -> Expr:
+        return (a - sqrt(a**2 + b))/2
+
+    t1, t2 = f1(S.NegativeOne, Integer(256))
+    z1, z3 = f1(t1, Integer(64))
+    z2, z4 = f1(t2, Integer(64))
+    y1, y5 = f1(z1, 4*(5 + t1 + 2*z1))
+    y6, y2 = f1(z2, 4*(5 + t2 + 2*z2))
+    y3, y7 = f1(z3, 4*(5 + t1 + 2*z3))
+    y8, y4 = f1(z4, 4*(5 + t2 + 2*z4))
+    x1, x9 = f1(y1, -4*(t1 + y1 + y3 + 2*y6))
+    x2, x10 = f1(y2, -4*(t2 + y2 + y4 + 2*y7))
+    x3, x11 = f1(y3, -4*(t1 + y3 + y5 + 2*y8))
+    x4, x12 = f1(y4, -4*(t2 + y4 + y6 + 2*y1))
+    x5, x13 = f1(y5, -4*(t1 + y5 + y7 + 2*y2))
+    x6, x14 = f1(y6, -4*(t2 + y6 + y8 + 2*y3))
+    x15, x7 = f1(y7, -4*(t1 + y7 + y1 + 2*y4))
+    x8, x16 = f1(y8, -4*(t2 + y8 + y2 + 2*y5))
+    v1 = f2(x1, -4*(x1 + x2 + x3 + x6))
+    v2 = f2(x2, -4*(x2 + x3 + x4 + x7))
+    v3 = f2(x8, -4*(x8 + x9 + x10 + x13))
+    v4 = f2(x9, -4*(x9 + x10 + x11 + x14))
+    v5 = f2(x10, -4*(x10 + x11 + x12 + x15))
+    v6 = f2(x16, -4*(x16 + x1 + x2 + x5))
+    u1 = -f2(-v1, -4*(v2 + v3))
+    u2 = -f2(-v4, -4*(v5 + v6))
+    w1 = -2*f2(-u1, -4*u2)
+    return sqrt(sqrt(2)*sqrt(w1 + 4)/8 + S.Half)
+
+
+def cos_table() -> dict[int, Callable[[], Expr]]:
+    r"""Lazily evaluated table for $\cos \frac{\pi}{n}$ in square roots for
+    $n \in \{3, 5, 17, 257, 65537\}$.
+
+    Notes
+    =====
+
+    65537 is the only other known Fermat prime and it is nearly impossible to
+    build in the current SymPy due to performance issues.
+
+    References
+    ==========
+
+    https://r-knott.surrey.ac.uk/Fibonacci/simpleTrig.html
+    """
+    return {
+        3: cos_3,
+        5: cos_5,
+        17: cos_17,
+        257: cos_257
+    }

llmeval-env/lib/python3.10/site-packages/sympy/functions/elementary/complexes.py

@@ -0,0 +1,1465 @@
+from typing import Tuple as tTuple
+
+from sympy.core import S, Add, Mul, sympify, Symbol, Dummy, Basic
+from sympy.core.expr import Expr
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import (Function, Derivative, ArgumentIndexError,
+    AppliedUndef, expand_mul)
+from sympy.core.logic import fuzzy_not, fuzzy_or
+from sympy.core.numbers import pi, I, oo
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+
+###############################################################################
+######################### REAL and IMAGINARY PARTS ############################
+###############################################################################
+
+
+class re(Function):
+    """
+    Returns real part of expression. This function performs only
+    elementary analysis and so it will fail to decompose properly
+    more complicated expressions. If completely simplified result
+    is needed then use ``Basic.as_real_imag()`` or perform complex
+    expansion on instance of this function.
+
+    Examples
+    ========
+
+    >>> from sympy import re, im, I, E, symbols
+    >>> x, y = symbols('x y', real=True)
+    >>> re(2*E)
+    2*E
+    >>> re(2*I + 17)
+    17
+    >>> re(2*I)
+    0
+    >>> re(im(x) + x*I + 2)
+    2
+    >>> re(5 + I + 2)
+    7
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Real part of expression.
+
+    See Also
+    ========
+
+    im
+    """
+
+    args: tTuple[Expr]
+
+    is_extended_real = True
+    unbranched = True  # implicitly works on the projection to C
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        if arg is S.NaN:
+            return S.NaN
+        elif arg is S.ComplexInfinity:
+            return S.NaN
+        elif arg.is_extended_real:
+            return arg
+        elif arg.is_imaginary or (I*arg).is_extended_real:
+            return S.Zero
+        elif arg.is_Matrix:
+            return arg.as_real_imag()[0]
+        elif arg.is_Function and isinstance(arg, conjugate):
+            return re(arg.args[0])
+        else:
+
+            included, reverted, excluded = [], [], []
+            args = Add.make_args(arg)
+            for term in args:
+                coeff = term.as_coefficient(I)
+
+                if coeff is not None:
+                    if not coeff.is_extended_real:
+                        reverted.append(coeff)
+                elif not term.has(I) and term.is_extended_real:
+                    excluded.append(term)
+                else:
+                    # Try to do some advanced expansion.  If
+                    # impossible, don't try to do re(arg) again
+                    # (because this is what we are trying to do now).
+                    real_imag = term.as_real_imag(ignore=arg)
+                    if real_imag:
+                        excluded.append(real_imag[0])
+                    else:
+                        included.append(term)
+
+            if len(args) != len(included):
+                a, b, c = (Add(*xs) for xs in [included, reverted, excluded])
+
+                return cls(a) - im(b) + c
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns the real number with a zero imaginary part.
+
+        """
+        return (self, S.Zero)
+
+    def _eval_derivative(self, x):
+        if x.is_extended_real or self.args[0].is_extended_real:
+            return re(Derivative(self.args[0], x, evaluate=True))
+        if x.is_imaginary or self.args[0].is_imaginary:
+            return -I \
+                * im(Derivative(self.args[0], x, evaluate=True))
+
+    def _eval_rewrite_as_im(self, arg, **kwargs):
+        return self.args[0] - I*im(self.args[0])
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+    def _eval_is_zero(self):
+        # is_imaginary implies nonzero
+        return fuzzy_or([self.args[0].is_imaginary, self.args[0].is_zero])
+
+    def _eval_is_finite(self):
+        if self.args[0].is_finite:
+            return True
+
+    def _eval_is_complex(self):
+        if self.args[0].is_finite:
+            return True
+
+
+class im(Function):
+    """
+    Returns imaginary part of expression. This function performs only
+    elementary analysis and so it will fail to decompose properly more
+    complicated expressions. If completely simplified result is needed then
+    use ``Basic.as_real_imag()`` or perform complex expansion on instance of
+    this function.
+
+    Examples
+    ========
+
+    >>> from sympy import re, im, E, I
+    >>> from sympy.abc import x, y
+    >>> im(2*E)
+    0
+    >>> im(2*I + 17)
+    2
+    >>> im(x*I)
+    re(x)
+    >>> im(re(x) + y)
+    im(y)
+    >>> im(2 + 3*I)
+    3
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Imaginary part of expression.
+
+    See Also
+    ========
+
+    re
+    """
+
+    args: tTuple[Expr]
+
+    is_extended_real = True
+    unbranched = True  # implicitly works on the projection to C
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        if arg is S.NaN:
+            return S.NaN
+        elif arg is S.ComplexInfinity:
+            return S.NaN
+        elif arg.is_extended_real:
+            return S.Zero
+        elif arg.is_imaginary or (I*arg).is_extended_real:
+            return -I * arg
+        elif arg.is_Matrix:
+            return arg.as_real_imag()[1]
+        elif arg.is_Function and isinstance(arg, conjugate):
+            return -im(arg.args[0])
+        else:
+            included, reverted, excluded = [], [], []
+            args = Add.make_args(arg)
+            for term in args:
+                coeff = term.as_coefficient(I)
+
+                if coeff is not None:
+                    if not coeff.is_extended_real:
+                        reverted.append(coeff)
+                    else:
+                        excluded.append(coeff)
+                elif term.has(I) or not term.is_extended_real:
+                    # Try to do some advanced expansion.  If
+                    # impossible, don't try to do im(arg) again
+                    # (because this is what we are trying to do now).
+                    real_imag = term.as_real_imag(ignore=arg)
+                    if real_imag:
+                        excluded.append(real_imag[1])
+                    else:
+                        included.append(term)
+
+            if len(args) != len(included):
+                a, b, c = (Add(*xs) for xs in [included, reverted, excluded])
+
+                return cls(a) + re(b) + c
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Return the imaginary part with a zero real part.
+
+        """
+        return (self, S.Zero)
+
+    def _eval_derivative(self, x):
+        if x.is_extended_real or self.args[0].is_extended_real:
+            return im(Derivative(self.args[0], x, evaluate=True))
+        if x.is_imaginary or self.args[0].is_imaginary:
+            return -I \
+                * re(Derivative(self.args[0], x, evaluate=True))
+
+    def _eval_rewrite_as_re(self, arg, **kwargs):
+        return -I*(self.args[0] - re(self.args[0]))
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+    def _eval_is_zero(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_finite(self):
+        if self.args[0].is_finite:
+            return True
+
+    def _eval_is_complex(self):
+        if self.args[0].is_finite:
+            return True
+
+###############################################################################
+############### SIGN, ABSOLUTE VALUE, ARGUMENT and CONJUGATION ################
+###############################################################################
+
+class sign(Function):
+    """
+    Returns the complex sign of an expression:
+
+    Explanation
+    ===========
+
+    If the expression is real the sign will be:
+
+        * $1$ if expression is positive
+        * $0$ if expression is equal to zero
+        * $-1$ if expression is negative
+
+    If the expression is imaginary the sign will be:
+
+        * $I$ if im(expression) is positive
+        * $-I$ if im(expression) is negative
+
+    Otherwise an unevaluated expression will be returned. When evaluated, the
+    result (in general) will be ``cos(arg(expr)) + I*sin(arg(expr))``.
+
+    Examples
+    ========
+
+    >>> from sympy import sign, I
+
+    >>> sign(-1)
+    -1
+    >>> sign(0)
+    0
+    >>> sign(-3*I)
+    -I
+    >>> sign(1 + I)
+    sign(1 + I)
+    >>> _.evalf()
+    0.707106781186548 + 0.707106781186548*I
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or imaginary expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Complex sign of expression.
+
+    See Also
+    ========
+
+    Abs, conjugate
+    """
+
+    is_complex = True
+    _singularities = True
+
+    def doit(self, **hints):
+        s = super().doit()
+        if s == self and self.args[0].is_zero is False:
+            return self.args[0] / Abs(self.args[0])
+        return s
+
+    @classmethod
+    def eval(cls, arg):
+        # handle what we can
+        if arg.is_Mul:
+            c, args = arg.as_coeff_mul()
+            unk = []
+            s = sign(c)
+            for a in args:
+                if a.is_extended_negative:
+                    s = -s
+                elif a.is_extended_positive:
+                    pass
+                else:
+                    if a.is_imaginary:
+                        ai = im(a)
+                        if ai.is_comparable:  # i.e. a = I*real
+                            s *= I
+                            if ai.is_extended_negative:
+                                # can't use sign(ai) here since ai might not be
+                                # a Number
+                                s = -s
+                        else:
+                            unk.append(a)
+                    else:
+                        unk.append(a)
+            if c is S.One and len(unk) == len(args):
+                return None
+            return s * cls(arg._new_rawargs(*unk))
+        if arg is S.NaN:
+            return S.NaN
+        if arg.is_zero:  # it may be an Expr that is zero
+            return S.Zero
+        if arg.is_extended_positive:
+            return S.One
+        if arg.is_extended_negative:
+            return S.NegativeOne
+        if arg.is_Function:
+            if isinstance(arg, sign):
+                return arg
+        if arg.is_imaginary:
+            if arg.is_Pow and arg.exp is S.Half:
+                # we catch this because non-trivial sqrt args are not expanded
+                # e.g. sqrt(1-sqrt(2)) --x-->  to I*sqrt(sqrt(2) - 1)
+                return I
+            arg2 = -I * arg
+            if arg2.is_extended_positive:
+                return I
+            if arg2.is_extended_negative:
+                return -I
+
+    def _eval_Abs(self):
+        if fuzzy_not(self.args[0].is_zero):
+            return S.One
+
+    def _eval_conjugate(self):
+        return sign(conjugate(self.args[0]))
+
+    def _eval_derivative(self, x):
+        if self.args[0].is_extended_real:
+            from sympy.functions.special.delta_functions import DiracDelta
+            return 2 * Derivative(self.args[0], x, evaluate=True) \
+                * DiracDelta(self.args[0])
+        elif self.args[0].is_imaginary:
+            from sympy.functions.special.delta_functions import DiracDelta
+            return 2 * Derivative(self.args[0], x, evaluate=True) \
+                * DiracDelta(-I * self.args[0])
+
+    def _eval_is_nonnegative(self):
+        if self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_nonpositive(self):
+        if self.args[0].is_nonpositive:
+            return True
+
+    def _eval_is_imaginary(self):
+        return self.args[0].is_imaginary
+
+    def _eval_is_integer(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+    def _eval_power(self, other):
+        if (
+            fuzzy_not(self.args[0].is_zero) and
+            other.is_integer and
+            other.is_even
+        ):
+            return S.One
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg0 = self.args[0]
+        x0 = arg0.subs(x, 0)
+        if x0 != 0:
+            return self.func(x0)
+        if cdir != 0:
+            cdir = arg0.dir(x, cdir)
+        return -S.One if re(cdir) < 0 else S.One
+
+    def _eval_rewrite_as_Piecewise(self, arg, **kwargs):
+        if arg.is_extended_real:
+            return Piecewise((1, arg > 0), (-1, arg < 0), (0, True))
+
+    def _eval_rewrite_as_Heaviside(self, arg, **kwargs):
+        from sympy.functions.special.delta_functions import Heaviside
+        if arg.is_extended_real:
+            return Heaviside(arg) * 2 - 1
+
+    def _eval_rewrite_as_Abs(self, arg, **kwargs):
+        return Piecewise((0, Eq(arg, 0)), (arg / Abs(arg), True))
+
+    def _eval_simplify(self, **kwargs):
+        return self.func(factor_terms(self.args[0]))  # XXX include doit?
+
+
+class Abs(Function):
+    """
+    Return the absolute value of the argument.
+
+    Explanation
+    ===========
+
+    This is an extension of the built-in function ``abs()`` to accept symbolic
+    values.  If you pass a SymPy expression to the built-in ``abs()``, it will
+    pass it automatically to ``Abs()``.
+
+    Examples
+    ========
+
+    >>> from sympy import Abs, Symbol, S, I
+    >>> Abs(-1)
+    1
+    >>> x = Symbol('x', real=True)
+    >>> Abs(-x)
+    Abs(x)
+    >>> Abs(x**2)
+    x**2
+    >>> abs(-x) # The Python built-in
+    Abs(x)
+    >>> Abs(3*x + 2*I)
+    sqrt(9*x**2 + 4)
+    >>> Abs(8*I)
+    8
+
+    Note that the Python built-in will return either an Expr or int depending on
+    the argument::
+
+        >>> type(abs(-1))
+        <... 'int'>
+        >>> type(abs(S.NegativeOne))
+        <class 'sympy.core.numbers.One'>
+
+    Abs will always return a SymPy object.
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Absolute value returned can be an expression or integer depending on
+        input arg.
+
+    See Also
+    ========
+
+    sign, conjugate
+    """
+
+    args: tTuple[Expr]
+
+    is_extended_real = True
+    is_extended_negative = False
+    is_extended_nonnegative = True
+    unbranched = True
+    _singularities = True  # non-holomorphic
+
+    def fdiff(self, argindex=1):
+        """
+        Get the first derivative of the argument to Abs().
+
+        """
+        if argindex == 1:
+            return sign(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.simplify.simplify import signsimp
+
+        if hasattr(arg, '_eval_Abs'):
+            obj = arg._eval_Abs()
+            if obj is not None:
+                return obj
+        if not isinstance(arg, Expr):
+            raise TypeError("Bad argument type for Abs(): %s" % type(arg))
+
+        # handle what we can
+        arg = signsimp(arg, evaluate=False)
+        n, d = arg.as_numer_denom()
+        if d.free_symbols and not n.free_symbols:
+            return cls(n)/cls(d)
+
+        if arg.is_Mul:
+            known = []
+            unk = []
+            for t in arg.args:
+                if t.is_Pow and t.exp.is_integer and t.exp.is_negative:
+                    bnew = cls(t.base)
+                    if isinstance(bnew, cls):
+                        unk.append(t)
+                    else:
+                        known.append(Pow(bnew, t.exp))
+                else:
+                    tnew = cls(t)
+                    if isinstance(tnew, cls):
+                        unk.append(t)
+                    else:
+                        known.append(tnew)
+            known = Mul(*known)
+            unk = cls(Mul(*unk), evaluate=False) if unk else S.One
+            return known*unk
+        if arg is S.NaN:
+            return S.NaN
+        if arg is S.ComplexInfinity:
+            return oo
+        from sympy.functions.elementary.exponential import exp, log
+
+        if arg.is_Pow:
+            base, exponent = arg.as_base_exp()
+            if base.is_extended_real:
+                if exponent.is_integer:
+                    if exponent.is_even:
+                        return arg
+                    if base is S.NegativeOne:
+                        return S.One
+                    return Abs(base)**exponent
+                if base.is_extended_nonnegative:
+                    return base**re(exponent)
+                if base.is_extended_negative:
+                    return (-base)**re(exponent)*exp(-pi*im(exponent))
+                return
+            elif not base.has(Symbol): # complex base
+                # express base**exponent as exp(exponent*log(base))
+                a, b = log(base).as_real_imag()
+                z = a + I*b
+                return exp(re(exponent*z))
+        if isinstance(arg, exp):
+            return exp(re(arg.args[0]))
+        if isinstance(arg, AppliedUndef):
+            if arg.is_positive:
+                return arg
+            elif arg.is_negative:
+                return -arg
+            return
+        if arg.is_Add and arg.has(oo, S.NegativeInfinity):
+            if any(a.is_infinite for a in arg.as_real_imag()):
+                return oo
+        if arg.is_zero:
+            return S.Zero
+        if arg.is_extended_nonnegative:
+            return arg
+        if arg.is_extended_nonpositive:
+            return -arg
+        if arg.is_imaginary:
+            arg2 = -I * arg
+            if arg2.is_extended_nonnegative:
+                return arg2
+        if arg.is_extended_real:
+            return
+        # reject result if all new conjugates are just wrappers around
+        # an expression that was already in the arg
+        conj = signsimp(arg.conjugate(), evaluate=False)
+        new_conj = conj.atoms(conjugate) - arg.atoms(conjugate)
+        if new_conj and all(arg.has(i.args[0]) for i in new_conj):
+            return
+        if arg != conj and arg != -conj:
+            ignore = arg.atoms(Abs)
+            abs_free_arg = arg.xreplace({i: Dummy(real=True) for i in ignore})
+            unk = [a for a in abs_free_arg.free_symbols if a.is_extended_real is None]
+            if not unk or not all(conj.has(conjugate(u)) for u in unk):
+                return sqrt(expand_mul(arg*conj))
+
+    def _eval_is_real(self):
+        if self.args[0].is_finite:
+            return True
+
+    def _eval_is_integer(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_integer
+
+    def _eval_is_extended_nonzero(self):
+        return fuzzy_not(self._args[0].is_zero)
+
+    def _eval_is_zero(self):
+        return self._args[0].is_zero
+
+    def _eval_is_extended_positive(self):
+        return fuzzy_not(self._args[0].is_zero)
+
+    def _eval_is_rational(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_rational
+
+    def _eval_is_even(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_even
+
+    def _eval_is_odd(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_odd
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+    def _eval_power(self, exponent):
+        if self.args[0].is_extended_real and exponent.is_integer:
+            if exponent.is_even:
+                return self.args[0]**exponent
+            elif exponent is not S.NegativeOne and exponent.is_Integer:
+                return self.args[0]**(exponent - 1)*self
+        return
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.functions.elementary.exponential import log
+        direction = self.args[0].leadterm(x)[0]
+        if direction.has(log(x)):
+            direction = direction.subs(log(x), logx)
+        s = self.args[0]._eval_nseries(x, n=n, logx=logx)
+        return (sign(direction)*s).expand()
+
+    def _eval_derivative(self, x):
+        if self.args[0].is_extended_real or self.args[0].is_imaginary:
+            return Derivative(self.args[0], x, evaluate=True) \
+                * sign(conjugate(self.args[0]))
+        rv = (re(self.args[0]) * Derivative(re(self.args[0]), x,
+            evaluate=True) + im(self.args[0]) * Derivative(im(self.args[0]),
+                x, evaluate=True)) / Abs(self.args[0])
+        return rv.rewrite(sign)
+
+    def _eval_rewrite_as_Heaviside(self, arg, **kwargs):
+        # Note this only holds for real arg (since Heaviside is not defined
+        # for complex arguments).
+        from sympy.functions.special.delta_functions import Heaviside
+        if arg.is_extended_real:
+            return arg*(Heaviside(arg) - Heaviside(-arg))
+
+    def _eval_rewrite_as_Piecewise(self, arg, **kwargs):
+        if arg.is_extended_real:
+            return Piecewise((arg, arg >= 0), (-arg, True))
+        elif arg.is_imaginary:
+            return Piecewise((I*arg, I*arg >= 0), (-I*arg, True))
+
+    def _eval_rewrite_as_sign(self, arg, **kwargs):
+        return arg/sign(arg)
+
+    def _eval_rewrite_as_conjugate(self, arg, **kwargs):
+        return sqrt(arg*conjugate(arg))
+
+
+class arg(Function):
+    r"""
+    Returns the argument (in radians) of a complex number. The argument is
+    evaluated in consistent convention with ``atan2`` where the branch-cut is
+    taken along the negative real axis and ``arg(z)`` is in the interval
+    $(-\pi,\pi]$. For a positive number, the argument is always 0; the
+    argument of a negative number is $\pi$; and the argument of 0
+    is undefined and returns ``nan``. So the ``arg`` function will never nest
+    greater than 3 levels since at the 4th application, the result must be
+    nan; for a real number, nan is returned on the 3rd application.
+
+    Examples
+    ========
+
+    >>> from sympy import arg, I, sqrt, Dummy
+    >>> from sympy.abc import x
+    >>> arg(2.0)
+    0
+    >>> arg(I)
+    pi/2
+    >>> arg(sqrt(2) + I*sqrt(2))
+    pi/4
+    >>> arg(sqrt(3)/2 + I/2)
+    pi/6
+    >>> arg(4 + 3*I)
+    atan(3/4)
+    >>> arg(0.8 + 0.6*I)
+    0.643501108793284
+    >>> arg(arg(arg(arg(x))))
+    nan
+    >>> real = Dummy(real=True)
+    >>> arg(arg(arg(real)))
+    nan
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    value : Expr
+        Returns arc tangent of arg measured in radians.
+
+    """
+
+    is_extended_real = True
+    is_real = True
+    is_finite = True
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        a = arg
+        for i in range(3):
+            if isinstance(a, cls):
+                a = a.args[0]
+            else:
+                if i == 2 and a.is_extended_real:
+                    return S.NaN
+                break
+        else:
+            return S.NaN
+        from sympy.functions.elementary.exponential import exp_polar
+        if isinstance(arg, exp_polar):
+            return periodic_argument(arg, oo)
+        if not arg.is_Atom:
+            c, arg_ = factor_terms(arg).as_coeff_Mul()
+            if arg_.is_Mul:
+                arg_ = Mul(*[a if (sign(a) not in (-1, 1)) else
+                    sign(a) for a in arg_.args])
+            arg_ = sign(c)*arg_
+        else:
+            arg_ = arg
+        if any(i.is_extended_positive is None for i in arg_.atoms(AppliedUndef)):
+            return
+        from sympy.functions.elementary.trigonometric import atan2
+        x, y = arg_.as_real_imag()
+        rv = atan2(y, x)
+        if rv.is_number:
+            return rv
+        if arg_ != arg:
+            return cls(arg_, evaluate=False)
+
+    def _eval_derivative(self, t):
+        x, y = self.args[0].as_real_imag()
+        return (x * Derivative(y, t, evaluate=True) - y *
+                    Derivative(x, t, evaluate=True)) / (x**2 + y**2)
+
+    def _eval_rewrite_as_atan2(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import atan2
+        x, y = self.args[0].as_real_imag()
+        return atan2(y, x)
+
+
+class conjugate(Function):
+    """
+    Returns the *complex conjugate* [1]_ of an argument.
+    In mathematics, the complex conjugate of a complex number
+    is given by changing the sign of the imaginary part.
+
+    Thus, the conjugate of the complex number
+    :math:`a + ib` (where $a$ and $b$ are real numbers) is :math:`a - ib`
+
+    Examples
+    ========
+
+    >>> from sympy import conjugate, I
+    >>> conjugate(2)
+    2
+    >>> conjugate(I)
+    -I
+    >>> conjugate(3 + 2*I)
+    3 - 2*I
+    >>> conjugate(5 - I)
+    5 + I
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    arg : Expr
+        Complex conjugate of arg as real, imaginary or mixed expression.
+
+    See Also
+    ========
+
+    sign, Abs
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Complex_conjugation
+    """
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        obj = arg._eval_conjugate()
+        if obj is not None:
+            return obj
+
+    def inverse(self):
+        return conjugate
+
+    def _eval_Abs(self):
+        return Abs(self.args[0], evaluate=True)
+
+    def _eval_adjoint(self):
+        return transpose(self.args[0])
+
+    def _eval_conjugate(self):
+        return self.args[0]
+
+    def _eval_derivative(self, x):
+        if x.is_real:
+            return conjugate(Derivative(self.args[0], x, evaluate=True))
+        elif x.is_imaginary:
+            return -conjugate(Derivative(self.args[0], x, evaluate=True))
+
+    def _eval_transpose(self):
+        return adjoint(self.args[0])
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+
+class transpose(Function):
+    """
+    Linear map transposition.
+
+    Examples
+    ========
+
+    >>> from sympy import transpose, Matrix, MatrixSymbol
+    >>> A = MatrixSymbol('A', 25, 9)
+    >>> transpose(A)
+    A.T
+    >>> B = MatrixSymbol('B', 9, 22)
+    >>> transpose(B)
+    B.T
+    >>> transpose(A*B)
+    B.T*A.T
+    >>> M = Matrix([[4, 5], [2, 1], [90, 12]])
+    >>> M
+    Matrix([
+    [ 4,  5],
+    [ 2,  1],
+    [90, 12]])
+    >>> transpose(M)
+    Matrix([
+    [4, 2, 90],
+    [5, 1, 12]])
+
+    Parameters
+    ==========
+
+    arg : Matrix
+         Matrix or matrix expression to take the transpose of.
+
+    Returns
+    =======
+
+    value : Matrix
+        Transpose of arg.
+
+    """
+
+    @classmethod
+    def eval(cls, arg):
+        obj = arg._eval_transpose()
+        if obj is not None:
+            return obj
+
+    def _eval_adjoint(self):
+        return conjugate(self.args[0])
+
+    def _eval_conjugate(self):
+        return adjoint(self.args[0])
+
+    def _eval_transpose(self):
+        return self.args[0]
+
+
+class adjoint(Function):
+    """
+    Conjugate transpose or Hermite conjugation.
+
+    Examples
+    ========
+
+    >>> from sympy import adjoint, MatrixSymbol
+    >>> A = MatrixSymbol('A', 10, 5)
+    >>> adjoint(A)
+    Adjoint(A)
+
+    Parameters
+    ==========
+
+    arg : Matrix
+        Matrix or matrix expression to take the adjoint of.
+
+    Returns
+    =======
+
+    value : Matrix
+        Represents the conjugate transpose or Hermite
+        conjugation of arg.
+
+    """
+
+    @classmethod
+    def eval(cls, arg):
+        obj = arg._eval_adjoint()
+        if obj is not None:
+            return obj
+        obj = arg._eval_transpose()
+        if obj is not None:
+            return conjugate(obj)
+
+    def _eval_adjoint(self):
+        return self.args[0]
+
+    def _eval_conjugate(self):
+        return transpose(self.args[0])
+
+    def _eval_transpose(self):
+        return conjugate(self.args[0])
+
+    def _latex(self, printer, exp=None, *args):
+        arg = printer._print(self.args[0])
+        tex = r'%s^{\dagger}' % arg
+        if exp:
+            tex = r'\left(%s\right)^{%s}' % (tex, exp)
+        return tex
+
+    def _pretty(self, printer, *args):
+        from sympy.printing.pretty.stringpict import prettyForm
+        pform = printer._print(self.args[0], *args)
+        if printer._use_unicode:
+            pform = pform**prettyForm('\N{DAGGER}')
+        else:
+            pform = pform**prettyForm('+')
+        return pform
+
+###############################################################################
+############### HANDLING OF POLAR NUMBERS #####################################
+###############################################################################
+
+
+class polar_lift(Function):
+    """
+    Lift argument to the Riemann surface of the logarithm, using the
+    standard branch.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, polar_lift, I
+    >>> p = Symbol('p', polar=True)
+    >>> x = Symbol('x')
+    >>> polar_lift(4)
+    4*exp_polar(0)
+    >>> polar_lift(-4)
+    4*exp_polar(I*pi)
+    >>> polar_lift(-I)
+    exp_polar(-I*pi/2)
+    >>> polar_lift(I + 2)
+    polar_lift(2 + I)
+
+    >>> polar_lift(4*x)
+    4*polar_lift(x)
+    >>> polar_lift(4*p)
+    4*p
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    See Also
+    ========
+
+    sympy.functions.elementary.exponential.exp_polar
+    periodic_argument
+    """
+
+    is_polar = True
+    is_comparable = False  # Cannot be evalf'd.
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.functions.elementary.complexes import arg as argument
+        if arg.is_number:
+            ar = argument(arg)
+            # In general we want to affirm that something is known,
+            # e.g. `not ar.has(argument) and not ar.has(atan)`
+            # but for now we will just be more restrictive and
+            # see that it has evaluated to one of the known values.
+            if ar in (0, pi/2, -pi/2, pi):
+                from sympy.functions.elementary.exponential import exp_polar
+                return exp_polar(I*ar)*abs(arg)
+
+        if arg.is_Mul:
+            args = arg.args
+        else:
+            args = [arg]
+        included = []
+        excluded = []
+        positive = []
+        for arg in args:
+            if arg.is_polar:
+                included += [arg]
+            elif arg.is_positive:
+                positive += [arg]
+            else:
+                excluded += [arg]
+        if len(excluded) < len(args):
+            if excluded:
+                return Mul(*(included + positive))*polar_lift(Mul(*excluded))
+            elif included:
+                return Mul(*(included + positive))
+            else:
+                from sympy.functions.elementary.exponential import exp_polar
+                return Mul(*positive)*exp_polar(0)
+
+    def _eval_evalf(self, prec):
+        """ Careful! any evalf of polar numbers is flaky """
+        return self.args[0]._eval_evalf(prec)
+
+    def _eval_Abs(self):
+        return Abs(self.args[0], evaluate=True)
+
+
+class periodic_argument(Function):
+    r"""
+    Represent the argument on a quotient of the Riemann surface of the
+    logarithm. That is, given a period $P$, always return a value in
+    $(-P/2, P/2]$, by using $\exp(PI) = 1$.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, periodic_argument
+    >>> from sympy import I, pi
+    >>> periodic_argument(exp_polar(10*I*pi), 2*pi)
+    0
+    >>> periodic_argument(exp_polar(5*I*pi), 4*pi)
+    pi
+    >>> from sympy import exp_polar, periodic_argument
+    >>> from sympy import I, pi
+    >>> periodic_argument(exp_polar(5*I*pi), 2*pi)
+    pi
+    >>> periodic_argument(exp_polar(5*I*pi), 3*pi)
+    -pi
+    >>> periodic_argument(exp_polar(5*I*pi), pi)
+    0
+
+    Parameters
+    ==========
+
+    ar : Expr
+        A polar number.
+
+    period : Expr
+        The period $P$.
+
+    See Also
+    ========
+
+    sympy.functions.elementary.exponential.exp_polar
+    polar_lift : Lift argument to the Riemann surface of the logarithm
+    principal_branch
+    """
+
+    @classmethod
+    def _getunbranched(cls, ar):
+        from sympy.functions.elementary.exponential import exp_polar, log
+        if ar.is_Mul:
+            args = ar.args
+        else:
+            args = [ar]
+        unbranched = 0
+        for a in args:
+            if not a.is_polar:
+                unbranched += arg(a)
+            elif isinstance(a, exp_polar):
+                unbranched += a.exp.as_real_imag()[1]
+            elif a.is_Pow:
+                re, im = a.exp.as_real_imag()
+                unbranched += re*unbranched_argument(
+                    a.base) + im*log(abs(a.base))
+            elif isinstance(a, polar_lift):
+                unbranched += arg(a.args[0])
+            else:
+                return None
+        return unbranched
+
+    @classmethod
+    def eval(cls, ar, period):
+        # Our strategy is to evaluate the argument on the Riemann surface of the
+        # logarithm, and then reduce.
+        # NOTE evidently this means it is a rather bad idea to use this with
+        # period != 2*pi and non-polar numbers.
+        if not period.is_extended_positive:
+            return None
+        if period == oo and isinstance(ar, principal_branch):
+            return periodic_argument(*ar.args)
+        if isinstance(ar, polar_lift) and period >= 2*pi:
+            return periodic_argument(ar.args[0], period)
+        if ar.is_Mul:
+            newargs = [x for x in ar.args if not x.is_positive]
+            if len(newargs) != len(ar.args):
+                return periodic_argument(Mul(*newargs), period)
+        unbranched = cls._getunbranched(ar)
+        if unbranched is None:
+            return None
+        from sympy.functions.elementary.trigonometric import atan, atan2
+        if unbranched.has(periodic_argument, atan2, atan):
+            return None
+        if period == oo:
+            return unbranched
+        if period != oo:
+            from sympy.functions.elementary.integers import ceiling
+            n = ceiling(unbranched/period - S.Half)*period
+            if not n.has(ceiling):
+                return unbranched - n
+
+    def _eval_evalf(self, prec):
+        z, period = self.args
+        if period == oo:
+            unbranched = periodic_argument._getunbranched(z)
+            if unbranched is None:
+                return self
+            return unbranched._eval_evalf(prec)
+        ub = periodic_argument(z, oo)._eval_evalf(prec)
+        from sympy.functions.elementary.integers import ceiling
+        return (ub - ceiling(ub/period - S.Half)*period)._eval_evalf(prec)
+
+
+def unbranched_argument(arg):
+    '''
+    Returns periodic argument of arg with period as infinity.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, unbranched_argument
+    >>> from sympy import I, pi
+    >>> unbranched_argument(exp_polar(15*I*pi))
+    15*pi
+    >>> unbranched_argument(exp_polar(7*I*pi))
+    7*pi
+
+    See also
+    ========
+
+    periodic_argument
+    '''
+    return periodic_argument(arg, oo)
+
+
+class principal_branch(Function):
+    """
+    Represent a polar number reduced to its principal branch on a quotient
+    of the Riemann surface of the logarithm.
+
+    Explanation
+    ===========
+
+    This is a function of two arguments. The first argument is a polar
+    number `z`, and the second one a positive real number or infinity, `p`.
+    The result is ``z mod exp_polar(I*p)``.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, principal_branch, oo, I, pi
+    >>> from sympy.abc import z
+    >>> principal_branch(z, oo)
+    z
+    >>> principal_branch(exp_polar(2*pi*I)*3, 2*pi)
+    3*exp_polar(0)
+    >>> principal_branch(exp_polar(2*pi*I)*3*z, 2*pi)
+    3*principal_branch(z, 2*pi)
+
+    Parameters
+    ==========
+
+    x : Expr
+        A polar number.
+
+    period : Expr
+        Positive real number or infinity.
+
+    See Also
+    ========
+
+    sympy.functions.elementary.exponential.exp_polar
+    polar_lift : Lift argument to the Riemann surface of the logarithm
+    periodic_argument
+    """
+
+    is_polar = True
+    is_comparable = False  # cannot always be evalf'd
+
+    @classmethod
+    def eval(self, x, period):
+        from sympy.functions.elementary.exponential import exp_polar
+        if isinstance(x, polar_lift):
+            return principal_branch(x.args[0], period)
+        if period == oo:
+            return x
+        ub = periodic_argument(x, oo)
+        barg = periodic_argument(x, period)
+        if ub != barg and not ub.has(periodic_argument) \
+                and not barg.has(periodic_argument):
+            pl = polar_lift(x)
+
+            def mr(expr):
+                if not isinstance(expr, Symbol):
+                    return polar_lift(expr)
+                return expr
+            pl = pl.replace(polar_lift, mr)
+            # Recompute unbranched argument
+            ub = periodic_argument(pl, oo)
+            if not pl.has(polar_lift):
+                if ub != barg:
+                    res = exp_polar(I*(barg - ub))*pl
+                else:
+                    res = pl
+                if not res.is_polar and not res.has(exp_polar):
+                    res *= exp_polar(0)
+                return res
+
+        if not x.free_symbols:
+            c, m = x, ()
+        else:
+            c, m = x.as_coeff_mul(*x.free_symbols)
+        others = []
+        for y in m:
+            if y.is_positive:
+                c *= y
+            else:
+                others += [y]
+        m = tuple(others)
+        arg = periodic_argument(c, period)
+        if arg.has(periodic_argument):
+            return None
+        if arg.is_number and (unbranched_argument(c) != arg or
+                              (arg == 0 and m != () and c != 1)):
+            if arg == 0:
+                return abs(c)*principal_branch(Mul(*m), period)
+            return principal_branch(exp_polar(I*arg)*Mul(*m), period)*abs(c)
+        if arg.is_number and ((abs(arg) < period/2) == True or arg == period/2) \
+                and m == ():
+            return exp_polar(arg*I)*abs(c)
+
+    def _eval_evalf(self, prec):
+        z, period = self.args
+        p = periodic_argument(z, period)._eval_evalf(prec)
+        if abs(p) > pi or p == -pi:
+            return self  # Cannot evalf for this argument.
+        from sympy.functions.elementary.exponential import exp
+        return (abs(z)*exp(I*p))._eval_evalf(prec)
+
+
+def _polarify(eq, lift, pause=False):
+    from sympy.integrals.integrals import Integral
+    if eq.is_polar:
+        return eq
+    if eq.is_number and not pause:
+        return polar_lift(eq)
+    if isinstance(eq, Symbol) and not pause and lift:
+        return polar_lift(eq)
+    elif eq.is_Atom:
+        return eq
+    elif eq.is_Add:
+        r = eq.func(*[_polarify(arg, lift, pause=True) for arg in eq.args])
+        if lift:
+            return polar_lift(r)
+        return r
+    elif eq.is_Pow and eq.base == S.Exp1:
+        return eq.func(S.Exp1, _polarify(eq.exp, lift, pause=False))
+    elif eq.is_Function:
+        return eq.func(*[_polarify(arg, lift, pause=False) for arg in eq.args])
+    elif isinstance(eq, Integral):
+        # Don't lift the integration variable
+        func = _polarify(eq.function, lift, pause=pause)
+        limits = []
+        for limit in eq.args[1:]:
+            var = _polarify(limit[0], lift=False, pause=pause)
+            rest = _polarify(limit[1:], lift=lift, pause=pause)
+            limits.append((var,) + rest)
+        return Integral(*((func,) + tuple(limits)))
+    else:
+        return eq.func(*[_polarify(arg, lift, pause=pause)
+                         if isinstance(arg, Expr) else arg for arg in eq.args])
+
+
+def polarify(eq, subs=True, lift=False):
+    """
+    Turn all numbers in eq into their polar equivalents (under the standard
+    choice of argument).
+
+    Note that no attempt is made to guess a formal convention of adding
+    polar numbers, expressions like $1 + x$ will generally not be altered.
+
+    Note also that this function does not promote ``exp(x)`` to ``exp_polar(x)``.
+
+    If ``subs`` is ``True``, all symbols which are not already polar will be
+    substituted for polar dummies; in this case the function behaves much
+    like :func:`~.posify`.
+
+    If ``lift`` is ``True``, both addition statements and non-polar symbols are
+    changed to their ``polar_lift()``ed versions.
+    Note that ``lift=True`` implies ``subs=False``.
+
+    Examples
+    ========
+
+    >>> from sympy import polarify, sin, I
+    >>> from sympy.abc import x, y
+    >>> expr = (-x)**y
+    >>> expr.expand()
+    (-x)**y
+    >>> polarify(expr)
+    ((_x*exp_polar(I*pi))**_y, {_x: x, _y: y})
+    >>> polarify(expr)[0].expand()
+    _x**_y*exp_polar(_y*I*pi)
+    >>> polarify(x, lift=True)
+    polar_lift(x)
+    >>> polarify(x*(1+y), lift=True)
+    polar_lift(x)*polar_lift(y + 1)
+
+    Adds are treated carefully:
+
+    >>> polarify(1 + sin((1 + I)*x))
+    (sin(_x*polar_lift(1 + I)) + 1, {_x: x})
+    """
+    if lift:
+        subs = False
+    eq = _polarify(sympify(eq), lift)
+    if not subs:
+        return eq
+    reps = {s: Dummy(s.name, polar=True) for s in eq.free_symbols}
+    eq = eq.subs(reps)
+    return eq, {r: s for s, r in reps.items()}
+
+
+def _unpolarify(eq, exponents_only, pause=False):
+    if not isinstance(eq, Basic) or eq.is_Atom:
+        return eq
+
+    if not pause:
+        from sympy.functions.elementary.exponential import exp, exp_polar
+        if isinstance(eq, exp_polar):
+            return exp(_unpolarify(eq.exp, exponents_only))
+        if isinstance(eq, principal_branch) and eq.args[1] == 2*pi:
+            return _unpolarify(eq.args[0], exponents_only)
+        if (
+            eq.is_Add or eq.is_Mul or eq.is_Boolean or
+            eq.is_Relational and (
+                eq.rel_op in ('==', '!=') and 0 in eq.args or
+                eq.rel_op not in ('==', '!='))
+        ):
+            return eq.func(*[_unpolarify(x, exponents_only) for x in eq.args])
+        if isinstance(eq, polar_lift):
+            return _unpolarify(eq.args[0], exponents_only)
+
+    if eq.is_Pow:
+        expo = _unpolarify(eq.exp, exponents_only)
+        base = _unpolarify(eq.base, exponents_only,
+            not (expo.is_integer and not pause))
+        return base**expo
+
+    if eq.is_Function and getattr(eq.func, 'unbranched', False):
+        return eq.func(*[_unpolarify(x, exponents_only, exponents_only)
+            for x in eq.args])
+
+    return eq.func(*[_unpolarify(x, exponents_only, True) for x in eq.args])
+
+
+def unpolarify(eq, subs=None, exponents_only=False):
+    """
+    If `p` denotes the projection from the Riemann surface of the logarithm to
+    the complex line, return a simplified version `eq'` of `eq` such that
+    `p(eq') = p(eq)`.
+    Also apply the substitution subs in the end. (This is a convenience, since
+    ``unpolarify``, in a certain sense, undoes :func:`polarify`.)
+
+    Examples
+    ========
+
+    >>> from sympy import unpolarify, polar_lift, sin, I
+    >>> unpolarify(polar_lift(I + 2))
+    2 + I
+    >>> unpolarify(sin(polar_lift(I + 7)))
+    sin(7 + I)
+    """
+    if isinstance(eq, bool):
+        return eq
+
+    eq = sympify(eq)
+    if subs is not None:
+        return unpolarify(eq.subs(subs))
+    changed = True
+    pause = False
+    if exponents_only:
+        pause = True
+    while changed:
+        changed = False
+        res = _unpolarify(eq, exponents_only, pause)
+        if res != eq:
+            changed = True
+            eq = res
+        if isinstance(res, bool):
+            return res
+    # Finally, replacing Exp(0) by 1 is always correct.
+    # So is polar_lift(0) -> 0.
+    from sympy.functions.elementary.exponential import exp_polar
+    return res.subs({exp_polar(0): 1, polar_lift(0): 0})

llmeval-env/lib/python3.10/site-packages/sympy/functions/elementary/exponential.py

@@ -0,0 +1,1291 @@
+from itertools import product
+from typing import Tuple as tTuple
+
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.expr import Expr
+from sympy.core.function import (Function, ArgumentIndexError, expand_log,
+    expand_mul, FunctionClass, PoleError, expand_multinomial, expand_complex)
+from sympy.core.logic import fuzzy_and, fuzzy_not, fuzzy_or
+from sympy.core.mul import Mul
+from sympy.core.numbers import Integer, Rational, pi, I, ImaginaryUnit
+from sympy.core.parameters import global_parameters
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Wild, Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import arg, unpolarify, im, re, Abs
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.ntheory import multiplicity, perfect_power
+from sympy.ntheory.factor_ import factorint
+
+# NOTE IMPORTANT
+# The series expansion code in this file is an important part of the gruntz
+# algorithm for determining limits. _eval_nseries has to return a generalized
+# power series with coefficients in C(log(x), log).
+# In more detail, the result of _eval_nseries(self, x, n) must be
+#   c_0*x**e_0 + ... (finitely many terms)
+# where e_i are numbers (not necessarily integers) and c_i involve only
+# numbers, the function log, and log(x). [This also means it must not contain
+# log(x(1+p)), this *has* to be expanded to log(x)+log(1+p) if x.is_positive and
+# p.is_positive.]
+
+
+class ExpBase(Function):
+
+    unbranched = True
+    _singularities = (S.ComplexInfinity,)
+
+    @property
+    def kind(self):
+        return self.exp.kind
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse function of ``exp(x)``.
+        """
+        return log
+
+    def as_numer_denom(self):
+        """
+        Returns this with a positive exponent as a 2-tuple (a fraction).
+
+        Examples
+        ========
+
+        >>> from sympy import exp
+        >>> from sympy.abc import x
+        >>> exp(-x).as_numer_denom()
+        (1, exp(x))
+        >>> exp(x).as_numer_denom()
+        (exp(x), 1)
+        """
+        # this should be the same as Pow.as_numer_denom wrt
+        # exponent handling
+        exp = self.exp
+        neg_exp = exp.is_negative
+        if not neg_exp and not (-exp).is_negative:
+            neg_exp = exp.could_extract_minus_sign()
+        if neg_exp:
+            return S.One, self.func(-exp)
+        return self, S.One
+
+    @property
+    def exp(self):
+        """
+        Returns the exponent of the function.
+        """
+        return self.args[0]
+
+    def as_base_exp(self):
+        """
+        Returns the 2-tuple (base, exponent).
+        """
+        return self.func(1), Mul(*self.args)
+
+    def _eval_adjoint(self):
+        return self.func(self.exp.adjoint())
+
+    def _eval_conjugate(self):
+        return self.func(self.exp.conjugate())
+
+    def _eval_transpose(self):
+        return self.func(self.exp.transpose())
+
+    def _eval_is_finite(self):
+        arg = self.exp
+        if arg.is_infinite:
+            if arg.is_extended_negative:
+                return True
+            if arg.is_extended_positive:
+                return False
+        if arg.is_finite:
+            return True
+
+    def _eval_is_rational(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            z = s.exp.is_zero
+            if z:
+                return True
+            elif s.exp.is_rational and fuzzy_not(z):
+                return False
+        else:
+            return s.is_rational
+
+    def _eval_is_zero(self):
+        return self.exp is S.NegativeInfinity
+
+    def _eval_power(self, other):
+        """exp(arg)**e -> exp(arg*e) if assumptions allow it.
+        """
+        b, e = self.as_base_exp()
+        return Pow._eval_power(Pow(b, e, evaluate=False), other)
+
+    def _eval_expand_power_exp(self, **hints):
+        from sympy.concrete.products import Product
+        from sympy.concrete.summations import Sum
+        arg = self.args[0]
+        if arg.is_Add and arg.is_commutative:
+            return Mul.fromiter(self.func(x) for x in arg.args)
+        elif isinstance(arg, Sum) and arg.is_commutative:
+            return Product(self.func(arg.function), *arg.limits)
+        return self.func(arg)
+
+
+class exp_polar(ExpBase):
+    r"""
+    Represent a *polar number* (see g-function Sphinx documentation).
+
+    Explanation
+    ===========
+
+    ``exp_polar`` represents the function
+    `Exp: \mathbb{C} \rightarrow \mathcal{S}`, sending the complex number
+    `z = a + bi` to the polar number `r = exp(a), \theta = b`. It is one of
+    the main functions to construct polar numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, pi, I, exp
+
+    The main difference is that polar numbers do not "wrap around" at `2 \pi`:
+
+    >>> exp(2*pi*I)
+    1
+    >>> exp_polar(2*pi*I)
+    exp_polar(2*I*pi)
+
+    apart from that they behave mostly like classical complex numbers:
+
+    >>> exp_polar(2)*exp_polar(3)
+    exp_polar(5)
+
+    See Also
+    ========
+
+    sympy.simplify.powsimp.powsimp
+    polar_lift
+    periodic_argument
+    principal_branch
+    """
+
+    is_polar = True
+    is_comparable = False  # cannot be evalf'd
+
+    def _eval_Abs(self):   # Abs is never a polar number
+        return exp(re(self.args[0]))
+
+    def _eval_evalf(self, prec):
+        """ Careful! any evalf of polar numbers is flaky """
+        i = im(self.args[0])
+        try:
+            bad = (i <= -pi or i > pi)
+        except TypeError:
+            bad = True
+        if bad:
+            return self  # cannot evalf for this argument
+        res = exp(self.args[0])._eval_evalf(prec)
+        if i > 0 and im(res) < 0:
+            # i ~ pi, but exp(I*i) evaluated to argument slightly bigger than pi
+            return re(res)
+        return res
+
+    def _eval_power(self, other):
+        return self.func(self.args[0]*other)
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+
+    def as_base_exp(self):
+        # XXX exp_polar(0) is special!
+        if self.args[0] == 0:
+            return self, S.One
+        return ExpBase.as_base_exp(self)
+
+
+class ExpMeta(FunctionClass):
+    def __instancecheck__(cls, instance):
+        if exp in instance.__class__.__mro__:
+            return True
+        return isinstance(instance, Pow) and instance.base is S.Exp1
+
+
+class exp(ExpBase, metaclass=ExpMeta):
+    """
+    The exponential function, :math:`e^x`.
+
+    Examples
+    ========
+
+    >>> from sympy import exp, I, pi
+    >>> from sympy.abc import x
+    >>> exp(x)
+    exp(x)
+    >>> exp(x).diff(x)
+    exp(x)
+    >>> exp(I*pi)
+    -1
+
+    Parameters
+    ==========
+
+    arg : Expr
+
+    See Also
+    ========
+
+    log
+    """
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return self
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_refine(self, assumptions):
+        from sympy.assumptions import ask, Q
+        arg = self.args[0]
+        if arg.is_Mul:
+            Ioo = I*S.Infinity
+            if arg in [Ioo, -Ioo]:
+                return S.NaN
+
+            coeff = arg.as_coefficient(pi*I)
+            if coeff:
+                if ask(Q.integer(2*coeff)):
+                    if ask(Q.even(coeff)):
+                        return S.One
+                    elif ask(Q.odd(coeff)):
+                        return S.NegativeOne
+                    elif ask(Q.even(coeff + S.Half)):
+                        return -I
+                    elif ask(Q.odd(coeff + S.Half)):
+                        return I
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.calculus import AccumBounds
+        from sympy.matrices.matrices import MatrixBase
+        from sympy.sets.setexpr import SetExpr
+        from sympy.simplify.simplify import logcombine
+        if isinstance(arg, MatrixBase):
+            return arg.exp()
+        elif global_parameters.exp_is_pow:
+            return Pow(S.Exp1, arg)
+        elif arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg.is_zero:
+                return S.One
+            elif arg is S.One:
+                return S.Exp1
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+        elif arg is S.ComplexInfinity:
+            return S.NaN
+        elif isinstance(arg, log):
+            return arg.args[0]
+        elif isinstance(arg, AccumBounds):
+            return AccumBounds(exp(arg.min), exp(arg.max))
+        elif isinstance(arg, SetExpr):
+            return arg._eval_func(cls)
+        elif arg.is_Mul:
+            coeff = arg.as_coefficient(pi*I)
+            if coeff:
+                if (2*coeff).is_integer:
+                    if coeff.is_even:
+                        return S.One
+                    elif coeff.is_odd:
+                        return S.NegativeOne
+                    elif (coeff + S.Half).is_even:
+                        return -I
+                    elif (coeff + S.Half).is_odd:
+                        return I
+                elif coeff.is_Rational:
+                    ncoeff = coeff % 2 # restrict to [0, 2pi)
+                    if ncoeff > 1: # restrict to (-pi, pi]
+                        ncoeff -= 2
+                    if ncoeff != coeff:
+                        return cls(ncoeff*pi*I)
+
+            # Warning: code in risch.py will be very sensitive to changes
+            # in this (see DifferentialExtension).
+
+            # look for a single log factor
+
+            coeff, terms = arg.as_coeff_Mul()
+
+            # but it can't be multiplied by oo
+            if coeff in [S.NegativeInfinity, S.Infinity]:
+                if terms.is_number:
+                    if coeff is S.NegativeInfinity:
+                        terms = -terms
+                    if re(terms).is_zero and terms is not S.Zero:
+                        return S.NaN
+                    if re(terms).is_positive and im(terms) is not S.Zero:
+                        return S.ComplexInfinity
+                    if re(terms).is_negative:
+                        return S.Zero
+                return None
+
+            coeffs, log_term = [coeff], None
+            for term in Mul.make_args(terms):
+                term_ = logcombine(term)
+                if isinstance(term_, log):
+                    if log_term is None:
+                        log_term = term_.args[0]
+                    else:
+                        return None
+                elif term.is_comparable:
+                    coeffs.append(term)
+                else:
+                    return None
+
+            return log_term**Mul(*coeffs) if log_term else None
+
+        elif arg.is_Add:
+            out = []
+            add = []
+            argchanged = False
+            for a in arg.args:
+                if a is S.One:
+                    add.append(a)
+                    continue
+                newa = cls(a)
+                if isinstance(newa, cls):
+                    if newa.args[0] != a:
+                        add.append(newa.args[0])
+                        argchanged = True
+                    else:
+                        add.append(a)
+                else:
+                    out.append(newa)
+            if out or argchanged:
+                return Mul(*out)*cls(Add(*add), evaluate=False)
+
+        if arg.is_zero:
+            return S.One
+
+    @property
+    def base(self):
+        """
+        Returns the base of the exponential function.
+        """
+        return S.Exp1
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        """
+        Calculates the next term in the Taylor series expansion.
+        """
+        if n < 0:
+            return S.Zero
+        if n == 0:
+            return S.One
+        x = sympify(x)
+        if previous_terms:
+            p = previous_terms[-1]
+            if p is not None:
+                return p * x / n
+        return x**n/factorial(n)
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns this function as a 2-tuple representing a complex number.
+
+        Examples
+        ========
+
+        >>> from sympy import exp, I
+        >>> from sympy.abc import x
+        >>> exp(x).as_real_imag()
+        (exp(re(x))*cos(im(x)), exp(re(x))*sin(im(x)))
+        >>> exp(1).as_real_imag()
+        (E, 0)
+        >>> exp(I).as_real_imag()
+        (cos(1), sin(1))
+        >>> exp(1+I).as_real_imag()
+        (E*cos(1), E*sin(1))
+
+        See Also
+        ========
+
+        sympy.functions.elementary.complexes.re
+        sympy.functions.elementary.complexes.im
+        """
+        from sympy.functions.elementary.trigonometric import cos, sin
+        re, im = self.args[0].as_real_imag()
+        if deep:
+            re = re.expand(deep, **hints)
+            im = im.expand(deep, **hints)
+        cos, sin = cos(im), sin(im)
+        return (exp(re)*cos, exp(re)*sin)
+
+    def _eval_subs(self, old, new):
+        # keep processing of power-like args centralized in Pow
+        if old.is_Pow:  # handle (exp(3*log(x))).subs(x**2, z) -> z**(3/2)
+            old = exp(old.exp*log(old.base))
+        elif old is S.Exp1 and new.is_Function:
+            old = exp
+        if isinstance(old, exp) or old is S.Exp1:
+            f = lambda a: Pow(*a.as_base_exp(), evaluate=False) if (
+                a.is_Pow or isinstance(a, exp)) else a
+            return Pow._eval_subs(f(self), f(old), new)
+
+        if old is exp and not new.is_Function:
+            return new**self.exp._subs(old, new)
+        return Function._eval_subs(self, old, new)
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+        elif self.args[0].is_imaginary:
+            arg2 = -S(2) * I * self.args[0] / pi
+            return arg2.is_even
+
+    def _eval_is_complex(self):
+        def complex_extended_negative(arg):
+            yield arg.is_complex
+            yield arg.is_extended_negative
+        return fuzzy_or(complex_extended_negative(self.args[0]))
+
+    def _eval_is_algebraic(self):
+        if (self.exp / pi / I).is_rational:
+            return True
+        if fuzzy_not(self.exp.is_zero):
+            if self.exp.is_algebraic:
+                return False
+            elif (self.exp / pi).is_rational:
+                return False
+
+    def _eval_is_extended_positive(self):
+        if self.exp.is_extended_real:
+            return self.args[0] is not S.NegativeInfinity
+        elif self.exp.is_imaginary:
+            arg2 = -I * self.args[0] / pi
+            return arg2.is_even
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # NOTE Please see the comment at the beginning of this file, labelled
+        #      IMPORTANT.
+        from sympy.functions.elementary.complexes import sign
+        from sympy.functions.elementary.integers import ceiling
+        from sympy.series.limits import limit
+        from sympy.series.order import Order
+        from sympy.simplify.powsimp import powsimp
+        arg = self.exp
+        arg_series = arg._eval_nseries(x, n=n, logx=logx)
+        if arg_series.is_Order:
+            return 1 + arg_series
+        arg0 = limit(arg_series.removeO(), x, 0)
+        if arg0 is S.NegativeInfinity:
+            return Order(x**n, x)
+        if arg0 is S.Infinity:
+            return self
+        # checking for indecisiveness/ sign terms in arg0
+        if any(isinstance(arg, (sign, ImaginaryUnit)) for arg in arg0.args):
+            return self
+        t = Dummy("t")
+        nterms = n
+        try:
+            cf = Order(arg.as_leading_term(x, logx=logx), x).getn()
+        except (NotImplementedError, PoleError):
+            cf = 0
+        if cf and cf > 0:
+            nterms = ceiling(n/cf)
+        exp_series = exp(t)._taylor(t, nterms)
+        r = exp(arg0)*exp_series.subs(t, arg_series - arg0)
+        rep = {logx: log(x)} if logx is not None else {}
+        if r.subs(rep) == self:
+            return r
+        if cf and cf > 1:
+            r += Order((arg_series - arg0)**n, x)/x**((cf-1)*n)
+        else:
+            r += Order((arg_series - arg0)**n, x)
+        r = r.expand()
+        r = powsimp(r, deep=True, combine='exp')
+        # powsimp may introduce unexpanded (-1)**Rational; see PR #17201
+        simplerat = lambda x: x.is_Rational and x.q in [3, 4, 6]
+        w = Wild('w', properties=[simplerat])
+        r = r.replace(S.NegativeOne**w, expand_complex(S.NegativeOne**w))
+        return r
+
+    def _taylor(self, x, n):
+        l = []
+        g = None
+        for i in range(n):
+            g = self.taylor_term(i, self.args[0], g)
+            g = g.nseries(x, n=n)
+            l.append(g.removeO())
+        return Add(*l)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.calculus.util import AccumBounds
+        arg = self.args[0].cancel().as_leading_term(x, logx=logx)
+        arg0 = arg.subs(x, 0)
+        if arg is S.NaN:
+            return S.NaN
+        if isinstance(arg0, AccumBounds):
+            # This check addresses a corner case involving AccumBounds.
+            # if isinstance(arg, AccumBounds) is True, then arg0 can either be 0,
+            # AccumBounds(-oo, 0) or AccumBounds(-oo, oo).
+            # Check out function: test_issue_18473() in test_exponential.py and
+            # test_limits.py for more information.
+            if re(cdir) < S.Zero:
+                return exp(-arg0)
+            return exp(arg0)
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0)
+        if arg0.is_infinite is False:
+            return exp(arg0)
+        raise PoleError("Cannot expand %s around 0" % (self))
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import sin
+        return sin(I*arg + pi/2) - I*sin(I*arg)
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import cos
+        return cos(I*arg) + I*cos(I*arg + pi/2)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        from sympy.functions.elementary.hyperbolic import tanh
+        return (1 + tanh(arg/2))/(1 - tanh(arg/2))
+
+    def _eval_rewrite_as_sqrt(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import sin, cos
+        if arg.is_Mul:
+            coeff = arg.coeff(pi*I)
+            if coeff and coeff.is_number:
+                cosine, sine = cos(pi*coeff), sin(pi*coeff)
+                if not isinstance(cosine, cos) and not isinstance (sine, sin):
+                    return cosine + I*sine
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        if arg.is_Mul:
+            logs = [a for a in arg.args if isinstance(a, log) and len(a.args) == 1]
+            if logs:
+                return Pow(logs[0].args[0], arg.coeff(logs[0]))
+
+
+def match_real_imag(expr):
+    r"""
+    Try to match expr with $a + Ib$ for real $a$ and $b$.
+
+    ``match_real_imag`` returns a tuple containing the real and imaginary
+    parts of expr or ``(None, None)`` if direct matching is not possible. Contrary
+    to :func:`~.re()`, :func:`~.im()``, and ``as_real_imag()``, this helper will not force things
+    by returning expressions themselves containing ``re()`` or ``im()`` and it
+    does not expand its argument either.
+
+    """
+    r_, i_ = expr.as_independent(I, as_Add=True)
+    if i_ == 0 and r_.is_real:
+        return (r_, i_)
+    i_ = i_.as_coefficient(I)
+    if i_ and i_.is_real and r_.is_real:
+        return (r_, i_)
+    else:
+        return (None, None) # simpler to check for than None
+
+
+class log(Function):
+    r"""
+    The natural logarithm function `\ln(x)` or `\log(x)`.
+
+    Explanation
+    ===========
+
+    Logarithms are taken with the natural base, `e`. To get
+    a logarithm of a different base ``b``, use ``log(x, b)``,
+    which is essentially short-hand for ``log(x)/log(b)``.
+
+    ``log`` represents the principal branch of the natural
+    logarithm. As such it has a branch cut along the negative
+    real axis and returns values having a complex argument in
+    `(-\pi, \pi]`.
+
+    Examples
+    ========
+
+    >>> from sympy import log, sqrt, S, I
+    >>> log(8, 2)
+    3
+    >>> log(S(8)/3, 2)
+    -log(3)/log(2) + 3
+    >>> log(-1 + I*sqrt(3))
+    log(2) + 2*I*pi/3
+
+    See Also
+    ========
+
+    exp
+
+    """
+
+    args: tTuple[Expr]
+
+    _singularities = (S.Zero, S.ComplexInfinity)
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of the function.
+        """
+        if argindex == 1:
+            return 1/self.args[0]
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        r"""
+        Returns `e^x`, the inverse function of `\log(x)`.
+        """
+        return exp
+
+    @classmethod
+    def eval(cls, arg, base=None):
+        from sympy.calculus import AccumBounds
+        from sympy.sets.setexpr import SetExpr
+
+        arg = sympify(arg)
+
+        if base is not None:
+            base = sympify(base)
+            if base == 1:
+                if arg == 1:
+                    return S.NaN
+                else:
+                    return S.ComplexInfinity
+            try:
+                # handle extraction of powers of the base now
+                # or else expand_log in Mul would have to handle this
+                n = multiplicity(base, arg)
+                if n:
+                    return n + log(arg / base**n) / log(base)
+                else:
+                    return log(arg)/log(base)
+            except ValueError:
+                pass
+            if base is not S.Exp1:
+                return cls(arg)/cls(base)
+            else:
+                return cls(arg)
+
+        if arg.is_Number:
+            if arg.is_zero:
+                return S.ComplexInfinity
+            elif arg is S.One:
+                return S.Zero
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Infinity
+            elif arg is S.NaN:
+                return S.NaN
+            elif arg.is_Rational and arg.p == 1:
+                return -cls(arg.q)
+
+        if arg.is_Pow and arg.base is S.Exp1 and arg.exp.is_extended_real:
+            return arg.exp
+        if isinstance(arg, exp) and arg.exp.is_extended_real:
+            return arg.exp
+        elif isinstance(arg, exp) and arg.exp.is_number:
+            r_, i_ = match_real_imag(arg.exp)
+            if i_ and i_.is_comparable:
+                i_ %= 2*pi
+                if i_ > pi:
+                    i_ -= 2*pi
+                return r_ + expand_mul(i_ * I, deep=False)
+        elif isinstance(arg, exp_polar):
+            return unpolarify(arg.exp)
+        elif isinstance(arg, AccumBounds):
+            if arg.min.is_positive:
+                return AccumBounds(log(arg.min), log(arg.max))
+            elif arg.min.is_zero:
+                return AccumBounds(S.NegativeInfinity, log(arg.max))
+            else:
+                return S.NaN
+        elif isinstance(arg, SetExpr):
+            return arg._eval_func(cls)
+
+        if arg.is_number:
+            if arg.is_negative:
+                return pi * I + cls(-arg)
+            elif arg is S.ComplexInfinity:
+                return S.ComplexInfinity
+            elif arg is S.Exp1:
+                return S.One
+
+        if arg.is_zero:
+            return S.ComplexInfinity
+
+        # don't autoexpand Pow or Mul (see the issue 3351):
+        if not arg.is_Add:
+            coeff = arg.as_coefficient(I)
+
+            if coeff is not None:
+                if coeff is S.Infinity:
+                    return S.Infinity
+                elif coeff is S.NegativeInfinity:
+                    return S.Infinity
+                elif coeff.is_Rational:
+                    if coeff.is_nonnegative:
+                        return pi * I * S.Half + cls(coeff)
+                    else:
+                        return -pi * I * S.Half + cls(-coeff)
+
+        if arg.is_number and arg.is_algebraic:
+            # Match arg = coeff*(r_ + i_*I) with coeff>0, r_ and i_ real.
+            coeff, arg_ = arg.as_independent(I, as_Add=False)
+            if coeff.is_negative:
+                coeff *= -1
+                arg_ *= -1
+            arg_ = expand_mul(arg_, deep=False)
+            r_, i_ = arg_.as_independent(I, as_Add=True)
+            i_ = i_.as_coefficient(I)
+            if coeff.is_real and i_ and i_.is_real and r_.is_real:
+                if r_.is_zero:
+                    if i_.is_positive:
+                        return pi * I * S.Half + cls(coeff * i_)
+                    elif i_.is_negative:
+                        return -pi * I * S.Half + cls(coeff * -i_)
+                else:
+                    from sympy.simplify import ratsimp
+                    # Check for arguments involving rational multiples of pi
+                    t = (i_/r_).cancel()
+                    t1 = (-t).cancel()
+                    atan_table = _log_atan_table()
+                    if t in atan_table:
+                        modulus = ratsimp(coeff * Abs(arg_))
+                        if r_.is_positive:
+                            return cls(modulus) + I * atan_table[t]
+                        else:
+                            return cls(modulus) + I * (atan_table[t] - pi)
+                    elif t1 in atan_table:
+                        modulus = ratsimp(coeff * Abs(arg_))
+                        if r_.is_positive:
+                            return cls(modulus) + I * (-atan_table[t1])
+                        else:
+                            return cls(modulus) + I * (pi - atan_table[t1])
+
+    def as_base_exp(self):
+        """
+        Returns this function in the form (base, exponent).
+        """
+        return self, S.One
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):  # of log(1+x)
+        r"""
+        Returns the next term in the Taylor series expansion of `\log(1+x)`.
+        """
+        from sympy.simplify.powsimp import powsimp
+        if n < 0:
+            return S.Zero
+        x = sympify(x)
+        if n == 0:
+            return x
+        if previous_terms:
+            p = previous_terms[-1]
+            if p is not None:
+                return powsimp((-n) * p * x / (n + 1), deep=True, combine='exp')
+        return (1 - 2*(n % 2)) * x**(n + 1)/(n + 1)
+
+    def _eval_expand_log(self, deep=True, **hints):
+        from sympy.concrete import Sum, Product
+        force = hints.get('force', False)
+        factor = hints.get('factor', False)
+        if (len(self.args) == 2):
+            return expand_log(self.func(*self.args), deep=deep, force=force)
+        arg = self.args[0]
+        if arg.is_Integer:
+            # remove perfect powers
+            p = perfect_power(arg)
+            logarg = None
+            coeff = 1
+            if p is not False:
+                arg, coeff = p
+                logarg = self.func(arg)
+            # expand as product of its prime factors if factor=True
+            if factor:
+                p = factorint(arg)
+                if arg not in p.keys():
+                    logarg = sum(n*log(val) for val, n in p.items())
+            if logarg is not None:
+                return coeff*logarg
+        elif arg.is_Rational:
+            return log(arg.p) - log(arg.q)
+        elif arg.is_Mul:
+            expr = []
+            nonpos = []
+            for x in arg.args:
+                if force or x.is_positive or x.is_polar:
+                    a = self.func(x)
+                    if isinstance(a, log):
+                        expr.append(self.func(x)._eval_expand_log(**hints))
+                    else:
+                        expr.append(a)
+                elif x.is_negative:
+                    a = self.func(-x)
+                    expr.append(a)
+                    nonpos.append(S.NegativeOne)
+                else:
+                    nonpos.append(x)
+            return Add(*expr) + log(Mul(*nonpos))
+        elif arg.is_Pow or isinstance(arg, exp):
+            if force or (arg.exp.is_extended_real and (arg.base.is_positive or ((arg.exp+1)
+                .is_positive and (arg.exp-1).is_nonpositive))) or arg.base.is_polar:
+                b = arg.base
+                e = arg.exp
+                a = self.func(b)
+                if isinstance(a, log):
+                    return unpolarify(e) * a._eval_expand_log(**hints)
+                else:
+                    return unpolarify(e) * a
+        elif isinstance(arg, Product):
+            if force or arg.function.is_positive:
+                return Sum(log(arg.function), *arg.limits)
+
+        return self.func(arg)
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.simplify import expand_log, simplify, inversecombine
+        if len(self.args) == 2:  # it's unevaluated
+            return simplify(self.func(*self.args), **kwargs)
+
+        expr = self.func(simplify(self.args[0], **kwargs))
+        if kwargs['inverse']:
+            expr = inversecombine(expr)
+        expr = expand_log(expr, deep=True)
+        return min([expr, self], key=kwargs['measure'])
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns this function as a complex coordinate.
+
+        Examples
+        ========
+
+        >>> from sympy import I, log
+        >>> from sympy.abc import x
+        >>> log(x).as_real_imag()
+        (log(Abs(x)), arg(x))
+        >>> log(I).as_real_imag()
+        (0, pi/2)
+        >>> log(1 + I).as_real_imag()
+        (log(sqrt(2)), pi/4)
+        >>> log(I*x).as_real_imag()
+        (log(Abs(x)), arg(I*x))
+
+        """
+        sarg = self.args[0]
+        if deep:
+            sarg = self.args[0].expand(deep, **hints)
+        sarg_abs = Abs(sarg)
+        if sarg_abs == sarg:
+            return self, S.Zero
+        sarg_arg = arg(sarg)
+        if hints.get('log', False):  # Expand the log
+            hints['complex'] = False
+            return (log(sarg_abs).expand(deep, **hints), sarg_arg)
+        else:
+            return log(sarg_abs), sarg_arg
+
+    def _eval_is_rational(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if (self.args[0] - 1).is_zero:
+                return True
+            if s.args[0].is_rational and fuzzy_not((self.args[0] - 1).is_zero):
+                return False
+        else:
+            return s.is_rational
+
+    def _eval_is_algebraic(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if (self.args[0] - 1).is_zero:
+                return True
+            elif fuzzy_not((self.args[0] - 1).is_zero):
+                if self.args[0].is_algebraic:
+                    return False
+        else:
+            return s.is_algebraic
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_positive
+
+    def _eval_is_complex(self):
+        z = self.args[0]
+        return fuzzy_and([z.is_complex, fuzzy_not(z.is_zero)])
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+        if arg.is_zero:
+            return False
+        return arg.is_finite
+
+    def _eval_is_extended_positive(self):
+        return (self.args[0] - 1).is_extended_positive
+
+    def _eval_is_zero(self):
+        return (self.args[0] - 1).is_zero
+
+    def _eval_is_extended_nonnegative(self):
+        return (self.args[0] - 1).is_extended_nonnegative
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # NOTE Please see the comment at the beginning of this file, labelled
+        #      IMPORTANT.
+        from sympy.series.order import Order
+        from sympy.simplify.simplify import logcombine
+        from sympy.core.symbol import Dummy
+
+        if self.args[0] == x:
+            return log(x) if logx is None else logx
+        arg = self.args[0]
+        t = Dummy('t', positive=True)
+        if cdir == 0:
+            cdir = 1
+        z = arg.subs(x, cdir*t)
+
+        k, l = Wild("k"), Wild("l")
+        r = z.match(k*t**l)
+        if r is not None:
+            k, l = r[k], r[l]
+            if l != 0 and not l.has(t) and not k.has(t):
+                r = l*log(x) if logx is None else l*logx
+                r += log(k) - l*log(cdir) # XXX true regardless of assumptions?
+                return r
+
+        def coeff_exp(term, x):
+            coeff, exp = S.One, S.Zero
+            for factor in Mul.make_args(term):
+                if factor.has(x):
+                    base, exp = factor.as_base_exp()
+                    if base != x:
+                        try:
+                            return term.leadterm(x)
+                        except ValueError:
+                            return term, S.Zero
+                else:
+                    coeff *= factor
+            return coeff, exp
+
+        # TODO new and probably slow
+        try:
+            a, b = z.leadterm(t, logx=logx, cdir=1)
+        except (ValueError, NotImplementedError, PoleError):
+            s = z._eval_nseries(t, n=n, logx=logx, cdir=1)
+            while s.is_Order:
+                n += 1
+                s = z._eval_nseries(t, n=n, logx=logx, cdir=1)
+            try:
+                a, b = s.removeO().leadterm(t, cdir=1)
+            except ValueError:
+                a, b = s.removeO().as_leading_term(t, cdir=1), S.Zero
+
+        p = (z/(a*t**b) - 1)._eval_nseries(t, n=n, logx=logx, cdir=1)
+        if p.has(exp):
+            p = logcombine(p)
+        if isinstance(p, Order):
+            n = p.getn()
+        _, d = coeff_exp(p, t)
+        logx = log(x) if logx is None else logx
+
+        if not d.is_positive:
+            res = log(a) - b*log(cdir) + b*logx
+            _res = res
+            logflags = {"deep": True, "log": True, "mul": False, "power_exp": False,
+                "power_base": False, "multinomial": False, "basic": False, "force": True,
+                "factor": False}
+            expr = self.expand(**logflags)
+            if (not a.could_extract_minus_sign() and
+                logx.could_extract_minus_sign()):
+                _res = _res.subs(-logx, -log(x)).expand(**logflags)
+            else:
+                _res = _res.subs(logx, log(x)).expand(**logflags)
+            if _res == expr:
+                return res
+            return res + Order(x**n, x)
+
+        def mul(d1, d2):
+            res = {}
+            for e1, e2 in product(d1, d2):
+                ex = e1 + e2
+                if ex < n:
+                    res[ex] = res.get(ex, S.Zero) + d1[e1]*d2[e2]
+            return res
+
+        pterms = {}
+
+        for term in Add.make_args(p.removeO()):
+            co1, e1 = coeff_exp(term, t)
+            pterms[e1] = pterms.get(e1, S.Zero) + co1
+
+        k = S.One
+        terms = {}
+        pk = pterms
+
+        while k*d < n:
+            coeff = -S.NegativeOne**k/k
+            for ex in pk:
+                _ = terms.get(ex, S.Zero) + coeff*pk[ex]
+                terms[ex] = _.nsimplify()
+            pk = mul(pk, pterms)
+            k += S.One
+
+        res = log(a) - b*log(cdir) + b*logx
+        for ex in terms:
+            res += terms[ex]*t**(ex)
+
+        if a.is_negative and im(z) != 0:
+            from sympy.functions.special.delta_functions import Heaviside
+            for i, term in enumerate(z.lseries(t)):
+                if not term.is_real or i == 5:
+                    break
+            if i < 5:
+                coeff, _ = term.as_coeff_exponent(t)
+                res += -2*I*pi*Heaviside(-im(coeff), 0)
+
+        res = res.subs(t, x/cdir)
+        return res + Order(x**n, x)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        # NOTE
+        # Refer https://github.com/sympy/sympy/pull/23592 for more information
+        # on each of the following steps involved in this method.
+        arg0 = self.args[0].together()
+
+        # STEP 1
+        t = Dummy('t', positive=True)
+        if cdir == 0:
+            cdir = 1
+        z = arg0.subs(x, cdir*t)
+
+        # STEP 2
+        try:
+            c, e = z.leadterm(t, logx=logx, cdir=1)
+        except ValueError:
+            arg = arg0.as_leading_term(x, logx=logx, cdir=cdir)
+            return log(arg)
+        if c.has(t):
+            c = c.subs(t, x/cdir)
+            if e != 0:
+                raise PoleError("Cannot expand %s around 0" % (self))
+            return log(c)
+
+        # STEP 3
+        if c == S.One and e == S.Zero:
+            return (arg0 - S.One).as_leading_term(x, logx=logx)
+
+        # STEP 4
+        res = log(c) - e*log(cdir)
+        logx = log(x) if logx is None else logx
+        res += e*logx
+
+        # STEP 5
+        if c.is_negative and im(z) != 0:
+            from sympy.functions.special.delta_functions import Heaviside
+            for i, term in enumerate(z.lseries(t)):
+                if not term.is_real or i == 5:
+                    break
+            if i < 5:
+                coeff, _ = term.as_coeff_exponent(t)
+                res += -2*I*pi*Heaviside(-im(coeff), 0)
+        return res
+
+
+class LambertW(Function):
+    r"""
+    The Lambert W function $W(z)$ is defined as the inverse
+    function of $w \exp(w)$ [1]_.
+
+    Explanation
+    ===========
+
+    In other words, the value of $W(z)$ is such that $z = W(z) \exp(W(z))$
+    for any complex number $z$.  The Lambert W function is a multivalued
+    function with infinitely many branches $W_k(z)$, indexed by
+    $k \in \mathbb{Z}$.  Each branch gives a different solution $w$
+    of the equation $z = w \exp(w)$.
+
+    The Lambert W function has two partially real branches: the
+    principal branch ($k = 0$) is real for real $z > -1/e$, and the
+    $k = -1$ branch is real for $-1/e < z < 0$. All branches except
+    $k = 0$ have a logarithmic singularity at $z = 0$.
+
+    Examples
+    ========
+
+    >>> from sympy import LambertW
+    >>> LambertW(1.2)
+    0.635564016364870
+    >>> LambertW(1.2, -1).n()
+    -1.34747534407696 - 4.41624341514535*I
+    >>> LambertW(-1).is_real
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lambert_W_function
+    """
+    _singularities = (-Pow(S.Exp1, -1, evaluate=False), S.ComplexInfinity)
+
+    @classmethod
+    def eval(cls, x, k=None):
+        if k == S.Zero:
+            return cls(x)
+        elif k is None:
+            k = S.Zero
+
+        if k.is_zero:
+            if x.is_zero:
+                return S.Zero
+            if x is S.Exp1:
+                return S.One
+            if x == -1/S.Exp1:
+                return S.NegativeOne
+            if x == -log(2)/2:
+                return -log(2)
+            if x == 2*log(2):
+                return log(2)
+            if x == -pi/2:
+                return I*pi/2
+            if x == exp(1 + S.Exp1):
+                return S.Exp1
+            if x is S.Infinity:
+                return S.Infinity
+            if x.is_zero:
+                return S.Zero
+
+        if fuzzy_not(k.is_zero):
+            if x.is_zero:
+                return S.NegativeInfinity
+        if k is S.NegativeOne:
+            if x == -pi/2:
+                return -I*pi/2
+            elif x == -1/S.Exp1:
+                return S.NegativeOne
+            elif x == -2*exp(-2):
+                return -Integer(2)
+
+    def fdiff(self, argindex=1):
+        """
+        Return the first derivative of this function.
+        """
+        x = self.args[0]
+
+        if len(self.args) == 1:
+            if argindex == 1:
+                return LambertW(x)/(x*(1 + LambertW(x)))
+        else:
+            k = self.args[1]
+            if argindex == 1:
+                return LambertW(x, k)/(x*(1 + LambertW(x, k)))
+
+        raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_extended_real(self):
+        x = self.args[0]
+        if len(self.args) == 1:
+            k = S.Zero
+        else:
+            k = self.args[1]
+        if k.is_zero:
+            if (x + 1/S.Exp1).is_positive:
+                return True
+            elif (x + 1/S.Exp1).is_nonpositive:
+                return False
+        elif (k + 1).is_zero:
+            if x.is_negative and (x + 1/S.Exp1).is_positive:
+                return True
+            elif x.is_nonpositive or (x + 1/S.Exp1).is_nonnegative:
+                return False
+        elif fuzzy_not(k.is_zero) and fuzzy_not((k + 1).is_zero):
+            if x.is_extended_real:
+                return False
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+    def _eval_is_algebraic(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if fuzzy_not(self.args[0].is_zero) and self.args[0].is_algebraic:
+                return False
+        else:
+            return s.is_algebraic
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        if len(self.args) == 1:
+            arg = self.args[0]
+            arg0 = arg.subs(x, 0).cancel()
+            if not arg0.is_zero:
+                return self.func(arg0)
+            return arg.as_leading_term(x)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        if len(self.args) == 1:
+            from sympy.functions.elementary.integers import ceiling
+            from sympy.series.order import Order
+            arg = self.args[0].nseries(x, n=n, logx=logx)
+            lt = arg.as_leading_term(x, logx=logx)
+            lte = 1
+            if lt.is_Pow:
+                lte = lt.exp
+            if ceiling(n/lte) >= 1:
+                s = Add(*[(-S.One)**(k - 1)*Integer(k)**(k - 2)/
+                          factorial(k - 1)*arg**k for k in range(1, ceiling(n/lte))])
+                s = expand_multinomial(s)
+            else:
+                s = S.Zero
+
+            return s + Order(x**n, x)
+        return super()._eval_nseries(x, n, logx)
+
+    def _eval_is_zero(self):
+        x = self.args[0]
+        if len(self.args) == 1:
+            return x.is_zero
+        else:
+            return fuzzy_and([x.is_zero, self.args[1].is_zero])
+
+
+@cacheit
+def _log_atan_table():
+    return {
+        # first quadrant only
+        sqrt(3): pi / 3,
+        1: pi / 4,
+        sqrt(5 - 2 * sqrt(5)): pi / 5,
+        sqrt(2) * sqrt(5 - sqrt(5)) / (1 + sqrt(5)): pi / 5,
+        sqrt(5 + 2 * sqrt(5)): pi * Rational(2, 5),
+        sqrt(2) * sqrt(sqrt(5) + 5) / (-1 + sqrt(5)): pi * Rational(2, 5),
+        sqrt(3) / 3: pi / 6,
+        sqrt(2) - 1: pi / 8,
+        sqrt(2 - sqrt(2)) / sqrt(sqrt(2) + 2): pi / 8,
+        sqrt(2) + 1: pi * Rational(3, 8),
+        sqrt(sqrt(2) + 2) / sqrt(2 - sqrt(2)): pi * Rational(3, 8),
+        sqrt(1 - 2 * sqrt(5) / 5): pi / 10,
+        (-sqrt(2) + sqrt(10)) / (2 * sqrt(sqrt(5) + 5)): pi / 10,
+        sqrt(1 + 2 * sqrt(5) / 5): pi * Rational(3, 10),
+        (sqrt(2) + sqrt(10)) / (2 * sqrt(5 - sqrt(5))): pi * Rational(3, 10),
+        2 - sqrt(3): pi / 12,
+        (-1 + sqrt(3)) / (1 + sqrt(3)): pi / 12,
+        2 + sqrt(3): pi * Rational(5, 12),
+        (1 + sqrt(3)) / (-1 + sqrt(3)): pi * Rational(5, 12)
+    }

llmeval-env/lib/python3.10/site-packages/sympy/functions/elementary/hyperbolic.py

@@ -0,0 +1,2203 @@
+from sympy.core import S, sympify, cacheit
+from sympy.core.add import Add
+from sympy.core.function import Function, ArgumentIndexError
+from sympy.core.logic import fuzzy_or, fuzzy_and, FuzzyBool
+from sympy.core.numbers import I, pi, Rational
+from sympy.core.symbol import Dummy
+from sympy.functions.combinatorial.factorials import (binomial, factorial,
+                                                      RisingFactorial)
+from sympy.functions.combinatorial.numbers import bernoulli, euler, nC
+from sympy.functions.elementary.complexes import Abs, im, re
+from sympy.functions.elementary.exponential import exp, log, match_real_imag
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (
+    acos, acot, asin, atan, cos, cot, csc, sec, sin, tan,
+    _imaginary_unit_as_coefficient)
+from sympy.polys.specialpolys import symmetric_poly
+
+
+def _rewrite_hyperbolics_as_exp(expr):
+    return expr.xreplace({h: h.rewrite(exp)
+        for h in expr.atoms(HyperbolicFunction)})
+
+
+@cacheit
+def _acosh_table():
+    return {
+        I: log(I*(1 + sqrt(2))),
+        -I: log(-I*(1 + sqrt(2))),
+        S.Half: pi/3,
+        Rational(-1, 2): pi*Rational(2, 3),
+        sqrt(2)/2: pi/4,
+        -sqrt(2)/2: pi*Rational(3, 4),
+        1/sqrt(2): pi/4,
+        -1/sqrt(2): pi*Rational(3, 4),
+        sqrt(3)/2: pi/6,
+        -sqrt(3)/2: pi*Rational(5, 6),
+        (sqrt(3) - 1)/sqrt(2**3): pi*Rational(5, 12),
+        -(sqrt(3) - 1)/sqrt(2**3): pi*Rational(7, 12),
+        sqrt(2 + sqrt(2))/2: pi/8,
+        -sqrt(2 + sqrt(2))/2: pi*Rational(7, 8),
+        sqrt(2 - sqrt(2))/2: pi*Rational(3, 8),
+        -sqrt(2 - sqrt(2))/2: pi*Rational(5, 8),
+        (1 + sqrt(3))/(2*sqrt(2)): pi/12,
+        -(1 + sqrt(3))/(2*sqrt(2)): pi*Rational(11, 12),
+        (sqrt(5) + 1)/4: pi/5,
+        -(sqrt(5) + 1)/4: pi*Rational(4, 5)
+    }
+
+
+@cacheit
+def _acsch_table():
+    return {
+            I: -pi / 2,
+            I*(sqrt(2) + sqrt(6)): -pi / 12,
+            I*(1 + sqrt(5)): -pi / 10,
+            I*2 / sqrt(2 - sqrt(2)): -pi / 8,
+            I*2: -pi / 6,
+            I*sqrt(2 + 2/sqrt(5)): -pi / 5,
+            I*sqrt(2): -pi / 4,
+            I*(sqrt(5)-1): -3*pi / 10,
+            I*2 / sqrt(3): -pi / 3,
+            I*2 / sqrt(2 + sqrt(2)): -3*pi / 8,
+            I*sqrt(2 - 2/sqrt(5)): -2*pi / 5,
+            I*(sqrt(6) - sqrt(2)): -5*pi / 12,
+            S(2): -I*log((1+sqrt(5))/2),
+        }
+
+
+@cacheit
+def _asech_table():
+        return {
+            I: - (pi*I / 2) + log(1 + sqrt(2)),
+            -I: (pi*I / 2) + log(1 + sqrt(2)),
+            (sqrt(6) - sqrt(2)): pi / 12,
+            (sqrt(2) - sqrt(6)): 11*pi / 12,
+            sqrt(2 - 2/sqrt(5)): pi / 10,
+            -sqrt(2 - 2/sqrt(5)): 9*pi / 10,
+            2 / sqrt(2 + sqrt(2)): pi / 8,
+            -2 / sqrt(2 + sqrt(2)): 7*pi / 8,
+            2 / sqrt(3): pi / 6,
+            -2 / sqrt(3): 5*pi / 6,
+            (sqrt(5) - 1): pi / 5,
+            (1 - sqrt(5)): 4*pi / 5,
+            sqrt(2): pi / 4,
+            -sqrt(2): 3*pi / 4,
+            sqrt(2 + 2/sqrt(5)): 3*pi / 10,
+            -sqrt(2 + 2/sqrt(5)): 7*pi / 10,
+            S(2): pi / 3,
+            -S(2): 2*pi / 3,
+            sqrt(2*(2 + sqrt(2))): 3*pi / 8,
+            -sqrt(2*(2 + sqrt(2))): 5*pi / 8,
+            (1 + sqrt(5)): 2*pi / 5,
+            (-1 - sqrt(5)): 3*pi / 5,
+            (sqrt(6) + sqrt(2)): 5*pi / 12,
+            (-sqrt(6) - sqrt(2)): 7*pi / 12,
+            I*S.Infinity: -pi*I / 2,
+            I*S.NegativeInfinity: pi*I / 2,
+        }
+
+###############################################################################
+########################### HYPERBOLIC FUNCTIONS ##############################
+###############################################################################
+
+
+class HyperbolicFunction(Function):
+    """
+    Base class for hyperbolic functions.
+
+    See Also
+    ========
+
+    sinh, cosh, tanh, coth
+    """
+
+    unbranched = True
+
+
+def _peeloff_ipi(arg):
+    r"""
+    Split ARG into two parts, a "rest" and a multiple of $I\pi$.
+    This assumes ARG to be an ``Add``.
+    The multiple of $I\pi$ returned in the second position is always a ``Rational``.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.hyperbolic import _peeloff_ipi as peel
+    >>> from sympy import pi, I
+    >>> from sympy.abc import x, y
+    >>> peel(x + I*pi/2)
+    (x, 1/2)
+    >>> peel(x + I*2*pi/3 + I*pi*y)
+    (x + I*pi*y + I*pi/6, 1/2)
+    """
+    ipi = pi*I
+    for a in Add.make_args(arg):
+        if a == ipi:
+            K = S.One
+            break
+        elif a.is_Mul:
+            K, p = a.as_two_terms()
+            if p == ipi and K.is_Rational:
+                break
+    else:
+        return arg, S.Zero
+
+    m1 = (K % S.Half)
+    m2 = K - m1
+    return arg - m2*ipi, m2
+
+
+class sinh(HyperbolicFunction):
+    r"""
+    ``sinh(x)`` is the hyperbolic sine of ``x``.
+
+    The hyperbolic sine function is $\frac{e^x - e^{-x}}{2}$.
+
+    Examples
+    ========
+
+    >>> from sympy import sinh
+    >>> from sympy.abc import x
+    >>> sinh(x)
+    sinh(x)
+
+    See Also
+    ========
+
+    cosh, tanh, asinh
+    """
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return cosh(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return asinh
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.NegativeInfinity
+            elif arg.is_zero:
+                return S.Zero
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return I * sin(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    m = m*pi*I
+                    return sinh(m)*cosh(x) + cosh(m)*sinh(x)
+
+            if arg.is_zero:
+                return S.Zero
+
+            if arg.func == asinh:
+                return arg.args[0]
+
+            if arg.func == acosh:
+                x = arg.args[0]
+                return sqrt(x - 1) * sqrt(x + 1)
+
+            if arg.func == atanh:
+                x = arg.args[0]
+                return x/sqrt(1 - x**2)
+
+            if arg.func == acoth:
+                x = arg.args[0]
+                return 1/(sqrt(x - 1) * sqrt(x + 1))
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        """
+        Returns the next term in the Taylor series expansion.
+        """
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            if len(previous_terms) > 2:
+                p = previous_terms[-2]
+                return p * x**2 / (n*(n - 1))
+            else:
+                return x**(n) / factorial(n)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns this function as a complex coordinate.
+        """
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+        return (sinh(re)*cos(im), cosh(re)*sin(im))
+
+    def _eval_expand_complex(self, deep=True, **hints):
+        re_part, im_part = self.as_real_imag(deep=deep, **hints)
+        return re_part + im_part*I
+
+    def _eval_expand_trig(self, deep=True, **hints):
+        if deep:
+            arg = self.args[0].expand(deep, **hints)
+        else:
+            arg = self.args[0]
+        x = None
+        if arg.is_Add: # TODO, implement more if deep stuff here
+            x, y = arg.as_two_terms()
+        else:
+            coeff, terms = arg.as_coeff_Mul(rational=True)
+            if coeff is not S.One and coeff.is_Integer and terms is not S.One:
+                x = terms
+                y = (coeff - 1)*x
+        if x is not None:
+            return (sinh(x)*cosh(y) + sinh(y)*cosh(x)).expand(trig=True)
+        return sinh(arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        return (exp(arg) - exp(-arg)) / 2
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return (exp(arg) - exp(-arg)) / 2
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        return -I * sin(I * arg)
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        return -I / csc(I * arg)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return -I*cosh(arg + pi*I/2)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        tanh_half = tanh(S.Half*arg)
+        return 2*tanh_half/(1 - tanh_half**2)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        coth_half = coth(S.Half*arg)
+        return 2*coth_half/(coth_half**2 - 1)
+
+    def _eval_rewrite_as_csch(self, arg, **kwargs):
+        return 1 / csch(arg)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if cdir.is_negative else '+')
+        if arg0.is_zero:
+            return arg
+        elif arg0.is_finite:
+            return self.func(arg0)
+        else:
+            return self
+
+    def _eval_is_real(self):
+        arg = self.args[0]
+        if arg.is_real:
+            return True
+
+        # if `im` is of the form n*pi
+        # else, check if it is a number
+        re, im = arg.as_real_imag()
+        return (im%pi).is_zero
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+        return arg.is_finite
+
+    def _eval_is_zero(self):
+        rest, ipi_mult = _peeloff_ipi(self.args[0])
+        if rest.is_zero:
+            return ipi_mult.is_integer
+
+
+class cosh(HyperbolicFunction):
+    r"""
+    ``cosh(x)`` is the hyperbolic cosine of ``x``.
+
+    The hyperbolic cosine function is $\frac{e^x + e^{-x}}{2}$.
+
+    Examples
+    ========
+
+    >>> from sympy import cosh
+    >>> from sympy.abc import x
+    >>> cosh(x)
+    cosh(x)
+
+    See Also
+    ========
+
+    sinh, tanh, acosh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return sinh(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.functions.elementary.trigonometric import cos
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Infinity
+            elif arg.is_zero:
+                return S.One
+            elif arg.is_negative:
+                return cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return cos(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    m = m*pi*I
+                    return cosh(m)*cosh(x) + sinh(m)*sinh(x)
+
+            if arg.is_zero:
+                return S.One
+
+            if arg.func == asinh:
+                return sqrt(1 + arg.args[0]**2)
+
+            if arg.func == acosh:
+                return arg.args[0]
+
+            if arg.func == atanh:
+                return 1/sqrt(1 - arg.args[0]**2)
+
+            if arg.func == acoth:
+                x = arg.args[0]
+                return x/(sqrt(x - 1) * sqrt(x + 1))
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            if len(previous_terms) > 2:
+                p = previous_terms[-2]
+                return p * x**2 / (n*(n - 1))
+            else:
+                return x**(n)/factorial(n)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+
+        return (cosh(re)*cos(im), sinh(re)*sin(im))
+
+    def _eval_expand_complex(self, deep=True, **hints):
+        re_part, im_part = self.as_real_imag(deep=deep, **hints)
+        return re_part + im_part*I
+
+    def _eval_expand_trig(self, deep=True, **hints):
+        if deep:
+            arg = self.args[0].expand(deep, **hints)
+        else:
+            arg = self.args[0]
+        x = None
+        if arg.is_Add: # TODO, implement more if deep stuff here
+            x, y = arg.as_two_terms()
+        else:
+            coeff, terms = arg.as_coeff_Mul(rational=True)
+            if coeff is not S.One and coeff.is_Integer and terms is not S.One:
+                x = terms
+                y = (coeff - 1)*x
+        if x is not None:
+            return (cosh(x)*cosh(y) + sinh(x)*sinh(y)).expand(trig=True)
+        return cosh(arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        return (exp(arg) + exp(-arg)) / 2
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return (exp(arg) + exp(-arg)) / 2
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        return cos(I * arg)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        return 1 / sec(I * arg)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return -I*sinh(arg + pi*I/2)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        tanh_half = tanh(S.Half*arg)**2
+        return (1 + tanh_half)/(1 - tanh_half)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        coth_half = coth(S.Half*arg)**2
+        return (coth_half + 1)/(coth_half - 1)
+
+    def _eval_rewrite_as_sech(self, arg, **kwargs):
+        return 1 / sech(arg)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if cdir.is_negative else '+')
+        if arg0.is_zero:
+            return S.One
+        elif arg0.is_finite:
+            return self.func(arg0)
+        else:
+            return self
+
+    def _eval_is_real(self):
+        arg = self.args[0]
+
+        # `cosh(x)` is real for real OR purely imaginary `x`
+        if arg.is_real or arg.is_imaginary:
+            return True
+
+        # cosh(a+ib) = cos(b)*cosh(a) + i*sin(b)*sinh(a)
+        # the imaginary part can be an expression like n*pi
+        # if not, check if the imaginary part is a number
+        re, im = arg.as_real_imag()
+        return (im%pi).is_zero
+
+    def _eval_is_positive(self):
+        # cosh(x+I*y) = cos(y)*cosh(x) + I*sin(y)*sinh(x)
+        # cosh(z) is positive iff it is real and the real part is positive.
+        # So we need sin(y)*sinh(x) = 0 which gives x=0 or y=n*pi
+        # Case 1 (y=n*pi): cosh(z) = (-1)**n * cosh(x) -> positive for n even
+        # Case 2 (x=0): cosh(z) = cos(y) -> positive when cos(y) is positive
+        z = self.args[0]
+
+        x, y = z.as_real_imag()
+        ymod = y % (2*pi)
+
+        yzero = ymod.is_zero
+        # shortcut if ymod is zero
+        if yzero:
+            return True
+
+        xzero = x.is_zero
+        # shortcut x is not zero
+        if xzero is False:
+            return yzero
+
+        return fuzzy_or([
+                # Case 1:
+                yzero,
+                # Case 2:
+                fuzzy_and([
+                    xzero,
+                    fuzzy_or([ymod < pi/2, ymod > 3*pi/2])
+                ])
+            ])
+
+
+    def _eval_is_nonnegative(self):
+        z = self.args[0]
+
+        x, y = z.as_real_imag()
+        ymod = y % (2*pi)
+
+        yzero = ymod.is_zero
+        # shortcut if ymod is zero
+        if yzero:
+            return True
+
+        xzero = x.is_zero
+        # shortcut x is not zero
+        if xzero is False:
+            return yzero
+
+        return fuzzy_or([
+                # Case 1:
+                yzero,
+                # Case 2:
+                fuzzy_and([
+                    xzero,
+                    fuzzy_or([ymod <= pi/2, ymod >= 3*pi/2])
+                ])
+            ])
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+        return arg.is_finite
+
+    def _eval_is_zero(self):
+        rest, ipi_mult = _peeloff_ipi(self.args[0])
+        if ipi_mult and rest.is_zero:
+            return (ipi_mult - S.Half).is_integer
+
+
+class tanh(HyperbolicFunction):
+    r"""
+    ``tanh(x)`` is the hyperbolic tangent of ``x``.
+
+    The hyperbolic tangent function is $\frac{\sinh(x)}{\cosh(x)}$.
+
+    Examples
+    ========
+
+    >>> from sympy import tanh
+    >>> from sympy.abc import x
+    >>> tanh(x)
+    tanh(x)
+
+    See Also
+    ========
+
+    sinh, cosh, atanh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return S.One - tanh(self.args[0])**2
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return atanh
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.One
+            elif arg is S.NegativeInfinity:
+                return S.NegativeOne
+            elif arg.is_zero:
+                return S.Zero
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                if i_coeff.could_extract_minus_sign():
+                    return -I * tan(-i_coeff)
+                return I * tan(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    tanhm = tanh(m*pi*I)
+                    if tanhm is S.ComplexInfinity:
+                        return coth(x)
+                    else: # tanhm == 0
+                        return tanh(x)
+
+            if arg.is_zero:
+                return S.Zero
+
+            if arg.func == asinh:
+                x = arg.args[0]
+                return x/sqrt(1 + x**2)
+
+            if arg.func == acosh:
+                x = arg.args[0]
+                return sqrt(x - 1) * sqrt(x + 1) / x
+
+            if arg.func == atanh:
+                return arg.args[0]
+
+            if arg.func == acoth:
+                return 1/arg.args[0]
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            a = 2**(n + 1)
+
+            B = bernoulli(n + 1)
+            F = factorial(n + 1)
+
+            return a*(a - 1) * B/F * x**n
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+        denom = sinh(re)**2 + cos(im)**2
+        return (sinh(re)*cosh(re)/denom, sin(im)*cos(im)/denom)
+
+    def _eval_expand_trig(self, **hints):
+        arg = self.args[0]
+        if arg.is_Add:
+            n = len(arg.args)
+            TX = [tanh(x, evaluate=False)._eval_expand_trig()
+                for x in arg.args]
+            p = [0, 0]  # [den, num]
+            for i in range(n + 1):
+                p[i % 2] += symmetric_poly(i, TX)
+            return p[1]/p[0]
+        elif arg.is_Mul:
+            coeff, terms = arg.as_coeff_Mul()
+            if coeff.is_Integer and coeff > 1:
+                T = tanh(terms)
+                n = [nC(range(coeff), k)*T**k for k in range(1, coeff + 1, 2)]
+                d = [nC(range(coeff), k)*T**k for k in range(0, coeff + 1, 2)]
+                return Add(*n)/Add(*d)
+        return tanh(arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp - neg_exp)/(pos_exp + neg_exp)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp - neg_exp)/(pos_exp + neg_exp)
+
+    def _eval_rewrite_as_tan(self, arg, **kwargs):
+        return -I * tan(I * arg)
+
+    def _eval_rewrite_as_cot(self, arg, **kwargs):
+        return -I / cot(I * arg)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return I*sinh(arg)/sinh(pi*I/2 - arg)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return I*cosh(pi*I/2 - arg)/cosh(arg)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        return 1/coth(arg)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.series.order import Order
+        arg = self.args[0].as_leading_term(x)
+
+        if x in arg.free_symbols and Order(1, x).contains(arg):
+            return arg
+        else:
+            return self.func(arg)
+
+    def _eval_is_real(self):
+        arg = self.args[0]
+        if arg.is_real:
+            return True
+
+        re, im = arg.as_real_imag()
+
+        # if denom = 0, tanh(arg) = zoo
+        if re == 0 and im % pi == pi/2:
+            return None
+
+        # check if im is of the form n*pi/2 to make sin(2*im) = 0
+        # if not, im could be a number, return False in that case
+        return (im % (pi/2)).is_zero
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+
+        re, im = arg.as_real_imag()
+        denom = cos(im)**2 + sinh(re)**2
+        if denom == 0:
+            return False
+        elif denom.is_number:
+            return True
+        if arg.is_extended_real:
+            return True
+
+    def _eval_is_zero(self):
+        arg = self.args[0]
+        if arg.is_zero:
+            return True
+
+
+class coth(HyperbolicFunction):
+    r"""
+    ``coth(x)`` is the hyperbolic cotangent of ``x``.
+
+    The hyperbolic cotangent function is $\frac{\cosh(x)}{\sinh(x)}$.
+
+    Examples
+    ========
+
+    >>> from sympy import coth
+    >>> from sympy.abc import x
+    >>> coth(x)
+    coth(x)
+
+    See Also
+    ========
+
+    sinh, cosh, acoth
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return -1/sinh(self.args[0])**2
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return acoth
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.One
+            elif arg is S.NegativeInfinity:
+                return S.NegativeOne
+            elif arg.is_zero:
+                return S.ComplexInfinity
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                if i_coeff.could_extract_minus_sign():
+                    return I * cot(-i_coeff)
+                return -I * cot(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    cothm = coth(m*pi*I)
+                    if cothm is S.ComplexInfinity:
+                        return coth(x)
+                    else: # cothm == 0
+                        return tanh(x)
+
+            if arg.is_zero:
+                return S.ComplexInfinity
+
+            if arg.func == asinh:
+                x = arg.args[0]
+                return sqrt(1 + x**2)/x
+
+            if arg.func == acosh:
+                x = arg.args[0]
+                return x/(sqrt(x - 1) * sqrt(x + 1))
+
+            if arg.func == atanh:
+                return 1/arg.args[0]
+
+            if arg.func == acoth:
+                return arg.args[0]
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return 1 / sympify(x)
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            B = bernoulli(n + 1)
+            F = factorial(n + 1)
+
+            return 2**(n + 1) * B/F * x**n
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        from sympy.functions.elementary.trigonometric import (cos, sin)
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+        denom = sinh(re)**2 + sin(im)**2
+        return (sinh(re)*cosh(re)/denom, -sin(im)*cos(im)/denom)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp + neg_exp)/(pos_exp - neg_exp)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp + neg_exp)/(pos_exp - neg_exp)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return -I*sinh(pi*I/2 - arg)/sinh(arg)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return -I*cosh(arg)/cosh(pi*I/2 - arg)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        return 1/tanh(arg)
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.series.order import Order
+        arg = self.args[0].as_leading_term(x)
+
+        if x in arg.free_symbols and Order(1, x).contains(arg):
+            return 1/arg
+        else:
+            return self.func(arg)
+
+    def _eval_expand_trig(self, **hints):
+        arg = self.args[0]
+        if arg.is_Add:
+            CX = [coth(x, evaluate=False)._eval_expand_trig() for x in arg.args]
+            p = [[], []]
+            n = len(arg.args)
+            for i in range(n, -1, -1):
+                p[(n - i) % 2].append(symmetric_poly(i, CX))
+            return Add(*p[0])/Add(*p[1])
+        elif arg.is_Mul:
+            coeff, x = arg.as_coeff_Mul(rational=True)
+            if coeff.is_Integer and coeff > 1:
+                c = coth(x, evaluate=False)
+                p = [[], []]
+                for i in range(coeff, -1, -1):
+                    p[(coeff - i) % 2].append(binomial(coeff, i)*c**i)
+                return Add(*p[0])/Add(*p[1])
+        return coth(arg)
+
+
+class ReciprocalHyperbolicFunction(HyperbolicFunction):
+    """Base class for reciprocal functions of hyperbolic functions. """
+
+    #To be defined in class
+    _reciprocal_of = None
+    _is_even: FuzzyBool = None
+    _is_odd: FuzzyBool = None
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.could_extract_minus_sign():
+            if cls._is_even:
+                return cls(-arg)
+            if cls._is_odd:
+                return -cls(-arg)
+
+        t = cls._reciprocal_of.eval(arg)
+        if hasattr(arg, 'inverse') and arg.inverse() == cls:
+            return arg.args[0]
+        return 1/t if t is not None else t
+
+    def _call_reciprocal(self, method_name, *args, **kwargs):
+        # Calls method_name on _reciprocal_of
+        o = self._reciprocal_of(self.args[0])
+        return getattr(o, method_name)(*args, **kwargs)
+
+    def _calculate_reciprocal(self, method_name, *args, **kwargs):
+        # If calling method_name on _reciprocal_of returns a value != None
+        # then return the reciprocal of that value
+        t = self._call_reciprocal(method_name, *args, **kwargs)
+        return 1/t if t is not None else t
+
+    def _rewrite_reciprocal(self, method_name, arg):
+        # Special handling for rewrite functions. If reciprocal rewrite returns
+        # unmodified expression, then return None
+        t = self._call_reciprocal(method_name, arg)
+        if t is not None and t != self._reciprocal_of(arg):
+            return 1/t
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_exp", arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_tractable", arg)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_tanh", arg)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_coth", arg)
+
+    def as_real_imag(self, deep = True, **hints):
+        return (1 / self._reciprocal_of(self.args[0])).as_real_imag(deep, **hints)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_expand_complex(self, deep=True, **hints):
+        re_part, im_part = self.as_real_imag(deep=True, **hints)
+        return re_part + I*im_part
+
+    def _eval_expand_trig(self, **hints):
+        return self._calculate_reciprocal("_eval_expand_trig", **hints)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        return (1/self._reciprocal_of(self.args[0]))._eval_as_leading_term(x)
+
+    def _eval_is_extended_real(self):
+        return self._reciprocal_of(self.args[0]).is_extended_real
+
+    def _eval_is_finite(self):
+        return (1/self._reciprocal_of(self.args[0])).is_finite
+
+
+class csch(ReciprocalHyperbolicFunction):
+    r"""
+    ``csch(x)`` is the hyperbolic cosecant of ``x``.
+
+    The hyperbolic cosecant function is $\frac{2}{e^x - e^{-x}}$
+
+    Examples
+    ========
+
+    >>> from sympy import csch
+    >>> from sympy.abc import x
+    >>> csch(x)
+    csch(x)
+
+    See Also
+    ========
+
+    sinh, cosh, tanh, sech, asinh, acosh
+    """
+
+    _reciprocal_of = sinh
+    _is_odd = True
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function
+        """
+        if argindex == 1:
+            return -coth(self.args[0]) * csch(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        """
+        Returns the next term in the Taylor series expansion
+        """
+        if n == 0:
+            return 1/sympify(x)
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            B = bernoulli(n + 1)
+            F = factorial(n + 1)
+
+            return 2 * (1 - 2**n) * B/F * x**n
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        return I / sin(I * arg)
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        return I * csc(I * arg)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return I / cosh(arg + I * pi / 2)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return 1 / sinh(arg)
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+
+class sech(ReciprocalHyperbolicFunction):
+    r"""
+    ``sech(x)`` is the hyperbolic secant of ``x``.
+
+    The hyperbolic secant function is $\frac{2}{e^x + e^{-x}}$
+
+    Examples
+    ========
+
+    >>> from sympy import sech
+    >>> from sympy.abc import x
+    >>> sech(x)
+    sech(x)
+
+    See Also
+    ========
+
+    sinh, cosh, tanh, coth, csch, asinh, acosh
+    """
+
+    _reciprocal_of = cosh
+    _is_even = True
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return - tanh(self.args[0])*sech(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            return euler(n) / factorial(n) * x**(n)
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        return 1 / cos(I * arg)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        return sec(I * arg)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return I / sinh(arg + I * pi /2)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return 1 / cosh(arg)
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return True
+
+
+###############################################################################
+############################# HYPERBOLIC INVERSES #############################
+###############################################################################
+
+class InverseHyperbolicFunction(Function):
+    """Base class for inverse hyperbolic functions."""
+
+    pass
+
+
+class asinh(InverseHyperbolicFunction):
+    """
+    ``asinh(x)`` is the inverse hyperbolic sine of ``x``.
+
+    The inverse hyperbolic sine function.
+
+    Examples
+    ========
+
+    >>> from sympy import asinh
+    >>> from sympy.abc import x
+    >>> asinh(x).diff(x)
+    1/sqrt(x**2 + 1)
+    >>> asinh(1)
+    log(1 + sqrt(2))
+
+    See Also
+    ========
+
+    acosh, atanh, sinh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/sqrt(self.args[0]**2 + 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.NegativeInfinity
+            elif arg.is_zero:
+                return S.Zero
+            elif arg is S.One:
+                return log(sqrt(2) + 1)
+            elif arg is S.NegativeOne:
+                return log(sqrt(2) - 1)
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.ComplexInfinity
+
+            if arg.is_zero:
+                return S.Zero
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return I * asin(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+        if isinstance(arg, sinh) and arg.args[0].is_number:
+            z = arg.args[0]
+            if z.is_real:
+                return z
+            r, i = match_real_imag(z)
+            if r is not None and i is not None:
+                f = floor((i + pi/2)/pi)
+                m = z - I*pi*f
+                even = f.is_even
+                if even is True:
+                    return m
+                elif even is False:
+                    return -m
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) >= 2 and n > 2:
+                p = previous_terms[-2]
+                return -p * (n - 2)**2/(n*(n - 1)) * x**2
+            else:
+                k = (n - 1) // 2
+                R = RisingFactorial(S.Half, k)
+                F = factorial(k)
+                return S.NegativeOne**k * R / F * x**n / n
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # asinh
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0.is_zero:
+            return arg.as_leading_term(x)
+        # Handling branch points
+        if x0 in (-I, I, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-I*oo, -I) U (I, I*oo)
+        if (1 + x0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(x0).is_negative:
+                    return -self.func(x0) - I*pi
+            elif re(ndir).is_negative:
+                if im(x0).is_positive:
+                    return -self.func(x0) + I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # asinh
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (I, -I):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-I*oo, -I) U (I, I*oo)
+        if (1 + arg0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(arg0).is_negative:
+                    return -res - I*pi
+            elif re(ndir).is_negative:
+                if im(arg0).is_positive:
+                    return -res + I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return log(x + sqrt(x**2 + 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        return atanh(x/sqrt(1 + x**2))
+
+    def _eval_rewrite_as_acosh(self, x, **kwargs):
+        ix = I*x
+        return I*(sqrt(1 - ix)/sqrt(ix - 1) * acosh(ix) - pi/2)
+
+    def _eval_rewrite_as_asin(self, x, **kwargs):
+        return -I * asin(I * x)
+
+    def _eval_rewrite_as_acos(self, x, **kwargs):
+        return I * acos(I * x) - I*pi/2
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return sinh
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+
+class acosh(InverseHyperbolicFunction):
+    """
+    ``acosh(x)`` is the inverse hyperbolic cosine of ``x``.
+
+    The inverse hyperbolic cosine function.
+
+    Examples
+    ========
+
+    >>> from sympy import acosh
+    >>> from sympy.abc import x
+    >>> acosh(x).diff(x)
+    1/(sqrt(x - 1)*sqrt(x + 1))
+    >>> acosh(1)
+    0
+
+    See Also
+    ========
+
+    asinh, atanh, cosh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            arg = self.args[0]
+            return 1/(sqrt(arg - 1)*sqrt(arg + 1))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Infinity
+            elif arg.is_zero:
+                return pi*I / 2
+            elif arg is S.One:
+                return S.Zero
+            elif arg is S.NegativeOne:
+                return pi*I
+
+        if arg.is_number:
+            cst_table = _acosh_table()
+
+            if arg in cst_table:
+                if arg.is_extended_real:
+                    return cst_table[arg]*I
+                return cst_table[arg]
+
+        if arg is S.ComplexInfinity:
+            return S.ComplexInfinity
+        if arg == I*S.Infinity:
+            return S.Infinity + I*pi/2
+        if arg == -I*S.Infinity:
+            return S.Infinity - I*pi/2
+
+        if arg.is_zero:
+            return pi*I*S.Half
+
+        if isinstance(arg, cosh) and arg.args[0].is_number:
+            z = arg.args[0]
+            if z.is_real:
+                return Abs(z)
+            r, i = match_real_imag(z)
+            if r is not None and i is not None:
+                f = floor(i/pi)
+                m = z - I*pi*f
+                even = f.is_even
+                if even is True:
+                    if r.is_nonnegative:
+                        return m
+                    elif r.is_negative:
+                        return -m
+                elif even is False:
+                    m -= I*pi
+                    if r.is_nonpositive:
+                        return -m
+                    elif r.is_positive:
+                        return m
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return I*pi/2
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) >= 2 and n > 2:
+                p = previous_terms[-2]
+                return p * (n - 2)**2/(n*(n - 1)) * x**2
+            else:
+                k = (n - 1) // 2
+                R = RisingFactorial(S.Half, k)
+                F = factorial(k)
+                return -R / F * I * x**n / n
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # acosh
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        # Handling branch points
+        if x0 in (-S.One, S.Zero, S.One, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-oo, 1)
+        if (x0 - 1).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if (x0 + 1).is_negative:
+                    return self.func(x0) - 2*I*pi
+                return -self.func(x0)
+            elif not im(ndir).is_positive:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acosh
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (S.One, S.NegativeOne):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-oo, 1)
+        if (arg0 - 1).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if (arg0 + 1).is_negative:
+                    return res - 2*I*pi
+                return -res
+            elif not im(ndir).is_positive:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return log(x + sqrt(x + 1) * sqrt(x - 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_acos(self, x, **kwargs):
+        return sqrt(x - 1)/sqrt(1 - x) * acos(x)
+
+    def _eval_rewrite_as_asin(self, x, **kwargs):
+        return sqrt(x - 1)/sqrt(1 - x) * (pi/2 - asin(x))
+
+    def _eval_rewrite_as_asinh(self, x, **kwargs):
+        return sqrt(x - 1)/sqrt(1 - x) * (pi/2 + I*asinh(I*x))
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        sxm1 = sqrt(x - 1)
+        s1mx = sqrt(1 - x)
+        sx2m1 = sqrt(x**2 - 1)
+        return (pi/2*sxm1/s1mx*(1 - x * sqrt(1/x**2)) +
+                sxm1*sqrt(x + 1)/sx2m1 * atanh(sx2m1/x))
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return cosh
+
+    def _eval_is_zero(self):
+        if (self.args[0] - 1).is_zero:
+            return True
+
+
+class atanh(InverseHyperbolicFunction):
+    """
+    ``atanh(x)`` is the inverse hyperbolic tangent of ``x``.
+
+    The inverse hyperbolic tangent function.
+
+    Examples
+    ========
+
+    >>> from sympy import atanh
+    >>> from sympy.abc import x
+    >>> atanh(x).diff(x)
+    1/(1 - x**2)
+
+    See Also
+    ========
+
+    asinh, acosh, tanh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/(1 - self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg.is_zero:
+                return S.Zero
+            elif arg is S.One:
+                return S.Infinity
+            elif arg is S.NegativeOne:
+                return S.NegativeInfinity
+            elif arg is S.Infinity:
+                return -I * atan(arg)
+            elif arg is S.NegativeInfinity:
+                return I * atan(-arg)
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                from sympy.calculus.accumulationbounds import AccumBounds
+                return I*AccumBounds(-pi/2, pi/2)
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return I * atan(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+        if arg.is_zero:
+            return S.Zero
+
+        if isinstance(arg, tanh) and arg.args[0].is_number:
+            z = arg.args[0]
+            if z.is_real:
+                return z
+            r, i = match_real_imag(z)
+            if r is not None and i is not None:
+                f = floor(2*i/pi)
+                even = f.is_even
+                m = z - I*f*pi/2
+                if even is True:
+                    return m
+                elif even is False:
+                    return m - I*pi/2
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            return x**n / n
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # atanh
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0.is_zero:
+            return arg.as_leading_term(x)
+        # Handling branch points
+        if x0 in (-S.One, S.One, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-oo, -1] U [1, oo)
+        if (1 - x0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if x0.is_negative:
+                    return self.func(x0) - I*pi
+            elif im(ndir).is_positive:
+                if x0.is_positive:
+                    return self.func(x0) + I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # atanh
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (S.One, S.NegativeOne):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-oo, -1] U [1, oo)
+        if (1 - arg0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if arg0.is_negative:
+                    return res - I*pi
+            elif im(ndir).is_positive:
+                if arg0.is_positive:
+                    return res + I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return (log(1 + x) - log(1 - x)) / 2
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_asinh(self, x, **kwargs):
+        f = sqrt(1/(x**2 - 1))
+        return (pi*x/(2*sqrt(-x**2)) -
+                sqrt(-x)*sqrt(1 - x**2)/sqrt(x)*f*asinh(f))
+
+    def _eval_is_zero(self):
+        if self.args[0].is_zero:
+            return True
+
+    def _eval_is_imaginary(self):
+        return self.args[0].is_imaginary
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return tanh
+
+
+class acoth(InverseHyperbolicFunction):
+    """
+    ``acoth(x)`` is the inverse hyperbolic cotangent of ``x``.
+
+    The inverse hyperbolic cotangent function.
+
+    Examples
+    ========
+
+    >>> from sympy import acoth
+    >>> from sympy.abc import x
+    >>> acoth(x).diff(x)
+    1/(1 - x**2)
+
+    See Also
+    ========
+
+    asinh, acosh, coth
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/(1 - self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Zero
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+            elif arg.is_zero:
+                return pi*I / 2
+            elif arg is S.One:
+                return S.Infinity
+            elif arg is S.NegativeOne:
+                return S.NegativeInfinity
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.Zero
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return -I * acot(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+        if arg.is_zero:
+            return pi*I*S.Half
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return -I*pi/2
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            return x**n / n
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # acoth
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0 is S.ComplexInfinity:
+            return (1/arg).as_leading_term(x)
+        # Handling branch points
+        if x0 in (-S.One, S.One, S.Zero):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts [-1, 1]
+        if x0.is_real and (1 - x0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if x0.is_positive:
+                    return self.func(x0) + I*pi
+            elif im(ndir).is_positive:
+                if x0.is_negative:
+                    return self.func(x0) - I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acoth
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (S.One, S.NegativeOne):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts [-1, 1]
+        if arg0.is_real and (1 - arg0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if arg0.is_positive:
+                    return res + I*pi
+            elif im(ndir).is_positive:
+                if arg0.is_negative:
+                    return res - I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return (log(1 + 1/x) - log(1 - 1/x)) / 2
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        return atanh(1/x)
+
+    def _eval_rewrite_as_asinh(self, x, **kwargs):
+        return (pi*I/2*(sqrt((x - 1)/x)*sqrt(x/(x - 1)) - sqrt(1 + 1/x)*sqrt(x/(x + 1))) +
+                x*sqrt(1/x**2)*asinh(sqrt(1/(x**2 - 1))))
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return coth
+
+
+class asech(InverseHyperbolicFunction):
+    """
+    ``asech(x)`` is the inverse hyperbolic secant of ``x``.
+
+    The inverse hyperbolic secant function.
+
+    Examples
+    ========
+
+    >>> from sympy import asech, sqrt, S
+    >>> from sympy.abc import x
+    >>> asech(x).diff(x)
+    -1/(x*sqrt(1 - x**2))
+    >>> asech(1).diff(x)
+    0
+    >>> asech(1)
+    0
+    >>> asech(S(2))
+    I*pi/3
+    >>> asech(-sqrt(2))
+    3*I*pi/4
+    >>> asech((sqrt(6) - sqrt(2)))
+    I*pi/12
+
+    See Also
+    ========
+
+    asinh, atanh, cosh, acoth
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    .. [2] https://dlmf.nist.gov/4.37
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcSech/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            z = self.args[0]
+            return -1/(z*sqrt(1 - z**2))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return pi*I / 2
+            elif arg is S.NegativeInfinity:
+                return pi*I / 2
+            elif arg.is_zero:
+                return S.Infinity
+            elif arg is S.One:
+                return S.Zero
+            elif arg is S.NegativeOne:
+                return pi*I
+
+        if arg.is_number:
+            cst_table = _asech_table()
+
+            if arg in cst_table:
+                if arg.is_extended_real:
+                    return cst_table[arg]*I
+                return cst_table[arg]
+
+        if arg is S.ComplexInfinity:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            return I*AccumBounds(-pi/2, pi/2)
+
+        if arg.is_zero:
+            return S.Infinity
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return log(2 / x)
+        elif n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 2 and n > 2:
+                p = previous_terms[-2]
+                return p * ((n - 1)*(n-2)) * x**2/(4 * (n//2)**2)
+            else:
+                k = n // 2
+                R = RisingFactorial(S.Half, k) * n
+                F = factorial(k) * n // 2 * n // 2
+                return -1 * R / F * x**n / 4
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # asech
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        # Handling branch points
+        if x0 in (-S.One, S.Zero, S.One, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-oo, 0] U (1, oo)
+        if x0.is_negative or (1 - x0).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_positive:
+                if x0.is_positive or (x0 + 1).is_negative:
+                    return -self.func(x0)
+                return self.func(x0) - 2*I*pi
+            elif not im(ndir).is_negative:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # asech
+        from sympy.series.order import O
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 is S.One:
+            t = Dummy('t', positive=True)
+            ser = asech(S.One - t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.One - self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        if arg0 is S.NegativeOne:
+            t = Dummy('t', positive=True)
+            ser = asech(S.NegativeOne + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.One + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else I*pi + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-oo, 0] U (1, oo)
+        if arg0.is_negative or (1 - arg0).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_positive:
+                if arg0.is_positive or (arg0 + 1).is_negative:
+                    return -res
+                return res - 2*I*pi
+            elif not im(ndir).is_negative:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return sech
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return log(1/arg + sqrt(1/arg - 1) * sqrt(1/arg + 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_acosh(self, arg, **kwargs):
+        return acosh(1/arg)
+
+    def _eval_rewrite_as_asinh(self, arg, **kwargs):
+        return sqrt(1/arg - 1)/sqrt(1 - 1/arg)*(I*asinh(I/arg)
+                                                + pi*S.Half)
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        return (I*pi*(1 - sqrt(x)*sqrt(1/x) - I/2*sqrt(-x)/sqrt(x) - I/2*sqrt(x**2)/sqrt(-x**2))
+                + sqrt(1/(x + 1))*sqrt(x + 1)*atanh(sqrt(1 - x**2)))
+
+    def _eval_rewrite_as_acsch(self, x, **kwargs):
+        return sqrt(1/x - 1)/sqrt(1 - 1/x)*(pi/2 - I*acsch(I*x))
+
+
+class acsch(InverseHyperbolicFunction):
+    """
+    ``acsch(x)`` is the inverse hyperbolic cosecant of ``x``.
+
+    The inverse hyperbolic cosecant function.
+
+    Examples
+    ========
+
+    >>> from sympy import acsch, sqrt, I
+    >>> from sympy.abc import x
+    >>> acsch(x).diff(x)
+    -1/(x**2*sqrt(1 + x**(-2)))
+    >>> acsch(1).diff(x)
+    0
+    >>> acsch(1)
+    log(1 + sqrt(2))
+    >>> acsch(I)
+    -I*pi/2
+    >>> acsch(-2*I)
+    I*pi/6
+    >>> acsch(I*(sqrt(6) - sqrt(2)))
+    -5*I*pi/12
+
+    See Also
+    ========
+
+    asinh
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    .. [2] https://dlmf.nist.gov/4.37
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcCsch/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            z = self.args[0]
+            return -1/(z**2*sqrt(1 + 1/z**2))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Zero
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+            elif arg.is_zero:
+                return S.ComplexInfinity
+            elif arg is S.One:
+                return log(1 + sqrt(2))
+            elif arg is S.NegativeOne:
+                return - log(1 + sqrt(2))
+
+        if arg.is_number:
+            cst_table = _acsch_table()
+
+            if arg in cst_table:
+                return cst_table[arg]*I
+
+        if arg is S.ComplexInfinity:
+            return S.Zero
+
+        if arg.is_infinite:
+            return S.Zero
+
+        if arg.is_zero:
+            return S.ComplexInfinity
+
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return log(2 / x)
+        elif n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 2 and n > 2:
+                p = previous_terms[-2]
+                return -p * ((n - 1)*(n-2)) * x**2/(4 * (n//2)**2)
+            else:
+                k = n // 2
+                R = RisingFactorial(S.Half, k) *  n
+                F = factorial(k) * n // 2 * n // 2
+                return S.NegativeOne**(k +1) * R / F * x**n / 4
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # acsch
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        # Handling branch points
+        if x0 in (-I, I, S.Zero):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        if x0 is S.ComplexInfinity:
+            return (1/arg).as_leading_term(x)
+        # Handling points lying on branch cuts (-I, I)
+        if x0.is_imaginary and (1 + x0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(x0).is_positive:
+                    return -self.func(x0) - I*pi
+            elif re(ndir).is_negative:
+                if im(x0).is_negative:
+                    return -self.func(x0) + I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acsch
+        from sympy.series.order import O
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 is I:
+            t = Dummy('t', positive=True)
+            ser = acsch(I + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = -I + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else -I*pi/2 + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            res = ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+            return res
+
+        if arg0 == S.NegativeOne*I:
+            t = Dummy('t', positive=True)
+            ser = acsch(-I + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = I + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else I*pi/2 + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-I, I)
+        if arg0.is_imaginary and (1 + arg0**2).is_positive:
+            ndir = self.args[0].dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(arg0).is_positive:
+                    return -res - I*pi
+            elif re(ndir).is_negative:
+                if im(arg0).is_negative:
+                    return -res + I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return csch
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return log(1/arg + sqrt(1/arg**2 + 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_asinh(self, arg, **kwargs):
+        return asinh(1/arg)
+
+    def _eval_rewrite_as_acosh(self, arg, **kwargs):
+        return I*(sqrt(1 - I/arg)/sqrt(I/arg - 1)*
+                                acosh(I/arg) - pi*S.Half)
+
+    def _eval_rewrite_as_atanh(self, arg, **kwargs):
+        arg2 = arg**2
+        arg2p1 = arg2 + 1
+        return sqrt(-arg2)/arg*(pi*S.Half -
+                                sqrt(-arg2p1**2)/arg2p1*atanh(sqrt(arg2p1)))
+
+    def _eval_is_zero(self):
+        return self.args[0].is_infinite

llmeval-env/lib/python3.10/site-packages/sympy/functions/elementary/integers.py

@@ -0,0 +1,625 @@
+from typing import Tuple as tTuple
+
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+
+from sympy.core import Add, S
+from sympy.core.evalf import get_integer_part, PrecisionExhausted
+from sympy.core.function import Function
+from sympy.core.logic import fuzzy_or
+from sympy.core.numbers import Integer
+from sympy.core.relational import Gt, Lt, Ge, Le, Relational, is_eq
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.complexes import im, re
+from sympy.multipledispatch import dispatch
+
+###############################################################################
+######################### FLOOR and CEILING FUNCTIONS #########################
+###############################################################################
+
+
+class RoundFunction(Function):
+    """Abstract base class for rounding functions."""
+
+    args: tTuple[Expr]
+
+    @classmethod
+    def eval(cls, arg):
+        v = cls._eval_number(arg)
+        if v is not None:
+            return v
+
+        if arg.is_integer or arg.is_finite is False:
+            return arg
+        if arg.is_imaginary or (S.ImaginaryUnit*arg).is_real:
+            i = im(arg)
+            if not i.has(S.ImaginaryUnit):
+                return cls(i)*S.ImaginaryUnit
+            return cls(arg, evaluate=False)
+
+        # Integral, numerical, symbolic part
+        ipart = npart = spart = S.Zero
+
+        # Extract integral (or complex integral) terms
+        terms = Add.make_args(arg)
+
+        for t in terms:
+            if t.is_integer or (t.is_imaginary and im(t).is_integer):
+                ipart += t
+            elif t.has(Symbol):
+                spart += t
+            else:
+                npart += t
+
+        if not (npart or spart):
+            return ipart
+
+        # Evaluate npart numerically if independent of spart
+        if npart and (
+            not spart or
+            npart.is_real and (spart.is_imaginary or (S.ImaginaryUnit*spart).is_real) or
+                npart.is_imaginary and spart.is_real):
+            try:
+                r, i = get_integer_part(
+                    npart, cls._dir, {}, return_ints=True)
+                ipart += Integer(r) + Integer(i)*S.ImaginaryUnit
+                npart = S.Zero
+            except (PrecisionExhausted, NotImplementedError):
+                pass
+
+        spart += npart
+        if not spart:
+            return ipart
+        elif spart.is_imaginary or (S.ImaginaryUnit*spart).is_real:
+            return ipart + cls(im(spart), evaluate=False)*S.ImaginaryUnit
+        elif isinstance(spart, (floor, ceiling)):
+            return ipart + spart
+        else:
+            return ipart + cls(spart, evaluate=False)
+
+    @classmethod
+    def _eval_number(cls, arg):
+        raise NotImplementedError()
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+    def _eval_is_real(self):
+        return self.args[0].is_real
+
+    def _eval_is_integer(self):
+        return self.args[0].is_real
+
+
+class floor(RoundFunction):
+    """
+    Floor is a univariate function which returns the largest integer
+    value not greater than its argument. This implementation
+    generalizes floor to complex numbers by taking the floor of the
+    real and imaginary parts separately.
+
+    Examples
+    ========
+
+    >>> from sympy import floor, E, I, S, Float, Rational
+    >>> floor(17)
+    17
+    >>> floor(Rational(23, 10))
+    2
+    >>> floor(2*E)
+    5
+    >>> floor(-Float(0.567))
+    -1
+    >>> floor(-I/2)
+    -I
+    >>> floor(S(5)/2 + 5*I/2)
+    2 + 2*I
+
+    See Also
+    ========
+
+    sympy.functions.elementary.integers.ceiling
+
+    References
+    ==========
+
+    .. [1] "Concrete mathematics" by Graham, pp. 87
+    .. [2] https://mathworld.wolfram.com/FloorFunction.html
+
+    """
+    _dir = -1
+
+    @classmethod
+    def _eval_number(cls, arg):
+        if arg.is_Number:
+            return arg.floor()
+        elif any(isinstance(i, j)
+                for i in (arg, -arg) for j in (floor, ceiling)):
+            return arg
+        if arg.is_NumberSymbol:
+            return arg.approximation_interval(Integer)[0]
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN or isinstance(arg0, AccumBounds):
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = floor(arg0)
+        if arg0.is_finite:
+            if arg0 == r:
+                ndir = arg.dir(x, cdir=cdir)
+                return r - 1 if ndir.is_negative else r
+            else:
+                return r
+        return arg.as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = floor(arg0)
+        if arg0.is_infinite:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            from sympy.series.order import Order
+            s = arg._eval_nseries(x, n, logx, cdir)
+            o = Order(1, (x, 0)) if n <= 0 else AccumBounds(-1, 0)
+            return s + o
+        if arg0 == r:
+            ndir = arg.dir(x, cdir=cdir if cdir != 0 else 1)
+            return r - 1 if ndir.is_negative else r
+        else:
+            return r
+
+    def _eval_is_negative(self):
+        return self.args[0].is_negative
+
+    def _eval_is_nonnegative(self):
+        return self.args[0].is_nonnegative
+
+    def _eval_rewrite_as_ceiling(self, arg, **kwargs):
+        return -ceiling(-arg)
+
+    def _eval_rewrite_as_frac(self, arg, **kwargs):
+        return arg - frac(arg)
+
+    def __le__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] < other + 1
+            if other.is_number and other.is_real:
+                return self.args[0] < ceiling(other)
+        if self.args[0] == other and other.is_real:
+            return S.true
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Le(self, other, evaluate=False)
+
+    def __ge__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] >= other
+            if other.is_number and other.is_real:
+                return self.args[0] >= ceiling(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Ge(self, other, evaluate=False)
+
+    def __gt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] >= other + 1
+            if other.is_number and other.is_real:
+                return self.args[0] >= ceiling(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Gt(self, other, evaluate=False)
+
+    def __lt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] < other
+            if other.is_number and other.is_real:
+                return self.args[0] < ceiling(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Lt(self, other, evaluate=False)
+
+
+@dispatch(floor, Expr)
+def _eval_is_eq(lhs, rhs): # noqa:F811
+   return is_eq(lhs.rewrite(ceiling), rhs) or \
+        is_eq(lhs.rewrite(frac),rhs)
+
+
+class ceiling(RoundFunction):
+    """
+    Ceiling is a univariate function which returns the smallest integer
+    value not less than its argument. This implementation
+    generalizes ceiling to complex numbers by taking the ceiling of the
+    real and imaginary parts separately.
+
+    Examples
+    ========
+
+    >>> from sympy import ceiling, E, I, S, Float, Rational
+    >>> ceiling(17)
+    17
+    >>> ceiling(Rational(23, 10))
+    3
+    >>> ceiling(2*E)
+    6
+    >>> ceiling(-Float(0.567))
+    0
+    >>> ceiling(I/2)
+    I
+    >>> ceiling(S(5)/2 + 5*I/2)
+    3 + 3*I
+
+    See Also
+    ========
+
+    sympy.functions.elementary.integers.floor
+
+    References
+    ==========
+
+    .. [1] "Concrete mathematics" by Graham, pp. 87
+    .. [2] https://mathworld.wolfram.com/CeilingFunction.html
+
+    """
+    _dir = 1
+
+    @classmethod
+    def _eval_number(cls, arg):
+        if arg.is_Number:
+            return arg.ceiling()
+        elif any(isinstance(i, j)
+                for i in (arg, -arg) for j in (floor, ceiling)):
+            return arg
+        if arg.is_NumberSymbol:
+            return arg.approximation_interval(Integer)[1]
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN or isinstance(arg0, AccumBounds):
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = ceiling(arg0)
+        if arg0.is_finite:
+            if arg0 == r:
+                ndir = arg.dir(x, cdir=cdir)
+                return r if ndir.is_negative else r + 1
+            else:
+                return r
+        return arg.as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = ceiling(arg0)
+        if arg0.is_infinite:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            from sympy.series.order import Order
+            s = arg._eval_nseries(x, n, logx, cdir)
+            o = Order(1, (x, 0)) if n <= 0 else AccumBounds(0, 1)
+            return s + o
+        if arg0 == r:
+            ndir = arg.dir(x, cdir=cdir if cdir != 0 else 1)
+            return r if ndir.is_negative else r + 1
+        else:
+            return r
+
+    def _eval_rewrite_as_floor(self, arg, **kwargs):
+        return -floor(-arg)
+
+    def _eval_rewrite_as_frac(self, arg, **kwargs):
+        return arg + frac(-arg)
+
+    def _eval_is_positive(self):
+        return self.args[0].is_positive
+
+    def _eval_is_nonpositive(self):
+        return self.args[0].is_nonpositive
+
+    def __lt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] <= other - 1
+            if other.is_number and other.is_real:
+                return self.args[0] <= floor(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Lt(self, other, evaluate=False)
+
+    def __gt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] > other
+            if other.is_number and other.is_real:
+                return self.args[0] > floor(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Gt(self, other, evaluate=False)
+
+    def __ge__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] > other - 1
+            if other.is_number and other.is_real:
+                return self.args[0] > floor(other)
+        if self.args[0] == other and other.is_real:
+            return S.true
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Ge(self, other, evaluate=False)
+
+    def __le__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] <= other
+            if other.is_number and other.is_real:
+                return self.args[0] <= floor(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Le(self, other, evaluate=False)
+
+
+@dispatch(ceiling, Basic)  # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa:F811
+    return is_eq(lhs.rewrite(floor), rhs) or is_eq(lhs.rewrite(frac),rhs)
+
+
+class frac(Function):
+    r"""Represents the fractional part of x
+
+    For real numbers it is defined [1]_ as
+
+    .. math::
+        x - \left\lfloor{x}\right\rfloor
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, frac, Rational, floor, I
+    >>> frac(Rational(4, 3))
+    1/3
+    >>> frac(-Rational(4, 3))
+    2/3
+
+    returns zero for integer arguments
+
+    >>> n = Symbol('n', integer=True)
+    >>> frac(n)
+    0
+
+    rewrite as floor
+
+    >>> x = Symbol('x')
+    >>> frac(x).rewrite(floor)
+    x - floor(x)
+
+    for complex arguments
+
+    >>> r = Symbol('r', real=True)
+    >>> t = Symbol('t', real=True)
+    >>> frac(t + I*r)
+    I*frac(r) + frac(t)
+
+    See Also
+    ========
+
+    sympy.functions.elementary.integers.floor
+    sympy.functions.elementary.integers.ceiling
+
+    References
+    ===========
+
+    .. [1] https://en.wikipedia.org/wiki/Fractional_part
+    .. [2] https://mathworld.wolfram.com/FractionalPart.html
+
+    """
+    @classmethod
+    def eval(cls, arg):
+        from sympy.calculus.accumulationbounds import AccumBounds
+
+        def _eval(arg):
+            if arg in (S.Infinity, S.NegativeInfinity):
+                return AccumBounds(0, 1)
+            if arg.is_integer:
+                return S.Zero
+            if arg.is_number:
+                if arg is S.NaN:
+                    return S.NaN
+                elif arg is S.ComplexInfinity:
+                    return S.NaN
+                else:
+                    return arg - floor(arg)
+            return cls(arg, evaluate=False)
+
+        terms = Add.make_args(arg)
+        real, imag = S.Zero, S.Zero
+        for t in terms:
+            # Two checks are needed for complex arguments
+            # see issue-7649 for details
+            if t.is_imaginary or (S.ImaginaryUnit*t).is_real:
+                i = im(t)
+                if not i.has(S.ImaginaryUnit):
+                    imag += i
+                else:
+                    real += t
+            else:
+                real += t
+
+        real = _eval(real)
+        imag = _eval(imag)
+        return real + S.ImaginaryUnit*imag
+
+    def _eval_rewrite_as_floor(self, arg, **kwargs):
+        return arg - floor(arg)
+
+    def _eval_rewrite_as_ceiling(self, arg, **kwargs):
+        return arg + ceiling(-arg)
+
+    def _eval_is_finite(self):
+        return True
+
+    def _eval_is_real(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_imaginary(self):
+        return self.args[0].is_imaginary
+
+    def _eval_is_integer(self):
+        return self.args[0].is_integer
+
+    def _eval_is_zero(self):
+        return fuzzy_or([self.args[0].is_zero, self.args[0].is_integer])
+
+    def _eval_is_negative(self):
+        return False
+
+    def __ge__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other <= 0
+            if other.is_extended_nonpositive:
+                return S.true
+            # Check if other >= 1
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return not(res)
+        return Ge(self, other, evaluate=False)
+
+    def __gt__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other < 0
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return not(res)
+            # Check if other >= 1
+            if other.is_extended_negative:
+                return S.true
+        return Gt(self, other, evaluate=False)
+
+    def __le__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other < 0
+            if other.is_extended_negative:
+                return S.false
+            # Check if other >= 1
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return res
+        return Le(self, other, evaluate=False)
+
+    def __lt__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other <= 0
+            if other.is_extended_nonpositive:
+                return S.false
+            # Check if other >= 1
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return res
+        return Lt(self, other, evaluate=False)
+
+    def _value_one_or_more(self, other):
+        if other.is_extended_real:
+            if other.is_number:
+                res = other >= 1
+                if res and not isinstance(res, Relational):
+                    return S.true
+            if other.is_integer and other.is_positive:
+                return S.true
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+
+        if arg0.is_finite:
+            if r.is_zero:
+                ndir = arg.dir(x, cdir=cdir)
+                if ndir.is_negative:
+                    return S.One
+                return (arg - arg0).as_leading_term(x, logx=logx, cdir=cdir)
+            else:
+                return r
+        elif arg0 in (S.ComplexInfinity, S.Infinity, S.NegativeInfinity):
+            return AccumBounds(0, 1)
+        return arg.as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.series.order import Order
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+
+        if arg0.is_infinite:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            o = Order(1, (x, 0)) if n <= 0 else AccumBounds(0, 1) + Order(x**n, (x, 0))
+            return o
+        else:
+            res = (arg - arg0)._eval_nseries(x, n, logx=logx, cdir=cdir)
+            if r.is_zero:
+                ndir = arg.dir(x, cdir=cdir)
+                res += S.One if ndir.is_negative else S.Zero
+            else:
+                res += r
+            return res
+
+
+@dispatch(frac, Basic)  # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa:F811
+    if (lhs.rewrite(floor) == rhs) or \
+        (lhs.rewrite(ceiling) == rhs):
+        return True
+    # Check if other < 0
+    if rhs.is_extended_negative:
+        return False
+    # Check if other >= 1
+    res = lhs._value_one_or_more(rhs)
+    if res is not None:
+        return False

llmeval-env/lib/python3.10/site-packages/sympy/functions/elementary/miscellaneous.py

@@ -0,0 +1,915 @@
+from sympy.core import Function, S, sympify, NumberKind
+from sympy.utilities.iterables import sift
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.operations import LatticeOp, ShortCircuit
+from sympy.core.function import (Application, Lambda,
+    ArgumentIndexError)
+from sympy.core.expr import Expr
+from sympy.core.exprtools import factor_terms
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core.numbers import Rational
+from sympy.core.power import Pow
+from sympy.core.relational import Eq, Relational
+from sympy.core.singleton import Singleton
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy
+from sympy.core.rules import Transform
+from sympy.core.logic import fuzzy_and, fuzzy_or, _torf
+from sympy.core.traversal import walk
+from sympy.core.numbers import Integer
+from sympy.logic.boolalg import And, Or
+
+
+def _minmax_as_Piecewise(op, *args):
+    # helper for Min/Max rewrite as Piecewise
+    from sympy.functions.elementary.piecewise import Piecewise
+    ec = []
+    for i, a in enumerate(args):
+        c = [Relational(a, args[j], op) for j in range(i + 1, len(args))]
+        ec.append((a, And(*c)))
+    return Piecewise(*ec)
+
+
+class IdentityFunction(Lambda, metaclass=Singleton):
+    """
+    The identity function
+
+    Examples
+    ========
+
+    >>> from sympy import Id, Symbol
+    >>> x = Symbol('x')
+    >>> Id(x)
+    x
+
+    """
+
+    _symbol = Dummy('x')
+
+    @property
+    def signature(self):
+        return Tuple(self._symbol)
+
+    @property
+    def expr(self):
+        return self._symbol
+
+
+Id = S.IdentityFunction
+
+###############################################################################
+############################# ROOT and SQUARE ROOT FUNCTION ###################
+###############################################################################
+
+
+def sqrt(arg, evaluate=None):
+    """Returns the principal square root.
+
+    Parameters
+    ==========
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt, Symbol, S
+    >>> x = Symbol('x')
+
+    >>> sqrt(x)
+    sqrt(x)
+
+    >>> sqrt(x)**2
+    x
+
+    Note that sqrt(x**2) does not simplify to x.
+
+    >>> sqrt(x**2)
+    sqrt(x**2)
+
+    This is because the two are not equal to each other in general.
+    For example, consider x == -1:
+
+    >>> from sympy import Eq
+    >>> Eq(sqrt(x**2), x).subs(x, -1)
+    False
+
+    This is because sqrt computes the principal square root, so the square may
+    put the argument in a different branch.  This identity does hold if x is
+    positive:
+
+    >>> y = Symbol('y', positive=True)
+    >>> sqrt(y**2)
+    y
+
+    You can force this simplification by using the powdenest() function with
+    the force option set to True:
+
+    >>> from sympy import powdenest
+    >>> sqrt(x**2)
+    sqrt(x**2)
+    >>> powdenest(sqrt(x**2), force=True)
+    x
+
+    To get both branches of the square root you can use the rootof function:
+
+    >>> from sympy import rootof
+
+    >>> [rootof(x**2-3,i) for i in (0,1)]
+    [-sqrt(3), sqrt(3)]
+
+    Although ``sqrt`` is printed, there is no ``sqrt`` function so looking for
+    ``sqrt`` in an expression will fail:
+
+    >>> from sympy.utilities.misc import func_name
+    >>> func_name(sqrt(x))
+    'Pow'
+    >>> sqrt(x).has(sqrt)
+    False
+
+    To find ``sqrt`` look for ``Pow`` with an exponent of ``1/2``:
+
+    >>> (x + 1/sqrt(x)).find(lambda i: i.is_Pow and abs(i.exp) is S.Half)
+    {1/sqrt(x)}
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof, root, real_root
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Square_root
+    .. [2] https://en.wikipedia.org/wiki/Principal_value
+    """
+    # arg = sympify(arg) is handled by Pow
+    return Pow(arg, S.Half, evaluate=evaluate)
+
+
+def cbrt(arg, evaluate=None):
+    """Returns the principal cube root.
+
+    Parameters
+    ==========
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import cbrt, Symbol
+    >>> x = Symbol('x')
+
+    >>> cbrt(x)
+    x**(1/3)
+
+    >>> cbrt(x)**3
+    x
+
+    Note that cbrt(x**3) does not simplify to x.
+
+    >>> cbrt(x**3)
+    (x**3)**(1/3)
+
+    This is because the two are not equal to each other in general.
+    For example, consider `x == -1`:
+
+    >>> from sympy import Eq
+    >>> Eq(cbrt(x**3), x).subs(x, -1)
+    False
+
+    This is because cbrt computes the principal cube root, this
+    identity does hold if `x` is positive:
+
+    >>> y = Symbol('y', positive=True)
+    >>> cbrt(y**3)
+    y
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof, root, real_root
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Cube_root
+    .. [2] https://en.wikipedia.org/wiki/Principal_value
+
+    """
+    return Pow(arg, Rational(1, 3), evaluate=evaluate)
+
+
+def root(arg, n, k=0, evaluate=None):
+    r"""Returns the *k*-th *n*-th root of ``arg``.
+
+    Parameters
+    ==========
+
+    k : int, optional
+        Should be an integer in $\{0, 1, ..., n-1\}$.
+        Defaults to the principal root if $0$.
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import root, Rational
+    >>> from sympy.abc import x, n
+
+    >>> root(x, 2)
+    sqrt(x)
+
+    >>> root(x, 3)
+    x**(1/3)
+
+    >>> root(x, n)
+    x**(1/n)
+
+    >>> root(x, -Rational(2, 3))
+    x**(-3/2)
+
+    To get the k-th n-th root, specify k:
+
+    >>> root(-2, 3, 2)
+    -(-1)**(2/3)*2**(1/3)
+
+    To get all n n-th roots you can use the rootof function.
+    The following examples show the roots of unity for n
+    equal 2, 3 and 4:
+
+    >>> from sympy import rootof
+
+    >>> [rootof(x**2 - 1, i) for i in range(2)]
+    [-1, 1]
+
+    >>> [rootof(x**3 - 1,i) for i in range(3)]
+    [1, -1/2 - sqrt(3)*I/2, -1/2 + sqrt(3)*I/2]
+
+    >>> [rootof(x**4 - 1,i) for i in range(4)]
+    [-1, 1, -I, I]
+
+    SymPy, like other symbolic algebra systems, returns the
+    complex root of negative numbers. This is the principal
+    root and differs from the text-book result that one might
+    be expecting. For example, the cube root of -8 does not
+    come back as -2:
+
+    >>> root(-8, 3)
+    2*(-1)**(1/3)
+
+    The real_root function can be used to either make the principal
+    result real (or simply to return the real root directly):
+
+    >>> from sympy import real_root
+    >>> real_root(_)
+    -2
+    >>> real_root(-32, 5)
+    -2
+
+    Alternatively, the n//2-th n-th root of a negative number can be
+    computed with root:
+
+    >>> root(-32, 5, 5//2)
+    -2
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof
+    sympy.core.power.integer_nthroot
+    sqrt, real_root
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Square_root
+    .. [2] https://en.wikipedia.org/wiki/Real_root
+    .. [3] https://en.wikipedia.org/wiki/Root_of_unity
+    .. [4] https://en.wikipedia.org/wiki/Principal_value
+    .. [5] https://mathworld.wolfram.com/CubeRoot.html
+
+    """
+    n = sympify(n)
+    if k:
+        return Mul(Pow(arg, S.One/n, evaluate=evaluate), S.NegativeOne**(2*k/n), evaluate=evaluate)
+    return Pow(arg, 1/n, evaluate=evaluate)
+
+
+def real_root(arg, n=None, evaluate=None):
+    r"""Return the real *n*'th-root of *arg* if possible.
+
+    Parameters
+    ==========
+
+    n : int or None, optional
+        If *n* is ``None``, then all instances of
+        $(-n)^{1/\text{odd}}$ will be changed to $-n^{1/\text{odd}}$.
+        This will only create a real root of a principal root.
+        The presence of other factors may cause the result to not be
+        real.
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import root, real_root
+
+    >>> real_root(-8, 3)
+    -2
+    >>> root(-8, 3)
+    2*(-1)**(1/3)
+    >>> real_root(_)
+    -2
+
+    If one creates a non-principal root and applies real_root, the
+    result will not be real (so use with caution):
+
+    >>> root(-8, 3, 2)
+    -2*(-1)**(2/3)
+    >>> real_root(_)
+    -2*(-1)**(2/3)
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof
+    sympy.core.power.integer_nthroot
+    root, sqrt
+    """
+    from sympy.functions.elementary.complexes import Abs, im, sign
+    from sympy.functions.elementary.piecewise import Piecewise
+    if n is not None:
+        return Piecewise(
+            (root(arg, n, evaluate=evaluate), Or(Eq(n, S.One), Eq(n, S.NegativeOne))),
+            (Mul(sign(arg), root(Abs(arg), n, evaluate=evaluate), evaluate=evaluate),
+            And(Eq(im(arg), S.Zero), Eq(Mod(n, 2), S.One))),
+            (root(arg, n, evaluate=evaluate), True))
+    rv = sympify(arg)
+    n1pow = Transform(lambda x: -(-x.base)**x.exp,
+                      lambda x:
+                      x.is_Pow and
+                      x.base.is_negative and
+                      x.exp.is_Rational and
+                      x.exp.p == 1 and x.exp.q % 2)
+    return rv.xreplace(n1pow)
+
+###############################################################################
+############################# MINIMUM and MAXIMUM #############################
+###############################################################################
+
+
+class MinMaxBase(Expr, LatticeOp):
+    def __new__(cls, *args, **assumptions):
+        from sympy.core.parameters import global_parameters
+        evaluate = assumptions.pop('evaluate', global_parameters.evaluate)
+        args = (sympify(arg) for arg in args)
+
+        # first standard filter, for cls.zero and cls.identity
+        # also reshape Max(a, Max(b, c)) to Max(a, b, c)
+
+        if evaluate:
+            try:
+                args = frozenset(cls._new_args_filter(args))
+            except ShortCircuit:
+                return cls.zero
+            # remove redundant args that are easily identified
+            args = cls._collapse_arguments(args, **assumptions)
+            # find local zeros
+            args = cls._find_localzeros(args, **assumptions)
+        args = frozenset(args)
+
+        if not args:
+            return cls.identity
+
+        if len(args) == 1:
+            return list(args).pop()
+
+        # base creation
+        obj = Expr.__new__(cls, *ordered(args), **assumptions)
+        obj._argset = args
+        return obj
+
+    @classmethod
+    def _collapse_arguments(cls, args, **assumptions):
+        """Remove redundant args.
+
+        Examples
+        ========
+
+        >>> from sympy import Min, Max
+        >>> from sympy.abc import a, b, c, d, e
+
+        Any arg in parent that appears in any
+        parent-like function in any of the flat args
+        of parent can be removed from that sub-arg:
+
+        >>> Min(a, Max(b, Min(a, c, d)))
+        Min(a, Max(b, Min(c, d)))
+
+        If the arg of parent appears in an opposite-than parent
+        function in any of the flat args of parent that function
+        can be replaced with the arg:
+
+        >>> Min(a, Max(b, Min(c, d, Max(a, e))))
+        Min(a, Max(b, Min(a, c, d)))
+        """
+        if not args:
+            return args
+        args = list(ordered(args))
+        if cls == Min:
+            other = Max
+        else:
+            other = Min
+
+        # find global comparable max of Max and min of Min if a new
+        # value is being introduced in these args at position 0 of
+        # the ordered args
+        if args[0].is_number:
+            sifted = mins, maxs = [], []
+            for i in args:
+                for v in walk(i, Min, Max):
+                    if v.args[0].is_comparable:
+                        sifted[isinstance(v, Max)].append(v)
+            small = Min.identity
+            for i in mins:
+                v = i.args[0]
+                if v.is_number and (v < small) == True:
+                    small = v
+            big = Max.identity
+            for i in maxs:
+                v = i.args[0]
+                if v.is_number and (v > big) == True:
+                    big = v
+            # at the point when this function is called from __new__,
+            # there may be more than one numeric arg present since
+            # local zeros have not been handled yet, so look through
+            # more than the first arg
+            if cls == Min:
+                for arg in args:
+                    if not arg.is_number:
+                        break
+                    if (arg < small) == True:
+                        small = arg
+            elif cls == Max:
+                for arg in args:
+                    if not arg.is_number:
+                        break
+                    if (arg > big) == True:
+                        big = arg
+            T = None
+            if cls == Min:
+                if small != Min.identity:
+                    other = Max
+                    T = small
+            elif big != Max.identity:
+                other = Min
+                T = big
+            if T is not None:
+                # remove numerical redundancy
+                for i in range(len(args)):
+                    a = args[i]
+                    if isinstance(a, other):
+                        a0 = a.args[0]
+                        if ((a0 > T) if other == Max else (a0 < T)) == True:
+                            args[i] = cls.identity
+
+        # remove redundant symbolic args
+        def do(ai, a):
+            if not isinstance(ai, (Min, Max)):
+                return ai
+            cond = a in ai.args
+            if not cond:
+                return ai.func(*[do(i, a) for i in ai.args],
+                    evaluate=False)
+            if isinstance(ai, cls):
+                return ai.func(*[do(i, a) for i in ai.args if i != a],
+                    evaluate=False)
+            return a
+        for i, a in enumerate(args):
+            args[i + 1:] = [do(ai, a) for ai in args[i + 1:]]
+
+        # factor out common elements as for
+        # Min(Max(x, y), Max(x, z)) -> Max(x, Min(y, z))
+        # and vice versa when swapping Min/Max -- do this only for the
+        # easy case where all functions contain something in common;
+        # trying to find some optimal subset of args to modify takes
+        # too long
+
+        def factor_minmax(args):
+            is_other = lambda arg: isinstance(arg, other)
+            other_args, remaining_args = sift(args, is_other, binary=True)
+            if not other_args:
+                return args
+
+            # Min(Max(x, y, z), Max(x, y, u, v)) -> {x,y}, ({z}, {u,v})
+            arg_sets = [set(arg.args) for arg in other_args]
+            common = set.intersection(*arg_sets)
+            if not common:
+                return args
+
+            new_other_args = list(common)
+            arg_sets_diff = [arg_set - common for arg_set in arg_sets]
+
+            # If any set is empty after removing common then all can be
+            # discarded e.g. Min(Max(a, b, c), Max(a, b)) -> Max(a, b)
+            if all(arg_sets_diff):
+                other_args_diff = [other(*s, evaluate=False) for s in arg_sets_diff]
+                new_other_args.append(cls(*other_args_diff, evaluate=False))
+
+            other_args_factored = other(*new_other_args, evaluate=False)
+            return remaining_args + [other_args_factored]
+
+        if len(args) > 1:
+            args = factor_minmax(args)
+
+        return args
+
+    @classmethod
+    def _new_args_filter(cls, arg_sequence):
+        """
+        Generator filtering args.
+
+        first standard filter, for cls.zero and cls.identity.
+        Also reshape ``Max(a, Max(b, c))`` to ``Max(a, b, c)``,
+        and check arguments for comparability
+        """
+        for arg in arg_sequence:
+            # pre-filter, checking comparability of arguments
+            if not isinstance(arg, Expr) or arg.is_extended_real is False or (
+                    arg.is_number and
+                    not arg.is_comparable):
+                raise ValueError("The argument '%s' is not comparable." % arg)
+
+            if arg == cls.zero:
+                raise ShortCircuit(arg)
+            elif arg == cls.identity:
+                continue
+            elif arg.func == cls:
+                yield from arg.args
+            else:
+                yield arg
+
+    @classmethod
+    def _find_localzeros(cls, values, **options):
+        """
+        Sequentially allocate values to localzeros.
+
+        When a value is identified as being more extreme than another member it
+        replaces that member; if this is never true, then the value is simply
+        appended to the localzeros.
+        """
+        localzeros = set()
+        for v in values:
+            is_newzero = True
+            localzeros_ = list(localzeros)
+            for z in localzeros_:
+                if id(v) == id(z):
+                    is_newzero = False
+                else:
+                    con = cls._is_connected(v, z)
+                    if con:
+                        is_newzero = False
+                        if con is True or con == cls:
+                            localzeros.remove(z)
+                            localzeros.update([v])
+            if is_newzero:
+                localzeros.update([v])
+        return localzeros
+
+    @classmethod
+    def _is_connected(cls, x, y):
+        """
+        Check if x and y are connected somehow.
+        """
+        for i in range(2):
+            if x == y:
+                return True
+            t, f = Max, Min
+            for op in "><":
+                for j in range(2):
+                    try:
+                        if op == ">":
+                            v = x >= y
+                        else:
+                            v = x <= y
+                    except TypeError:
+                        return False  # non-real arg
+                    if not v.is_Relational:
+                        return t if v else f
+                    t, f = f, t
+                    x, y = y, x
+                x, y = y, x  # run next pass with reversed order relative to start
+            # simplification can be expensive, so be conservative
+            # in what is attempted
+            x = factor_terms(x - y)
+            y = S.Zero
+
+        return False
+
+    def _eval_derivative(self, s):
+        # f(x).diff(s) -> x.diff(s) * f.fdiff(1)(s)
+        i = 0
+        l = []
+        for a in self.args:
+            i += 1
+            da = a.diff(s)
+            if da.is_zero:
+                continue
+            try:
+                df = self.fdiff(i)
+            except ArgumentIndexError:
+                df = Function.fdiff(self, i)
+            l.append(df * da)
+        return Add(*l)
+
+    def _eval_rewrite_as_Abs(self, *args, **kwargs):
+        from sympy.functions.elementary.complexes import Abs
+        s = (args[0] + self.func(*args[1:]))/2
+        d = abs(args[0] - self.func(*args[1:]))/2
+        return (s + d if isinstance(self, Max) else s - d).rewrite(Abs)
+
+    def evalf(self, n=15, **options):
+        return self.func(*[a.evalf(n, **options) for a in self.args])
+
+    def n(self, *args, **kwargs):
+        return self.evalf(*args, **kwargs)
+
+    _eval_is_algebraic = lambda s: _torf(i.is_algebraic for i in s.args)
+    _eval_is_antihermitian = lambda s: _torf(i.is_antihermitian for i in s.args)
+    _eval_is_commutative = lambda s: _torf(i.is_commutative for i in s.args)
+    _eval_is_complex = lambda s: _torf(i.is_complex for i in s.args)
+    _eval_is_composite = lambda s: _torf(i.is_composite for i in s.args)
+    _eval_is_even = lambda s: _torf(i.is_even for i in s.args)
+    _eval_is_finite = lambda s: _torf(i.is_finite for i in s.args)
+    _eval_is_hermitian = lambda s: _torf(i.is_hermitian for i in s.args)
+    _eval_is_imaginary = lambda s: _torf(i.is_imaginary for i in s.args)
+    _eval_is_infinite = lambda s: _torf(i.is_infinite for i in s.args)
+    _eval_is_integer = lambda s: _torf(i.is_integer for i in s.args)
+    _eval_is_irrational = lambda s: _torf(i.is_irrational for i in s.args)
+    _eval_is_negative = lambda s: _torf(i.is_negative for i in s.args)
+    _eval_is_noninteger = lambda s: _torf(i.is_noninteger for i in s.args)
+    _eval_is_nonnegative = lambda s: _torf(i.is_nonnegative for i in s.args)
+    _eval_is_nonpositive = lambda s: _torf(i.is_nonpositive for i in s.args)
+    _eval_is_nonzero = lambda s: _torf(i.is_nonzero for i in s.args)
+    _eval_is_odd = lambda s: _torf(i.is_odd for i in s.args)
+    _eval_is_polar = lambda s: _torf(i.is_polar for i in s.args)
+    _eval_is_positive = lambda s: _torf(i.is_positive for i in s.args)
+    _eval_is_prime = lambda s: _torf(i.is_prime for i in s.args)
+    _eval_is_rational = lambda s: _torf(i.is_rational for i in s.args)
+    _eval_is_real = lambda s: _torf(i.is_real for i in s.args)
+    _eval_is_extended_real = lambda s: _torf(i.is_extended_real for i in s.args)
+    _eval_is_transcendental = lambda s: _torf(i.is_transcendental for i in s.args)
+    _eval_is_zero = lambda s: _torf(i.is_zero for i in s.args)
+
+
+class Max(MinMaxBase, Application):
+    r"""
+    Return, if possible, the maximum value of the list.
+
+    When number of arguments is equal one, then
+    return this argument.
+
+    When number of arguments is equal two, then
+    return, if possible, the value from (a, b) that is $\ge$ the other.
+
+    In common case, when the length of list greater than 2, the task
+    is more complicated. Return only the arguments, which are greater
+    than others, if it is possible to determine directional relation.
+
+    If is not possible to determine such a relation, return a partially
+    evaluated result.
+
+    Assumptions are used to make the decision too.
+
+    Also, only comparable arguments are permitted.
+
+    It is named ``Max`` and not ``max`` to avoid conflicts
+    with the built-in function ``max``.
+
+
+    Examples
+    ========
+
+    >>> from sympy import Max, Symbol, oo
+    >>> from sympy.abc import x, y, z
+    >>> p = Symbol('p', positive=True)
+    >>> n = Symbol('n', negative=True)
+
+    >>> Max(x, -2)
+    Max(-2, x)
+    >>> Max(x, -2).subs(x, 3)
+    3
+    >>> Max(p, -2)
+    p
+    >>> Max(x, y)
+    Max(x, y)
+    >>> Max(x, y) == Max(y, x)
+    True
+    >>> Max(x, Max(y, z))
+    Max(x, y, z)
+    >>> Max(n, 8, p, 7, -oo)
+    Max(8, p)
+    >>> Max (1, x, oo)
+    oo
+
+    * Algorithm
+
+    The task can be considered as searching of supremums in the
+    directed complete partial orders [1]_.
+
+    The source values are sequentially allocated by the isolated subsets
+    in which supremums are searched and result as Max arguments.
+
+    If the resulted supremum is single, then it is returned.
+
+    The isolated subsets are the sets of values which are only the comparable
+    with each other in the current set. E.g. natural numbers are comparable with
+    each other, but not comparable with the `x` symbol. Another example: the
+    symbol `x` with negative assumption is comparable with a natural number.
+
+    Also there are "least" elements, which are comparable with all others,
+    and have a zero property (maximum or minimum for all elements).
+    For example, in case of $\infty$, the allocation operation is terminated
+    and only this value is returned.
+
+    Assumption:
+       - if $A > B > C$ then $A > C$
+       - if $A = B$ then $B$ can be removed
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Directed_complete_partial_order
+    .. [2] https://en.wikipedia.org/wiki/Lattice_%28order%29
+
+    See Also
+    ========
+
+    Min : find minimum values
+    """
+    zero = S.Infinity
+    identity = S.NegativeInfinity
+
+    def fdiff( self, argindex ):
+        from sympy.functions.special.delta_functions import Heaviside
+        n = len(self.args)
+        if 0 < argindex and argindex <= n:
+            argindex -= 1
+            if n == 2:
+                return Heaviside(self.args[argindex] - self.args[1 - argindex])
+            newargs = tuple([self.args[i] for i in range(n) if i != argindex])
+            return Heaviside(self.args[argindex] - Max(*newargs))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Heaviside(self, *args, **kwargs):
+        from sympy.functions.special.delta_functions import Heaviside
+        return Add(*[j*Mul(*[Heaviside(j - i) for i in args if i!=j]) \
+                for j in args])
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        return _minmax_as_Piecewise('>=', *args)
+
+    def _eval_is_positive(self):
+        return fuzzy_or(a.is_positive for a in self.args)
+
+    def _eval_is_nonnegative(self):
+        return fuzzy_or(a.is_nonnegative for a in self.args)
+
+    def _eval_is_negative(self):
+        return fuzzy_and(a.is_negative for a in self.args)
+
+
+class Min(MinMaxBase, Application):
+    """
+    Return, if possible, the minimum value of the list.
+    It is named ``Min`` and not ``min`` to avoid conflicts
+    with the built-in function ``min``.
+
+    Examples
+    ========
+
+    >>> from sympy import Min, Symbol, oo
+    >>> from sympy.abc import x, y
+    >>> p = Symbol('p', positive=True)
+    >>> n = Symbol('n', negative=True)
+
+    >>> Min(x, -2)
+    Min(-2, x)
+    >>> Min(x, -2).subs(x, 3)
+    -2
+    >>> Min(p, -3)
+    -3
+    >>> Min(x, y)
+    Min(x, y)
+    >>> Min(n, 8, p, -7, p, oo)
+    Min(-7, n)
+
+    See Also
+    ========
+
+    Max : find maximum values
+    """
+    zero = S.NegativeInfinity
+    identity = S.Infinity
+
+    def fdiff( self, argindex ):
+        from sympy.functions.special.delta_functions import Heaviside
+        n = len(self.args)
+        if 0 < argindex and argindex <= n:
+            argindex -= 1
+            if n == 2:
+                return Heaviside( self.args[1-argindex] - self.args[argindex] )
+            newargs = tuple([ self.args[i] for i in range(n) if i != argindex])
+            return Heaviside( Min(*newargs) - self.args[argindex] )
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Heaviside(self, *args, **kwargs):
+        from sympy.functions.special.delta_functions import Heaviside
+        return Add(*[j*Mul(*[Heaviside(i-j) for i in args if i!=j]) \
+                for j in args])
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        return _minmax_as_Piecewise('<=', *args)
+
+    def _eval_is_positive(self):
+        return fuzzy_and(a.is_positive for a in self.args)
+
+    def _eval_is_nonnegative(self):
+        return fuzzy_and(a.is_nonnegative for a in self.args)
+
+    def _eval_is_negative(self):
+        return fuzzy_or(a.is_negative for a in self.args)
+
+
+class Rem(Function):
+    """Returns the remainder when ``p`` is divided by ``q`` where ``p`` is finite
+    and ``q`` is not equal to zero. The result, ``p - int(p/q)*q``, has the same sign
+    as the divisor.
+
+    Parameters
+    ==========
+
+    p : Expr
+        Dividend.
+
+    q : Expr
+        Divisor.
+
+    Notes
+    =====
+
+    ``Rem`` corresponds to the ``%`` operator in C.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import Rem
+    >>> Rem(x**3, y)
+    Rem(x**3, y)
+    >>> Rem(x**3, y).subs({x: -5, y: 3})
+    -2
+
+    See Also
+    ========
+
+    Mod
+    """
+    kind = NumberKind
+
+    @classmethod
+    def eval(cls, p, q):
+        """Return the function remainder if both p, q are numbers and q is not
+        zero.
+        """
+
+        if q.is_zero:
+            raise ZeroDivisionError("Division by zero")
+        if p is S.NaN or q is S.NaN or p.is_finite is False or q.is_finite is False:
+            return S.NaN
+        if p is S.Zero or p in (q, -q) or (p.is_integer and q == 1):
+            return S.Zero
+
+        if q.is_Number:
+            if p.is_Number:
+                return p - Integer(p/q)*q

llmeval-env/lib/python3.10/site-packages/sympy/functions/elementary/piecewise.py

@@ -0,0 +1,1506 @@
+from sympy.core import S, Function, diff, Tuple, Dummy, Mul
+from sympy.core.basic import Basic, as_Basic
+from sympy.core.numbers import Rational, NumberSymbol, _illegal
+from sympy.core.parameters import global_parameters
+from sympy.core.relational import (Lt, Gt, Eq, Ne, Relational,
+    _canonical, _canonical_coeff)
+from sympy.core.sorting import ordered
+from sympy.functions.elementary.miscellaneous import Max, Min
+from sympy.logic.boolalg import (And, Boolean, distribute_and_over_or, Not,
+    true, false, Or, ITE, simplify_logic, to_cnf, distribute_or_over_and)
+from sympy.utilities.iterables import uniq, sift, common_prefix
+from sympy.utilities.misc import filldedent, func_name
+
+from itertools import product
+
+Undefined = S.NaN  # Piecewise()
+
+class ExprCondPair(Tuple):
+    """Represents an expression, condition pair."""
+
+    def __new__(cls, expr, cond):
+        expr = as_Basic(expr)
+        if cond == True:
+            return Tuple.__new__(cls, expr, true)
+        elif cond == False:
+            return Tuple.__new__(cls, expr, false)
+        elif isinstance(cond, Basic) and cond.has(Piecewise):
+            cond = piecewise_fold(cond)
+            if isinstance(cond, Piecewise):
+                cond = cond.rewrite(ITE)
+
+        if not isinstance(cond, Boolean):
+            raise TypeError(filldedent('''
+                Second argument must be a Boolean,
+                not `%s`''' % func_name(cond)))
+        return Tuple.__new__(cls, expr, cond)
+
+    @property
+    def expr(self):
+        """
+        Returns the expression of this pair.
+        """
+        return self.args[0]
+
+    @property
+    def cond(self):
+        """
+        Returns the condition of this pair.
+        """
+        return self.args[1]
+
+    @property
+    def is_commutative(self):
+        return self.expr.is_commutative
+
+    def __iter__(self):
+        yield self.expr
+        yield self.cond
+
+    def _eval_simplify(self, **kwargs):
+        return self.func(*[a.simplify(**kwargs) for a in self.args])
+
+
+class Piecewise(Function):
+    """
+    Represents a piecewise function.
+
+    Usage:
+
+      Piecewise( (expr,cond), (expr,cond), ... )
+        - Each argument is a 2-tuple defining an expression and condition
+        - The conds are evaluated in turn returning the first that is True.
+          If any of the evaluated conds are not explicitly False,
+          e.g. ``x < 1``, the function is returned in symbolic form.
+        - If the function is evaluated at a place where all conditions are False,
+          nan will be returned.
+        - Pairs where the cond is explicitly False, will be removed and no pair
+          appearing after a True condition will ever be retained. If a single
+          pair with a True condition remains, it will be returned, even when
+          evaluation is False.
+
+    Examples
+    ========
+
+    >>> from sympy import Piecewise, log, piecewise_fold
+    >>> from sympy.abc import x, y
+    >>> f = x**2
+    >>> g = log(x)
+    >>> p = Piecewise((0, x < -1), (f, x <= 1), (g, True))
+    >>> p.subs(x,1)
+    1
+    >>> p.subs(x,5)
+    log(5)
+
+    Booleans can contain Piecewise elements:
+
+    >>> cond = (x < y).subs(x, Piecewise((2, x < 0), (3, True))); cond
+    Piecewise((2, x < 0), (3, True)) < y
+
+    The folded version of this results in a Piecewise whose
+    expressions are Booleans:
+
+    >>> folded_cond = piecewise_fold(cond); folded_cond
+    Piecewise((2 < y, x < 0), (3 < y, True))
+
+    When a Boolean containing Piecewise (like cond) or a Piecewise
+    with Boolean expressions (like folded_cond) is used as a condition,
+    it is converted to an equivalent :class:`~.ITE` object:
+
+    >>> Piecewise((1, folded_cond))
+    Piecewise((1, ITE(x < 0, y > 2, y > 3)))
+
+    When a condition is an ``ITE``, it will be converted to a simplified
+    Boolean expression:
+
+    >>> piecewise_fold(_)
+    Piecewise((1, ((x >= 0) | (y > 2)) & ((y > 3) | (x < 0))))
+
+    See Also
+    ========
+
+    piecewise_fold
+    piecewise_exclusive
+    ITE
+    """
+
+    nargs = None
+    is_Piecewise = True
+
+    def __new__(cls, *args, **options):
+        if len(args) == 0:
+            raise TypeError("At least one (expr, cond) pair expected.")
+        # (Try to) sympify args first
+        newargs = []
+        for ec in args:
+            # ec could be a ExprCondPair or a tuple
+            pair = ExprCondPair(*getattr(ec, 'args', ec))
+            cond = pair.cond
+            if cond is false:
+                continue
+            newargs.append(pair)
+            if cond is true:
+                break
+
+        eval = options.pop('evaluate', global_parameters.evaluate)
+        if eval:
+            r = cls.eval(*newargs)
+            if r is not None:
+                return r
+        elif len(newargs) == 1 and newargs[0].cond == True:
+            return newargs[0].expr
+
+        return Basic.__new__(cls, *newargs, **options)
+
+    @classmethod
+    def eval(cls, *_args):
+        """Either return a modified version of the args or, if no
+        modifications were made, return None.
+
+        Modifications that are made here:
+
+        1. relationals are made canonical
+        2. any False conditions are dropped
+        3. any repeat of a previous condition is ignored
+        4. any args past one with a true condition are dropped
+
+        If there are no args left, nan will be returned.
+        If there is a single arg with a True condition, its
+        corresponding expression will be returned.
+
+        EXAMPLES
+        ========
+
+        >>> from sympy import Piecewise
+        >>> from sympy.abc import x
+        >>> cond = -x < -1
+        >>> args = [(1, cond), (4, cond), (3, False), (2, True), (5, x < 1)]
+        >>> Piecewise(*args, evaluate=False)
+        Piecewise((1, -x < -1), (4, -x < -1), (2, True))
+        >>> Piecewise(*args)
+        Piecewise((1, x > 1), (2, True))
+        """
+        if not _args:
+            return Undefined
+
+        if len(_args) == 1 and _args[0][-1] == True:
+            return _args[0][0]
+
+        newargs = _piecewise_collapse_arguments(_args)
+
+        # some conditions may have been redundant
+        missing = len(newargs) != len(_args)
+        # some conditions may have changed
+        same = all(a == b for a, b in zip(newargs, _args))
+        # if either change happened we return the expr with the
+        # updated args
+        if not newargs:
+            raise ValueError(filldedent('''
+                There are no conditions (or none that
+                are not trivially false) to define an
+                expression.'''))
+        if missing or not same:
+            return cls(*newargs)
+
+    def doit(self, **hints):
+        """
+        Evaluate this piecewise function.
+        """
+        newargs = []
+        for e, c in self.args:
+            if hints.get('deep', True):
+                if isinstance(e, Basic):
+                    newe = e.doit(**hints)
+                    if newe != self:
+                        e = newe
+                if isinstance(c, Basic):
+                    c = c.doit(**hints)
+            newargs.append((e, c))
+        return self.func(*newargs)
+
+    def _eval_simplify(self, **kwargs):
+        return piecewise_simplify(self, **kwargs)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        for e, c in self.args:
+            if c == True or c.subs(x, 0) == True:
+                return e.as_leading_term(x)
+
+    def _eval_adjoint(self):
+        return self.func(*[(e.adjoint(), c) for e, c in self.args])
+
+    def _eval_conjugate(self):
+        return self.func(*[(e.conjugate(), c) for e, c in self.args])
+
+    def _eval_derivative(self, x):
+        return self.func(*[(diff(e, x), c) for e, c in self.args])
+
+    def _eval_evalf(self, prec):
+        return self.func(*[(e._evalf(prec), c) for e, c in self.args])
+
+    def _eval_is_meromorphic(self, x, a):
+        # Conditions often implicitly assume that the argument is real.
+        # Hence, there needs to be some check for as_set.
+        if not a.is_real:
+            return None
+
+        # Then, scan ExprCondPairs in the given order to find a piece that would contain a,
+        # possibly as a boundary point.
+        for e, c in self.args:
+            cond = c.subs(x, a)
+
+            if cond.is_Relational:
+                return None
+            if a in c.as_set().boundary:
+                return None
+            # Apply expression if a is an interior point of the domain of e.
+            if cond:
+                return e._eval_is_meromorphic(x, a)
+
+    def piecewise_integrate(self, x, **kwargs):
+        """Return the Piecewise with each expression being
+        replaced with its antiderivative. To obtain a continuous
+        antiderivative, use the :func:`~.integrate` function or method.
+
+        Examples
+        ========
+
+        >>> from sympy import Piecewise
+        >>> from sympy.abc import x
+        >>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
+        >>> p.piecewise_integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x, True))
+
+        Note that this does not give a continuous function, e.g.
+        at x = 1 the 3rd condition applies and the antiderivative
+        there is 2*x so the value of the antiderivative is 2:
+
+        >>> anti = _
+        >>> anti.subs(x, 1)
+        2
+
+        The continuous derivative accounts for the integral *up to*
+        the point of interest, however:
+
+        >>> p.integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
+        >>> _.subs(x, 1)
+        1
+
+        See Also
+        ========
+        Piecewise._eval_integral
+        """
+        from sympy.integrals import integrate
+        return self.func(*[(integrate(e, x, **kwargs), c) for e, c in self.args])
+
+    def _handle_irel(self, x, handler):
+        """Return either None (if the conditions of self depend only on x) else
+        a Piecewise expression whose expressions (handled by the handler that
+        was passed) are paired with the governing x-independent relationals,
+        e.g. Piecewise((A, a(x) & b(y)), (B, c(x) | c(y)) ->
+        Piecewise(
+            (handler(Piecewise((A, a(x) & True), (B, c(x) | True)), b(y) & c(y)),
+            (handler(Piecewise((A, a(x) & True), (B, c(x) | False)), b(y)),
+            (handler(Piecewise((A, a(x) & False), (B, c(x) | True)), c(y)),
+            (handler(Piecewise((A, a(x) & False), (B, c(x) | False)), True))
+        """
+        # identify governing relationals
+        rel = self.atoms(Relational)
+        irel = list(ordered([r for r in rel if x not in r.free_symbols
+            and r not in (S.true, S.false)]))
+        if irel:
+            args = {}
+            exprinorder = []
+            for truth in product((1, 0), repeat=len(irel)):
+                reps = dict(zip(irel, truth))
+                # only store the true conditions since the false are implied
+                # when they appear lower in the Piecewise args
+                if 1 not in truth:
+                    cond = None  # flag this one so it doesn't get combined
+                else:
+                    andargs = Tuple(*[i for i in reps if reps[i]])
+                    free = list(andargs.free_symbols)
+                    if len(free) == 1:
+                        from sympy.solvers.inequalities import (
+                            reduce_inequalities, _solve_inequality)
+                        try:
+                            t = reduce_inequalities(andargs, free[0])
+                            # ValueError when there are potentially
+                            # nonvanishing imaginary parts
+                        except (ValueError, NotImplementedError):
+                            # at least isolate free symbol on left
+                            t = And(*[_solve_inequality(
+                                a, free[0], linear=True)
+                                for a in andargs])
+                    else:
+                        t = And(*andargs)
+                    if t is S.false:
+                        continue  # an impossible combination
+                    cond = t
+                expr = handler(self.xreplace(reps))
+                if isinstance(expr, self.func) and len(expr.args) == 1:
+                    expr, econd = expr.args[0]
+                    cond = And(econd, True if cond is None else cond)
+                # the ec pairs are being collected since all possibilities
+                # are being enumerated, but don't put the last one in since
+                # its expr might match a previous expression and it
+                # must appear last in the args
+                if cond is not None:
+                    args.setdefault(expr, []).append(cond)
+                    # but since we only store the true conditions we must maintain
+                    # the order so that the expression with the most true values
+                    # comes first
+                    exprinorder.append(expr)
+            # convert collected conditions as args of Or
+            for k in args:
+                args[k] = Or(*args[k])
+            # take them in the order obtained
+            args = [(e, args[e]) for e in uniq(exprinorder)]
+            # add in the last arg
+            args.append((expr, True))
+            return Piecewise(*args)
+
+    def _eval_integral(self, x, _first=True, **kwargs):
+        """Return the indefinite integral of the
+        Piecewise such that subsequent substitution of x with a
+        value will give the value of the integral (not including
+        the constant of integration) up to that point. To only
+        integrate the individual parts of Piecewise, use the
+        ``piecewise_integrate`` method.
+
+        Examples
+        ========
+
+        >>> from sympy import Piecewise
+        >>> from sympy.abc import x
+        >>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
+        >>> p.integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
+        >>> p.piecewise_integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x, True))
+
+        See Also
+        ========
+        Piecewise.piecewise_integrate
+        """
+        from sympy.integrals.integrals import integrate
+
+        if _first:
+            def handler(ipw):
+                if isinstance(ipw, self.func):
+                    return ipw._eval_integral(x, _first=False, **kwargs)
+                else:
+                    return ipw.integrate(x, **kwargs)
+            irv = self._handle_irel(x, handler)
+            if irv is not None:
+                return irv
+
+        # handle a Piecewise from -oo to oo with and no x-independent relationals
+        # -----------------------------------------------------------------------
+        ok, abei = self._intervals(x)
+        if not ok:
+            from sympy.integrals.integrals import Integral
+            return Integral(self, x)  # unevaluated
+
+        pieces = [(a, b) for a, b, _, _ in abei]
+        oo = S.Infinity
+        done = [(-oo, oo, -1)]
+        for k, p in enumerate(pieces):
+            if p == (-oo, oo):
+                # all undone intervals will get this key
+                for j, (a, b, i) in enumerate(done):
+                    if i == -1:
+                        done[j] = a, b, k
+                break  # nothing else to consider
+            N = len(done) - 1
+            for j, (a, b, i) in enumerate(reversed(done)):
+                if i == -1:
+                    j = N - j
+                    done[j: j + 1] = _clip(p, (a, b), k)
+        done = [(a, b, i) for a, b, i in done if a != b]
+
+        # append an arg if there is a hole so a reference to
+        # argument -1 will give Undefined
+        if any(i == -1 for (a, b, i) in done):
+            abei.append((-oo, oo, Undefined, -1))
+
+        # return the sum of the intervals
+        args = []
+        sum = None
+        for a, b, i in done:
+            anti = integrate(abei[i][-2], x, **kwargs)
+            if sum is None:
+                sum = anti
+            else:
+                sum = sum.subs(x, a)
+                e = anti._eval_interval(x, a, x)
+                if sum.has(*_illegal) or e.has(*_illegal):
+                    sum = anti
+                else:
+                    sum += e
+            # see if we know whether b is contained in original
+            # condition
+            if b is S.Infinity:
+                cond = True
+            elif self.args[abei[i][-1]].cond.subs(x, b) == False:
+                cond = (x < b)
+            else:
+                cond = (x <= b)
+            args.append((sum, cond))
+        return Piecewise(*args)
+
+    def _eval_interval(self, sym, a, b, _first=True):
+        """Evaluates the function along the sym in a given interval [a, b]"""
+        # FIXME: Currently complex intervals are not supported.  A possible
+        # replacement algorithm, discussed in issue 5227, can be found in the
+        # following papers;
+        #     http://portal.acm.org/citation.cfm?id=281649
+        #     http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.70.4127&rep=rep1&type=pdf
+
+        if a is None or b is None:
+            # In this case, it is just simple substitution
+            return super()._eval_interval(sym, a, b)
+        else:
+            x, lo, hi = map(as_Basic, (sym, a, b))
+
+        if _first:  # get only x-dependent relationals
+            def handler(ipw):
+                if isinstance(ipw, self.func):
+                    return ipw._eval_interval(x, lo, hi, _first=None)
+                else:
+                    return ipw._eval_interval(x, lo, hi)
+            irv = self._handle_irel(x, handler)
+            if irv is not None:
+                return irv
+
+            if (lo < hi) is S.false or (
+                    lo is S.Infinity or hi is S.NegativeInfinity):
+                rv = self._eval_interval(x, hi, lo, _first=False)
+                if isinstance(rv, Piecewise):
+                    rv = Piecewise(*[(-e, c) for e, c in rv.args])
+                else:
+                    rv = -rv
+                return rv
+
+            if (lo < hi) is S.true or (
+                    hi is S.Infinity or lo is S.NegativeInfinity):
+                pass
+            else:
+                _a = Dummy('lo')
+                _b = Dummy('hi')
+                a = lo if lo.is_comparable else _a
+                b = hi if hi.is_comparable else _b
+                pos = self._eval_interval(x, a, b, _first=False)
+                if a == _a and b == _b:
+                    # it's purely symbolic so just swap lo and hi and
+                    # change the sign to get the value for when lo > hi
+                    neg, pos = (-pos.xreplace({_a: hi, _b: lo}),
+                        pos.xreplace({_a: lo, _b: hi}))
+                else:
+                    # at least one of the bounds was comparable, so allow
+                    # _eval_interval to use that information when computing
+                    # the interval with lo and hi reversed
+                    neg, pos = (-self._eval_interval(x, hi, lo, _first=False),
+                        pos.xreplace({_a: lo, _b: hi}))
+
+                # allow simplification based on ordering of lo and hi
+                p = Dummy('', positive=True)
+                if lo.is_Symbol:
+                    pos = pos.xreplace({lo: hi - p}).xreplace({p: hi - lo})
+                    neg = neg.xreplace({lo: hi + p}).xreplace({p: lo - hi})
+                elif hi.is_Symbol:
+                    pos = pos.xreplace({hi: lo + p}).xreplace({p: hi - lo})
+                    neg = neg.xreplace({hi: lo - p}).xreplace({p: lo - hi})
+                # evaluate limits that may have unevaluate Min/Max
+                touch = lambda _: _.replace(
+                    lambda x: isinstance(x, (Min, Max)),
+                    lambda x: x.func(*x.args))
+                neg = touch(neg)
+                pos = touch(pos)
+                # assemble return expression; make the first condition be Lt
+                # b/c then the first expression will look the same whether
+                # the lo or hi limit is symbolic
+                if a == _a:  # the lower limit was symbolic
+                    rv = Piecewise(
+                        (pos,
+                            lo < hi),
+                        (neg,
+                            True))
+                else:
+                    rv = Piecewise(
+                        (neg,
+                            hi < lo),
+                        (pos,
+                            True))
+
+                if rv == Undefined:
+                    raise ValueError("Can't integrate across undefined region.")
+                if any(isinstance(i, Piecewise) for i in (pos, neg)):
+                    rv = piecewise_fold(rv)
+                return rv
+
+        # handle a Piecewise with lo <= hi and no x-independent relationals
+        # -----------------------------------------------------------------
+        ok, abei = self._intervals(x)
+        if not ok:
+            from sympy.integrals.integrals import Integral
+            # not being able to do the interval of f(x) can
+            # be stated as not being able to do the integral
+            # of f'(x) over the same range
+            return Integral(self.diff(x), (x, lo, hi))  # unevaluated
+
+        pieces = [(a, b) for a, b, _, _ in abei]
+        done = [(lo, hi, -1)]
+        oo = S.Infinity
+        for k, p in enumerate(pieces):
+            if p[:2] == (-oo, oo):
+                # all undone intervals will get this key
+                for j, (a, b, i) in enumerate(done):
+                    if i == -1:
+                        done[j] = a, b, k
+                break  # nothing else to consider
+            N = len(done) - 1
+            for j, (a, b, i) in enumerate(reversed(done)):
+                if i == -1:
+                    j = N - j
+                    done[j: j + 1] = _clip(p, (a, b), k)
+        done = [(a, b, i) for a, b, i in done if a != b]
+
+        # return the sum of the intervals
+        sum = S.Zero
+        upto = None
+        for a, b, i in done:
+            if i == -1:
+                if upto is None:
+                    return Undefined
+                # TODO simplify hi <= upto
+                return Piecewise((sum, hi <= upto), (Undefined, True))
+            sum += abei[i][-2]._eval_interval(x, a, b)
+            upto = b
+        return sum
+
+    def _intervals(self, sym, err_on_Eq=False):
+        r"""Return a bool and a message (when bool is False), else a
+        list of unique tuples, (a, b, e, i), where a and b
+        are the lower and upper bounds in which the expression e of
+        argument i in self is defined and $a < b$ (when involving
+        numbers) or $a \le b$ when involving symbols.
+
+        If there are any relationals not involving sym, or any
+        relational cannot be solved for sym, the bool will be False
+        a message be given as the second return value. The calling
+        routine should have removed such relationals before calling
+        this routine.
+
+        The evaluated conditions will be returned as ranges.
+        Discontinuous ranges will be returned separately with
+        identical expressions. The first condition that evaluates to
+        True will be returned as the last tuple with a, b = -oo, oo.
+        """
+        from sympy.solvers.inequalities import _solve_inequality
+
+        assert isinstance(self, Piecewise)
+
+        def nonsymfail(cond):
+            return False, filldedent('''
+                A condition not involving
+                %s appeared: %s''' % (sym, cond))
+
+        def _solve_relational(r):
+            if sym not in r.free_symbols:
+                return nonsymfail(r)
+            try:
+                rv = _solve_inequality(r, sym)
+            except NotImplementedError:
+                return False, 'Unable to solve relational %s for %s.' % (r, sym)
+            if isinstance(rv, Relational):
+                free = rv.args[1].free_symbols
+                if rv.args[0] != sym or sym in free:
+                    return False, 'Unable to solve relational %s for %s.' % (r, sym)
+                if rv.rel_op == '==':
+                    # this equality has been affirmed to have the form
+                    # Eq(sym, rhs) where rhs is sym-free; it represents
+                    # a zero-width interval which will be ignored
+                    # whether it is an isolated condition or contained
+                    # within an And or an Or
+                    rv = S.false
+                elif rv.rel_op == '!=':
+                    try:
+                        rv = Or(sym < rv.rhs, sym > rv.rhs)
+                    except TypeError:
+                        # e.g. x != I ==> all real x satisfy
+                        rv = S.true
+            elif rv == (S.NegativeInfinity < sym) & (sym < S.Infinity):
+                rv = S.true
+            return True, rv
+
+        args = list(self.args)
+        # make self canonical wrt Relationals
+        keys = self.atoms(Relational)
+        reps = {}
+        for r in keys:
+            ok, s = _solve_relational(r)
+            if ok != True:
+                return False, ok
+            reps[r] = s
+        # process args individually so if any evaluate, their position
+        # in the original Piecewise will be known
+        args = [i.xreplace(reps) for i in self.args]
+
+        # precondition args
+        expr_cond = []
+        default = idefault = None
+        for i, (expr, cond) in enumerate(args):
+            if cond is S.false:
+                continue
+            if cond is S.true:
+                default = expr
+                idefault = i
+                break
+            if isinstance(cond, Eq):
+                # unanticipated condition, but it is here in case a
+                # replacement caused an Eq to appear
+                if err_on_Eq:
+                    return False, 'encountered Eq condition: %s' % cond
+                continue  # zero width interval
+
+            cond = to_cnf(cond)
+            if isinstance(cond, And):
+                cond = distribute_or_over_and(cond)
+
+            if isinstance(cond, Or):
+                expr_cond.extend(
+                    [(i, expr, o) for o in cond.args
+                    if not isinstance(o, Eq)])
+            elif cond is not S.false:
+                expr_cond.append((i, expr, cond))
+            elif cond is S.true:
+                default = expr
+                idefault = i
+                break
+
+        # determine intervals represented by conditions
+        int_expr = []
+        for iarg, expr, cond in expr_cond:
+            if isinstance(cond, And):
+                lower = S.NegativeInfinity
+                upper = S.Infinity
+                exclude = []
+                for cond2 in cond.args:
+                    if not isinstance(cond2, Relational):
+                        return False, 'expecting only Relationals'
+                    if isinstance(cond2, Eq):
+                        lower = upper  # ignore
+                        if err_on_Eq:
+                            return False, 'encountered secondary Eq condition'
+                        break
+                    elif isinstance(cond2, Ne):
+                        l, r = cond2.args
+                        if l == sym:
+                            exclude.append(r)
+                        elif r == sym:
+                            exclude.append(l)
+                        else:
+                            return nonsymfail(cond2)
+                        continue
+                    elif cond2.lts == sym:
+                        upper = Min(cond2.gts, upper)
+                    elif cond2.gts == sym:
+                        lower = Max(cond2.lts, lower)
+                    else:
+                        return nonsymfail(cond2)  # should never get here
+                if exclude:
+                    exclude = list(ordered(exclude))
+                    newcond = []
+                    for i, e in enumerate(exclude):
+                        if e < lower == True or e > upper == True:
+                            continue
+                        if not newcond:
+                            newcond.append((None, lower))  # add a primer
+                        newcond.append((newcond[-1][1], e))
+                    newcond.append((newcond[-1][1], upper))
+                    newcond.pop(0)  # remove the primer
+                    expr_cond.extend([(iarg, expr, And(i[0] < sym, sym < i[1])) for i in newcond])
+                    continue
+            elif isinstance(cond, Relational) and cond.rel_op != '!=':
+                lower, upper = cond.lts, cond.gts  # part 1: initialize with givens
+                if cond.lts == sym:                # part 1a: expand the side ...
+                    lower = S.NegativeInfinity   # e.g. x <= 0 ---> -oo <= 0
+                elif cond.gts == sym:            # part 1a: ... that can be expanded
+                    upper = S.Infinity           # e.g. x >= 0 --->  oo >= 0
+                else:
+                    return nonsymfail(cond)
+            else:
+                return False, 'unrecognized condition: %s' % cond
+
+            lower, upper = lower, Max(lower, upper)
+            if err_on_Eq and lower == upper:
+                return False, 'encountered Eq condition'
+            if (lower >= upper) is not S.true:
+                int_expr.append((lower, upper, expr, iarg))
+
+        if default is not None:
+            int_expr.append(
+                (S.NegativeInfinity, S.Infinity, default, idefault))
+
+        return True, list(uniq(int_expr))
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        args = [(ec.expr._eval_nseries(x, n, logx), ec.cond) for ec in self.args]
+        return self.func(*args)
+
+    def _eval_power(self, s):
+        return self.func(*[(e**s, c) for e, c in self.args])
+
+    def _eval_subs(self, old, new):
+        # this is strictly not necessary, but we can keep track
+        # of whether True or False conditions arise and be
+        # somewhat more efficient by avoiding other substitutions
+        # and avoiding invalid conditions that appear after a
+        # True condition
+        args = list(self.args)
+        args_exist = False
+        for i, (e, c) in enumerate(args):
+            c = c._subs(old, new)
+            if c != False:
+                args_exist = True
+                e = e._subs(old, new)
+            args[i] = (e, c)
+            if c == True:
+                break
+        if not args_exist:
+            args = ((Undefined, True),)
+        return self.func(*args)
+
+    def _eval_transpose(self):
+        return self.func(*[(e.transpose(), c) for e, c in self.args])
+
+    def _eval_template_is_attr(self, is_attr):
+        b = None
+        for expr, _ in self.args:
+            a = getattr(expr, is_attr)
+            if a is None:
+                return
+            if b is None:
+                b = a
+            elif b is not a:
+                return
+        return b
+
+    _eval_is_finite = lambda self: self._eval_template_is_attr(
+        'is_finite')
+    _eval_is_complex = lambda self: self._eval_template_is_attr('is_complex')
+    _eval_is_even = lambda self: self._eval_template_is_attr('is_even')
+    _eval_is_imaginary = lambda self: self._eval_template_is_attr(
+        'is_imaginary')
+    _eval_is_integer = lambda self: self._eval_template_is_attr('is_integer')
+    _eval_is_irrational = lambda self: self._eval_template_is_attr(
+        'is_irrational')
+    _eval_is_negative = lambda self: self._eval_template_is_attr('is_negative')
+    _eval_is_nonnegative = lambda self: self._eval_template_is_attr(
+        'is_nonnegative')
+    _eval_is_nonpositive = lambda self: self._eval_template_is_attr(
+        'is_nonpositive')
+    _eval_is_nonzero = lambda self: self._eval_template_is_attr(
+        'is_nonzero')
+    _eval_is_odd = lambda self: self._eval_template_is_attr('is_odd')
+    _eval_is_polar = lambda self: self._eval_template_is_attr('is_polar')
+    _eval_is_positive = lambda self: self._eval_template_is_attr('is_positive')
+    _eval_is_extended_real = lambda self: self._eval_template_is_attr(
+            'is_extended_real')
+    _eval_is_extended_positive = lambda self: self._eval_template_is_attr(
+            'is_extended_positive')
+    _eval_is_extended_negative = lambda self: self._eval_template_is_attr(
+            'is_extended_negative')
+    _eval_is_extended_nonzero = lambda self: self._eval_template_is_attr(
+            'is_extended_nonzero')
+    _eval_is_extended_nonpositive = lambda self: self._eval_template_is_attr(
+            'is_extended_nonpositive')
+    _eval_is_extended_nonnegative = lambda self: self._eval_template_is_attr(
+            'is_extended_nonnegative')
+    _eval_is_real = lambda self: self._eval_template_is_attr('is_real')
+    _eval_is_zero = lambda self: self._eval_template_is_attr(
+        'is_zero')
+
+    @classmethod
+    def __eval_cond(cls, cond):
+        """Return the truth value of the condition."""
+        if cond == True:
+            return True
+        if isinstance(cond, Eq):
+            try:
+                diff = cond.lhs - cond.rhs
+                if diff.is_commutative:
+                    return diff.is_zero
+            except TypeError:
+                pass
+
+    def as_expr_set_pairs(self, domain=None):
+        """Return tuples for each argument of self that give
+        the expression and the interval in which it is valid
+        which is contained within the given domain.
+        If a condition cannot be converted to a set, an error
+        will be raised. The variable of the conditions is
+        assumed to be real; sets of real values are returned.
+
+        Examples
+        ========
+
+        >>> from sympy import Piecewise, Interval
+        >>> from sympy.abc import x
+        >>> p = Piecewise(
+        ...     (1, x < 2),
+        ...     (2,(x > 0) & (x < 4)),
+        ...     (3, True))
+        >>> p.as_expr_set_pairs()
+        [(1, Interval.open(-oo, 2)),
+         (2, Interval.Ropen(2, 4)),
+         (3, Interval(4, oo))]
+        >>> p.as_expr_set_pairs(Interval(0, 3))
+        [(1, Interval.Ropen(0, 2)),
+         (2, Interval(2, 3))]
+        """
+        if domain is None:
+            domain = S.Reals
+        exp_sets = []
+        U = domain
+        complex = not domain.is_subset(S.Reals)
+        cond_free = set()
+        for expr, cond in self.args:
+            cond_free |= cond.free_symbols
+            if len(cond_free) > 1:
+                raise NotImplementedError(filldedent('''
+                    multivariate conditions are not handled.'''))
+            if complex:
+                for i in cond.atoms(Relational):
+                    if not isinstance(i, (Eq, Ne)):
+                        raise ValueError(filldedent('''
+                            Inequalities in the complex domain are
+                            not supported. Try the real domain by
+                            setting domain=S.Reals'''))
+            cond_int = U.intersect(cond.as_set())
+            U = U - cond_int
+            if cond_int != S.EmptySet:
+                exp_sets.append((expr, cond_int))
+        return exp_sets
+
+    def _eval_rewrite_as_ITE(self, *args, **kwargs):
+        byfree = {}
+        args = list(args)
+        default = any(c == True for b, c in args)
+        for i, (b, c) in enumerate(args):
+            if not isinstance(b, Boolean) and b != True:
+                raise TypeError(filldedent('''
+                    Expecting Boolean or bool but got `%s`
+                    ''' % func_name(b)))
+            if c == True:
+                break
+            # loop over independent conditions for this b
+            for c in c.args if isinstance(c, Or) else [c]:
+                free = c.free_symbols
+                x = free.pop()
+                try:
+                    byfree[x] = byfree.setdefault(
+                        x, S.EmptySet).union(c.as_set())
+                except NotImplementedError:
+                    if not default:
+                        raise NotImplementedError(filldedent('''
+                            A method to determine whether a multivariate
+                            conditional is consistent with a complete coverage
+                            of all variables has not been implemented so the
+                            rewrite is being stopped after encountering `%s`.
+                            This error would not occur if a default expression
+                            like `(foo, True)` were given.
+                            ''' % c))
+                if byfree[x] in (S.UniversalSet, S.Reals):
+                    # collapse the ith condition to True and break
+                    args[i] = list(args[i])
+                    c = args[i][1] = True
+                    break
+            if c == True:
+                break
+        if c != True:
+            raise ValueError(filldedent('''
+                Conditions must cover all reals or a final default
+                condition `(foo, True)` must be given.
+                '''))
+        last, _ = args[i]  # ignore all past ith arg
+        for a, c in reversed(args[:i]):
+            last = ITE(c, a, last)
+        return _canonical(last)
+
+    def _eval_rewrite_as_KroneckerDelta(self, *args):
+        from sympy.functions.special.tensor_functions import KroneckerDelta
+
+        rules = {
+            And: [False, False],
+            Or: [True, True],
+            Not: [True, False],
+            Eq: [None, None],
+            Ne: [None, None]
+        }
+
+        class UnrecognizedCondition(Exception):
+            pass
+
+        def rewrite(cond):
+            if isinstance(cond, Eq):
+                return KroneckerDelta(*cond.args)
+            if isinstance(cond, Ne):
+                return 1 - KroneckerDelta(*cond.args)
+
+            cls, args = type(cond), cond.args
+            if cls not in rules:
+                raise UnrecognizedCondition(cls)
+
+            b1, b2 = rules[cls]
+            k = Mul(*[1 - rewrite(c) for c in args]) if b1 else Mul(*[rewrite(c) for c in args])
+
+            if b2:
+                return 1 - k
+            return k
+
+        conditions = []
+        true_value = None
+        for value, cond in args:
+            if type(cond) in rules:
+                conditions.append((value, cond))
+            elif cond is S.true:
+                if true_value is None:
+                    true_value = value
+            else:
+                return
+
+        if true_value is not None:
+            result = true_value
+
+            for value, cond in conditions[::-1]:
+                try:
+                    k = rewrite(cond)
+                    result = k * value + (1 - k) * result
+                except UnrecognizedCondition:
+                    return
+
+            return result
+
+
+def piecewise_fold(expr, evaluate=True):
+    """
+    Takes an expression containing a piecewise function and returns the
+    expression in piecewise form. In addition, any ITE conditions are
+    rewritten in negation normal form and simplified.
+
+    The final Piecewise is evaluated (default) but if the raw form
+    is desired, send ``evaluate=False``; if trivial evaluation is
+    desired, send ``evaluate=None`` and duplicate conditions and
+    processing of True and False will be handled.
+
+    Examples
+    ========
+
+    >>> from sympy import Piecewise, piecewise_fold, S
+    >>> from sympy.abc import x
+    >>> p = Piecewise((x, x < 1), (1, S(1) <= x))
+    >>> piecewise_fold(x*p)
+    Piecewise((x**2, x < 1), (x, True))
+
+    See Also
+    ========
+
+    Piecewise
+    piecewise_exclusive
+    """
+    if not isinstance(expr, Basic) or not expr.has(Piecewise):
+        return expr
+
+    new_args = []
+    if isinstance(expr, (ExprCondPair, Piecewise)):
+        for e, c in expr.args:
+            if not isinstance(e, Piecewise):
+                e = piecewise_fold(e)
+            # we don't keep Piecewise in condition because
+            # it has to be checked to see that it's complete
+            # and we convert it to ITE at that time
+            assert not c.has(Piecewise)  # pragma: no cover
+            if isinstance(c, ITE):
+                c = c.to_nnf()
+                c = simplify_logic(c, form='cnf')
+            if isinstance(e, Piecewise):
+                new_args.extend([(piecewise_fold(ei), And(ci, c))
+                    for ei, ci in e.args])
+            else:
+                new_args.append((e, c))
+    else:
+        # Given
+        #     P1 = Piecewise((e11, c1), (e12, c2), A)
+        #     P2 = Piecewise((e21, c1), (e22, c2), B)
+        #     ...
+        # the folding of f(P1, P2) is trivially
+        # Piecewise(
+        #   (f(e11, e21), c1),
+        #   (f(e12, e22), c2),
+        #   (f(Piecewise(A), Piecewise(B)), True))
+        # Certain objects end up rewriting themselves as thus, so
+        # we do that grouping before the more generic folding.
+        # The following applies this idea when f = Add or f = Mul
+        # (and the expression is commutative).
+        if expr.is_Add or expr.is_Mul and expr.is_commutative:
+            p, args = sift(expr.args, lambda x: x.is_Piecewise, binary=True)
+            pc = sift(p, lambda x: tuple([c for e,c in x.args]))
+            for c in list(ordered(pc)):
+                if len(pc[c]) > 1:
+                    pargs = [list(i.args) for i in pc[c]]
+                    # the first one is the same; there may be more
+                    com = common_prefix(*[
+                        [i.cond for i in j] for j in pargs])
+                    n = len(com)
+                    collected = []
+                    for i in range(n):
+                        collected.append((
+                            expr.func(*[ai[i].expr for ai in pargs]),
+                            com[i]))
+                    remains = []
+                    for a in pargs:
+                        if n == len(a):  # no more args
+                            continue
+                        if a[n].cond == True:  # no longer Piecewise
+                            remains.append(a[n].expr)
+                        else:  # restore the remaining Piecewise
+                            remains.append(
+                                Piecewise(*a[n:], evaluate=False))
+                    if remains:
+                        collected.append((expr.func(*remains), True))
+                    args.append(Piecewise(*collected, evaluate=False))
+                    continue
+                args.extend(pc[c])
+        else:
+            args = expr.args
+        # fold
+        folded = list(map(piecewise_fold, args))
+        for ec in product(*[
+                (i.args if isinstance(i, Piecewise) else
+                 [(i, true)]) for i in folded]):
+            e, c = zip(*ec)
+            new_args.append((expr.func(*e), And(*c)))
+
+    if evaluate is None:
+        # don't return duplicate conditions, otherwise don't evaluate
+        new_args = list(reversed([(e, c) for c, e in {
+            c: e for e, c in reversed(new_args)}.items()]))
+    rv = Piecewise(*new_args, evaluate=evaluate)
+    if evaluate is None and len(rv.args) == 1 and rv.args[0].cond == True:
+        return rv.args[0].expr
+    if any(s.expr.has(Piecewise) for p in rv.atoms(Piecewise) for s in p.args):
+        return piecewise_fold(rv)
+    return rv
+
+
+def _clip(A, B, k):
+    """Return interval B as intervals that are covered by A (keyed
+    to k) and all other intervals of B not covered by A keyed to -1.
+
+    The reference point of each interval is the rhs; if the lhs is
+    greater than the rhs then an interval of zero width interval will
+    result, e.g. (4, 1) is treated like (1, 1).
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.piecewise import _clip
+    >>> from sympy import Tuple
+    >>> A = Tuple(1, 3)
+    >>> B = Tuple(2, 4)
+    >>> _clip(A, B, 0)
+    [(2, 3, 0), (3, 4, -1)]
+
+    Interpretation: interval portion (2, 3) of interval (2, 4) is
+    covered by interval (1, 3) and is keyed to 0 as requested;
+    interval (3, 4) was not covered by (1, 3) and is keyed to -1.
+    """
+    a, b = B
+    c, d = A
+    c, d = Min(Max(c, a), b), Min(Max(d, a), b)
+    a, b = Min(a, b), b
+    p = []
+    if a != c:
+        p.append((a, c, -1))
+    else:
+        pass
+    if c != d:
+        p.append((c, d, k))
+    else:
+        pass
+    if b != d:
+        if d == c and p and p[-1][-1] == -1:
+            p[-1] = p[-1][0], b, -1
+        else:
+            p.append((d, b, -1))
+    else:
+        pass
+
+    return p
+
+
+def piecewise_simplify_arguments(expr, **kwargs):
+    from sympy.simplify.simplify import simplify
+
+    # simplify conditions
+    f1 = expr.args[0].cond.free_symbols
+    args = None
+    if len(f1) == 1 and not expr.atoms(Eq):
+        x = f1.pop()
+        # this won't return intervals involving Eq
+        # and it won't handle symbols treated as
+        # booleans
+        ok, abe_ = expr._intervals(x, err_on_Eq=True)
+        def include(c, x, a):
+            "return True if c.subs(x, a) is True, else False"
+            try:
+                return c.subs(x, a) == True
+            except TypeError:
+                return False
+        if ok:
+            args = []
+            covered = S.EmptySet
+            from sympy.sets.sets import Interval
+            for a, b, e, i in abe_:
+                c = expr.args[i].cond
+                incl_a = include(c, x, a)
+                incl_b = include(c, x, b)
+                iv = Interval(a, b, not incl_a, not incl_b)
+                cset = iv - covered
+                if not cset:
+                    continue
+                if incl_a and incl_b:
+                    if a.is_infinite and b.is_infinite:
+                        c = S.true
+                    elif b.is_infinite:
+                        c = (x >= a)
+                    elif a in covered or a.is_infinite:
+                        c = (x <= b)
+                    else:
+                        c = And(a <= x, x <= b)
+                elif incl_a:
+                    if a in covered or a.is_infinite:
+                        c = (x < b)
+                    else:
+                        c = And(a <= x, x < b)
+                elif incl_b:
+                    if b.is_infinite:
+                        c = (x > a)
+                    else:
+                        c = (x <= b)
+                else:
+                    if a in covered:
+                        c = (x < b)
+                    else:
+                        c = And(a < x, x < b)
+                covered |= iv
+                if a is S.NegativeInfinity and incl_a:
+                    covered |= {S.NegativeInfinity}
+                if b is S.Infinity and incl_b:
+                    covered |= {S.Infinity}
+                args.append((e, c))
+            if not S.Reals.is_subset(covered):
+                args.append((Undefined, True))
+    if args is None:
+        args = list(expr.args)
+        for i in range(len(args)):
+            e, c  = args[i]
+            if isinstance(c, Basic):
+                c = simplify(c, **kwargs)
+            args[i] = (e, c)
+
+    # simplify expressions
+    doit = kwargs.pop('doit', None)
+    for i in range(len(args)):
+        e, c  = args[i]
+        if isinstance(e, Basic):
+            # Skip doit to avoid growth at every call for some integrals
+            # and sums, see sympy/sympy#17165
+            newe = simplify(e, doit=False, **kwargs)
+            if newe != e:
+                e = newe
+        args[i] = (e, c)
+
+    # restore kwargs flag
+    if doit is not None:
+        kwargs['doit'] = doit
+
+    return Piecewise(*args)
+
+
+def _piecewise_collapse_arguments(_args):
+    newargs = []  # the unevaluated conditions
+    current_cond = set()  # the conditions up to a given e, c pair
+    for expr, cond in _args:
+        cond = cond.replace(
+            lambda _: _.is_Relational, _canonical_coeff)
+        # Check here if expr is a Piecewise and collapse if one of
+        # the conds in expr matches cond. This allows the collapsing
+        # of Piecewise((Piecewise((x,x<0)),x<0)) to Piecewise((x,x<0)).
+        # This is important when using piecewise_fold to simplify
+        # multiple Piecewise instances having the same conds.
+        # Eventually, this code should be able to collapse Piecewise's
+        # having different intervals, but this will probably require
+        # using the new assumptions.
+        if isinstance(expr, Piecewise):
+            unmatching = []
+            for i, (e, c) in enumerate(expr.args):
+                if c in current_cond:
+                    # this would already have triggered
+                    continue
+                if c == cond:
+                    if c != True:
+                        # nothing past this condition will ever
+                        # trigger and only those args before this
+                        # that didn't match a previous condition
+                        # could possibly trigger
+                        if unmatching:
+                            expr = Piecewise(*(
+                                unmatching + [(e, c)]))
+                        else:
+                            expr = e
+                    break
+                else:
+                    unmatching.append((e, c))
+
+        # check for condition repeats
+        got = False
+        # -- if an And contains a condition that was
+        #    already encountered, then the And will be
+        #    False: if the previous condition was False
+        #    then the And will be False and if the previous
+        #    condition is True then then we wouldn't get to
+        #    this point. In either case, we can skip this condition.
+        for i in ([cond] +
+                  (list(cond.args) if isinstance(cond, And) else
+                  [])):
+            if i in current_cond:
+                got = True
+                break
+        if got:
+            continue
+
+        # -- if not(c) is already in current_cond then c is
+        #    a redundant condition in an And. This does not
+        #    apply to Or, however: (e1, c), (e2, Or(~c, d))
+        #    is not (e1, c), (e2, d) because if c and d are
+        #    both False this would give no results when the
+        #    true answer should be (e2, True)
+        if isinstance(cond, And):
+            nonredundant = []
+            for c in cond.args:
+                if isinstance(c, Relational):
+                    if c.negated.canonical in current_cond:
+                        continue
+                    # if a strict inequality appears after
+                    # a non-strict one, then the condition is
+                    # redundant
+                    if isinstance(c, (Lt, Gt)) and (
+                        c.weak in current_cond):
+                        cond = False
+                        break
+                nonredundant.append(c)
+            else:
+                cond = cond.func(*nonredundant)
+        elif isinstance(cond, Relational):
+            if cond.negated.canonical in current_cond:
+                cond = S.true
+
+        current_cond.add(cond)
+
+        # collect successive e,c pairs when exprs or cond match
+        if newargs:
+            if newargs[-1].expr == expr:
+                orcond = Or(cond, newargs[-1].cond)
+                if isinstance(orcond, (And, Or)):
+                    orcond = distribute_and_over_or(orcond)
+                newargs[-1] = ExprCondPair(expr, orcond)
+                continue
+            elif newargs[-1].cond == cond:
+                continue
+        newargs.append(ExprCondPair(expr, cond))
+    return newargs
+
+
+_blessed = lambda e: getattr(e.lhs, '_diff_wrt', False) and (
+    getattr(e.rhs, '_diff_wrt', None) or
+    isinstance(e.rhs, (Rational, NumberSymbol)))
+
+
+def piecewise_simplify(expr, **kwargs):
+    expr = piecewise_simplify_arguments(expr, **kwargs)
+    if not isinstance(expr, Piecewise):
+        return expr
+    args = list(expr.args)
+
+    args = _piecewise_simplify_eq_and(args)
+    args = _piecewise_simplify_equal_to_next_segment(args)
+    return Piecewise(*args)
+
+
+def _piecewise_simplify_equal_to_next_segment(args):
+    """
+    See if expressions valid for an Equal expression happens to evaluate
+    to the same function as in the next piecewise segment, see:
+    https://github.com/sympy/sympy/issues/8458
+    """
+    prevexpr = None
+    for i, (expr, cond) in reversed(list(enumerate(args))):
+        if prevexpr is not None:
+            if isinstance(cond, And):
+                eqs, other = sift(cond.args,
+                                  lambda i: isinstance(i, Eq), binary=True)
+            elif isinstance(cond, Eq):
+                eqs, other = [cond], []
+            else:
+                eqs = other = []
+            _prevexpr = prevexpr
+            _expr = expr
+            if eqs and not other:
+                eqs = list(ordered(eqs))
+                for e in eqs:
+                    # allow 2 args to collapse into 1 for any e
+                    # otherwise limit simplification to only simple-arg
+                    # Eq instances
+                    if len(args) == 2 or _blessed(e):
+                        _prevexpr = _prevexpr.subs(*e.args)
+                        _expr = _expr.subs(*e.args)
+            # Did it evaluate to the same?
+            if _prevexpr == _expr:
+                # Set the expression for the Not equal section to the same
+                # as the next. These will be merged when creating the new
+                # Piecewise
+                args[i] = args[i].func(args[i + 1][0], cond)
+            else:
+                # Update the expression that we compare against
+                prevexpr = expr
+        else:
+            prevexpr = expr
+    return args
+
+
+def _piecewise_simplify_eq_and(args):
+    """
+    Try to simplify conditions and the expression for
+    equalities that are part of the condition, e.g.
+    Piecewise((n, And(Eq(n,0), Eq(n + m, 0))), (1, True))
+    -> Piecewise((0, And(Eq(n, 0), Eq(m, 0))), (1, True))
+    """
+    for i, (expr, cond) in enumerate(args):
+        if isinstance(cond, And):
+            eqs, other = sift(cond.args,
+                              lambda i: isinstance(i, Eq), binary=True)
+        elif isinstance(cond, Eq):
+            eqs, other = [cond], []
+        else:
+            eqs = other = []
+        if eqs:
+            eqs = list(ordered(eqs))
+            for j, e in enumerate(eqs):
+                # these blessed lhs objects behave like Symbols
+                # and the rhs are simple replacements for the "symbols"
+                if _blessed(e):
+                    expr = expr.subs(*e.args)
+                    eqs[j + 1:] = [ei.subs(*e.args) for ei in eqs[j + 1:]]
+                    other = [ei.subs(*e.args) for ei in other]
+            cond = And(*(eqs + other))
+            args[i] = args[i].func(expr, cond)
+    return args
+
+
+def piecewise_exclusive(expr, *, skip_nan=False, deep=True):
+    """
+    Rewrite :class:`Piecewise` with mutually exclusive conditions.
+
+    Explanation
+    ===========
+
+    SymPy represents the conditions of a :class:`Piecewise` in an
+    "if-elif"-fashion, allowing more than one condition to be simultaneously
+    True. The interpretation is that the first condition that is True is the
+    case that holds. While this is a useful representation computationally it
+    is not how a piecewise formula is typically shown in a mathematical text.
+    The :func:`piecewise_exclusive` function can be used to rewrite any
+    :class:`Piecewise` with more typical mutually exclusive conditions.
+
+    Note that further manipulation of the resulting :class:`Piecewise`, e.g.
+    simplifying it, will most likely make it non-exclusive. Hence, this is
+    primarily a function to be used in conjunction with printing the Piecewise
+    or if one would like to reorder the expression-condition pairs.
+
+    If it is not possible to determine that all possibilities are covered by
+    the different cases of the :class:`Piecewise` then a final
+    :class:`~sympy.core.numbers.NaN` case will be included explicitly. This
+    can be prevented by passing ``skip_nan=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import piecewise_exclusive, Symbol, Piecewise, S
+    >>> x = Symbol('x', real=True)
+    >>> p = Piecewise((0, x < 0), (S.Half, x <= 0), (1, True))
+    >>> piecewise_exclusive(p)
+    Piecewise((0, x < 0), (1/2, Eq(x, 0)), (1, x > 0))
+    >>> piecewise_exclusive(Piecewise((2, x > 1)))
+    Piecewise((2, x > 1), (nan, x <= 1))
+    >>> piecewise_exclusive(Piecewise((2, x > 1)), skip_nan=True)
+    Piecewise((2, x > 1))
+
+    Parameters
+    ==========
+
+    expr: a SymPy expression.
+        Any :class:`Piecewise` in the expression will be rewritten.
+    skip_nan: ``bool`` (default ``False``)
+        If ``skip_nan`` is set to ``True`` then a final
+        :class:`~sympy.core.numbers.NaN` case will not be included.
+    deep:  ``bool`` (default ``True``)
+        If ``deep`` is ``True`` then :func:`piecewise_exclusive` will rewrite
+        any :class:`Piecewise` subexpressions in ``expr`` rather than just
+        rewriting ``expr`` itself.
+
+    Returns
+    =======
+
+    An expression equivalent to ``expr`` but where all :class:`Piecewise` have
+    been rewritten with mutually exclusive conditions.
+
+    See Also
+    ========
+
+    Piecewise
+    piecewise_fold
+    """
+
+    def make_exclusive(*pwargs):
+
+        cumcond = false
+        newargs = []
+
+        # Handle the first n-1 cases
+        for expr_i, cond_i in pwargs[:-1]:
+            cancond = And(cond_i, Not(cumcond)).simplify()
+            cumcond = Or(cond_i, cumcond).simplify()
+            newargs.append((expr_i, cancond))
+
+        # For the nth case defer simplification of cumcond
+        expr_n, cond_n = pwargs[-1]
+        cancond_n = And(cond_n, Not(cumcond)).simplify()
+        newargs.append((expr_n, cancond_n))
+
+        if not skip_nan:
+            cumcond = Or(cond_n, cumcond).simplify()
+            if cumcond is not true:
+                newargs.append((Undefined, Not(cumcond).simplify()))
+
+        return Piecewise(*newargs, evaluate=False)
+
+    if deep:
+        return expr.replace(Piecewise, make_exclusive)
+    elif isinstance(expr, Piecewise):
+        return make_exclusive(*expr.args)
+    else:
+        return expr

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

@@ -0,0 +1,11 @@
+from .core import dispatch
+from .dispatcher import (Dispatcher, halt_ordering, restart_ordering,
+    MDNotImplementedError)
+
+__version__ = '0.4.9'
+
+__all__ = [
+    'dispatch',
+
+    'Dispatcher', 'halt_ordering', 'restart_ordering', 'MDNotImplementedError',
+]

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

@@ -0,0 +1,68 @@
+from .utils import _toposort, groupby
+
+class AmbiguityWarning(Warning):
+    pass
+
+
+def supercedes(a, b):
+    """ A is consistent and strictly more specific than B """
+    return len(a) == len(b) and all(map(issubclass, a, b))
+
+
+def consistent(a, b):
+    """ It is possible for an argument list to satisfy both A and B """
+    return (len(a) == len(b) and
+            all(issubclass(aa, bb) or issubclass(bb, aa)
+                           for aa, bb in zip(a, b)))
+
+
+def ambiguous(a, b):
+    """ A is consistent with B but neither is strictly more specific """
+    return consistent(a, b) and not (supercedes(a, b) or supercedes(b, a))
+
+
+def ambiguities(signatures):
+    """ All signature pairs such that A is ambiguous with B """
+    signatures = list(map(tuple, signatures))
+    return {(a, b) for a in signatures for b in signatures
+                       if hash(a) < hash(b)
+                       and ambiguous(a, b)
+                       and not any(supercedes(c, a) and supercedes(c, b)
+                                    for c in signatures)}
+
+
+def super_signature(signatures):
+    """ A signature that would break ambiguities """
+    n = len(signatures[0])
+    assert all(len(s) == n for s in signatures)
+
+    return [max([type.mro(sig[i]) for sig in signatures], key=len)[0]
+               for i in range(n)]
+
+
+def edge(a, b, tie_breaker=hash):
+    """ A should be checked before B
+
+    Tie broken by tie_breaker, defaults to ``hash``
+    """
+    if supercedes(a, b):
+        if supercedes(b, a):
+            return tie_breaker(a) > tie_breaker(b)
+        else:
+            return True
+    return False
+
+
+def ordering(signatures):
+    """ A sane ordering of signatures to check, first to last
+
+    Topoological sort of edges as given by ``edge`` and ``supercedes``
+    """
+    signatures = list(map(tuple, signatures))
+    edges = [(a, b) for a in signatures for b in signatures if edge(a, b)]
+    edges = groupby(lambda x: x[0], edges)
+    for s in signatures:
+        if s not in edges:
+            edges[s] = []
+    edges = {k: [b for a, b in v] for k, v in edges.items()}
+    return _toposort(edges)

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

@@ -0,0 +1,83 @@
+from __future__ import annotations
+from typing import Any
+
+import inspect
+
+from .dispatcher import Dispatcher, MethodDispatcher, ambiguity_warn
+
+# XXX: This parameter to dispatch isn't documented and isn't used anywhere in
+# sympy. Maybe it should just be removed.
+global_namespace: dict[str, Any] = {}
+
+
+def dispatch(*types, namespace=global_namespace, on_ambiguity=ambiguity_warn):
+    """ Dispatch function on the types of the inputs
+
+    Supports dispatch on all non-keyword arguments.
+
+    Collects implementations based on the function name.  Ignores namespaces.
+
+    If ambiguous type signatures occur a warning is raised when the function is
+    defined suggesting the additional method to break the ambiguity.
+
+    Examples
+    --------
+
+    >>> from sympy.multipledispatch import dispatch
+    >>> @dispatch(int)
+    ... def f(x):
+    ...     return x + 1
+
+    >>> @dispatch(float)
+    ... def f(x): # noqa: F811
+    ...     return x - 1
+
+    >>> f(3)
+    4
+    >>> f(3.0)
+    2.0
+
+    Specify an isolated namespace with the namespace keyword argument
+
+    >>> my_namespace = dict()
+    >>> @dispatch(int, namespace=my_namespace)
+    ... def foo(x):
+    ...     return x + 1
+
+    Dispatch on instance methods within classes
+
+    >>> class MyClass(object):
+    ...     @dispatch(list)
+    ...     def __init__(self, data):
+    ...         self.data = data
+    ...     @dispatch(int)
+    ...     def __init__(self, datum): # noqa: F811
+    ...         self.data = [datum]
+    """
+    types = tuple(types)
+
+    def _(func):
+        name = func.__name__
+
+        if ismethod(func):
+            dispatcher = inspect.currentframe().f_back.f_locals.get(
+                name,
+                MethodDispatcher(name))
+        else:
+            if name not in namespace:
+                namespace[name] = Dispatcher(name)
+            dispatcher = namespace[name]
+
+        dispatcher.add(types, func, on_ambiguity=on_ambiguity)
+        return dispatcher
+    return _
+
+
+def ismethod(func):
+    """ Is func a method?
+
+    Note that this has to work as the method is defined but before the class is
+    defined.  At this stage methods look like functions.
+    """
+    signature = inspect.signature(func)
+    return signature.parameters.get('self', None) is not None

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

@@ -0,0 +1,413 @@
+from __future__ import annotations
+
+from warnings import warn
+import inspect
+from .conflict import ordering, ambiguities, super_signature, AmbiguityWarning
+from .utils import expand_tuples
+import itertools as itl
+
+
+class MDNotImplementedError(NotImplementedError):
+    """ A NotImplementedError for multiple dispatch """
+
+
+### Functions for on_ambiguity
+
+def ambiguity_warn(dispatcher, ambiguities):
+    """ Raise warning when ambiguity is detected
+
+    Parameters
+    ----------
+    dispatcher : Dispatcher
+        The dispatcher on which the ambiguity was detected
+    ambiguities : set
+        Set of type signature pairs that are ambiguous within this dispatcher
+
+    See Also:
+        Dispatcher.add
+        warning_text
+    """
+    warn(warning_text(dispatcher.name, ambiguities), AmbiguityWarning)
+
+
+class RaiseNotImplementedError:
+    """Raise ``NotImplementedError`` when called."""
+
+    def __init__(self, dispatcher):
+        self.dispatcher = dispatcher
+
+    def __call__(self, *args, **kwargs):
+        types = tuple(type(a) for a in args)
+        raise NotImplementedError(
+            "Ambiguous signature for %s: <%s>" % (
+            self.dispatcher.name, str_signature(types)
+        ))
+
+def ambiguity_register_error_ignore_dup(dispatcher, ambiguities):
+    """
+    If super signature for ambiguous types is duplicate types, ignore it.
+    Else, register instance of ``RaiseNotImplementedError`` for ambiguous types.
+
+    Parameters
+    ----------
+    dispatcher : Dispatcher
+        The dispatcher on which the ambiguity was detected
+    ambiguities : set
+        Set of type signature pairs that are ambiguous within this dispatcher
+
+    See Also:
+        Dispatcher.add
+        ambiguity_warn
+    """
+    for amb in ambiguities:
+        signature = tuple(super_signature(amb))
+        if len(set(signature)) == 1:
+            continue
+        dispatcher.add(
+            signature, RaiseNotImplementedError(dispatcher),
+            on_ambiguity=ambiguity_register_error_ignore_dup
+        )
+
+###
+
+
+_unresolved_dispatchers: set[Dispatcher] = set()
+_resolve = [True]
+
+
+def halt_ordering():
+    _resolve[0] = False
+
+
+def restart_ordering(on_ambiguity=ambiguity_warn):
+    _resolve[0] = True
+    while _unresolved_dispatchers:
+        dispatcher = _unresolved_dispatchers.pop()
+        dispatcher.reorder(on_ambiguity=on_ambiguity)
+
+
+class Dispatcher:
+    """ Dispatch methods based on type signature
+
+    Use ``dispatch`` to add implementations
+
+    Examples
+    --------
+
+    >>> from sympy.multipledispatch import dispatch
+    >>> @dispatch(int)
+    ... def f(x):
+    ...     return x + 1
+
+    >>> @dispatch(float)
+    ... def f(x): # noqa: F811
+    ...     return x - 1
+
+    >>> f(3)
+    4
+    >>> f(3.0)
+    2.0
+    """
+    __slots__ = '__name__', 'name', 'funcs', 'ordering', '_cache', 'doc'
+
+    def __init__(self, name, doc=None):
+        self.name = self.__name__ = name
+        self.funcs = {}
+        self._cache = {}
+        self.ordering = []
+        self.doc = doc
+
+    def register(self, *types, **kwargs):
+        """ Register dispatcher with new implementation
+
+        >>> from sympy.multipledispatch.dispatcher import Dispatcher
+        >>> f = Dispatcher('f')
+        >>> @f.register(int)
+        ... def inc(x):
+        ...     return x + 1
+
+        >>> @f.register(float)
+        ... def dec(x):
+        ...     return x - 1
+
+        >>> @f.register(list)
+        ... @f.register(tuple)
+        ... def reverse(x):
+        ...     return x[::-1]
+
+        >>> f(1)
+        2
+
+        >>> f(1.0)
+        0.0
+
+        >>> f([1, 2, 3])
+        [3, 2, 1]
+        """
+        def _(func):
+            self.add(types, func, **kwargs)
+            return func
+        return _
+
+    @classmethod
+    def get_func_params(cls, func):
+        if hasattr(inspect, "signature"):
+            sig = inspect.signature(func)
+            return sig.parameters.values()
+
+    @classmethod
+    def get_func_annotations(cls, func):
+        """ Get annotations of function positional parameters
+        """
+        params = cls.get_func_params(func)
+        if params:
+            Parameter = inspect.Parameter
+
+            params = (param for param in params
+                      if param.kind in
+                      (Parameter.POSITIONAL_ONLY,
+                       Parameter.POSITIONAL_OR_KEYWORD))
+
+            annotations = tuple(
+                param.annotation
+                for param in params)
+
+            if not any(ann is Parameter.empty for ann in annotations):
+                return annotations
+
+    def add(self, signature, func, on_ambiguity=ambiguity_warn):
+        """ Add new types/method pair to dispatcher
+
+        >>> from sympy.multipledispatch import Dispatcher
+        >>> D = Dispatcher('add')
+        >>> D.add((int, int), lambda x, y: x + y)
+        >>> D.add((float, float), lambda x, y: x + y)
+
+        >>> D(1, 2)
+        3
+        >>> D(1, 2.0)
+        Traceback (most recent call last):
+        ...
+        NotImplementedError: Could not find signature for add: <int, float>
+
+        When ``add`` detects a warning it calls the ``on_ambiguity`` callback
+        with a dispatcher/itself, and a set of ambiguous type signature pairs
+        as inputs.  See ``ambiguity_warn`` for an example.
+        """
+        # Handle annotations
+        if not signature:
+            annotations = self.get_func_annotations(func)
+            if annotations:
+                signature = annotations
+
+        # Handle union types
+        if any(isinstance(typ, tuple) for typ in signature):
+            for typs in expand_tuples(signature):
+                self.add(typs, func, on_ambiguity)
+            return
+
+        for typ in signature:
+            if not isinstance(typ, type):
+                str_sig = ', '.join(c.__name__ if isinstance(c, type)
+                                    else str(c) for c in signature)
+                raise TypeError("Tried to dispatch on non-type: %s\n"
+                                "In signature: <%s>\n"
+                                "In function: %s" %
+                                (typ, str_sig, self.name))
+
+        self.funcs[signature] = func
+        self.reorder(on_ambiguity=on_ambiguity)
+        self._cache.clear()
+
+    def reorder(self, on_ambiguity=ambiguity_warn):
+        if _resolve[0]:
+            self.ordering = ordering(self.funcs)
+            amb = ambiguities(self.funcs)
+            if amb:
+                on_ambiguity(self, amb)
+        else:
+            _unresolved_dispatchers.add(self)
+
+    def __call__(self, *args, **kwargs):
+        types = tuple([type(arg) for arg in args])
+        try:
+            func = self._cache[types]
+        except KeyError:
+            func = self.dispatch(*types)
+            if not func:
+                raise NotImplementedError(
+                    'Could not find signature for %s: <%s>' %
+                    (self.name, str_signature(types)))
+            self._cache[types] = func
+        try:
+            return func(*args, **kwargs)
+
+        except MDNotImplementedError:
+            funcs = self.dispatch_iter(*types)
+            next(funcs)  # burn first
+            for func in funcs:
+                try:
+                    return func(*args, **kwargs)
+                except MDNotImplementedError:
+                    pass
+            raise NotImplementedError("Matching functions for "
+                                      "%s: <%s> found, but none completed successfully"
+                                      % (self.name, str_signature(types)))
+
+    def __str__(self):
+        return "<dispatched %s>" % self.name
+    __repr__ = __str__
+
+    def dispatch(self, *types):
+        """ Deterimine appropriate implementation for this type signature
+
+        This method is internal.  Users should call this object as a function.
+        Implementation resolution occurs within the ``__call__`` method.
+
+        >>> from sympy.multipledispatch import dispatch
+        >>> @dispatch(int)
+        ... def inc(x):
+        ...     return x + 1
+
+        >>> implementation = inc.dispatch(int)
+        >>> implementation(3)
+        4
+
+        >>> print(inc.dispatch(float))
+        None
+
+        See Also:
+            ``sympy.multipledispatch.conflict`` - module to determine resolution order
+        """
+
+        if types in self.funcs:
+            return self.funcs[types]
+
+        try:
+            return next(self.dispatch_iter(*types))
+        except StopIteration:
+            return None
+
+    def dispatch_iter(self, *types):
+        n = len(types)
+        for signature in self.ordering:
+            if len(signature) == n and all(map(issubclass, types, signature)):
+                result = self.funcs[signature]
+                yield result
+
+    def resolve(self, types):
+        """ Deterimine appropriate implementation for this type signature
+
+        .. deprecated:: 0.4.4
+            Use ``dispatch(*types)`` instead
+        """
+        warn("resolve() is deprecated, use dispatch(*types)",
+             DeprecationWarning)
+
+        return self.dispatch(*types)
+
+    def __getstate__(self):
+        return {'name': self.name,
+                'funcs': self.funcs}
+
+    def __setstate__(self, d):
+        self.name = d['name']
+        self.funcs = d['funcs']
+        self.ordering = ordering(self.funcs)
+        self._cache = {}
+
+    @property
+    def __doc__(self):
+        docs = ["Multiply dispatched method: %s" % self.name]
+
+        if self.doc:
+            docs.append(self.doc)
+
+        other = []
+        for sig in self.ordering[::-1]:
+            func = self.funcs[sig]
+            if func.__doc__:
+                s = 'Inputs: <%s>\n' % str_signature(sig)
+                s += '-' * len(s) + '\n'
+                s += func.__doc__.strip()
+                docs.append(s)
+            else:
+                other.append(str_signature(sig))
+
+        if other:
+            docs.append('Other signatures:\n    ' + '\n    '.join(other))
+
+        return '\n\n'.join(docs)
+
+    def _help(self, *args):
+        return self.dispatch(*map(type, args)).__doc__
+
+    def help(self, *args, **kwargs):
+        """ Print docstring for the function corresponding to inputs """
+        print(self._help(*args))
+
+    def _source(self, *args):
+        func = self.dispatch(*map(type, args))
+        if not func:
+            raise TypeError("No function found")
+        return source(func)
+
+    def source(self, *args, **kwargs):
+        """ Print source code for the function corresponding to inputs """
+        print(self._source(*args))
+
+
+def source(func):
+    s = 'File: %s\n\n' % inspect.getsourcefile(func)
+    s = s + inspect.getsource(func)
+    return s
+
+
+class MethodDispatcher(Dispatcher):
+    """ Dispatch methods based on type signature
+
+    See Also:
+        Dispatcher
+    """
+
+    @classmethod
+    def get_func_params(cls, func):
+        if hasattr(inspect, "signature"):
+            sig = inspect.signature(func)
+            return itl.islice(sig.parameters.values(), 1, None)
+
+    def __get__(self, instance, owner):
+        self.obj = instance
+        self.cls = owner
+        return self
+
+    def __call__(self, *args, **kwargs):
+        types = tuple([type(arg) for arg in args])
+        func = self.dispatch(*types)
+        if not func:
+            raise NotImplementedError('Could not find signature for %s: <%s>' %
+                                      (self.name, str_signature(types)))
+        return func(self.obj, *args, **kwargs)
+
+
+def str_signature(sig):
+    """ String representation of type signature
+
+    >>> from sympy.multipledispatch.dispatcher import str_signature
+    >>> str_signature((int, float))
+    'int, float'
+    """
+    return ', '.join(cls.__name__ for cls in sig)
+
+
+def warning_text(name, amb):
+    """ The text for ambiguity warnings """
+    text = "\nAmbiguities exist in dispatched function %s\n\n" % (name)
+    text += "The following signatures may result in ambiguous behavior:\n"
+    for pair in amb:
+        text += "\t" + \
+            ', '.join('[' + str_signature(s) + ']' for s in pair) + "\n"
+    text += "\n\nConsider making the following additions:\n\n"
+    text += '\n\n'.join(['@dispatch(' + str_signature(super_signature(s))
+                         + ')\ndef %s(...)' % name for s in amb])
+    return text

llmeval-env/lib/python3.10/site-packages/sympy/multipledispatch/tests/test_conflict.py

@@ -0,0 +1,62 @@
+from sympy.multipledispatch.conflict import (supercedes, ordering, ambiguities,
+        ambiguous, super_signature, consistent)
+
+
+class A: pass
+class B(A): pass
+class C: pass
+
+
+def test_supercedes():
+    assert supercedes([B], [A])
+    assert supercedes([B, A], [A, A])
+    assert not supercedes([B, A], [A, B])
+    assert not supercedes([A], [B])
+
+
+def test_consistent():
+    assert consistent([A], [A])
+    assert consistent([B], [B])
+    assert not consistent([A], [C])
+    assert consistent([A, B], [A, B])
+    assert consistent([B, A], [A, B])
+    assert not consistent([B, A], [B])
+    assert not consistent([B, A], [B, C])
+
+
+def test_super_signature():
+    assert super_signature([[A]]) == [A]
+    assert super_signature([[A], [B]]) == [B]
+    assert super_signature([[A, B], [B, A]]) == [B, B]
+    assert super_signature([[A, A, B], [A, B, A], [B, A, A]]) == [B, B, B]
+
+
+def test_ambiguous():
+    assert not ambiguous([A], [A])
+    assert not ambiguous([A], [B])
+    assert not ambiguous([B], [B])
+    assert not ambiguous([A, B], [B, B])
+    assert ambiguous([A, B], [B, A])
+
+
+def test_ambiguities():
+    signatures = [[A], [B], [A, B], [B, A], [A, C]]
+    expected = {((A, B), (B, A))}
+    result = ambiguities(signatures)
+    assert set(map(frozenset, expected)) == set(map(frozenset, result))
+
+    signatures = [[A], [B], [A, B], [B, A], [A, C], [B, B]]
+    expected = set()
+    result = ambiguities(signatures)
+    assert set(map(frozenset, expected)) == set(map(frozenset, result))
+
+
+def test_ordering():
+    signatures = [[A, A], [A, B], [B, A], [B, B], [A, C]]
+    ord = ordering(signatures)
+    assert ord[0] == (B, B) or ord[0] == (A, C)
+    assert ord[-1] == (A, A) or ord[-1] == (A, C)
+
+
+def test_type_mro():
+    assert super_signature([[object], [type]]) == [type]

llmeval-env/lib/python3.10/site-packages/sympy/multipledispatch/tests/test_core.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+from typing import Any
+
+from sympy.multipledispatch import dispatch
+from sympy.multipledispatch.conflict import AmbiguityWarning
+from sympy.testing.pytest import raises, warns
+from functools import partial
+
+test_namespace: dict[str, Any] = {}
+
+orig_dispatch = dispatch
+dispatch = partial(dispatch, namespace=test_namespace)
+
+
+def test_singledispatch():
+    @dispatch(int)
+    def f(x): # noqa:F811
+        return x + 1
+
+    @dispatch(int)
+    def g(x): # noqa:F811
+        return x + 2
+
+    @dispatch(float) # noqa:F811
+    def f(x): # noqa:F811
+        return x - 1
+
+    assert f(1) == 2
+    assert g(1) == 3
+    assert f(1.0) == 0
+
+    assert raises(NotImplementedError, lambda: f('hello'))
+
+
+def test_multipledispatch():
+    @dispatch(int, int)
+    def f(x, y): # noqa:F811
+        return x + y
+
+    @dispatch(float, float) # noqa:F811
+    def f(x, y): # noqa:F811
+        return x - y
+
+    assert f(1, 2) == 3
+    assert f(1.0, 2.0) == -1.0
+
+
+class A: pass
+class B: pass
+class C(A): pass
+class D(C): pass
+class E(C): pass
+
+
+def test_inheritance():
+    @dispatch(A)
+    def f(x): # noqa:F811
+        return 'a'
+
+    @dispatch(B) # noqa:F811
+    def f(x): # noqa:F811
+        return 'b'
+
+    assert f(A()) == 'a'
+    assert f(B()) == 'b'
+    assert f(C()) == 'a'
+
+
+def test_inheritance_and_multiple_dispatch():
+    @dispatch(A, A)
+    def f(x, y): # noqa:F811
+        return type(x), type(y)
+
+    @dispatch(A, B) # noqa:F811
+    def f(x, y): # noqa:F811
+        return 0
+
+    assert f(A(), A()) == (A, A)
+    assert f(A(), C()) == (A, C)
+    assert f(A(), B()) == 0
+    assert f(C(), B()) == 0
+    assert raises(NotImplementedError, lambda: f(B(), B()))
+
+
+def test_competing_solutions():
+    @dispatch(A)
+    def h(x): # noqa:F811
+        return 1
+
+    @dispatch(C) # noqa:F811
+    def h(x): # noqa:F811
+        return 2
+
+    assert h(D()) == 2
+
+
+def test_competing_multiple():
+    @dispatch(A, B)
+    def h(x, y): # noqa:F811
+        return 1
+
+    @dispatch(C, B) # noqa:F811
+    def h(x, y): # noqa:F811
+        return 2
+
+    assert h(D(), B()) == 2
+
+
+def test_competing_ambiguous():
+    test_namespace = {}
+    dispatch = partial(orig_dispatch, namespace=test_namespace)
+
+    @dispatch(A, C)
+    def f(x, y): # noqa:F811
+        return 2
+
+    with warns(AmbiguityWarning, test_stacklevel=False):
+        @dispatch(C, A) # noqa:F811
+        def f(x, y): # noqa:F811
+            return 2
+
+    assert f(A(), C()) == f(C(), A()) == 2
+    # assert raises(Warning, lambda : f(C(), C()))
+
+
+def test_caching_correct_behavior():
+    @dispatch(A)
+    def f(x): # noqa:F811
+        return 1
+
+    assert f(C()) == 1
+
+    @dispatch(C)
+    def f(x): # noqa:F811
+        return 2
+
+    assert f(C()) == 2
+
+
+def test_union_types():
+    @dispatch((A, C))
+    def f(x): # noqa:F811
+        return 1
+
+    assert f(A()) == 1
+    assert f(C()) == 1
+
+
+def test_namespaces():
+    ns1 = {}
+    ns2 = {}
+
+    def foo(x):
+        return 1
+    foo1 = orig_dispatch(int, namespace=ns1)(foo)
+
+    def foo(x):
+        return 2
+    foo2 = orig_dispatch(int, namespace=ns2)(foo)
+
+    assert foo1(0) == 1
+    assert foo2(0) == 2
+
+
+"""
+Fails
+def test_dispatch_on_dispatch():
+    @dispatch(A)
+    @dispatch(C)
+    def q(x): # noqa:F811
+        return 1
+
+    assert q(A()) == 1
+    assert q(C()) == 1
+"""
+
+
+def test_methods():
+    class Foo:
+        @dispatch(float)
+        def f(self, x): # noqa:F811
+            return x - 1
+
+        @dispatch(int) # noqa:F811
+        def f(self, x): # noqa:F811
+            return x + 1
+
+        @dispatch(int)
+        def g(self, x): # noqa:F811
+            return x + 3
+
+
+    foo = Foo()
+    assert foo.f(1) == 2
+    assert foo.f(1.0) == 0.0
+    assert foo.g(1) == 4
+
+
+def test_methods_multiple_dispatch():
+    class Foo:
+        @dispatch(A, A)
+        def f(x, y): # noqa:F811
+            return 1
+
+        @dispatch(A, C) # noqa:F811
+        def f(x, y): # noqa:F811
+            return 2
+
+
+    foo = Foo()
+    assert foo.f(A(), A()) == 1
+    assert foo.f(A(), C()) == 2
+    assert foo.f(C(), C()) == 2

llmeval-env/lib/python3.10/site-packages/sympy/multipledispatch/tests/test_dispatcher.py

@@ -0,0 +1,284 @@
+from sympy.multipledispatch.dispatcher import (Dispatcher, MDNotImplementedError,
+                                         MethodDispatcher, halt_ordering,
+                                         restart_ordering,
+                                         ambiguity_register_error_ignore_dup)
+from sympy.testing.pytest import raises, warns
+
+
+def identity(x):
+    return x
+
+
+def inc(x):
+    return x + 1
+
+
+def dec(x):
+    return x - 1
+
+
+def test_dispatcher():
+    f = Dispatcher('f')
+    f.add((int,), inc)
+    f.add((float,), dec)
+
+    with warns(DeprecationWarning, test_stacklevel=False):
+        assert f.resolve((int,)) == inc
+    assert f.dispatch(int) is inc
+
+    assert f(1) == 2
+    assert f(1.0) == 0.0
+
+
+def test_union_types():
+    f = Dispatcher('f')
+    f.register((int, float))(inc)
+
+    assert f(1) == 2
+    assert f(1.0) == 2.0
+
+
+def test_dispatcher_as_decorator():
+    f = Dispatcher('f')
+
+    @f.register(int)
+    def inc(x): # noqa:F811
+        return x + 1
+
+    @f.register(float) # noqa:F811
+    def inc(x): # noqa:F811
+        return x - 1
+
+    assert f(1) == 2
+    assert f(1.0) == 0.0
+
+
+def test_register_instance_method():
+
+    class Test:
+        __init__ = MethodDispatcher('f')
+
+        @__init__.register(list)
+        def _init_list(self, data):
+            self.data = data
+
+        @__init__.register(object)
+        def _init_obj(self, datum):
+            self.data = [datum]
+
+    a = Test(3)
+    b = Test([3])
+    assert a.data == b.data
+
+
+def test_on_ambiguity():
+    f = Dispatcher('f')
+
+    def identity(x): return x
+
+    ambiguities = [False]
+
+    def on_ambiguity(dispatcher, amb):
+        ambiguities[0] = True
+
+    f.add((object, object), identity, on_ambiguity=on_ambiguity)
+    assert not ambiguities[0]
+    f.add((object, float), identity, on_ambiguity=on_ambiguity)
+    assert not ambiguities[0]
+    f.add((float, object), identity, on_ambiguity=on_ambiguity)
+    assert ambiguities[0]
+
+
+def test_raise_error_on_non_class():
+    f = Dispatcher('f')
+    assert raises(TypeError, lambda: f.add((1,), inc))
+
+
+def test_docstring():
+
+    def one(x, y):
+        """ Docstring number one """
+        return x + y
+
+    def two(x, y):
+        """ Docstring number two """
+        return x + y
+
+    def three(x, y):
+        return x + y
+
+    master_doc = 'Doc of the multimethod itself'
+
+    f = Dispatcher('f', doc=master_doc)
+    f.add((object, object), one)
+    f.add((int, int), two)
+    f.add((float, float), three)
+
+    assert one.__doc__.strip() in f.__doc__
+    assert two.__doc__.strip() in f.__doc__
+    assert f.__doc__.find(one.__doc__.strip()) < \
+        f.__doc__.find(two.__doc__.strip())
+    assert 'object, object' in f.__doc__
+    assert master_doc in f.__doc__
+
+
+def test_help():
+    def one(x, y):
+        """ Docstring number one """
+        return x + y
+
+    def two(x, y):
+        """ Docstring number two """
+        return x + y
+
+    def three(x, y):
+        """ Docstring number three """
+        return x + y
+
+    master_doc = 'Doc of the multimethod itself'
+
+    f = Dispatcher('f', doc=master_doc)
+    f.add((object, object), one)
+    f.add((int, int), two)
+    f.add((float, float), three)
+
+    assert f._help(1, 1) == two.__doc__
+    assert f._help(1.0, 2.0) == three.__doc__
+
+
+def test_source():
+    def one(x, y):
+        """ Docstring number one """
+        return x + y
+
+    def two(x, y):
+        """ Docstring number two """
+        return x - y
+
+    master_doc = 'Doc of the multimethod itself'
+
+    f = Dispatcher('f', doc=master_doc)
+    f.add((int, int), one)
+    f.add((float, float), two)
+
+    assert 'x + y' in f._source(1, 1)
+    assert 'x - y' in f._source(1.0, 1.0)
+
+
+def test_source_raises_on_missing_function():
+    f = Dispatcher('f')
+
+    assert raises(TypeError, lambda: f.source(1))
+
+
+def test_halt_method_resolution():
+    g = [0]
+
+    def on_ambiguity(a, b):
+        g[0] += 1
+
+    f = Dispatcher('f')
+
+    halt_ordering()
+
+    def func(*args):
+        pass
+
+    f.add((int, object), func)
+    f.add((object, int), func)
+
+    assert g == [0]
+
+    restart_ordering(on_ambiguity=on_ambiguity)
+
+    assert g == [1]
+
+    assert set(f.ordering) == {(int, object), (object, int)}
+
+
+def test_no_implementations():
+    f = Dispatcher('f')
+    assert raises(NotImplementedError, lambda: f('hello'))
+
+
+def test_register_stacking():
+    f = Dispatcher('f')
+
+    @f.register(list)
+    @f.register(tuple)
+    def rev(x):
+        return x[::-1]
+
+    assert f((1, 2, 3)) == (3, 2, 1)
+    assert f([1, 2, 3]) == [3, 2, 1]
+
+    assert raises(NotImplementedError, lambda: f('hello'))
+    assert rev('hello') == 'olleh'
+
+
+def test_dispatch_method():
+    f = Dispatcher('f')
+
+    @f.register(list)
+    def rev(x):
+        return x[::-1]
+
+    @f.register(int, int)
+    def add(x, y):
+        return x + y
+
+    class MyList(list):
+        pass
+
+    assert f.dispatch(list) is rev
+    assert f.dispatch(MyList) is rev
+    assert f.dispatch(int, int) is add
+
+
+def test_not_implemented():
+    f = Dispatcher('f')
+
+    @f.register(object)
+    def _(x):
+        return 'default'
+
+    @f.register(int)
+    def _(x):
+        if x % 2 == 0:
+            return 'even'
+        else:
+            raise MDNotImplementedError()
+
+    assert f('hello') == 'default'  # default behavior
+    assert f(2) == 'even'          # specialized behavior
+    assert f(3) == 'default'       # fall bac to default behavior
+    assert raises(NotImplementedError, lambda: f(1, 2))
+
+
+def test_not_implemented_error():
+    f = Dispatcher('f')
+
+    @f.register(float)
+    def _(a):
+        raise MDNotImplementedError()
+
+    assert raises(NotImplementedError, lambda: f(1.0))
+
+def test_ambiguity_register_error_ignore_dup():
+    f = Dispatcher('f')
+
+    class A:
+        pass
+    class B(A):
+        pass
+    class C(A):
+        pass
+
+    # suppress warning for registering ambiguous signal
+    f.add((A, B), lambda x,y: None, ambiguity_register_error_ignore_dup)
+    f.add((B, A), lambda x,y: None, ambiguity_register_error_ignore_dup)
+    f.add((A, C), lambda x,y: None, ambiguity_register_error_ignore_dup)
+    f.add((C, A), lambda x,y: None, ambiguity_register_error_ignore_dup)
+
+    # raises error if ambiguous signal is passed
+    assert raises(NotImplementedError, lambda: f(B(), C()))

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

@@ -0,0 +1,105 @@
+from collections import OrderedDict
+
+
+def expand_tuples(L):
+    """
+    >>> from sympy.multipledispatch.utils import expand_tuples
+    >>> expand_tuples([1, (2, 3)])
+    [(1, 2), (1, 3)]
+
+    >>> expand_tuples([1, 2])
+    [(1, 2)]
+    """
+    if not L:
+        return [()]
+    elif not isinstance(L[0], tuple):
+        rest = expand_tuples(L[1:])
+        return [(L[0],) + t for t in rest]
+    else:
+        rest = expand_tuples(L[1:])
+        return [(item,) + t for t in rest for item in L[0]]
+
+
+# Taken from theano/theano/gof/sched.py
+# Avoids licensing issues because this was written by Matthew Rocklin
+def _toposort(edges):
+    """ Topological sort algorithm by Kahn [1] - O(nodes + vertices)
+
+    inputs:
+        edges - a dict of the form {a: {b, c}} where b and c depend on a
+    outputs:
+        L - an ordered list of nodes that satisfy the dependencies of edges
+
+    >>> from sympy.multipledispatch.utils import _toposort
+    >>> _toposort({1: (2, 3), 2: (3, )})
+    [1, 2, 3]
+
+    Closely follows the wikipedia page [2]
+
+    [1] Kahn, Arthur B. (1962), "Topological sorting of large networks",
+    Communications of the ACM
+    [2] https://en.wikipedia.org/wiki/Toposort#Algorithms
+    """
+    incoming_edges = reverse_dict(edges)
+    incoming_edges = {k: set(val) for k, val in incoming_edges.items()}
+    S = OrderedDict.fromkeys(v for v in edges if v not in incoming_edges)
+    L = []
+
+    while S:
+        n, _ = S.popitem()
+        L.append(n)
+        for m in edges.get(n, ()):
+            assert n in incoming_edges[m]
+            incoming_edges[m].remove(n)
+            if not incoming_edges[m]:
+                S[m] = None
+    if any(incoming_edges.get(v, None) for v in edges):
+        raise ValueError("Input has cycles")
+    return L
+
+
+def reverse_dict(d):
+    """Reverses direction of dependence dict
+
+    >>> d = {'a': (1, 2), 'b': (2, 3), 'c':()}
+    >>> reverse_dict(d)  # doctest: +SKIP
+    {1: ('a',), 2: ('a', 'b'), 3: ('b',)}
+
+    :note: dict order are not deterministic. As we iterate on the
+        input dict, it make the output of this function depend on the
+        dict order. So this function output order should be considered
+        as undeterministic.
+
+    """
+    result = {}
+    for key in d:
+        for val in d[key]:
+            result[val] = result.get(val, ()) + (key, )
+    return result
+
+
+# Taken from toolz
+# Avoids licensing issues because this version was authored by Matthew Rocklin
+def groupby(func, seq):
+    """ Group a collection by a key function
+
+    >>> from sympy.multipledispatch.utils import groupby
+    >>> names = ['Alice', 'Bob', 'Charlie', 'Dan', 'Edith', 'Frank']
+    >>> groupby(len, names)  # doctest: +SKIP
+    {3: ['Bob', 'Dan'], 5: ['Alice', 'Edith', 'Frank'], 7: ['Charlie']}
+
+    >>> iseven = lambda x: x % 2 == 0
+    >>> groupby(iseven, [1, 2, 3, 4, 5, 6, 7, 8])  # doctest: +SKIP
+    {False: [1, 3, 5, 7], True: [2, 4, 6, 8]}
+
+    See Also:
+        ``countby``
+    """
+
+    d = {}
+    for item in seq:
+        key = func(item)
+        if key not in d:
+            d[key] = []
+        d[key].append(item)
+    return d