Add files using upload-large-folder tool

lib/python3.12/site-packages/sympy/simplify/cse_main.py

@@ -0,0 +1,946 @@
+""" Tools for doing common subexpression elimination.
+"""
+from collections import defaultdict
+
+from sympy.core import Basic, Mul, Add, Pow, sympify
+from sympy.core.containers import Tuple, OrderedSet
+from sympy.core.exprtools import factor_terms
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import symbols, Symbol
+from sympy.matrices import (MatrixBase, Matrix, ImmutableMatrix,
+                            SparseMatrix, ImmutableSparseMatrix)
+from sympy.matrices.expressions import (MatrixExpr, MatrixSymbol, MatMul,
+                                        MatAdd, MatPow, Inverse)
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.polys.rootoftools import RootOf
+from sympy.utilities.iterables import numbered_symbols, sift, \
+        topological_sort, iterable
+
+from . import cse_opts
+
+# (preprocessor, postprocessor) pairs which are commonly useful. They should
+# each take a SymPy expression and return a possibly transformed expression.
+# When used in the function ``cse()``, the target expressions will be transformed
+# by each of the preprocessor functions in order. After the common
+# subexpressions are eliminated, each resulting expression will have the
+# postprocessor functions transform them in *reverse* order in order to undo the
+# transformation if necessary. This allows the algorithm to operate on
+# a representation of the expressions that allows for more optimization
+# opportunities.
+# ``None`` can be used to specify no transformation for either the preprocessor or
+# postprocessor.
+
+
+basic_optimizations = [(cse_opts.sub_pre, cse_opts.sub_post),
+                       (factor_terms, None)]
+
+# sometimes we want the output in a different format; non-trivial
+# transformations can be put here for users
+# ===============================================================
+
+
+def reps_toposort(r):
+    """Sort replacements ``r`` so (k1, v1) appears before (k2, v2)
+    if k2 is in v1's free symbols. This orders items in the
+    way that cse returns its results (hence, in order to use the
+    replacements in a substitution option it would make sense
+    to reverse the order).
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.cse_main import reps_toposort
+    >>> from sympy.abc import x, y
+    >>> from sympy import Eq
+    >>> for l, r in reps_toposort([(x, y + 1), (y, 2)]):
+    ...     print(Eq(l, r))
+    ...
+    Eq(y, 2)
+    Eq(x, y + 1)
+
+    """
+    r = sympify(r)
+    E = []
+    for c1, (k1, v1) in enumerate(r):
+        for c2, (k2, v2) in enumerate(r):
+            if k1 in v2.free_symbols:
+                E.append((c1, c2))
+    return [r[i] for i in topological_sort((range(len(r)), E))]
+
+
+def cse_separate(r, e):
+    """Move expressions that are in the form (symbol, expr) out of the
+    expressions and sort them into the replacements using the reps_toposort.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.cse_main import cse_separate
+    >>> from sympy.abc import x, y, z
+    >>> from sympy import cos, exp, cse, Eq, symbols
+    >>> x0, x1 = symbols('x:2')
+    >>> eq = (x + 1 + exp((x + 1)/(y + 1)) + cos(y + 1))
+    >>> cse([eq, Eq(x, z + 1), z - 2], postprocess=cse_separate) in [
+    ... [[(x0, y + 1), (x, z + 1), (x1, x + 1)],
+    ...  [x1 + exp(x1/x0) + cos(x0), z - 2]],
+    ... [[(x1, y + 1), (x, z + 1), (x0, x + 1)],
+    ...  [x0 + exp(x0/x1) + cos(x1), z - 2]]]
+    ...
+    True
+    """
+    d = sift(e, lambda w: w.is_Equality and w.lhs.is_Symbol)
+    r = r + [w.args for w in d[True]]
+    e = d[False]
+    return [reps_toposort(r), e]
+
+
+def cse_release_variables(r, e):
+    """
+    Return tuples giving ``(a, b)`` where ``a`` is a symbol and ``b`` is
+    either an expression or None. The value of None is used when a
+    symbol is no longer needed for subsequent expressions.
+
+    Use of such output can reduce the memory footprint of lambdified
+    expressions that contain large, repeated subexpressions.
+
+    Examples
+    ========
+
+    >>> from sympy import cse
+    >>> from sympy.simplify.cse_main import cse_release_variables
+    >>> from sympy.abc import x, y
+    >>> eqs = [(x + y - 1)**2, x, x + y, (x + y)/(2*x + 1) + (x + y - 1)**2, (2*x + 1)**(x + y)]
+    >>> defs, rvs = cse_release_variables(*cse(eqs))
+    >>> for i in defs:
+    ...   print(i)
+    ...
+    (x0, x + y)
+    (x1, (x0 - 1)**2)
+    (x2, 2*x + 1)
+    (_3, x0/x2 + x1)
+    (_4, x2**x0)
+    (x2, None)
+    (_0, x1)
+    (x1, None)
+    (_2, x0)
+    (x0, None)
+    (_1, x)
+    >>> print(rvs)
+    (_0, _1, _2, _3, _4)
+    """
+    if not r:
+        return r, e
+
+    s, p = zip(*r)
+    esyms = symbols('_:%d' % len(e))
+    syms = list(esyms)
+    s = list(s)
+    in_use = set(s)
+    p = list(p)
+    # sort e so those with most sub-expressions appear first
+    e = [(e[i], syms[i]) for i in range(len(e))]
+    e, syms = zip(*sorted(e,
+        key=lambda x: -sum(p[s.index(i)].count_ops()
+        for i in x[0].free_symbols & in_use)))
+    syms = list(syms)
+    p += e
+    rv = []
+    i = len(p) - 1
+    while i >= 0:
+        _p = p.pop()
+        c = in_use & _p.free_symbols
+        if c: # sorting for canonical results
+            rv.extend([(s, None) for s in sorted(c, key=str)])
+        if i >= len(r):
+            rv.append((syms.pop(), _p))
+        else:
+            rv.append((s[i], _p))
+        in_use -= c
+        i -= 1
+    rv.reverse()
+    return rv, esyms
+
+
+# ====end of cse postprocess idioms===========================
+
+
+def preprocess_for_cse(expr, optimizations):
+    """ Preprocess an expression to optimize for common subexpression
+    elimination.
+
+    Parameters
+    ==========
+
+    expr : SymPy expression
+        The target expression to optimize.
+    optimizations : list of (callable, callable) pairs
+        The (preprocessor, postprocessor) pairs.
+
+    Returns
+    =======
+
+    expr : SymPy expression
+        The transformed expression.
+    """
+    for pre, post in optimizations:
+        if pre is not None:
+            expr = pre(expr)
+    return expr
+
+
+def postprocess_for_cse(expr, optimizations):
+    """Postprocess an expression after common subexpression elimination to
+    return the expression to canonical SymPy form.
+
+    Parameters
+    ==========
+
+    expr : SymPy expression
+        The target expression to transform.
+    optimizations : list of (callable, callable) pairs, optional
+        The (preprocessor, postprocessor) pairs.  The postprocessors will be
+        applied in reversed order to undo the effects of the preprocessors
+        correctly.
+
+    Returns
+    =======
+
+    expr : SymPy expression
+        The transformed expression.
+    """
+    for pre, post in reversed(optimizations):
+        if post is not None:
+            expr = post(expr)
+    return expr
+
+
+class FuncArgTracker:
+    """
+    A class which manages a mapping from functions to arguments and an inverse
+    mapping from arguments to functions.
+    """
+
+    def __init__(self, funcs):
+        # To minimize the number of symbolic comparisons, all function arguments
+        # get assigned a value number.
+        self.value_numbers = {}
+        self.value_number_to_value = []
+
+        # Both of these maps use integer indices for arguments / functions.
+        self.arg_to_funcset = []
+        self.func_to_argset = []
+
+        for func_i, func in enumerate(funcs):
+            func_argset = OrderedSet()
+
+            for func_arg in func.args:
+                arg_number = self.get_or_add_value_number(func_arg)
+                func_argset.add(arg_number)
+                self.arg_to_funcset[arg_number].add(func_i)
+
+            self.func_to_argset.append(func_argset)
+
+    def get_args_in_value_order(self, argset):
+        """
+        Return the list of arguments in sorted order according to their value
+        numbers.
+        """
+        return [self.value_number_to_value[argn] for argn in sorted(argset)]
+
+    def get_or_add_value_number(self, value):
+        """
+        Return the value number for the given argument.
+        """
+        nvalues = len(self.value_numbers)
+        value_number = self.value_numbers.setdefault(value, nvalues)
+        if value_number == nvalues:
+            self.value_number_to_value.append(value)
+            self.arg_to_funcset.append(OrderedSet())
+        return value_number
+
+    def stop_arg_tracking(self, func_i):
+        """
+        Remove the function func_i from the argument to function mapping.
+        """
+        for arg in self.func_to_argset[func_i]:
+            self.arg_to_funcset[arg].remove(func_i)
+
+
+    def get_common_arg_candidates(self, argset, min_func_i=0):
+        """Return a dict whose keys are function numbers. The entries of the dict are
+        the number of arguments said function has in common with
+        ``argset``. Entries have at least 2 items in common.  All keys have
+        value at least ``min_func_i``.
+        """
+        count_map = defaultdict(lambda: 0)
+        if not argset:
+            return count_map
+
+        funcsets = [self.arg_to_funcset[arg] for arg in argset]
+        # As an optimization below, we handle the largest funcset separately from
+        # the others.
+        largest_funcset = max(funcsets, key=len)
+
+        for funcset in funcsets:
+            if largest_funcset is funcset:
+                continue
+            for func_i in funcset:
+                if func_i >= min_func_i:
+                    count_map[func_i] += 1
+
+        # We pick the smaller of the two containers (count_map, largest_funcset)
+        # to iterate over to reduce the number of iterations needed.
+        (smaller_funcs_container,
+         larger_funcs_container) = sorted(
+                 [largest_funcset, count_map],
+                 key=len)
+
+        for func_i in smaller_funcs_container:
+            # Not already in count_map? It can't possibly be in the output, so
+            # skip it.
+            if count_map[func_i] < 1:
+                continue
+
+            if func_i in larger_funcs_container:
+                count_map[func_i] += 1
+
+        return {k: v for k, v in count_map.items() if v >= 2}
+
+    def get_subset_candidates(self, argset, restrict_to_funcset=None):
+        """
+        Return a set of functions each of which whose argument list contains
+        ``argset``, optionally filtered only to contain functions in
+        ``restrict_to_funcset``.
+        """
+        iarg = iter(argset)
+
+        indices = OrderedSet(
+            fi for fi in self.arg_to_funcset[next(iarg)])
+
+        if restrict_to_funcset is not None:
+            indices &= restrict_to_funcset
+
+        for arg in iarg:
+            indices &= self.arg_to_funcset[arg]
+
+        return indices
+
+    def update_func_argset(self, func_i, new_argset):
+        """
+        Update a function with a new set of arguments.
+        """
+        new_args = OrderedSet(new_argset)
+        old_args = self.func_to_argset[func_i]
+
+        for deleted_arg in old_args - new_args:
+            self.arg_to_funcset[deleted_arg].remove(func_i)
+        for added_arg in new_args - old_args:
+            self.arg_to_funcset[added_arg].add(func_i)
+
+        self.func_to_argset[func_i].clear()
+        self.func_to_argset[func_i].update(new_args)
+
+
+class Unevaluated:
+
+    def __init__(self, func, args):
+        self.func = func
+        self.args = args
+
+    def __str__(self):
+        return "Uneval<{}>({})".format(
+                self.func, ", ".join(str(a) for a in self.args))
+
+    def as_unevaluated_basic(self):
+        return self.func(*self.args, evaluate=False)
+
+    @property
+    def free_symbols(self):
+        return set().union(*[a.free_symbols for a in self.args])
+
+    __repr__ = __str__
+
+
+def match_common_args(func_class, funcs, opt_subs):
+    """
+    Recognize and extract common subexpressions of function arguments within a
+    set of function calls. For instance, for the following function calls::
+
+        x + z + y
+        sin(x + y)
+
+    this will extract a common subexpression of `x + y`::
+
+        w = x + y
+        w + z
+        sin(w)
+
+    The function we work with is assumed to be associative and commutative.
+
+    Parameters
+    ==========
+
+    func_class: class
+        The function class (e.g. Add, Mul)
+    funcs: list of functions
+        A list of function calls.
+    opt_subs: dict
+        A dictionary of substitutions which this function may update.
+    """
+
+    # Sort to ensure that whole-function subexpressions come before the items
+    # that use them.
+    funcs = sorted(funcs, key=lambda f: len(f.args))
+    arg_tracker = FuncArgTracker(funcs)
+
+    changed = OrderedSet()
+
+    for i in range(len(funcs)):
+        common_arg_candidates_counts = arg_tracker.get_common_arg_candidates(
+                arg_tracker.func_to_argset[i], min_func_i=i + 1)
+
+        # Sort the candidates in order of match size.
+        # This makes us try combining smaller matches first.
+        common_arg_candidates = OrderedSet(sorted(
+                common_arg_candidates_counts.keys(),
+                key=lambda k: (common_arg_candidates_counts[k], k)))
+
+        while common_arg_candidates:
+            j = common_arg_candidates.pop(last=False)
+
+            com_args = arg_tracker.func_to_argset[i].intersection(
+                    arg_tracker.func_to_argset[j])
+
+            if len(com_args) <= 1:
+                # This may happen if a set of common arguments was already
+                # combined in a previous iteration.
+                continue
+
+            # For all sets, replace the common symbols by the function
+            # over them, to allow recursive matches.
+
+            diff_i = arg_tracker.func_to_argset[i].difference(com_args)
+            if diff_i:
+                # com_func needs to be unevaluated to allow for recursive matches.
+                com_func = Unevaluated(
+                        func_class, arg_tracker.get_args_in_value_order(com_args))
+                com_func_number = arg_tracker.get_or_add_value_number(com_func)
+                arg_tracker.update_func_argset(i, diff_i | OrderedSet([com_func_number]))
+                changed.add(i)
+            else:
+                # Treat the whole expression as a CSE.
+                #
+                # The reason this needs to be done is somewhat subtle. Within
+                # tree_cse(), to_eliminate only contains expressions that are
+                # seen more than once. The problem is unevaluated expressions
+                # do not compare equal to the evaluated equivalent. So
+                # tree_cse() won't mark funcs[i] as a CSE if we use an
+                # unevaluated version.
+                com_func_number = arg_tracker.get_or_add_value_number(funcs[i])
+
+            diff_j = arg_tracker.func_to_argset[j].difference(com_args)
+            arg_tracker.update_func_argset(j, diff_j | OrderedSet([com_func_number]))
+            changed.add(j)
+
+            for k in arg_tracker.get_subset_candidates(
+                    com_args, common_arg_candidates):
+                diff_k = arg_tracker.func_to_argset[k].difference(com_args)
+                arg_tracker.update_func_argset(k, diff_k | OrderedSet([com_func_number]))
+                changed.add(k)
+
+        if i in changed:
+            opt_subs[funcs[i]] = Unevaluated(func_class,
+                arg_tracker.get_args_in_value_order(arg_tracker.func_to_argset[i]))
+
+        arg_tracker.stop_arg_tracking(i)
+
+
+def opt_cse(exprs, order='canonical'):
+    """Find optimization opportunities in Adds, Muls, Pows and negative
+    coefficient Muls.
+
+    Parameters
+    ==========
+
+    exprs : list of SymPy expressions
+        The expressions to optimize.
+    order : string, 'none' or 'canonical'
+        The order by which Mul and Add arguments are processed. For large
+        expressions where speed is a concern, use the setting order='none'.
+
+    Returns
+    =======
+
+    opt_subs : dictionary of expression substitutions
+        The expression substitutions which can be useful to optimize CSE.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.cse_main import opt_cse
+    >>> from sympy.abc import x
+    >>> opt_subs = opt_cse([x**-2])
+    >>> k, v = list(opt_subs.keys())[0], list(opt_subs.values())[0]
+    >>> print((k, v.as_unevaluated_basic()))
+    (x**(-2), 1/(x**2))
+    """
+    opt_subs = {}
+
+    adds = OrderedSet()
+    muls = OrderedSet()
+
+    seen_subexp = set()
+    collapsible_subexp = set()
+
+    def _find_opts(expr):
+
+        if not isinstance(expr, (Basic, Unevaluated)):
+            return
+
+        if expr.is_Atom or expr.is_Order:
+            return
+
+        if iterable(expr):
+            list(map(_find_opts, expr))
+            return
+
+        if expr in seen_subexp:
+            return expr
+        seen_subexp.add(expr)
+
+        list(map(_find_opts, expr.args))
+
+        if not isinstance(expr, MatrixExpr) and expr.could_extract_minus_sign():
+            # XXX -expr does not always work rigorously for some expressions
+            # containing UnevaluatedExpr.
+            # https://github.com/sympy/sympy/issues/24818
+            if isinstance(expr, Add):
+                neg_expr = Add(*(-i for i in expr.args))
+            else:
+                neg_expr = -expr
+
+            if not neg_expr.is_Atom:
+                opt_subs[expr] = Unevaluated(Mul, (S.NegativeOne, neg_expr))
+                seen_subexp.add(neg_expr)
+                expr = neg_expr
+
+        if isinstance(expr, (Mul, MatMul)):
+            if len(expr.args) == 1:
+                collapsible_subexp.add(expr)
+            else:
+                muls.add(expr)
+
+        elif isinstance(expr, (Add, MatAdd)):
+            if len(expr.args) == 1:
+                collapsible_subexp.add(expr)
+            else:
+                adds.add(expr)
+
+        elif isinstance(expr, Inverse):
+            # Do not want to treat `Inverse` as a `MatPow`
+            pass
+
+        elif isinstance(expr, (Pow, MatPow)):
+            base, exp = expr.base, expr.exp
+            if exp.could_extract_minus_sign():
+                opt_subs[expr] = Unevaluated(Pow, (Pow(base, -exp), -1))
+
+    for e in exprs:
+        if isinstance(e, (Basic, Unevaluated)):
+            _find_opts(e)
+
+    # Handle collapsing of multinary operations with single arguments
+    edges = [(s, s.args[0]) for s in collapsible_subexp
+             if s.args[0] in collapsible_subexp]
+    for e in reversed(topological_sort((collapsible_subexp, edges))):
+        opt_subs[e] = opt_subs.get(e.args[0], e.args[0])
+
+    # split muls into commutative
+    commutative_muls = OrderedSet()
+    for m in muls:
+        c, nc = m.args_cnc(cset=False)
+        if c:
+            c_mul = m.func(*c)
+            if nc:
+                if c_mul == 1:
+                    new_obj = m.func(*nc)
+                else:
+                    if isinstance(m, MatMul):
+                        new_obj = m.func(c_mul, *nc, evaluate=False)
+                    else:
+                        new_obj = m.func(c_mul, m.func(*nc), evaluate=False)
+                opt_subs[m] = new_obj
+            if len(c) > 1:
+                commutative_muls.add(c_mul)
+
+    match_common_args(Add, adds, opt_subs)
+    match_common_args(Mul, commutative_muls, opt_subs)
+
+    return opt_subs
+
+
+def tree_cse(exprs, symbols, opt_subs=None, order='canonical', ignore=()):
+    """Perform raw CSE on expression tree, taking opt_subs into account.
+
+    Parameters
+    ==========
+
+    exprs : list of SymPy expressions
+        The expressions to reduce.
+    symbols : infinite iterator yielding unique Symbols
+        The symbols used to label the common subexpressions which are pulled
+        out.
+    opt_subs : dictionary of expression substitutions
+        The expressions to be substituted before any CSE action is performed.
+    order : string, 'none' or 'canonical'
+        The order by which Mul and Add arguments are processed. For large
+        expressions where speed is a concern, use the setting order='none'.
+    ignore : iterable of Symbols
+        Substitutions containing any Symbol from ``ignore`` will be ignored.
+    """
+    if opt_subs is None:
+        opt_subs = {}
+
+    ## Find repeated sub-expressions
+
+    to_eliminate = set()
+
+    seen_subexp = set()
+    excluded_symbols = set()
+
+    def _find_repeated(expr):
+        if not isinstance(expr, (Basic, Unevaluated)):
+            return
+
+        if isinstance(expr, RootOf):
+            return
+
+        if isinstance(expr, Basic) and (
+                expr.is_Atom or
+                expr.is_Order or
+                isinstance(expr, (MatrixSymbol, MatrixElement))):
+            if expr.is_Symbol:
+                excluded_symbols.add(expr.name)
+            return
+
+        if iterable(expr):
+            args = expr
+
+        else:
+            if expr in seen_subexp:
+                for ign in ignore:
+                    if ign in expr.free_symbols:
+                        break
+                else:
+                    to_eliminate.add(expr)
+                    return
+
+            seen_subexp.add(expr)
+
+            if expr in opt_subs:
+                expr = opt_subs[expr]
+
+            args = expr.args
+
+        list(map(_find_repeated, args))
+
+    for e in exprs:
+        if isinstance(e, Basic):
+            _find_repeated(e)
+
+    ## Rebuild tree
+
+    # Remove symbols from the generator that conflict with names in the expressions.
+    symbols = (_ for _ in symbols if _.name not in excluded_symbols)
+
+    replacements = []
+
+    subs = {}
+
+    def _rebuild(expr):
+        if not isinstance(expr, (Basic, Unevaluated)):
+            return expr
+
+        if not expr.args:
+            return expr
+
+        if iterable(expr):
+            new_args = [_rebuild(arg) for arg in expr.args]
+            return expr.func(*new_args)
+
+        if expr in subs:
+            return subs[expr]
+
+        orig_expr = expr
+        if expr in opt_subs:
+            expr = opt_subs[expr]
+
+        # If enabled, parse Muls and Adds arguments by order to ensure
+        # replacement order independent from hashes
+        if order != 'none':
+            if isinstance(expr, (Mul, MatMul)):
+                c, nc = expr.args_cnc()
+                if c == [1]:
+                    args = nc
+                else:
+                    args = list(ordered(c)) + nc
+            elif isinstance(expr, (Add, MatAdd)):
+                args = list(ordered(expr.args))
+            else:
+                args = expr.args
+        else:
+            args = expr.args
+
+        new_args = list(map(_rebuild, args))
+        if isinstance(expr, Unevaluated) or new_args != args:
+            new_expr = expr.func(*new_args)
+        else:
+            new_expr = expr
+
+        if orig_expr in to_eliminate:
+            try:
+                sym = next(symbols)
+            except StopIteration:
+                raise ValueError("Symbols iterator ran out of symbols.")
+
+            if isinstance(orig_expr, MatrixExpr):
+                sym = MatrixSymbol(sym.name, orig_expr.rows,
+                    orig_expr.cols)
+
+            subs[orig_expr] = sym
+            replacements.append((sym, new_expr))
+            return sym
+
+        else:
+            return new_expr
+
+    reduced_exprs = []
+    for e in exprs:
+        if isinstance(e, Basic):
+            reduced_e = _rebuild(e)
+        else:
+            reduced_e = e
+        reduced_exprs.append(reduced_e)
+    return replacements, reduced_exprs
+
+
+def cse(exprs, symbols=None, optimizations=None, postprocess=None,
+        order='canonical', ignore=(), list=True):
+    """ Perform common subexpression elimination on an expression.
+
+    Parameters
+    ==========
+
+    exprs : list of SymPy expressions, or a single SymPy expression
+        The expressions to reduce.
+    symbols : infinite iterator yielding unique Symbols
+        The symbols used to label the common subexpressions which are pulled
+        out. The ``numbered_symbols`` generator is useful. The default is a
+        stream of symbols of the form "x0", "x1", etc. This must be an
+        infinite iterator.
+    optimizations : list of (callable, callable) pairs
+        The (preprocessor, postprocessor) pairs of external optimization
+        functions. Optionally 'basic' can be passed for a set of predefined
+        basic optimizations. Such 'basic' optimizations were used by default
+        in old implementation, however they can be really slow on larger
+        expressions. Now, no pre or post optimizations are made by default.
+    postprocess : a function which accepts the two return values of cse and
+        returns the desired form of output from cse, e.g. if you want the
+        replacements reversed the function might be the following lambda:
+        lambda r, e: return reversed(r), e
+    order : string, 'none' or 'canonical'
+        The order by which Mul and Add arguments are processed. If set to
+        'canonical', arguments will be canonically ordered. If set to 'none',
+        ordering will be faster but dependent on expressions hashes, thus
+        machine dependent and variable. For large expressions where speed is a
+        concern, use the setting order='none'.
+    ignore : iterable of Symbols
+        Substitutions containing any Symbol from ``ignore`` will be ignored.
+    list : bool, (default True)
+        Returns expression in list or else with same type as input (when False).
+
+    Returns
+    =======
+
+    replacements : list of (Symbol, expression) pairs
+        All of the common subexpressions that were replaced. Subexpressions
+        earlier in this list might show up in subexpressions later in this
+        list.
+    reduced_exprs : list of SymPy expressions
+        The reduced expressions with all of the replacements above.
+
+    Examples
+    ========
+
+    >>> from sympy import cse, SparseMatrix
+    >>> from sympy.abc import x, y, z, w
+    >>> cse(((w + x + y + z)*(w + y + z))/(w + x)**3)
+    ([(x0, y + z), (x1, w + x)], [(w + x0)*(x0 + x1)/x1**3])
+
+
+    List of expressions with recursive substitutions:
+
+    >>> m = SparseMatrix([x + y, x + y + z])
+    >>> cse([(x+y)**2, x + y + z, y + z, x + z + y, m])
+    ([(x0, x + y), (x1, x0 + z)], [x0**2, x1, y + z, x1, Matrix([
+    [x0],
+    [x1]])])
+
+    Note: the type and mutability of input matrices is retained.
+
+    >>> isinstance(_[1][-1], SparseMatrix)
+    True
+
+    The user may disallow substitutions containing certain symbols:
+
+    >>> cse([y**2*(x + 1), 3*y**2*(x + 1)], ignore=(y,))
+    ([(x0, x + 1)], [x0*y**2, 3*x0*y**2])
+
+    The default return value for the reduced expression(s) is a list, even if there is only
+    one expression. The `list` flag preserves the type of the input in the output:
+
+    >>> cse(x)
+    ([], [x])
+    >>> cse(x, list=False)
+    ([], x)
+    """
+    if not list:
+        return _cse_homogeneous(exprs,
+            symbols=symbols, optimizations=optimizations,
+            postprocess=postprocess, order=order, ignore=ignore)
+
+    if isinstance(exprs, (int, float)):
+        exprs = sympify(exprs)
+
+    # Handle the case if just one expression was passed.
+    if isinstance(exprs, (Basic, MatrixBase)):
+        exprs = [exprs]
+
+    copy = exprs
+    temp = []
+    for e in exprs:
+        if isinstance(e, (Matrix, ImmutableMatrix)):
+            temp.append(Tuple(*e.flat()))
+        elif isinstance(e, (SparseMatrix, ImmutableSparseMatrix)):
+            temp.append(Tuple(*e.todok().items()))
+        else:
+            temp.append(e)
+    exprs = temp
+    del temp
+
+    if optimizations is None:
+        optimizations = []
+    elif optimizations == 'basic':
+        optimizations = basic_optimizations
+
+    # Preprocess the expressions to give us better optimization opportunities.
+    reduced_exprs = [preprocess_for_cse(e, optimizations) for e in exprs]
+
+    if symbols is None:
+        symbols = numbered_symbols(cls=Symbol)
+    else:
+        # In case we get passed an iterable with an __iter__ method instead of
+        # an actual iterator.
+        symbols = iter(symbols)
+
+    # Find other optimization opportunities.
+    opt_subs = opt_cse(reduced_exprs, order)
+
+    # Main CSE algorithm.
+    replacements, reduced_exprs = tree_cse(reduced_exprs, symbols, opt_subs,
+                                           order, ignore)
+
+    # Postprocess the expressions to return the expressions to canonical form.
+    exprs = copy
+    for i, (sym, subtree) in enumerate(replacements):
+        subtree = postprocess_for_cse(subtree, optimizations)
+        replacements[i] = (sym, subtree)
+    reduced_exprs = [postprocess_for_cse(e, optimizations)
+                     for e in reduced_exprs]
+
+    # Get the matrices back
+    for i, e in enumerate(exprs):
+        if isinstance(e, (Matrix, ImmutableMatrix)):
+            reduced_exprs[i] = Matrix(e.rows, e.cols, reduced_exprs[i])
+            if isinstance(e, ImmutableMatrix):
+                reduced_exprs[i] = reduced_exprs[i].as_immutable()
+        elif isinstance(e, (SparseMatrix, ImmutableSparseMatrix)):
+            m = SparseMatrix(e.rows, e.cols, {})
+            for k, v in reduced_exprs[i]:
+                m[k] = v
+            if isinstance(e, ImmutableSparseMatrix):
+                m = m.as_immutable()
+            reduced_exprs[i] = m
+
+    if postprocess is None:
+        return replacements, reduced_exprs
+
+    return postprocess(replacements, reduced_exprs)
+
+
+def _cse_homogeneous(exprs, **kwargs):
+    """
+    Same as ``cse`` but the ``reduced_exprs`` are returned
+    with the same type as ``exprs`` or a sympified version of the same.
+
+    Parameters
+    ==========
+
+    exprs : an Expr, iterable of Expr or dictionary with Expr values
+        the expressions in which repeated subexpressions will be identified
+    kwargs : additional arguments for the ``cse`` function
+
+    Returns
+    =======
+
+    replacements : list of (Symbol, expression) pairs
+        All of the common subexpressions that were replaced. Subexpressions
+        earlier in this list might show up in subexpressions later in this
+        list.
+    reduced_exprs : list of SymPy expressions
+        The reduced expressions with all of the replacements above.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.cse_main import cse
+    >>> from sympy import cos, Tuple, Matrix
+    >>> from sympy.abc import x
+    >>> output = lambda x: type(cse(x, list=False)[1])
+    >>> output(1)
+    <class 'sympy.core.numbers.One'>
+    >>> output('cos(x)')
+    <class 'str'>
+    >>> output(cos(x))
+    cos
+    >>> output(Tuple(1, x))
+    <class 'sympy.core.containers.Tuple'>
+    >>> output(Matrix([[1,0], [0,1]]))
+    <class 'sympy.matrices.dense.MutableDenseMatrix'>
+    >>> output([1, x])
+    <class 'list'>
+    >>> output((1, x))
+    <class 'tuple'>
+    >>> output({1, x})
+    <class 'set'>
+    """
+    if isinstance(exprs, str):
+        replacements, reduced_exprs = _cse_homogeneous(
+            sympify(exprs), **kwargs)
+        return replacements, repr(reduced_exprs)
+    if isinstance(exprs, (list, tuple, set)):
+        replacements, reduced_exprs = cse(exprs, **kwargs)
+        return replacements, type(exprs)(reduced_exprs)
+    if isinstance(exprs, dict):
+        keys = list(exprs.keys()) # In order to guarantee the order of the elements.
+        replacements, values = cse([exprs[k] for k in keys], **kwargs)
+        reduced_exprs = dict(zip(keys, values))
+        return replacements, reduced_exprs
+
+    try:
+        replacements, (reduced_exprs,) = cse(exprs, **kwargs)
+    except TypeError: # For example 'mpf' objects
+        return [], exprs
+    else:
+        return replacements, reduced_exprs

lib/python3.12/site-packages/sympy/simplify/epathtools.py

@@ -0,0 +1,356 @@
+"""Tools for manipulation of expressions using paths. """
+
+from sympy.core import Basic
+
+
+class EPath:
+    r"""
+    Manipulate expressions using paths.
+
+    EPath grammar in EBNF notation::
+
+        literal   ::= /[A-Za-z_][A-Za-z_0-9]*/
+        number    ::= /-?\d+/
+        type      ::= literal
+        attribute ::= literal "?"
+        all       ::= "*"
+        slice     ::= "[" number? (":" number? (":" number?)?)? "]"
+        range     ::= all | slice
+        query     ::= (type | attribute) ("|" (type | attribute))*
+        selector  ::= range | query range?
+        path      ::= "/" selector ("/" selector)*
+
+    See the docstring of the epath() function.
+
+    """
+
+    __slots__ = ("_path", "_epath")
+
+    def __new__(cls, path):
+        """Construct new EPath. """
+        if isinstance(path, EPath):
+            return path
+
+        if not path:
+            raise ValueError("empty EPath")
+
+        _path = path
+
+        if path[0] == '/':
+            path = path[1:]
+        else:
+            raise NotImplementedError("non-root EPath")
+
+        epath = []
+
+        for selector in path.split('/'):
+            selector = selector.strip()
+
+            if not selector:
+                raise ValueError("empty selector")
+
+            index = 0
+
+            for c in selector:
+                if c.isalnum() or c in ('_', '|', '?'):
+                    index += 1
+                else:
+                    break
+
+            attrs = []
+            types = []
+
+            if index:
+                elements = selector[:index]
+                selector = selector[index:]
+
+                for element in elements.split('|'):
+                    element = element.strip()
+
+                    if not element:
+                        raise ValueError("empty element")
+
+                    if element.endswith('?'):
+                        attrs.append(element[:-1])
+                    else:
+                        types.append(element)
+
+            span = None
+
+            if selector == '*':
+                pass
+            else:
+                if selector.startswith('['):
+                    try:
+                        i = selector.index(']')
+                    except ValueError:
+                        raise ValueError("expected ']', got EOL")
+
+                    _span, span = selector[1:i], []
+
+                    if ':' not in _span:
+                        span = int(_span)
+                    else:
+                        for elt in _span.split(':', 3):
+                            if not elt:
+                                span.append(None)
+                            else:
+                                span.append(int(elt))
+
+                        span = slice(*span)
+
+                    selector = selector[i + 1:]
+
+                if selector:
+                    raise ValueError("trailing characters in selector")
+
+            epath.append((attrs, types, span))
+
+        obj = object.__new__(cls)
+
+        obj._path = _path
+        obj._epath = epath
+
+        return obj
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self._path)
+
+    def _get_ordered_args(self, expr):
+        """Sort ``expr.args`` using printing order. """
+        if expr.is_Add:
+            return expr.as_ordered_terms()
+        elif expr.is_Mul:
+            return expr.as_ordered_factors()
+        else:
+            return expr.args
+
+    def _hasattrs(self, expr, attrs):
+        """Check if ``expr`` has any of ``attrs``. """
+        for attr in attrs:
+            if not hasattr(expr, attr):
+                return False
+
+        return True
+
+    def _hastypes(self, expr, types):
+        """Check if ``expr`` is any of ``types``. """
+        _types = [ cls.__name__ for cls in expr.__class__.mro() ]
+        return bool(set(_types).intersection(types))
+
+    def _has(self, expr, attrs, types):
+        """Apply ``_hasattrs`` and ``_hastypes`` to ``expr``. """
+        if not (attrs or types):
+            return True
+
+        if attrs and self._hasattrs(expr, attrs):
+            return True
+
+        if types and self._hastypes(expr, types):
+            return True
+
+        return False
+
+    def apply(self, expr, func, args=None, kwargs=None):
+        """
+        Modify parts of an expression selected by a path.
+
+        Examples
+        ========
+
+        >>> from sympy.simplify.epathtools import EPath
+        >>> from sympy import sin, cos, E
+        >>> from sympy.abc import x, y, z, t
+
+        >>> path = EPath("/*/[0]/Symbol")
+        >>> expr = [((x, 1), 2), ((3, y), z)]
+
+        >>> path.apply(expr, lambda expr: expr**2)
+        [((x**2, 1), 2), ((3, y**2), z)]
+
+        >>> path = EPath("/*/*/Symbol")
+        >>> expr = t + sin(x + 1) + cos(x + y + E)
+
+        >>> path.apply(expr, lambda expr: 2*expr)
+        t + sin(2*x + 1) + cos(2*x + 2*y + E)
+
+        """
+        def _apply(path, expr, func):
+            if not path:
+                return func(expr)
+            else:
+                selector, path = path[0], path[1:]
+                attrs, types, span = selector
+
+                if isinstance(expr, Basic):
+                    if not expr.is_Atom:
+                        args, basic = self._get_ordered_args(expr), True
+                    else:
+                        return expr
+                elif hasattr(expr, '__iter__'):
+                    args, basic = expr, False
+                else:
+                    return expr
+
+                args = list(args)
+
+                if span is not None:
+                    if isinstance(span, slice):
+                        indices = range(*span.indices(len(args)))
+                    else:
+                        indices = [span]
+                else:
+                    indices = range(len(args))
+
+                for i in indices:
+                    try:
+                        arg = args[i]
+                    except IndexError:
+                        continue
+
+                    if self._has(arg, attrs, types):
+                        args[i] = _apply(path, arg, func)
+
+                if basic:
+                    return expr.func(*args)
+                else:
+                    return expr.__class__(args)
+
+        _args, _kwargs = args or (), kwargs or {}
+        _func = lambda expr: func(expr, *_args, **_kwargs)
+
+        return _apply(self._epath, expr, _func)
+
+    def select(self, expr):
+        """
+        Retrieve parts of an expression selected by a path.
+
+        Examples
+        ========
+
+        >>> from sympy.simplify.epathtools import EPath
+        >>> from sympy import sin, cos, E
+        >>> from sympy.abc import x, y, z, t
+
+        >>> path = EPath("/*/[0]/Symbol")
+        >>> expr = [((x, 1), 2), ((3, y), z)]
+
+        >>> path.select(expr)
+        [x, y]
+
+        >>> path = EPath("/*/*/Symbol")
+        >>> expr = t + sin(x + 1) + cos(x + y + E)
+
+        >>> path.select(expr)
+        [x, x, y]
+
+        """
+        result = []
+
+        def _select(path, expr):
+            if not path:
+                result.append(expr)
+            else:
+                selector, path = path[0], path[1:]
+                attrs, types, span = selector
+
+                if isinstance(expr, Basic):
+                    args = self._get_ordered_args(expr)
+                elif hasattr(expr, '__iter__'):
+                    args = expr
+                else:
+                    return
+
+                if span is not None:
+                    if isinstance(span, slice):
+                        args = args[span]
+                    else:
+                        try:
+                            args = [args[span]]
+                        except IndexError:
+                            return
+
+                for arg in args:
+                    if self._has(arg, attrs, types):
+                        _select(path, arg)
+
+        _select(self._epath, expr)
+        return result
+
+
+def epath(path, expr=None, func=None, args=None, kwargs=None):
+    r"""
+    Manipulate parts of an expression selected by a path.
+
+    Explanation
+    ===========
+
+    This function allows to manipulate large nested expressions in single
+    line of code, utilizing techniques to those applied in XML processing
+    standards (e.g. XPath).
+
+    If ``func`` is ``None``, :func:`epath` retrieves elements selected by
+    the ``path``. Otherwise it applies ``func`` to each matching element.
+
+    Note that it is more efficient to create an EPath object and use the select
+    and apply methods of that object, since this will compile the path string
+    only once.  This function should only be used as a convenient shortcut for
+    interactive use.
+
+    This is the supported syntax:
+
+    * select all: ``/*``
+          Equivalent of ``for arg in args:``.
+    * select slice: ``/[0]`` or ``/[1:5]`` or ``/[1:5:2]``
+          Supports standard Python's slice syntax.
+    * select by type: ``/list`` or ``/list|tuple``
+          Emulates ``isinstance()``.
+    * select by attribute: ``/__iter__?``
+          Emulates ``hasattr()``.
+
+    Parameters
+    ==========
+
+    path : str | EPath
+        A path as a string or a compiled EPath.
+    expr : Basic | iterable
+        An expression or a container of expressions.
+    func : callable (optional)
+        A callable that will be applied to matching parts.
+    args : tuple (optional)
+        Additional positional arguments to ``func``.
+    kwargs : dict (optional)
+        Additional keyword arguments to ``func``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.epathtools import epath
+    >>> from sympy import sin, cos, E
+    >>> from sympy.abc import x, y, z, t
+
+    >>> path = "/*/[0]/Symbol"
+    >>> expr = [((x, 1), 2), ((3, y), z)]
+
+    >>> epath(path, expr)
+    [x, y]
+    >>> epath(path, expr, lambda expr: expr**2)
+    [((x**2, 1), 2), ((3, y**2), z)]
+
+    >>> path = "/*/*/Symbol"
+    >>> expr = t + sin(x + 1) + cos(x + y + E)
+
+    >>> epath(path, expr)
+    [x, x, y]
+    >>> epath(path, expr, lambda expr: 2*expr)
+    t + sin(2*x + 1) + cos(2*x + 2*y + E)
+
+    """
+    _epath = EPath(path)
+
+    if expr is None:
+        return _epath
+    if func is None:
+        return _epath.select(expr)
+    else:
+        return _epath.apply(expr, func, args, kwargs)

lib/python3.12/site-packages/sympy/simplify/fu.py

@@ -0,0 +1,2111 @@
+from collections import defaultdict
+
+from sympy.core.add import Add
+from sympy.core.expr import Expr
+from sympy.core.exprtools import Factors, gcd_terms, factor_terms
+from sympy.core.function import expand_mul
+from sympy.core.mul import Mul
+from sympy.core.numbers import pi, I
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.core.traversal import bottom_up
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.elementary.hyperbolic import (
+    cosh, sinh, tanh, coth, sech, csch, HyperbolicFunction)
+from sympy.functions.elementary.trigonometric import (
+    cos, sin, tan, cot, sec, csc, sqrt, TrigonometricFunction)
+from sympy.ntheory.factor_ import perfect_power
+from sympy.polys.polytools import factor
+from sympy.strategies.tree import greedy
+from sympy.strategies.core import identity, debug
+
+from sympy import SYMPY_DEBUG
+
+
+# ================== Fu-like tools ===========================
+
+
+def TR0(rv):
+    """Simplification of rational polynomials, trying to simplify
+    the expression, e.g. combine things like 3*x + 2*x, etc....
+    """
+    # although it would be nice to use cancel, it doesn't work
+    # with noncommutatives
+    return rv.normal().factor().expand()
+
+
+def TR1(rv):
+    """Replace sec, csc with 1/cos, 1/sin
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR1, sec, csc
+    >>> from sympy.abc import x
+    >>> TR1(2*csc(x) + sec(x))
+    1/cos(x) + 2/sin(x)
+    """
+
+    def f(rv):
+        if isinstance(rv, sec):
+            a = rv.args[0]
+            return S.One/cos(a)
+        elif isinstance(rv, csc):
+            a = rv.args[0]
+            return S.One/sin(a)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR2(rv):
+    """Replace tan and cot with sin/cos and cos/sin
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR2
+    >>> from sympy.abc import x
+    >>> from sympy import tan, cot, sin, cos
+    >>> TR2(tan(x))
+    sin(x)/cos(x)
+    >>> TR2(cot(x))
+    cos(x)/sin(x)
+    >>> TR2(tan(tan(x) - sin(x)/cos(x)))
+    0
+
+    """
+
+    def f(rv):
+        if isinstance(rv, tan):
+            a = rv.args[0]
+            return sin(a)/cos(a)
+        elif isinstance(rv, cot):
+            a = rv.args[0]
+            return cos(a)/sin(a)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR2i(rv, half=False):
+    """Converts ratios involving sin and cos as follows::
+        sin(x)/cos(x) -> tan(x)
+        sin(x)/(cos(x) + 1) -> tan(x/2) if half=True
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR2i
+    >>> from sympy.abc import x, a
+    >>> from sympy import sin, cos
+    >>> TR2i(sin(x)/cos(x))
+    tan(x)
+
+    Powers of the numerator and denominator are also recognized
+
+    >>> TR2i(sin(x)**2/(cos(x) + 1)**2, half=True)
+    tan(x/2)**2
+
+    The transformation does not take place unless assumptions allow
+    (i.e. the base must be positive or the exponent must be an integer
+    for both numerator and denominator)
+
+    >>> TR2i(sin(x)**a/(cos(x) + 1)**a)
+    sin(x)**a/(cos(x) + 1)**a
+
+    """
+
+    def f(rv):
+        if not rv.is_Mul:
+            return rv
+
+        n, d = rv.as_numer_denom()
+        if n.is_Atom or d.is_Atom:
+            return rv
+
+        def ok(k, e):
+            # initial filtering of factors
+            return (
+                (e.is_integer or k.is_positive) and (
+                k.func in (sin, cos) or (half and
+                k.is_Add and
+                len(k.args) >= 2 and
+                any(any(isinstance(ai, cos) or ai.is_Pow and ai.base is cos
+                for ai in Mul.make_args(a)) for a in k.args))))
+
+        n = n.as_powers_dict()
+        ndone = [(k, n.pop(k)) for k in list(n.keys()) if not ok(k, n[k])]
+        if not n:
+            return rv
+
+        d = d.as_powers_dict()
+        ddone = [(k, d.pop(k)) for k in list(d.keys()) if not ok(k, d[k])]
+        if not d:
+            return rv
+
+        # factoring if necessary
+
+        def factorize(d, ddone):
+            newk = []
+            for k in d:
+                if k.is_Add and len(k.args) > 1:
+                    knew = factor(k) if half else factor_terms(k)
+                    if knew != k:
+                        newk.append((k, knew))
+            if newk:
+                for i, (k, knew) in enumerate(newk):
+                    del d[k]
+                    newk[i] = knew
+                newk = Mul(*newk).as_powers_dict()
+                for k in newk:
+                    v = d[k] + newk[k]
+                    if ok(k, v):
+                        d[k] = v
+                    else:
+                        ddone.append((k, v))
+                del newk
+        factorize(n, ndone)
+        factorize(d, ddone)
+
+        # joining
+        t = []
+        for k in n:
+            if isinstance(k, sin):
+                a = cos(k.args[0], evaluate=False)
+                if a in d and d[a] == n[k]:
+                    t.append(tan(k.args[0])**n[k])
+                    n[k] = d[a] = None
+                elif half:
+                    a1 = 1 + a
+                    if a1 in d and d[a1] == n[k]:
+                        t.append((tan(k.args[0]/2))**n[k])
+                        n[k] = d[a1] = None
+            elif isinstance(k, cos):
+                a = sin(k.args[0], evaluate=False)
+                if a in d and d[a] == n[k]:
+                    t.append(tan(k.args[0])**-n[k])
+                    n[k] = d[a] = None
+            elif half and k.is_Add and k.args[0] is S.One and \
+                    isinstance(k.args[1], cos):
+                a = sin(k.args[1].args[0], evaluate=False)
+                if a in d and d[a] == n[k] and (d[a].is_integer or \
+                        a.is_positive):
+                    t.append(tan(a.args[0]/2)**-n[k])
+                    n[k] = d[a] = None
+
+        if t:
+            rv = Mul(*(t + [b**e for b, e in n.items() if e]))/\
+                Mul(*[b**e for b, e in d.items() if e])
+            rv *= Mul(*[b**e for b, e in ndone])/Mul(*[b**e for b, e in ddone])
+
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR3(rv):
+    """Induced formula: example sin(-a) = -sin(a)
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR3
+    >>> from sympy.abc import x, y
+    >>> from sympy import pi
+    >>> from sympy import cos
+    >>> TR3(cos(y - x*(y - x)))
+    cos(x*(x - y) + y)
+    >>> cos(pi/2 + x)
+    -sin(x)
+    >>> cos(30*pi/2 + x)
+    -cos(x)
+
+    """
+    from sympy.simplify.simplify import signsimp
+
+    # Negative argument (already automatic for funcs like sin(-x) -> -sin(x)
+    # but more complicated expressions can use it, too). Also, trig angles
+    # between pi/4 and pi/2 are not reduced to an angle between 0 and pi/4.
+    # The following are automatically handled:
+    #   Argument of type: pi/2 +/- angle
+    #   Argument of type: pi +/- angle
+    #   Argument of type : 2k*pi +/- angle
+
+    def f(rv):
+        if not isinstance(rv, TrigonometricFunction):
+            return rv
+        rv = rv.func(signsimp(rv.args[0]))
+        if not isinstance(rv, TrigonometricFunction):
+            return rv
+        if (rv.args[0] - S.Pi/4).is_positive is (S.Pi/2 - rv.args[0]).is_positive is True:
+            fmap = {cos: sin, sin: cos, tan: cot, cot: tan, sec: csc, csc: sec}
+            rv = fmap[type(rv)](S.Pi/2 - rv.args[0])
+        return rv
+
+    # touch numbers iside of trig functions to let them automatically update
+    rv = rv.replace(
+        lambda x: isinstance(x, TrigonometricFunction),
+        lambda x: x.replace(
+            lambda n: n.is_number and n.is_Mul,
+            lambda n: n.func(*n.args)))
+
+    return bottom_up(rv, f)
+
+
+def TR4(rv):
+    """Identify values of special angles.
+
+        a=  0   pi/6        pi/4        pi/3        pi/2
+    ----------------------------------------------------
+    sin(a)  0   1/2         sqrt(2)/2   sqrt(3)/2   1
+    cos(a)  1   sqrt(3)/2   sqrt(2)/2   1/2         0
+    tan(a)  0   sqt(3)/3    1           sqrt(3)     --
+
+    Examples
+    ========
+
+    >>> from sympy import pi
+    >>> from sympy import cos, sin, tan, cot
+    >>> for s in (0, pi/6, pi/4, pi/3, pi/2):
+    ...    print('%s %s %s %s' % (cos(s), sin(s), tan(s), cot(s)))
+    ...
+    1 0 0 zoo
+    sqrt(3)/2 1/2 sqrt(3)/3 sqrt(3)
+    sqrt(2)/2 sqrt(2)/2 1 1
+    1/2 sqrt(3)/2 sqrt(3) sqrt(3)/3
+    0 1 zoo 0
+    """
+    # special values at 0, pi/6, pi/4, pi/3, pi/2 already handled
+    return rv.replace(
+        lambda x:
+            isinstance(x, TrigonometricFunction) and
+            (r:=x.args[0]/pi).is_Rational and r.q in (1, 2, 3, 4, 6),
+        lambda x:
+            x.func(x.args[0].func(*x.args[0].args)))
+
+
+def _TR56(rv, f, g, h, max, pow):
+    """Helper for TR5 and TR6 to replace f**2 with h(g**2)
+
+    Options
+    =======
+
+    max :   controls size of exponent that can appear on f
+            e.g. if max=4 then f**4 will be changed to h(g**2)**2.
+    pow :   controls whether the exponent must be a perfect power of 2
+            e.g. if pow=True (and max >= 6) then f**6 will not be changed
+            but f**8 will be changed to h(g**2)**4
+
+    >>> from sympy.simplify.fu import _TR56 as T
+    >>> from sympy.abc import x
+    >>> from sympy import sin, cos
+    >>> h = lambda x: 1 - x
+    >>> T(sin(x)**3, sin, cos, h, 4, False)
+    (1 - cos(x)**2)*sin(x)
+    >>> T(sin(x)**6, sin, cos, h, 6, False)
+    (1 - cos(x)**2)**3
+    >>> T(sin(x)**6, sin, cos, h, 6, True)
+    sin(x)**6
+    >>> T(sin(x)**8, sin, cos, h, 10, True)
+    (1 - cos(x)**2)**4
+    """
+
+    def _f(rv):
+        # I'm not sure if this transformation should target all even powers
+        # or only those expressible as powers of 2. Also, should it only
+        # make the changes in powers that appear in sums -- making an isolated
+        # change is not going to allow a simplification as far as I can tell.
+        if not (rv.is_Pow and rv.base.func == f):
+            return rv
+        if not rv.exp.is_real:
+            return rv
+
+        if (rv.exp < 0) == True:
+            return rv
+        if (rv.exp > max) == True:
+            return rv
+        if rv.exp == 1:
+            return rv
+        if rv.exp == 2:
+            return h(g(rv.base.args[0])**2)
+        else:
+            if rv.exp % 2 == 1:
+                e = rv.exp//2
+                return f(rv.base.args[0])*h(g(rv.base.args[0])**2)**e
+            elif rv.exp == 4:
+                e = 2
+            elif not pow:
+                if rv.exp % 2:
+                    return rv
+                e = rv.exp//2
+            else:
+                p = perfect_power(rv.exp)
+                if not p:
+                    return rv
+                e = rv.exp//2
+            return h(g(rv.base.args[0])**2)**e
+
+    return bottom_up(rv, _f)
+
+
+def TR5(rv, max=4, pow=False):
+    """Replacement of sin**2 with 1 - cos(x)**2.
+
+    See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR5
+    >>> from sympy.abc import x
+    >>> from sympy import sin
+    >>> TR5(sin(x)**2)
+    1 - cos(x)**2
+    >>> TR5(sin(x)**-2)  # unchanged
+    sin(x)**(-2)
+    >>> TR5(sin(x)**4)
+    (1 - cos(x)**2)**2
+    """
+    return _TR56(rv, sin, cos, lambda x: 1 - x, max=max, pow=pow)
+
+
+def TR6(rv, max=4, pow=False):
+    """Replacement of cos**2 with 1 - sin(x)**2.
+
+    See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR6
+    >>> from sympy.abc import x
+    >>> from sympy import cos
+    >>> TR6(cos(x)**2)
+    1 - sin(x)**2
+    >>> TR6(cos(x)**-2)  #unchanged
+    cos(x)**(-2)
+    >>> TR6(cos(x)**4)
+    (1 - sin(x)**2)**2
+    """
+    return _TR56(rv, cos, sin, lambda x: 1 - x, max=max, pow=pow)
+
+
+def TR7(rv):
+    """Lowering the degree of cos(x)**2.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR7
+    >>> from sympy.abc import x
+    >>> from sympy import cos
+    >>> TR7(cos(x)**2)
+    cos(2*x)/2 + 1/2
+    >>> TR7(cos(x)**2 + 1)
+    cos(2*x)/2 + 3/2
+
+    """
+
+    def f(rv):
+        if not (rv.is_Pow and rv.base.func == cos and rv.exp == 2):
+            return rv
+        return (1 + cos(2*rv.base.args[0]))/2
+
+    return bottom_up(rv, f)
+
+
+def TR8(rv, first=True):
+    """Converting products of ``cos`` and/or ``sin`` to a sum or
+    difference of ``cos`` and or ``sin`` terms.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR8
+    >>> from sympy import cos, sin
+    >>> TR8(cos(2)*cos(3))
+    cos(5)/2 + cos(1)/2
+    >>> TR8(cos(2)*sin(3))
+    sin(5)/2 + sin(1)/2
+    >>> TR8(sin(2)*sin(3))
+    -cos(5)/2 + cos(1)/2
+    """
+
+    def f(rv):
+        if not (
+            rv.is_Mul or
+            rv.is_Pow and
+            rv.base.func in (cos, sin) and
+            (rv.exp.is_integer or rv.base.is_positive)):
+            return rv
+
+        if first:
+            n, d = [expand_mul(i) for i in rv.as_numer_denom()]
+            newn = TR8(n, first=False)
+            newd = TR8(d, first=False)
+            if newn != n or newd != d:
+                rv = gcd_terms(newn/newd)
+                if rv.is_Mul and rv.args[0].is_Rational and \
+                        len(rv.args) == 2 and rv.args[1].is_Add:
+                    rv = Mul(*rv.as_coeff_Mul())
+            return rv
+
+        args = {cos: [], sin: [], None: []}
+        for a in Mul.make_args(rv):
+            if a.func in (cos, sin):
+                args[type(a)].append(a.args[0])
+            elif (a.is_Pow and a.exp.is_Integer and a.exp > 0 and \
+                    a.base.func in (cos, sin)):
+                # XXX this is ok but pathological expression could be handled
+                # more efficiently as in TRmorrie
+                args[type(a.base)].extend([a.base.args[0]]*a.exp)
+            else:
+                args[None].append(a)
+        c = args[cos]
+        s = args[sin]
+        if not (c and s or len(c) > 1 or len(s) > 1):
+            return rv
+
+        args = args[None]
+        n = min(len(c), len(s))
+        for i in range(n):
+            a1 = s.pop()
+            a2 = c.pop()
+            args.append((sin(a1 + a2) + sin(a1 - a2))/2)
+        while len(c) > 1:
+            a1 = c.pop()
+            a2 = c.pop()
+            args.append((cos(a1 + a2) + cos(a1 - a2))/2)
+        if c:
+            args.append(cos(c.pop()))
+        while len(s) > 1:
+            a1 = s.pop()
+            a2 = s.pop()
+            args.append((-cos(a1 + a2) + cos(a1 - a2))/2)
+        if s:
+            args.append(sin(s.pop()))
+        return TR8(expand_mul(Mul(*args)))
+
+    return bottom_up(rv, f)
+
+
+def TR9(rv):
+    """Sum of ``cos`` or ``sin`` terms as a product of ``cos`` or ``sin``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR9
+    >>> from sympy import cos, sin
+    >>> TR9(cos(1) + cos(2))
+    2*cos(1/2)*cos(3/2)
+    >>> TR9(cos(1) + 2*sin(1) + 2*sin(2))
+    cos(1) + 4*sin(3/2)*cos(1/2)
+
+    If no change is made by TR9, no re-arrangement of the
+    expression will be made. For example, though factoring
+    of common term is attempted, if the factored expression
+    was not changed, the original expression will be returned:
+
+    >>> TR9(cos(3) + cos(3)*cos(2))
+    cos(3) + cos(2)*cos(3)
+
+    """
+
+    def f(rv):
+        if not rv.is_Add:
+            return rv
+
+        def do(rv, first=True):
+            # cos(a)+/-cos(b) can be combined into a product of cosines and
+            # sin(a)+/-sin(b) can be combined into a product of cosine and
+            # sine.
+            #
+            # If there are more than two args, the pairs which "work" will
+            # have a gcd extractable and the remaining two terms will have
+            # the above structure -- all pairs must be checked to find the
+            # ones that work. args that don't have a common set of symbols
+            # are skipped since this doesn't lead to a simpler formula and
+            # also has the arbitrariness of combining, for example, the x
+            # and y term instead of the y and z term in something like
+            # cos(x) + cos(y) + cos(z).
+
+            if not rv.is_Add:
+                return rv
+
+            args = list(ordered(rv.args))
+            if len(args) != 2:
+                hit = False
+                for i in range(len(args)):
+                    ai = args[i]
+                    if ai is None:
+                        continue
+                    for j in range(i + 1, len(args)):
+                        aj = args[j]
+                        if aj is None:
+                            continue
+                        was = ai + aj
+                        new = do(was)
+                        if new != was:
+                            args[i] = new  # update in place
+                            args[j] = None
+                            hit = True
+                            break  # go to next i
+                if hit:
+                    rv = Add(*[_f for _f in args if _f])
+                    if rv.is_Add:
+                        rv = do(rv)
+
+                return rv
+
+            # two-arg Add
+            split = trig_split(*args)
+            if not split:
+                return rv
+            gcd, n1, n2, a, b, iscos = split
+
+            # application of rule if possible
+            if iscos:
+                if n1 == n2:
+                    return gcd*n1*2*cos((a + b)/2)*cos((a - b)/2)
+                if n1 < 0:
+                    a, b = b, a
+                return -2*gcd*sin((a + b)/2)*sin((a - b)/2)
+            else:
+                if n1 == n2:
+                    return gcd*n1*2*sin((a + b)/2)*cos((a - b)/2)
+                if n1 < 0:
+                    a, b = b, a
+                return 2*gcd*cos((a + b)/2)*sin((a - b)/2)
+
+        return process_common_addends(rv, do)  # DON'T sift by free symbols
+
+    return bottom_up(rv, f)
+
+
+def TR10(rv, first=True):
+    """Separate sums in ``cos`` and ``sin``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR10
+    >>> from sympy.abc import a, b, c
+    >>> from sympy import cos, sin
+    >>> TR10(cos(a + b))
+    -sin(a)*sin(b) + cos(a)*cos(b)
+    >>> TR10(sin(a + b))
+    sin(a)*cos(b) + sin(b)*cos(a)
+    >>> TR10(sin(a + b + c))
+    (-sin(a)*sin(b) + cos(a)*cos(b))*sin(c) + \
+    (sin(a)*cos(b) + sin(b)*cos(a))*cos(c)
+    """
+
+    def f(rv):
+        if rv.func not in (cos, sin):
+            return rv
+
+        f = rv.func
+        arg = rv.args[0]
+        if arg.is_Add:
+            if first:
+                args = list(ordered(arg.args))
+            else:
+                args = list(arg.args)
+            a = args.pop()
+            b = Add._from_args(args)
+            if b.is_Add:
+                if f == sin:
+                    return sin(a)*TR10(cos(b), first=False) + \
+                        cos(a)*TR10(sin(b), first=False)
+                else:
+                    return cos(a)*TR10(cos(b), first=False) - \
+                        sin(a)*TR10(sin(b), first=False)
+            else:
+                if f == sin:
+                    return sin(a)*cos(b) + cos(a)*sin(b)
+                else:
+                    return cos(a)*cos(b) - sin(a)*sin(b)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR10i(rv):
+    """Sum of products to function of sum.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR10i
+    >>> from sympy import cos, sin, sqrt
+    >>> from sympy.abc import x
+
+    >>> TR10i(cos(1)*cos(3) + sin(1)*sin(3))
+    cos(2)
+    >>> TR10i(cos(1)*sin(3) + sin(1)*cos(3) + cos(3))
+    cos(3) + sin(4)
+    >>> TR10i(sqrt(2)*cos(x)*x + sqrt(6)*sin(x)*x)
+    2*sqrt(2)*x*sin(x + pi/6)
+
+    """
+    global _ROOT2, _ROOT3, _invROOT3
+    if _ROOT2 is None:
+        _roots()
+
+    def f(rv):
+        if not rv.is_Add:
+            return rv
+
+        def do(rv, first=True):
+            # args which can be expressed as A*(cos(a)*cos(b)+/-sin(a)*sin(b))
+            # or B*(cos(a)*sin(b)+/-cos(b)*sin(a)) can be combined into
+            # A*f(a+/-b) where f is either sin or cos.
+            #
+            # If there are more than two args, the pairs which "work" will have
+            # a gcd extractable and the remaining two terms will have the above
+            # structure -- all pairs must be checked to find the ones that
+            # work.
+
+            if not rv.is_Add:
+                return rv
+
+            args = list(ordered(rv.args))
+            if len(args) != 2:
+                hit = False
+                for i in range(len(args)):
+                    ai = args[i]
+                    if ai is None:
+                        continue
+                    for j in range(i + 1, len(args)):
+                        aj = args[j]
+                        if aj is None:
+                            continue
+                        was = ai + aj
+                        new = do(was)
+                        if new != was:
+                            args[i] = new  # update in place
+                            args[j] = None
+                            hit = True
+                            break  # go to next i
+                if hit:
+                    rv = Add(*[_f for _f in args if _f])
+                    if rv.is_Add:
+                        rv = do(rv)
+
+                return rv
+
+            # two-arg Add
+            split = trig_split(*args, two=True)
+            if not split:
+                return rv
+            gcd, n1, n2, a, b, same = split
+
+            # identify and get c1 to be cos then apply rule if possible
+            if same:  # coscos, sinsin
+                gcd = n1*gcd
+                if n1 == n2:
+                    return gcd*cos(a - b)
+                return gcd*cos(a + b)
+            else:  #cossin, cossin
+                gcd = n1*gcd
+                if n1 == n2:
+                    return gcd*sin(a + b)
+                return gcd*sin(b - a)
+
+        rv = process_common_addends(
+            rv, do, lambda x: tuple(ordered(x.free_symbols)))
+
+        # need to check for inducible pairs in ratio of sqrt(3):1 that
+        # appeared in different lists when sorting by coefficient
+        while rv.is_Add:
+            byrad = defaultdict(list)
+            for a in rv.args:
+                hit = 0
+                if a.is_Mul:
+                    for ai in a.args:
+                        if ai.is_Pow and ai.exp is S.Half and \
+                                ai.base.is_Integer:
+                            byrad[ai].append(a)
+                            hit = 1
+                            break
+                if not hit:
+                    byrad[S.One].append(a)
+
+            # no need to check all pairs -- just check for the onees
+            # that have the right ratio
+            args = []
+            for a in byrad:
+                for b in [_ROOT3*a, _invROOT3]:
+                    if b in byrad:
+                        for i in range(len(byrad[a])):
+                            if byrad[a][i] is None:
+                                continue
+                            for j in range(len(byrad[b])):
+                                if byrad[b][j] is None:
+                                    continue
+                                was = Add(byrad[a][i] + byrad[b][j])
+                                new = do(was)
+                                if new != was:
+                                    args.append(new)
+                                    byrad[a][i] = None
+                                    byrad[b][j] = None
+                                    break
+            if args:
+                rv = Add(*(args + [Add(*[_f for _f in v if _f])
+                    for v in byrad.values()]))
+            else:
+                rv = do(rv)  # final pass to resolve any new inducible pairs
+                break
+
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR11(rv, base=None):
+    """Function of double angle to product. The ``base`` argument can be used
+    to indicate what is the un-doubled argument, e.g. if 3*pi/7 is the base
+    then cosine and sine functions with argument 6*pi/7 will be replaced.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR11
+    >>> from sympy import cos, sin, pi
+    >>> from sympy.abc import x
+    >>> TR11(sin(2*x))
+    2*sin(x)*cos(x)
+    >>> TR11(cos(2*x))
+    -sin(x)**2 + cos(x)**2
+    >>> TR11(sin(4*x))
+    4*(-sin(x)**2 + cos(x)**2)*sin(x)*cos(x)
+    >>> TR11(sin(4*x/3))
+    4*(-sin(x/3)**2 + cos(x/3)**2)*sin(x/3)*cos(x/3)
+
+    If the arguments are simply integers, no change is made
+    unless a base is provided:
+
+    >>> TR11(cos(2))
+    cos(2)
+    >>> TR11(cos(4), 2)
+    -sin(2)**2 + cos(2)**2
+
+    There is a subtle issue here in that autosimplification will convert
+    some higher angles to lower angles
+
+    >>> cos(6*pi/7) + cos(3*pi/7)
+    -cos(pi/7) + cos(3*pi/7)
+
+    The 6*pi/7 angle is now pi/7 but can be targeted with TR11 by supplying
+    the 3*pi/7 base:
+
+    >>> TR11(_, 3*pi/7)
+    -sin(3*pi/7)**2 + cos(3*pi/7)**2 + cos(3*pi/7)
+
+    """
+
+    def f(rv):
+        if rv.func not in (cos, sin):
+            return rv
+
+        if base:
+            f = rv.func
+            t = f(base*2)
+            co = S.One
+            if t.is_Mul:
+                co, t = t.as_coeff_Mul()
+            if t.func not in (cos, sin):
+                return rv
+            if rv.args[0] == t.args[0]:
+                c = cos(base)
+                s = sin(base)
+                if f is cos:
+                    return (c**2 - s**2)/co
+                else:
+                    return 2*c*s/co
+            return rv
+
+        elif not rv.args[0].is_Number:
+            # make a change if the leading coefficient's numerator is
+            # divisible by 2
+            c, m = rv.args[0].as_coeff_Mul(rational=True)
+            if c.p % 2 == 0:
+                arg = c.p//2*m/c.q
+                c = TR11(cos(arg))
+                s = TR11(sin(arg))
+                if rv.func == sin:
+                    rv = 2*s*c
+                else:
+                    rv = c**2 - s**2
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def _TR11(rv):
+    """
+    Helper for TR11 to find half-arguments for sin in factors of
+    num/den that appear in cos or sin factors in the den/num.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR11, _TR11
+    >>> from sympy import cos, sin
+    >>> from sympy.abc import x
+    >>> TR11(sin(x/3)/(cos(x/6)))
+    sin(x/3)/cos(x/6)
+    >>> _TR11(sin(x/3)/(cos(x/6)))
+    2*sin(x/6)
+    >>> TR11(sin(x/6)/(sin(x/3)))
+    sin(x/6)/sin(x/3)
+    >>> _TR11(sin(x/6)/(sin(x/3)))
+    1/(2*cos(x/6))
+
+    """
+    def f(rv):
+        if not isinstance(rv, Expr):
+            return rv
+
+        def sincos_args(flat):
+            # find arguments of sin and cos that
+            # appears as bases in args of flat
+            # and have Integer exponents
+            args = defaultdict(set)
+            for fi in Mul.make_args(flat):
+                b, e = fi.as_base_exp()
+                if e.is_Integer and e > 0:
+                    if b.func in (cos, sin):
+                        args[type(b)].add(b.args[0])
+            return args
+        num_args, den_args = map(sincos_args, rv.as_numer_denom())
+        def handle_match(rv, num_args, den_args):
+            # for arg in sin args of num_args, look for arg/2
+            # in den_args and pass this half-angle to TR11
+            # for handling in rv
+            for narg in num_args[sin]:
+                half = narg/2
+                if half in den_args[cos]:
+                    func = cos
+                elif half in den_args[sin]:
+                    func = sin
+                else:
+                    continue
+                rv = TR11(rv, half)
+                den_args[func].remove(half)
+            return rv
+        # sin in num, sin or cos in den
+        rv = handle_match(rv, num_args, den_args)
+        # sin in den, sin or cos in num
+        rv = handle_match(rv, den_args, num_args)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR12(rv, first=True):
+    """Separate sums in ``tan``.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import tan
+    >>> from sympy.simplify.fu import TR12
+    >>> TR12(tan(x + y))
+    (tan(x) + tan(y))/(-tan(x)*tan(y) + 1)
+    """
+
+    def f(rv):
+        if not rv.func == tan:
+            return rv
+
+        arg = rv.args[0]
+        if arg.is_Add:
+            if first:
+                args = list(ordered(arg.args))
+            else:
+                args = list(arg.args)
+            a = args.pop()
+            b = Add._from_args(args)
+            if b.is_Add:
+                tb = TR12(tan(b), first=False)
+            else:
+                tb = tan(b)
+            return (tan(a) + tb)/(1 - tan(a)*tb)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR12i(rv):
+    """Combine tan arguments as
+    (tan(y) + tan(x))/(tan(x)*tan(y) - 1) -> -tan(x + y).
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR12i
+    >>> from sympy import tan
+    >>> from sympy.abc import a, b, c
+    >>> ta, tb, tc = [tan(i) for i in (a, b, c)]
+    >>> TR12i((ta + tb)/(-ta*tb + 1))
+    tan(a + b)
+    >>> TR12i((ta + tb)/(ta*tb - 1))
+    -tan(a + b)
+    >>> TR12i((-ta - tb)/(ta*tb - 1))
+    tan(a + b)
+    >>> eq = (ta + tb)/(-ta*tb + 1)**2*(-3*ta - 3*tc)/(2*(ta*tc - 1))
+    >>> TR12i(eq.expand())
+    -3*tan(a + b)*tan(a + c)/(2*(tan(a) + tan(b) - 1))
+    """
+    def f(rv):
+        if not (rv.is_Add or rv.is_Mul or rv.is_Pow):
+            return rv
+
+        n, d = rv.as_numer_denom()
+        if not d.args or not n.args:
+            return rv
+
+        dok = {}
+
+        def ok(di):
+            m = as_f_sign_1(di)
+            if m:
+                g, f, s = m
+                if s is S.NegativeOne and f.is_Mul and len(f.args) == 2 and \
+                        all(isinstance(fi, tan) for fi in f.args):
+                    return g, f
+
+        d_args = list(Mul.make_args(d))
+        for i, di in enumerate(d_args):
+            m = ok(di)
+            if m:
+                g, t = m
+                s = Add(*[_.args[0] for _ in t.args])
+                dok[s] = S.One
+                d_args[i] = g
+                continue
+            if di.is_Add:
+                di = factor(di)
+                if di.is_Mul:
+                    d_args.extend(di.args)
+                    d_args[i] = S.One
+            elif di.is_Pow and (di.exp.is_integer or di.base.is_positive):
+                m = ok(di.base)
+                if m:
+                    g, t = m
+                    s = Add(*[_.args[0] for _ in t.args])
+                    dok[s] = di.exp
+                    d_args[i] = g**di.exp
+                else:
+                    di = factor(di)
+                    if di.is_Mul:
+                        d_args.extend(di.args)
+                        d_args[i] = S.One
+        if not dok:
+            return rv
+
+        def ok(ni):
+            if ni.is_Add and len(ni.args) == 2:
+                a, b = ni.args
+                if isinstance(a, tan) and isinstance(b, tan):
+                    return a, b
+        n_args = list(Mul.make_args(factor_terms(n)))
+        hit = False
+        for i, ni in enumerate(n_args):
+            m = ok(ni)
+            if not m:
+                m = ok(-ni)
+                if m:
+                    n_args[i] = S.NegativeOne
+                else:
+                    if ni.is_Add:
+                        ni = factor(ni)
+                        if ni.is_Mul:
+                            n_args.extend(ni.args)
+                            n_args[i] = S.One
+                        continue
+                    elif ni.is_Pow and (
+                            ni.exp.is_integer or ni.base.is_positive):
+                        m = ok(ni.base)
+                        if m:
+                            n_args[i] = S.One
+                        else:
+                            ni = factor(ni)
+                            if ni.is_Mul:
+                                n_args.extend(ni.args)
+                                n_args[i] = S.One
+                            continue
+                    else:
+                        continue
+            else:
+                n_args[i] = S.One
+            hit = True
+            s = Add(*[_.args[0] for _ in m])
+            ed = dok[s]
+            newed = ed.extract_additively(S.One)
+            if newed is not None:
+                if newed:
+                    dok[s] = newed
+                else:
+                    dok.pop(s)
+            n_args[i] *= -tan(s)
+
+        if hit:
+            rv = Mul(*n_args)/Mul(*d_args)/Mul(*[(Add(*[
+                tan(a) for a in i.args]) - 1)**e for i, e in dok.items()])
+
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR13(rv):
+    """Change products of ``tan`` or ``cot``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR13
+    >>> from sympy import tan, cot
+    >>> TR13(tan(3)*tan(2))
+    -tan(2)/tan(5) - tan(3)/tan(5) + 1
+    >>> TR13(cot(3)*cot(2))
+    cot(2)*cot(5) + 1 + cot(3)*cot(5)
+    """
+
+    def f(rv):
+        if not rv.is_Mul:
+            return rv
+
+        # XXX handle products of powers? or let power-reducing handle it?
+        args = {tan: [], cot: [], None: []}
+        for a in Mul.make_args(rv):
+            if a.func in (tan, cot):
+                args[type(a)].append(a.args[0])
+            else:
+                args[None].append(a)
+        t = args[tan]
+        c = args[cot]
+        if len(t) < 2 and len(c) < 2:
+            return rv
+        args = args[None]
+        while len(t) > 1:
+            t1 = t.pop()
+            t2 = t.pop()
+            args.append(1 - (tan(t1)/tan(t1 + t2) + tan(t2)/tan(t1 + t2)))
+        if t:
+            args.append(tan(t.pop()))
+        while len(c) > 1:
+            t1 = c.pop()
+            t2 = c.pop()
+            args.append(1 + cot(t1)*cot(t1 + t2) + cot(t2)*cot(t1 + t2))
+        if c:
+            args.append(cot(c.pop()))
+        return Mul(*args)
+
+    return bottom_up(rv, f)
+
+
+def TRmorrie(rv):
+    """Returns cos(x)*cos(2*x)*...*cos(2**(k-1)*x) -> sin(2**k*x)/(2**k*sin(x))
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TRmorrie, TR8, TR3
+    >>> from sympy.abc import x
+    >>> from sympy import Mul, cos, pi
+    >>> TRmorrie(cos(x)*cos(2*x))
+    sin(4*x)/(4*sin(x))
+    >>> TRmorrie(7*Mul(*[cos(x) for x in range(10)]))
+    7*sin(12)*sin(16)*cos(5)*cos(7)*cos(9)/(64*sin(1)*sin(3))
+
+    Sometimes autosimplification will cause a power to be
+    not recognized. e.g. in the following, cos(4*pi/7) automatically
+    simplifies to -cos(3*pi/7) so only 2 of the 3 terms are
+    recognized:
+
+    >>> TRmorrie(cos(pi/7)*cos(2*pi/7)*cos(4*pi/7))
+    -sin(3*pi/7)*cos(3*pi/7)/(4*sin(pi/7))
+
+    A touch by TR8 resolves the expression to a Rational
+
+    >>> TR8(_)
+    -1/8
+
+    In this case, if eq is unsimplified, the answer is obtained
+    directly:
+
+    >>> eq = cos(pi/9)*cos(2*pi/9)*cos(3*pi/9)*cos(4*pi/9)
+    >>> TRmorrie(eq)
+    1/16
+
+    But if angles are made canonical with TR3 then the answer
+    is not simplified without further work:
+
+    >>> TR3(eq)
+    sin(pi/18)*cos(pi/9)*cos(2*pi/9)/2
+    >>> TRmorrie(_)
+    sin(pi/18)*sin(4*pi/9)/(8*sin(pi/9))
+    >>> TR8(_)
+    cos(7*pi/18)/(16*sin(pi/9))
+    >>> TR3(_)
+    1/16
+
+    The original expression would have resolve to 1/16 directly with TR8,
+    however:
+
+    >>> TR8(eq)
+    1/16
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Morrie%27s_law
+
+    """
+
+    def f(rv, first=True):
+        if not rv.is_Mul:
+            return rv
+        if first:
+            n, d = rv.as_numer_denom()
+            return f(n, 0)/f(d, 0)
+
+        args = defaultdict(list)
+        coss = {}
+        other = []
+        for c in rv.args:
+            b, e = c.as_base_exp()
+            if e.is_Integer and isinstance(b, cos):
+                co, a = b.args[0].as_coeff_Mul()
+                args[a].append(co)
+                coss[b] = e
+            else:
+                other.append(c)
+
+        new = []
+        for a in args:
+            c = args[a]
+            c.sort()
+            while c:
+                k = 0
+                cc = ci = c[0]
+                while cc in c:
+                    k += 1
+                    cc *= 2
+                if k > 1:
+                    newarg = sin(2**k*ci*a)/2**k/sin(ci*a)
+                    # see how many times this can be taken
+                    take = None
+                    ccs = []
+                    for i in range(k):
+                        cc /= 2
+                        key = cos(a*cc, evaluate=False)
+                        ccs.append(cc)
+                        take = min(coss[key], take or coss[key])
+                    # update exponent counts
+                    for i in range(k):
+                        cc = ccs.pop()
+                        key = cos(a*cc, evaluate=False)
+                        coss[key] -= take
+                        if not coss[key]:
+                            c.remove(cc)
+                    new.append(newarg**take)
+                else:
+                    b = cos(c.pop(0)*a)
+                    other.append(b**coss[b])
+
+        if new:
+            rv = Mul(*(new + other + [
+                cos(k*a, evaluate=False) for a in args for k in args[a]]))
+
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR14(rv, first=True):
+    """Convert factored powers of sin and cos identities into simpler
+    expressions.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR14
+    >>> from sympy.abc import x, y
+    >>> from sympy import cos, sin
+    >>> TR14((cos(x) - 1)*(cos(x) + 1))
+    -sin(x)**2
+    >>> TR14((sin(x) - 1)*(sin(x) + 1))
+    -cos(x)**2
+    >>> p1 = (cos(x) + 1)*(cos(x) - 1)
+    >>> p2 = (cos(y) - 1)*2*(cos(y) + 1)
+    >>> p3 = (3*(cos(y) - 1))*(3*(cos(y) + 1))
+    >>> TR14(p1*p2*p3*(x - 1))
+    -18*(x - 1)*sin(x)**2*sin(y)**4
+
+    """
+
+    def f(rv):
+        if not rv.is_Mul:
+            return rv
+
+        if first:
+            # sort them by location in numerator and denominator
+            # so the code below can just deal with positive exponents
+            n, d = rv.as_numer_denom()
+            if d is not S.One:
+                newn = TR14(n, first=False)
+                newd = TR14(d, first=False)
+                if newn != n or newd != d:
+                    rv = newn/newd
+                return rv
+
+        other = []
+        process = []
+        for a in rv.args:
+            if a.is_Pow:
+                b, e = a.as_base_exp()
+                if not (e.is_integer or b.is_positive):
+                    other.append(a)
+                    continue
+                a = b
+            else:
+                e = S.One
+            m = as_f_sign_1(a)
+            if not m or m[1].func not in (cos, sin):
+                if e is S.One:
+                    other.append(a)
+                else:
+                    other.append(a**e)
+                continue
+            g, f, si = m
+            process.append((g, e.is_Number, e, f, si, a))
+
+        # sort them to get like terms next to each other
+        process = list(ordered(process))
+
+        # keep track of whether there was any change
+        nother = len(other)
+
+        # access keys
+        keys = (g, t, e, f, si, a) = list(range(6))
+
+        while process:
+            A = process.pop(0)
+            if process:
+                B = process[0]
+
+                if A[e].is_Number and B[e].is_Number:
+                    # both exponents are numbers
+                    if A[f] == B[f]:
+                        if A[si] != B[si]:
+                            B = process.pop(0)
+                            take = min(A[e], B[e])
+
+                            # reinsert any remainder
+                            # the B will likely sort after A so check it first
+                            if B[e] != take:
+                                rem = [B[i] for i in keys]
+                                rem[e] -= take
+                                process.insert(0, rem)
+                            elif A[e] != take:
+                                rem = [A[i] for i in keys]
+                                rem[e] -= take
+                                process.insert(0, rem)
+
+                            if isinstance(A[f], cos):
+                                t = sin
+                            else:
+                                t = cos
+                            other.append((-A[g]*B[g]*t(A[f].args[0])**2)**take)
+                            continue
+
+                elif A[e] == B[e]:
+                    # both exponents are equal symbols
+                    if A[f] == B[f]:
+                        if A[si] != B[si]:
+                            B = process.pop(0)
+                            take = A[e]
+                            if isinstance(A[f], cos):
+                                t = sin
+                            else:
+                                t = cos
+                            other.append((-A[g]*B[g]*t(A[f].args[0])**2)**take)
+                            continue
+
+            # either we are done or neither condition above applied
+            other.append(A[a]**A[e])
+
+        if len(other) != nother:
+            rv = Mul(*other)
+
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR15(rv, max=4, pow=False):
+    """Convert sin(x)**-2 to 1 + cot(x)**2.
+
+    See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR15
+    >>> from sympy.abc import x
+    >>> from sympy import sin
+    >>> TR15(1 - 1/sin(x)**2)
+    -cot(x)**2
+
+    """
+
+    def f(rv):
+        if not (isinstance(rv, Pow) and isinstance(rv.base, sin)):
+            return rv
+
+        e = rv.exp
+        if e % 2 == 1:
+            return TR15(rv.base**(e + 1))/rv.base
+
+        ia = 1/rv
+        a = _TR56(ia, sin, cot, lambda x: 1 + x, max=max, pow=pow)
+        if a != ia:
+            rv = a
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR16(rv, max=4, pow=False):
+    """Convert cos(x)**-2 to 1 + tan(x)**2.
+
+    See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR16
+    >>> from sympy.abc import x
+    >>> from sympy import cos
+    >>> TR16(1 - 1/cos(x)**2)
+    -tan(x)**2
+
+    """
+
+    def f(rv):
+        if not (isinstance(rv, Pow) and isinstance(rv.base, cos)):
+            return rv
+
+        e = rv.exp
+        if e % 2 == 1:
+            return TR15(rv.base**(e + 1))/rv.base
+
+        ia = 1/rv
+        a = _TR56(ia, cos, tan, lambda x: 1 + x, max=max, pow=pow)
+        if a != ia:
+            rv = a
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR111(rv):
+    """Convert f(x)**-i to g(x)**i where either ``i`` is an integer
+    or the base is positive and f, g are: tan, cot; sin, csc; or cos, sec.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR111
+    >>> from sympy.abc import x
+    >>> from sympy import tan
+    >>> TR111(1 - 1/tan(x)**2)
+    1 - cot(x)**2
+
+    """
+
+    def f(rv):
+        if not (
+            isinstance(rv, Pow) and
+            (rv.base.is_positive or rv.exp.is_integer and rv.exp.is_negative)):
+            return rv
+
+        if isinstance(rv.base, tan):
+            return cot(rv.base.args[0])**-rv.exp
+        elif isinstance(rv.base, sin):
+            return csc(rv.base.args[0])**-rv.exp
+        elif isinstance(rv.base, cos):
+            return sec(rv.base.args[0])**-rv.exp
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR22(rv, max=4, pow=False):
+    """Convert tan(x)**2 to sec(x)**2 - 1 and cot(x)**2 to csc(x)**2 - 1.
+
+    See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR22
+    >>> from sympy.abc import x
+    >>> from sympy import tan, cot
+    >>> TR22(1 + tan(x)**2)
+    sec(x)**2
+    >>> TR22(1 + cot(x)**2)
+    csc(x)**2
+
+    """
+
+    def f(rv):
+        if not (isinstance(rv, Pow) and rv.base.func in (cot, tan)):
+            return rv
+
+        rv = _TR56(rv, tan, sec, lambda x: x - 1, max=max, pow=pow)
+        rv = _TR56(rv, cot, csc, lambda x: x - 1, max=max, pow=pow)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TRpower(rv):
+    """Convert sin(x)**n and cos(x)**n with positive n to sums.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TRpower
+    >>> from sympy.abc import x
+    >>> from sympy import cos, sin
+    >>> TRpower(sin(x)**6)
+    -15*cos(2*x)/32 + 3*cos(4*x)/16 - cos(6*x)/32 + 5/16
+    >>> TRpower(sin(x)**3*cos(2*x)**4)
+    (3*sin(x)/4 - sin(3*x)/4)*(cos(4*x)/2 + cos(8*x)/8 + 3/8)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/List_of_trigonometric_identities#Power-reduction_formulae
+
+    """
+
+    def f(rv):
+        if not (isinstance(rv, Pow) and isinstance(rv.base, (sin, cos))):
+            return rv
+        b, n = rv.as_base_exp()
+        x = b.args[0]
+        if n.is_Integer and n.is_positive:
+            if n.is_odd and isinstance(b, cos):
+                rv = 2**(1-n)*Add(*[binomial(n, k)*cos((n - 2*k)*x)
+                    for k in range((n + 1)/2)])
+            elif n.is_odd and isinstance(b, sin):
+                rv = 2**(1-n)*S.NegativeOne**((n-1)/2)*Add(*[binomial(n, k)*
+                    S.NegativeOne**k*sin((n - 2*k)*x) for k in range((n + 1)/2)])
+            elif n.is_even and isinstance(b, cos):
+                rv = 2**(1-n)*Add(*[binomial(n, k)*cos((n - 2*k)*x)
+                    for k in range(n/2)])
+            elif n.is_even and isinstance(b, sin):
+                rv = 2**(1-n)*S.NegativeOne**(n/2)*Add(*[binomial(n, k)*
+                    S.NegativeOne**k*cos((n - 2*k)*x) for k in range(n/2)])
+            if n.is_even:
+                rv += 2**(-n)*binomial(n, n/2)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def L(rv):
+    """Return count of trigonometric functions in expression.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import L
+    >>> from sympy.abc import x
+    >>> from sympy import cos, sin
+    >>> L(cos(x)+sin(x))
+    2
+    """
+    return S(rv.count(TrigonometricFunction))
+
+
+# ============== end of basic Fu-like tools =====================
+
+if SYMPY_DEBUG:
+    (TR0, TR1, TR2, TR3, TR4, TR5, TR6, TR7, TR8, TR9, TR10, TR11, TR12, TR13,
+    TR2i, TRmorrie, TR14, TR15, TR16, TR12i, TR111, TR22
+    )= list(map(debug,
+    (TR0, TR1, TR2, TR3, TR4, TR5, TR6, TR7, TR8, TR9, TR10, TR11, TR12, TR13,
+    TR2i, TRmorrie, TR14, TR15, TR16, TR12i, TR111, TR22)))
+
+
+# tuples are chains  --  (f, g) -> lambda x: g(f(x))
+# lists are choices  --  [f, g] -> lambda x: min(f(x), g(x), key=objective)
+
+CTR1 = [(TR5, TR0), (TR6, TR0), identity]
+
+CTR2 = (TR11, [(TR5, TR0), (TR6, TR0), TR0])
+
+CTR3 = [(TRmorrie, TR8, TR0), (TRmorrie, TR8, TR10i, TR0), identity]
+
+CTR4 = [(TR4, TR10i), identity]
+
+RL1 = (TR4, TR3, TR4, TR12, TR4, TR13, TR4, TR0)
+
+
+# XXX it's a little unclear how this one is to be implemented
+# see Fu paper of reference, page 7. What is the Union symbol referring to?
+# The diagram shows all these as one chain of transformations, but the
+# text refers to them being applied independently. Also, a break
+# if L starts to increase has not been implemented.
+RL2 = [
+    (TR4, TR3, TR10, TR4, TR3, TR11),
+    (TR5, TR7, TR11, TR4),
+    (CTR3, CTR1, TR9, CTR2, TR4, TR9, TR9, CTR4),
+    identity,
+    ]
+
+
+def fu(rv, measure=lambda x: (L(x), x.count_ops())):
+    """Attempt to simplify expression by using transformation rules given
+    in the algorithm by Fu et al.
+
+    :func:`fu` will try to minimize the objective function ``measure``.
+    By default this first minimizes the number of trig terms and then minimizes
+    the number of total operations.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import fu
+    >>> from sympy import cos, sin, tan, pi, S, sqrt
+    >>> from sympy.abc import x, y, a, b
+
+    >>> fu(sin(50)**2 + cos(50)**2 + sin(pi/6))
+    3/2
+    >>> fu(sqrt(6)*cos(x) + sqrt(2)*sin(x))
+    2*sqrt(2)*sin(x + pi/3)
+
+    CTR1 example
+
+    >>> eq = sin(x)**4 - cos(y)**2 + sin(y)**2 + 2*cos(x)**2
+    >>> fu(eq)
+    cos(x)**4 - 2*cos(y)**2 + 2
+
+    CTR2 example
+
+    >>> fu(S.Half - cos(2*x)/2)
+    sin(x)**2
+
+    CTR3 example
+
+    >>> fu(sin(a)*(cos(b) - sin(b)) + cos(a)*(sin(b) + cos(b)))
+    sqrt(2)*sin(a + b + pi/4)
+
+    CTR4 example
+
+    >>> fu(sqrt(3)*cos(x)/2 + sin(x)/2)
+    sin(x + pi/3)
+
+    Example 1
+
+    >>> fu(1-sin(2*x)**2/4-sin(y)**2-cos(x)**4)
+    -cos(x)**2 + cos(y)**2
+
+    Example 2
+
+    >>> fu(cos(4*pi/9))
+    sin(pi/18)
+    >>> fu(cos(pi/9)*cos(2*pi/9)*cos(3*pi/9)*cos(4*pi/9))
+    1/16
+
+    Example 3
+
+    >>> fu(tan(7*pi/18)+tan(5*pi/18)-sqrt(3)*tan(5*pi/18)*tan(7*pi/18))
+    -sqrt(3)
+
+    Objective function example
+
+    >>> fu(sin(x)/cos(x))  # default objective function
+    tan(x)
+    >>> fu(sin(x)/cos(x), measure=lambda x: -x.count_ops()) # maximize op count
+    sin(x)/cos(x)
+
+    References
+    ==========
+
+    .. [1] https://www.sciencedirect.com/science/article/pii/S0895717706001609
+    """
+    fRL1 = greedy(RL1, measure)
+    fRL2 = greedy(RL2, measure)
+
+    was = rv
+    rv = sympify(rv)
+    if not isinstance(rv, Expr):
+        return rv.func(*[fu(a, measure=measure) for a in rv.args])
+    rv = TR1(rv)
+    if rv.has(tan, cot):
+        rv1 = fRL1(rv)
+        if (measure(rv1) < measure(rv)):
+            rv = rv1
+        if rv.has(tan, cot):
+            rv = TR2(rv)
+    if rv.has(sin, cos):
+        rv1 = fRL2(rv)
+        rv2 = TR8(TRmorrie(rv1))
+        rv = min([was, rv, rv1, rv2], key=measure)
+    return min(TR2i(rv), rv, key=measure)
+
+
+def process_common_addends(rv, do, key2=None, key1=True):
+    """Apply ``do`` to addends of ``rv`` that (if ``key1=True``) share at least
+    a common absolute value of their coefficient and the value of ``key2`` when
+    applied to the argument. If ``key1`` is False ``key2`` must be supplied and
+    will be the only key applied.
+    """
+
+    # collect by absolute value of coefficient and key2
+    absc = defaultdict(list)
+    if key1:
+        for a in rv.args:
+            c, a = a.as_coeff_Mul()
+            if c < 0:
+                c = -c
+                a = -a  # put the sign on `a`
+            absc[(c, key2(a) if key2 else 1)].append(a)
+    elif key2:
+        for a in rv.args:
+            absc[(S.One, key2(a))].append(a)
+    else:
+        raise ValueError('must have at least one key')
+
+    args = []
+    hit = False
+    for k in absc:
+        v = absc[k]
+        c, _ = k
+        if len(v) > 1:
+            e = Add(*v, evaluate=False)
+            new = do(e)
+            if new != e:
+                e = new
+                hit = True
+            args.append(c*e)
+        else:
+            args.append(c*v[0])
+    if hit:
+        rv = Add(*args)
+
+    return rv
+
+
+fufuncs = '''
+    TR0 TR1 TR2 TR3 TR4 TR5 TR6 TR7 TR8 TR9 TR10 TR10i TR11
+    TR12 TR13 L TR2i TRmorrie TR12i
+    TR14 TR15 TR16 TR111 TR22'''.split()
+FU = dict(list(zip(fufuncs, list(map(locals().get, fufuncs)))))
+
+
+def _roots():
+    global _ROOT2, _ROOT3, _invROOT3
+    _ROOT2, _ROOT3 = sqrt(2), sqrt(3)
+    _invROOT3 = 1/_ROOT3
+_ROOT2 = None
+
+
+def trig_split(a, b, two=False):
+    """Return the gcd, s1, s2, a1, a2, bool where
+
+    If two is False (default) then::
+        a + b = gcd*(s1*f(a1) + s2*f(a2)) where f = cos if bool else sin
+    else:
+        if bool, a + b was +/- cos(a1)*cos(a2) +/- sin(a1)*sin(a2) and equals
+            n1*gcd*cos(a - b) if n1 == n2 else
+            n1*gcd*cos(a + b)
+        else a + b was +/- cos(a1)*sin(a2) +/- sin(a1)*cos(a2) and equals
+            n1*gcd*sin(a + b) if n1 = n2 else
+            n1*gcd*sin(b - a)
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import trig_split
+    >>> from sympy.abc import x, y, z
+    >>> from sympy import cos, sin, sqrt
+
+    >>> trig_split(cos(x), cos(y))
+    (1, 1, 1, x, y, True)
+    >>> trig_split(2*cos(x), -2*cos(y))
+    (2, 1, -1, x, y, True)
+    >>> trig_split(cos(x)*sin(y), cos(y)*sin(y))
+    (sin(y), 1, 1, x, y, True)
+
+    >>> trig_split(cos(x), -sqrt(3)*sin(x), two=True)
+    (2, 1, -1, x, pi/6, False)
+    >>> trig_split(cos(x), sin(x), two=True)
+    (sqrt(2), 1, 1, x, pi/4, False)
+    >>> trig_split(cos(x), -sin(x), two=True)
+    (sqrt(2), 1, -1, x, pi/4, False)
+    >>> trig_split(sqrt(2)*cos(x), -sqrt(6)*sin(x), two=True)
+    (2*sqrt(2), 1, -1, x, pi/6, False)
+    >>> trig_split(-sqrt(6)*cos(x), -sqrt(2)*sin(x), two=True)
+    (-2*sqrt(2), 1, 1, x, pi/3, False)
+    >>> trig_split(cos(x)/sqrt(6), sin(x)/sqrt(2), two=True)
+    (sqrt(6)/3, 1, 1, x, pi/6, False)
+    >>> trig_split(-sqrt(6)*cos(x)*sin(y), -sqrt(2)*sin(x)*sin(y), two=True)
+    (-2*sqrt(2)*sin(y), 1, 1, x, pi/3, False)
+
+    >>> trig_split(cos(x), sin(x))
+    >>> trig_split(cos(x), sin(z))
+    >>> trig_split(2*cos(x), -sin(x))
+    >>> trig_split(cos(x), -sqrt(3)*sin(x))
+    >>> trig_split(cos(x)*cos(y), sin(x)*sin(z))
+    >>> trig_split(cos(x)*cos(y), sin(x)*sin(y))
+    >>> trig_split(-sqrt(6)*cos(x), sqrt(2)*sin(x)*sin(y), two=True)
+    """
+    global _ROOT2, _ROOT3, _invROOT3
+    if _ROOT2 is None:
+        _roots()
+
+    a, b = [Factors(i) for i in (a, b)]
+    ua, ub = a.normal(b)
+    gcd = a.gcd(b).as_expr()
+    n1 = n2 = 1
+    if S.NegativeOne in ua.factors:
+        ua = ua.quo(S.NegativeOne)
+        n1 = -n1
+    elif S.NegativeOne in ub.factors:
+        ub = ub.quo(S.NegativeOne)
+        n2 = -n2
+    a, b = [i.as_expr() for i in (ua, ub)]
+
+    def pow_cos_sin(a, two):
+        """Return ``a`` as a tuple (r, c, s) such that
+        ``a = (r or 1)*(c or 1)*(s or 1)``.
+
+        Three arguments are returned (radical, c-factor, s-factor) as
+        long as the conditions set by ``two`` are met; otherwise None is
+        returned. If ``two`` is True there will be one or two non-None
+        values in the tuple: c and s or c and r or s and r or s or c with c
+        being a cosine function (if possible) else a sine, and s being a sine
+        function (if possible) else oosine. If ``two`` is False then there
+        will only be a c or s term in the tuple.
+
+        ``two`` also require that either two cos and/or sin be present (with
+        the condition that if the functions are the same the arguments are
+        different or vice versa) or that a single cosine or a single sine
+        be present with an optional radical.
+
+        If the above conditions dictated by ``two`` are not met then None
+        is returned.
+        """
+        c = s = None
+        co = S.One
+        if a.is_Mul:
+            co, a = a.as_coeff_Mul()
+            if len(a.args) > 2 or not two:
+                return None
+            if a.is_Mul:
+                args = list(a.args)
+            else:
+                args = [a]
+            a = args.pop(0)
+            if isinstance(a, cos):
+                c = a
+            elif isinstance(a, sin):
+                s = a
+            elif a.is_Pow and a.exp is S.Half:  # autoeval doesn't allow -1/2
+                co *= a
+            else:
+                return None
+            if args:
+                b = args[0]
+                if isinstance(b, cos):
+                    if c:
+                        s = b
+                    else:
+                        c = b
+                elif isinstance(b, sin):
+                    if s:
+                        c = b
+                    else:
+                        s = b
+                elif b.is_Pow and b.exp is S.Half:
+                    co *= b
+                else:
+                    return None
+            return co if co is not S.One else None, c, s
+        elif isinstance(a, cos):
+            c = a
+        elif isinstance(a, sin):
+            s = a
+        if c is None and s is None:
+            return
+        co = co if co is not S.One else None
+        return co, c, s
+
+    # get the parts
+    m = pow_cos_sin(a, two)
+    if m is None:
+        return
+    coa, ca, sa = m
+    m = pow_cos_sin(b, two)
+    if m is None:
+        return
+    cob, cb, sb = m
+
+    # check them
+    if (not ca) and cb or ca and isinstance(ca, sin):
+        coa, ca, sa, cob, cb, sb = cob, cb, sb, coa, ca, sa
+        n1, n2 = n2, n1
+    if not two:  # need cos(x) and cos(y) or sin(x) and sin(y)
+        c = ca or sa
+        s = cb or sb
+        if not isinstance(c, s.func):
+            return None
+        return gcd, n1, n2, c.args[0], s.args[0], isinstance(c, cos)
+    else:
+        if not coa and not cob:
+            if (ca and cb and sa and sb):
+                if isinstance(ca, sa.func) is not isinstance(cb, sb.func):
+                    return
+                args = {j.args for j in (ca, sa)}
+                if not all(i.args in args for i in (cb, sb)):
+                    return
+                return gcd, n1, n2, ca.args[0], sa.args[0], isinstance(ca, sa.func)
+        if ca and sa or cb and sb or \
+            two and (ca is None and sa is None or cb is None and sb is None):
+            return
+        c = ca or sa
+        s = cb or sb
+        if c.args != s.args:
+            return
+        if not coa:
+            coa = S.One
+        if not cob:
+            cob = S.One
+        if coa is cob:
+            gcd *= _ROOT2
+            return gcd, n1, n2, c.args[0], pi/4, False
+        elif coa/cob == _ROOT3:
+            gcd *= 2*cob
+            return gcd, n1, n2, c.args[0], pi/3, False
+        elif coa/cob == _invROOT3:
+            gcd *= 2*coa
+            return gcd, n1, n2, c.args[0], pi/6, False
+
+
+def as_f_sign_1(e):
+    """If ``e`` is a sum that can be written as ``g*(a + s)`` where
+    ``s`` is ``+/-1``, return ``g``, ``a``, and ``s`` where ``a`` does
+    not have a leading negative coefficient.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import as_f_sign_1
+    >>> from sympy.abc import x
+    >>> as_f_sign_1(x + 1)
+    (1, x, 1)
+    >>> as_f_sign_1(x - 1)
+    (1, x, -1)
+    >>> as_f_sign_1(-x + 1)
+    (-1, x, -1)
+    >>> as_f_sign_1(-x - 1)
+    (-1, x, 1)
+    >>> as_f_sign_1(2*x + 2)
+    (2, x, 1)
+    """
+    if not e.is_Add or len(e.args) != 2:
+        return
+    # exact match
+    a, b = e.args
+    if a in (S.NegativeOne, S.One):
+        g = S.One
+        if b.is_Mul and b.args[0].is_Number and b.args[0] < 0:
+            a, b = -a, -b
+            g = -g
+        return g, b, a
+    # gcd match
+    a, b = [Factors(i) for i in e.args]
+    ua, ub = a.normal(b)
+    gcd = a.gcd(b).as_expr()
+    if S.NegativeOne in ua.factors:
+        ua = ua.quo(S.NegativeOne)
+        n1 = -1
+        n2 = 1
+    elif S.NegativeOne in ub.factors:
+        ub = ub.quo(S.NegativeOne)
+        n1 = 1
+        n2 = -1
+    else:
+        n1 = n2 = 1
+    a, b = [i.as_expr() for i in (ua, ub)]
+    if a is S.One:
+        a, b = b, a
+        n1, n2 = n2, n1
+    if n1 == -1:
+        gcd = -gcd
+        n2 = -n2
+
+    if b is S.One:
+        return gcd, a, n2
+
+
+def _osborne(e, d):
+    """Replace all hyperbolic functions with trig functions using
+    the Osborne rule.
+
+    Notes
+    =====
+
+    ``d`` is a dummy variable to prevent automatic evaluation
+    of trigonometric/hyperbolic functions.
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    """
+
+    def f(rv):
+        if not isinstance(rv, HyperbolicFunction):
+            return rv
+        a = rv.args[0]
+        a = a*d if not a.is_Add else Add._from_args([i*d for i in a.args])
+        if isinstance(rv, sinh):
+            return I*sin(a)
+        elif isinstance(rv, cosh):
+            return cos(a)
+        elif isinstance(rv, tanh):
+            return I*tan(a)
+        elif isinstance(rv, coth):
+            return cot(a)/I
+        elif isinstance(rv, sech):
+            return sec(a)
+        elif isinstance(rv, csch):
+            return csc(a)/I
+        else:
+            raise NotImplementedError('unhandled %s' % rv.func)
+
+    return bottom_up(e, f)
+
+
+def _osbornei(e, d):
+    """Replace all trig functions with hyperbolic functions using
+    the Osborne rule.
+
+    Notes
+    =====
+
+    ``d`` is a dummy variable to prevent automatic evaluation
+    of trigonometric/hyperbolic functions.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    """
+
+    def f(rv):
+        if not isinstance(rv, TrigonometricFunction):
+            return rv
+        const, x = rv.args[0].as_independent(d, as_Add=True)
+        a = x.xreplace({d: S.One}) + const*I
+        if isinstance(rv, sin):
+            return sinh(a)/I
+        elif isinstance(rv, cos):
+            return cosh(a)
+        elif isinstance(rv, tan):
+            return tanh(a)/I
+        elif isinstance(rv, cot):
+            return coth(a)*I
+        elif isinstance(rv, sec):
+            return sech(a)
+        elif isinstance(rv, csc):
+            return csch(a)*I
+        else:
+            raise NotImplementedError('unhandled %s' % rv.func)
+
+    return bottom_up(e, f)
+
+
+def hyper_as_trig(rv):
+    """Return an expression containing hyperbolic functions in terms
+    of trigonometric functions. Any trigonometric functions initially
+    present are replaced with Dummy symbols and the function to undo
+    the masking and the conversion back to hyperbolics is also returned. It
+    should always be true that::
+
+        t, f = hyper_as_trig(expr)
+        expr == f(t)
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import hyper_as_trig, fu
+    >>> from sympy.abc import x
+    >>> from sympy import cosh, sinh
+    >>> eq = sinh(x)**2 + cosh(x)**2
+    >>> t, f = hyper_as_trig(eq)
+    >>> f(fu(t))
+    cosh(2*x)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    """
+    from sympy.simplify.simplify import signsimp
+    from sympy.simplify.radsimp import collect
+
+    # mask off trig functions
+    trigs = rv.atoms(TrigonometricFunction)
+    reps = [(t, Dummy()) for t in trigs]
+    masked = rv.xreplace(dict(reps))
+
+    # get inversion substitutions in place
+    reps = [(v, k) for k, v in reps]
+
+    d = Dummy()
+
+    return _osborne(masked, d), lambda x: collect(signsimp(
+        _osbornei(x, d).xreplace(dict(reps))), S.ImaginaryUnit)
+
+
+def sincos_to_sum(expr):
+    """Convert products and powers of sin and cos to sums.
+
+    Explanation
+    ===========
+
+    Applied power reduction TRpower first, then expands products, and
+    converts products to sums with TR8.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import sincos_to_sum
+    >>> from sympy.abc import x
+    >>> from sympy import cos, sin
+    >>> sincos_to_sum(16*sin(x)**3*cos(2*x)**2)
+    7*sin(x) - 5*sin(3*x) + 3*sin(5*x) - sin(7*x)
+    """
+
+    if not expr.has(cos, sin):
+        return expr
+    else:
+        return TR8(expand_mul(TRpower(expr)))

lib/python3.12/site-packages/sympy/simplify/gammasimp.py

@@ -0,0 +1,497 @@
+from sympy.core import Function, S, Mul, Pow, Add
+from sympy.core.sorting import ordered, default_sort_key
+from sympy.core.function import expand_func
+from sympy.core.symbol import Dummy
+from sympy.functions import gamma, sqrt, sin
+from sympy.polys import factor, cancel
+from sympy.utilities.iterables import sift, uniq
+
+
+def gammasimp(expr):
+    r"""
+    Simplify expressions with gamma functions.
+
+    Explanation
+    ===========
+
+    This function takes as input an expression containing gamma
+    functions or functions that can be rewritten in terms of gamma
+    functions and tries to minimize the number of those functions and
+    reduce the size of their arguments.
+
+    The algorithm works by rewriting all gamma functions as expressions
+    involving rising factorials (Pochhammer symbols) and applies
+    recurrence relations and other transformations applicable to rising
+    factorials, to reduce their arguments, possibly letting the resulting
+    rising factorial to cancel. Rising factorials with the second argument
+    being an integer are expanded into polynomial forms and finally all
+    other rising factorial are rewritten in terms of gamma functions.
+
+    Then the following two steps are performed.
+
+    1. Reduce the number of gammas by applying the reflection theorem
+       gamma(x)*gamma(1-x) == pi/sin(pi*x).
+    2. Reduce the number of gammas by applying the multiplication theorem
+       gamma(x)*gamma(x+1/n)*...*gamma(x+(n-1)/n) == C*gamma(n*x).
+
+    It then reduces the number of prefactors by absorbing them into gammas
+    where possible and expands gammas with rational argument.
+
+    All transformation rules can be found (or were derived from) here:
+
+    .. [1] https://functions.wolfram.com/GammaBetaErf/Pochhammer/17/01/02/
+    .. [2] https://functions.wolfram.com/GammaBetaErf/Pochhammer/27/01/0005/
+
+    Examples
+    ========
+
+    >>> from sympy.simplify import gammasimp
+    >>> from sympy import gamma, Symbol
+    >>> from sympy.abc import x
+    >>> n = Symbol('n', integer = True)
+
+    >>> gammasimp(gamma(x)/gamma(x - 3))
+    (x - 3)*(x - 2)*(x - 1)
+    >>> gammasimp(gamma(n + 3))
+    gamma(n + 3)
+
+    """
+
+    expr = expr.rewrite(gamma)
+
+    # compute_ST will be looking for Functions and we don't want
+    # it looking for non-gamma functions: issue 22606
+    # so we mask free, non-gamma functions
+    f = expr.atoms(Function)
+    # take out gammas
+    gammas = {i for i in f if isinstance(i, gamma)}
+    if not gammas:
+        return expr  # avoid side effects like factoring
+    f -= gammas
+    # keep only those without bound symbols
+    f = f & expr.as_dummy().atoms(Function)
+    if f:
+        dum, fun, simp = zip(*[
+            (Dummy(), fi, fi.func(*[
+                _gammasimp(a, as_comb=False) for a in fi.args]))
+            for fi in ordered(f)])
+        d = expr.xreplace(dict(zip(fun, dum)))
+        return _gammasimp(d, as_comb=False).xreplace(dict(zip(dum, simp)))
+
+    return _gammasimp(expr, as_comb=False)
+
+
+def _gammasimp(expr, as_comb):
+    """
+    Helper function for gammasimp and combsimp.
+
+    Explanation
+    ===========
+
+    Simplifies expressions written in terms of gamma function. If
+    as_comb is True, it tries to preserve integer arguments. See
+    docstring of gammasimp for more information. This was part of
+    combsimp() in combsimp.py.
+    """
+    expr = expr.replace(gamma,
+        lambda n: _rf(1, (n - 1).expand()))
+
+    if as_comb:
+        expr = expr.replace(_rf,
+            lambda a, b: gamma(b + 1))
+    else:
+        expr = expr.replace(_rf,
+            lambda a, b: gamma(a + b)/gamma(a))
+
+    def rule_gamma(expr, level=0):
+        """ Simplify products of gamma functions further. """
+
+        if expr.is_Atom:
+            return expr
+
+        def gamma_rat(x):
+            # helper to simplify ratios of gammas
+            was = x.count(gamma)
+            xx = x.replace(gamma, lambda n: _rf(1, (n - 1).expand()
+                ).replace(_rf, lambda a, b: gamma(a + b)/gamma(a)))
+            if xx.count(gamma) < was:
+                x = xx
+            return x
+
+        def gamma_factor(x):
+            # return True if there is a gamma factor in shallow args
+            if isinstance(x, gamma):
+                return True
+            if x.is_Add or x.is_Mul:
+                return any(gamma_factor(xi) for xi in x.args)
+            if x.is_Pow and (x.exp.is_integer or x.base.is_positive):
+                return gamma_factor(x.base)
+            return False
+
+        # recursion step
+        if level == 0:
+            expr = expr.func(*[rule_gamma(x, level + 1) for x in expr.args])
+            level += 1
+
+        if not expr.is_Mul:
+            return expr
+
+        # non-commutative step
+        if level == 1:
+            args, nc = expr.args_cnc()
+            if not args:
+                return expr
+            if nc:
+                return rule_gamma(Mul._from_args(args), level + 1)*Mul._from_args(nc)
+            level += 1
+
+        # pure gamma handling, not factor absorption
+        if level == 2:
+            T, F = sift(expr.args, gamma_factor, binary=True)
+            gamma_ind = Mul(*F)
+            d = Mul(*T)
+
+            nd, dd = d.as_numer_denom()
+            for ipass in range(2):
+                args = list(ordered(Mul.make_args(nd)))
+                for i, ni in enumerate(args):
+                    if ni.is_Add:
+                        ni, dd = Add(*[
+                            rule_gamma(gamma_rat(a/dd), level + 1) for a in ni.args]
+                            ).as_numer_denom()
+                        args[i] = ni
+                        if not dd.has(gamma):
+                            break
+                nd = Mul(*args)
+                if ipass ==  0 and not gamma_factor(nd):
+                    break
+                nd, dd = dd, nd  # now process in reversed order
+            expr = gamma_ind*nd/dd
+            if not (expr.is_Mul and (gamma_factor(dd) or gamma_factor(nd))):
+                return expr
+            level += 1
+
+        # iteration until constant
+        if level == 3:
+            while True:
+                was = expr
+                expr = rule_gamma(expr, 4)
+                if expr == was:
+                    return expr
+
+        numer_gammas = []
+        denom_gammas = []
+        numer_others = []
+        denom_others = []
+        def explicate(p):
+            if p is S.One:
+                return None, []
+            b, e = p.as_base_exp()
+            if e.is_Integer:
+                if isinstance(b, gamma):
+                    return True, [b.args[0]]*e
+                else:
+                    return False, [b]*e
+            else:
+                return False, [p]
+
+        newargs = list(ordered(expr.args))
+        while newargs:
+            n, d = newargs.pop().as_numer_denom()
+            isg, l = explicate(n)
+            if isg:
+                numer_gammas.extend(l)
+            elif isg is False:
+                numer_others.extend(l)
+            isg, l = explicate(d)
+            if isg:
+                denom_gammas.extend(l)
+            elif isg is False:
+                denom_others.extend(l)
+
+        # =========== level 2 work: pure gamma manipulation =========
+
+        if not as_comb:
+            # Try to reduce the number of gamma factors by applying the
+            # reflection formula gamma(x)*gamma(1-x) = pi/sin(pi*x)
+            for gammas, numer, denom in [(
+                numer_gammas, numer_others, denom_others),
+                    (denom_gammas, denom_others, numer_others)]:
+                new = []
+                while gammas:
+                    g1 = gammas.pop()
+                    if g1.is_integer:
+                        new.append(g1)
+                        continue
+                    for i, g2 in enumerate(gammas):
+                        n = g1 + g2 - 1
+                        if not n.is_Integer:
+                            continue
+                        numer.append(S.Pi)
+                        denom.append(sin(S.Pi*g1))
+                        gammas.pop(i)
+                        if n > 0:
+                            for k in range(n):
+                                numer.append(1 - g1 + k)
+                        elif n < 0:
+                            for k in range(-n):
+                                denom.append(-g1 - k)
+                        break
+                    else:
+                        new.append(g1)
+                # /!\ updating IN PLACE
+                gammas[:] = new
+
+            # Try to reduce the number of gammas by using the duplication
+            # theorem to cancel an upper and lower: gamma(2*s)/gamma(s) =
+            # 2**(2*s + 1)/(4*sqrt(pi))*gamma(s + 1/2). Although this could
+            # be done with higher argument ratios like gamma(3*x)/gamma(x),
+            # this would not reduce the number of gammas as in this case.
+            for ng, dg, no, do in [(numer_gammas, denom_gammas, numer_others,
+                                    denom_others),
+                                   (denom_gammas, numer_gammas, denom_others,
+                                    numer_others)]:
+
+                while True:
+                    for x in ng:
+                        for y in dg:
+                            n = x - 2*y
+                            if n.is_Integer:
+                                break
+                        else:
+                            continue
+                        break
+                    else:
+                        break
+                    ng.remove(x)
+                    dg.remove(y)
+                    if n > 0:
+                        for k in range(n):
+                            no.append(2*y + k)
+                    elif n < 0:
+                        for k in range(-n):
+                            do.append(2*y - 1 - k)
+                    ng.append(y + S.Half)
+                    no.append(2**(2*y - 1))
+                    do.append(sqrt(S.Pi))
+
+            # Try to reduce the number of gamma factors by applying the
+            # multiplication theorem (used when n gammas with args differing
+            # by 1/n mod 1 are encountered).
+            #
+            # run of 2 with args differing by 1/2
+            #
+            # >>> gammasimp(gamma(x)*gamma(x+S.Half))
+            # 2*sqrt(2)*2**(-2*x - 1/2)*sqrt(pi)*gamma(2*x)
+            #
+            # run of 3 args differing by 1/3 (mod 1)
+            #
+            # >>> gammasimp(gamma(x)*gamma(x+S(1)/3)*gamma(x+S(2)/3))
+            # 6*3**(-3*x - 1/2)*pi*gamma(3*x)
+            # >>> gammasimp(gamma(x)*gamma(x+S(1)/3)*gamma(x+S(5)/3))
+            # 2*3**(-3*x - 1/2)*pi*(3*x + 2)*gamma(3*x)
+            #
+            def _run(coeffs):
+                # find runs in coeffs such that the difference in terms (mod 1)
+                # of t1, t2, ..., tn is 1/n
+                u = list(uniq(coeffs))
+                for i in range(len(u)):
+                    dj = ([((u[j] - u[i]) % 1, j) for j in range(i + 1, len(u))])
+                    for one, j in dj:
+                        if one.p == 1 and one.q != 1:
+                            n = one.q
+                            got = [i]
+                            get = list(range(1, n))
+                            for d, j in dj:
+                                m = n*d
+                                if m.is_Integer and m in get:
+                                    get.remove(m)
+                                    got.append(j)
+                                    if not get:
+                                        break
+                            else:
+                                continue
+                            for i, j in enumerate(got):
+                                c = u[j]
+                                coeffs.remove(c)
+                                got[i] = c
+                            return one.q, got[0], got[1:]
+
+            def _mult_thm(gammas, numer, denom):
+                # pull off and analyze the leading coefficient from each gamma arg
+                # looking for runs in those Rationals
+
+                # expr -> coeff + resid -> rats[resid] = coeff
+                rats = {}
+                for g in gammas:
+                    c, resid = g.as_coeff_Add()
+                    rats.setdefault(resid, []).append(c)
+
+                # look for runs in Rationals for each resid
+                keys = sorted(rats, key=default_sort_key)
+                for resid in keys:
+                    coeffs = sorted(rats[resid])
+                    new = []
+                    while True:
+                        run = _run(coeffs)
+                        if run is None:
+                            break
+
+                        # process the sequence that was found:
+                        # 1) convert all the gamma functions to have the right
+                        #    argument (could be off by an integer)
+                        # 2) append the factors corresponding to the theorem
+                        # 3) append the new gamma function
+
+                        n, ui, other = run
+
+                        # (1)
+                        for u in other:
+                            con = resid + u - 1
+                            for k in range(int(u - ui)):
+                                numer.append(con - k)
+
+                        con = n*(resid + ui)  # for (2) and (3)
+
+                        # (2)
+                        numer.append((2*S.Pi)**(S(n - 1)/2)*
+                                     n**(S.Half - con))
+                        # (3)
+                        new.append(con)
+
+                    # restore resid to coeffs
+                    rats[resid] = [resid + c for c in coeffs] + new
+
+                # rebuild the gamma arguments
+                g = []
+                for resid in keys:
+                    g += rats[resid]
+                # /!\ updating IN PLACE
+                gammas[:] = g
+
+            for l, numer, denom in [(numer_gammas, numer_others, denom_others),
+                                    (denom_gammas, denom_others, numer_others)]:
+                _mult_thm(l, numer, denom)
+
+        # =========== level >= 2 work: factor absorption =========
+
+        if level >= 2:
+            # Try to absorb factors into the gammas: x*gamma(x) -> gamma(x + 1)
+            # and gamma(x)/(x - 1) -> gamma(x - 1)
+            # This code (in particular repeated calls to find_fuzzy) can be very
+            # slow.
+            def find_fuzzy(l, x):
+                if not l:
+                    return
+                S1, T1 = compute_ST(x)
+                for y in l:
+                    S2, T2 = inv[y]
+                    if T1 != T2 or (not S1.intersection(S2) and
+                                    (S1 != set() or S2 != set())):
+                        continue
+                    # XXX we want some simplification (e.g. cancel or
+                    # simplify) but no matter what it's slow.
+                    a = len(cancel(x/y).free_symbols)
+                    b = len(x.free_symbols)
+                    c = len(y.free_symbols)
+                    # TODO is there a better heuristic?
+                    if a == 0 and (b > 0 or c > 0):
+                        return y
+
+            # We thus try to avoid expensive calls by building the following
+            # "invariants": For every factor or gamma function argument
+            #   - the set of free symbols S
+            #   - the set of functional components T
+            # We will only try to absorb if T1==T2 and (S1 intersect S2 != emptyset
+            # or S1 == S2 == emptyset)
+            inv = {}
+
+            def compute_ST(expr):
+                if expr in inv:
+                    return inv[expr]
+                return (expr.free_symbols, expr.atoms(Function).union(
+                        {e.exp for e in expr.atoms(Pow)}))
+
+            def update_ST(expr):
+                inv[expr] = compute_ST(expr)
+            for expr in numer_gammas + denom_gammas + numer_others + denom_others:
+                update_ST(expr)
+
+            for gammas, numer, denom in [(
+                numer_gammas, numer_others, denom_others),
+                    (denom_gammas, denom_others, numer_others)]:
+                new = []
+                while gammas:
+                    g = gammas.pop()
+                    cont = True
+                    while cont:
+                        cont = False
+                        y = find_fuzzy(numer, g)
+                        if y is not None:
+                            numer.remove(y)
+                            if y != g:
+                                numer.append(y/g)
+                                update_ST(y/g)
+                            g += 1
+                            cont = True
+                        y = find_fuzzy(denom, g - 1)
+                        if y is not None:
+                            denom.remove(y)
+                            if y != g - 1:
+                                numer.append((g - 1)/y)
+                                update_ST((g - 1)/y)
+                            g -= 1
+                            cont = True
+                    new.append(g)
+                # /!\ updating IN PLACE
+                gammas[:] = new
+
+        # =========== rebuild expr ==================================
+
+        return Mul(*[gamma(g) for g in numer_gammas]) \
+            / Mul(*[gamma(g) for g in denom_gammas]) \
+            * Mul(*numer_others) / Mul(*denom_others)
+
+    was = factor(expr)
+    # (for some reason we cannot use Basic.replace in this case)
+    expr = rule_gamma(was)
+    if expr != was:
+        expr = factor(expr)
+
+    expr = expr.replace(gamma,
+        lambda n: expand_func(gamma(n)) if n.is_Rational else gamma(n))
+
+    return expr
+
+
+class _rf(Function):
+    @classmethod
+    def eval(cls, a, b):
+        if b.is_Integer:
+            if not b:
+                return S.One
+
+            n = int(b)
+
+            if n > 0:
+                return Mul(*[a + i for i in range(n)])
+            elif n < 0:
+                return 1/Mul(*[a - i for i in range(1, -n + 1)])
+        else:
+            if b.is_Add:
+                c, _b = b.as_coeff_Add()
+
+                if c.is_Integer:
+                    if c > 0:
+                        return _rf(a, _b)*_rf(a + _b, c)
+                    elif c < 0:
+                        return _rf(a, _b)/_rf(a + _b + c, -c)
+
+            if a.is_Add:
+                c, _a = a.as_coeff_Add()
+
+                if c.is_Integer:
+                    if c > 0:
+                        return _rf(_a, b)*_rf(_a + b, c)/_rf(_a, c)
+                    elif c < 0:
+                        return _rf(_a, b)*_rf(_a + c, -c)/_rf(_a + b + c, -c)

lib/python3.12/site-packages/sympy/simplify/ratsimp.py

@@ -0,0 +1,222 @@
+from itertools import combinations_with_replacement
+from sympy.core import symbols, Add, Dummy
+from sympy.core.numbers import Rational
+from sympy.polys import cancel, ComputationFailed, parallel_poly_from_expr, reduced, Poly
+from sympy.polys.monomials import Monomial, monomial_div
+from sympy.polys.polyerrors import DomainError, PolificationFailed
+from sympy.utilities.misc import debug, debugf
+
+def ratsimp(expr):
+    """
+    Put an expression over a common denominator, cancel and reduce.
+
+    Examples
+    ========
+
+    >>> from sympy import ratsimp
+    >>> from sympy.abc import x, y
+    >>> ratsimp(1/x + 1/y)
+    (x + y)/(x*y)
+    """
+
+    f, g = cancel(expr).as_numer_denom()
+    try:
+        Q, r = reduced(f, [g], field=True, expand=False)
+    except ComputationFailed:
+        return f/g
+
+    return Add(*Q) + cancel(r/g)
+
+
+def ratsimpmodprime(expr, G, *gens, quick=True, polynomial=False, **args):
+    """
+    Simplifies a rational expression ``expr`` modulo the prime ideal
+    generated by ``G``.  ``G`` should be a Groebner basis of the
+    ideal.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.ratsimp import ratsimpmodprime
+    >>> from sympy.abc import x, y
+    >>> eq = (x + y**5 + y)/(x - y)
+    >>> ratsimpmodprime(eq, [x*y**5 - x - y], x, y, order='lex')
+    (-x**2 - x*y - x - y)/(-x**2 + x*y)
+
+    If ``polynomial`` is ``False``, the algorithm computes a rational
+    simplification which minimizes the sum of the total degrees of
+    the numerator and the denominator.
+
+    If ``polynomial`` is ``True``, this function just brings numerator and
+    denominator into a canonical form. This is much faster, but has
+    potentially worse results.
+
+    References
+    ==========
+
+    .. [1] M. Monagan, R. Pearce, Rational Simplification Modulo a Polynomial
+        Ideal, https://dl.acm.org/doi/pdf/10.1145/1145768.1145809
+        (specifically, the second algorithm)
+    """
+    from sympy.solvers.solvers import solve
+
+    debug('ratsimpmodprime', expr)
+
+    # usual preparation of polynomials:
+
+    num, denom = cancel(expr).as_numer_denom()
+
+    try:
+        polys, opt = parallel_poly_from_expr([num, denom] + G, *gens, **args)
+    except PolificationFailed:
+        return expr
+
+    domain = opt.domain
+
+    if domain.has_assoc_Field:
+        opt.domain = domain.get_field()
+    else:
+        raise DomainError(
+            "Cannot compute rational simplification over %s" % domain)
+
+    # compute only once
+    leading_monomials = [g.LM(opt.order) for g in polys[2:]]
+    tested = set()
+
+    def staircase(n):
+        """
+        Compute all monomials with degree less than ``n`` that are
+        not divisible by any element of ``leading_monomials``.
+        """
+        if n == 0:
+            return [1]
+        S = []
+        for mi in combinations_with_replacement(range(len(opt.gens)), n):
+            m = [0]*len(opt.gens)
+            for i in mi:
+                m[i] += 1
+            if all(monomial_div(m, lmg) is None for lmg in
+                   leading_monomials):
+                S.append(m)
+
+        return [Monomial(s).as_expr(*opt.gens) for s in S] + staircase(n - 1)
+
+    def _ratsimpmodprime(a, b, allsol, N=0, D=0):
+        r"""
+        Computes a rational simplification of ``a/b`` which minimizes
+        the sum of the total degrees of the numerator and the denominator.
+
+        Explanation
+        ===========
+
+        The algorithm proceeds by looking at ``a * d - b * c`` modulo
+        the ideal generated by ``G`` for some ``c`` and ``d`` with degree
+        less than ``a`` and ``b`` respectively.
+        The coefficients of ``c`` and ``d`` are indeterminates and thus
+        the coefficients of the normalform of ``a * d - b * c`` are
+        linear polynomials in these indeterminates.
+        If these linear polynomials, considered as system of
+        equations, have a nontrivial solution, then `\frac{a}{b}
+        \equiv \frac{c}{d}` modulo the ideal generated by ``G``. So,
+        by construction, the degree of ``c`` and ``d`` is less than
+        the degree of ``a`` and ``b``, so a simpler representation
+        has been found.
+        After a simpler representation has been found, the algorithm
+        tries to reduce the degree of the numerator and denominator
+        and returns the result afterwards.
+
+        As an extension, if quick=False, we look at all possible degrees such
+        that the total degree is less than *or equal to* the best current
+        solution. We retain a list of all solutions of minimal degree, and try
+        to find the best one at the end.
+        """
+        c, d = a, b
+        steps = 0
+
+        maxdeg = a.total_degree() + b.total_degree()
+        if quick:
+            bound = maxdeg - 1
+        else:
+            bound = maxdeg
+        while N + D <= bound:
+            if (N, D) in tested:
+                break
+            tested.add((N, D))
+
+            M1 = staircase(N)
+            M2 = staircase(D)
+            debugf('%s / %s: %s, %s', (N, D, M1, M2))
+
+            Cs = symbols("c:%d" % len(M1), cls=Dummy)
+            Ds = symbols("d:%d" % len(M2), cls=Dummy)
+            ng = Cs + Ds
+
+            c_hat = Poly(
+                sum(Cs[i] * M1[i] for i in range(len(M1))), opt.gens + ng)
+            d_hat = Poly(
+                sum(Ds[i] * M2[i] for i in range(len(M2))), opt.gens + ng)
+
+            r = reduced(a * d_hat - b * c_hat, G, opt.gens + ng,
+                        order=opt.order, polys=True)[1]
+
+            S = Poly(r, gens=opt.gens).coeffs()
+            sol = solve(S, Cs + Ds, particular=True, quick=True)
+
+            if sol and not all(s == 0 for s in sol.values()):
+                c = c_hat.subs(sol)
+                d = d_hat.subs(sol)
+
+                # The "free" variables occurring before as parameters
+                # might still be in the substituted c, d, so set them
+                # to the value chosen before:
+                c = c.subs(dict(list(zip(Cs + Ds, [1] * (len(Cs) + len(Ds))))))
+                d = d.subs(dict(list(zip(Cs + Ds, [1] * (len(Cs) + len(Ds))))))
+
+                c = Poly(c, opt.gens)
+                d = Poly(d, opt.gens)
+                if d == 0:
+                    raise ValueError('Ideal not prime?')
+
+                allsol.append((c_hat, d_hat, S, Cs + Ds))
+                if N + D != maxdeg:
+                    allsol = [allsol[-1]]
+
+                break
+
+            steps += 1
+            N += 1
+            D += 1
+
+        if steps > 0:
+            c, d, allsol = _ratsimpmodprime(c, d, allsol, N, D - steps)
+            c, d, allsol = _ratsimpmodprime(c, d, allsol, N - steps, D)
+
+        return c, d, allsol
+
+    # preprocessing. this improves performance a bit when deg(num)
+    # and deg(denom) are large:
+    num = reduced(num, G, opt.gens, order=opt.order)[1]
+    denom = reduced(denom, G, opt.gens, order=opt.order)[1]
+
+    if polynomial:
+        return (num/denom).cancel()
+
+    c, d, allsol = _ratsimpmodprime(
+        Poly(num, opt.gens, domain=opt.domain), Poly(denom, opt.gens, domain=opt.domain), [])
+    if not quick and allsol:
+        debugf('Looking for best minimal solution. Got: %s', len(allsol))
+        newsol = []
+        for c_hat, d_hat, S, ng in allsol:
+            sol = solve(S, ng, particular=True, quick=False)
+            # all values of sol should be numbers; if not, solve is broken
+            newsol.append((c_hat.subs(sol), d_hat.subs(sol)))
+        c, d = min(newsol, key=lambda x: len(x[0].terms()) + len(x[1].terms()))
+
+    if not domain.is_Field:
+        cn, c = c.clear_denoms(convert=True)
+        dn, d = d.clear_denoms(convert=True)
+        r = Rational(cn, dn)
+    else:
+        r = Rational(1)
+
+    return (c*r.q)/(d*r.p)

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

@@ -0,0 +1,2150 @@
+from collections import defaultdict
+
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core import (Basic, S, Add, Mul, Pow, Symbol, sympify,
+                        expand_func, Function, Dummy, Expr, factor_terms,
+                        expand_power_exp, Eq)
+from sympy.core.exprtools import factor_nc
+from sympy.core.parameters import global_parameters
+from sympy.core.function import (expand_log, count_ops, _mexpand,
+    nfloat, expand_mul, expand)
+from sympy.core.numbers import Float, I, pi, Rational, equal_valued
+from sympy.core.relational import Relational
+from sympy.core.rules import Transform
+from sympy.core.sorting import ordered
+from sympy.core.sympify import _sympify
+from sympy.core.traversal import bottom_up as _bottom_up, walk as _walk
+from sympy.functions import gamma, exp, sqrt, log, exp_polar, re
+from sympy.functions.combinatorial.factorials import CombinatorialFunction
+from sympy.functions.elementary.complexes import unpolarify, Abs, sign
+from sympy.functions.elementary.exponential import ExpBase
+from sympy.functions.elementary.hyperbolic import HyperbolicFunction
+from sympy.functions.elementary.integers import ceiling
+from sympy.functions.elementary.piecewise import (Piecewise, piecewise_fold,
+                                                  piecewise_simplify)
+from sympy.functions.elementary.trigonometric import TrigonometricFunction
+from sympy.functions.special.bessel import (BesselBase, besselj, besseli,
+                                            besselk, bessely, jn)
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.integrals.integrals import Integral
+from sympy.matrices.expressions import (MatrixExpr, MatAdd, MatMul,
+                                            MatPow, MatrixSymbol)
+from sympy.polys import together, cancel, factor
+from sympy.polys.numberfields.minpoly import _is_sum_surds, _minimal_polynomial_sq
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.cse_opts import sub_pre, sub_post
+from sympy.simplify.hyperexpand import hyperexpand
+from sympy.simplify.powsimp import powsimp
+from sympy.simplify.radsimp import radsimp, fraction, collect_abs
+from sympy.simplify.sqrtdenest import sqrtdenest
+from sympy.simplify.trigsimp import trigsimp, exptrigsimp
+from sympy.utilities.decorator import deprecated
+from sympy.utilities.iterables import has_variety, sift, subsets, iterable
+from sympy.utilities.misc import as_int
+
+import mpmath
+
+
+def separatevars(expr, symbols=[], dict=False, force=False):
+    """
+    Separates variables in an expression, if possible.  By
+    default, it separates with respect to all symbols in an
+    expression and collects constant coefficients that are
+    independent of symbols.
+
+    Explanation
+    ===========
+
+    If ``dict=True`` then the separated terms will be returned
+    in a dictionary keyed to their corresponding symbols.
+    By default, all symbols in the expression will appear as
+    keys; if symbols are provided, then all those symbols will
+    be used as keys, and any terms in the expression containing
+    other symbols or non-symbols will be returned keyed to the
+    string 'coeff'. (Passing None for symbols will return the
+    expression in a dictionary keyed to 'coeff'.)
+
+    If ``force=True``, then bases of powers will be separated regardless
+    of assumptions on the symbols involved.
+
+    Notes
+    =====
+
+    The order of the factors is determined by Mul, so that the
+    separated expressions may not necessarily be grouped together.
+
+    Although factoring is necessary to separate variables in some
+    expressions, it is not necessary in all cases, so one should not
+    count on the returned factors being factored.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z, alpha
+    >>> from sympy import separatevars, sin
+    >>> separatevars((x*y)**y)
+    (x*y)**y
+    >>> separatevars((x*y)**y, force=True)
+    x**y*y**y
+
+    >>> e = 2*x**2*z*sin(y)+2*z*x**2
+    >>> separatevars(e)
+    2*x**2*z*(sin(y) + 1)
+    >>> separatevars(e, symbols=(x, y), dict=True)
+    {'coeff': 2*z, x: x**2, y: sin(y) + 1}
+    >>> separatevars(e, [x, y, alpha], dict=True)
+    {'coeff': 2*z, alpha: 1, x: x**2, y: sin(y) + 1}
+
+    If the expression is not really separable, or is only partially
+    separable, separatevars will do the best it can to separate it
+    by using factoring.
+
+    >>> separatevars(x + x*y - 3*x**2)
+    -x*(3*x - y - 1)
+
+    If the expression is not separable then expr is returned unchanged
+    or (if dict=True) then None is returned.
+
+    >>> eq = 2*x + y*sin(x)
+    >>> separatevars(eq) == eq
+    True
+    >>> separatevars(2*x + y*sin(x), symbols=(x, y), dict=True) is None
+    True
+
+    """
+    expr = sympify(expr)
+    if dict:
+        return _separatevars_dict(_separatevars(expr, force), symbols)
+    else:
+        return _separatevars(expr, force)
+
+
+def _separatevars(expr, force):
+    if isinstance(expr, Abs):
+        arg = expr.args[0]
+        if arg.is_Mul and not arg.is_number:
+            s = separatevars(arg, dict=True, force=force)
+            if s is not None:
+                return Mul(*map(expr.func, s.values()))
+            else:
+                return expr
+
+    if len(expr.free_symbols) < 2:
+        return expr
+
+    # don't destroy a Mul since much of the work may already be done
+    if expr.is_Mul:
+        args = list(expr.args)
+        changed = False
+        for i, a in enumerate(args):
+            args[i] = separatevars(a, force)
+            changed = changed or args[i] != a
+        if changed:
+            expr = expr.func(*args)
+        return expr
+
+    # get a Pow ready for expansion
+    if expr.is_Pow and expr.base != S.Exp1:
+        expr = Pow(separatevars(expr.base, force=force), expr.exp)
+
+    # First try other expansion methods
+    expr = expr.expand(mul=False, multinomial=False, force=force)
+
+    _expr, reps = posify(expr) if force else (expr, {})
+    expr = factor(_expr).subs(reps)
+
+    if not expr.is_Add:
+        return expr
+
+    # Find any common coefficients to pull out
+    args = list(expr.args)
+    commonc = args[0].args_cnc(cset=True, warn=False)[0]
+    for i in args[1:]:
+        commonc &= i.args_cnc(cset=True, warn=False)[0]
+    commonc = Mul(*commonc)
+    commonc = commonc.as_coeff_Mul()[1]  # ignore constants
+    commonc_set = commonc.args_cnc(cset=True, warn=False)[0]
+
+    # remove them
+    for i, a in enumerate(args):
+        c, nc = a.args_cnc(cset=True, warn=False)
+        c = c - commonc_set
+        args[i] = Mul(*c)*Mul(*nc)
+    nonsepar = Add(*args)
+
+    if len(nonsepar.free_symbols) > 1:
+        _expr = nonsepar
+        _expr, reps = posify(_expr) if force else (_expr, {})
+        _expr = (factor(_expr)).subs(reps)
+
+        if not _expr.is_Add:
+            nonsepar = _expr
+
+    return commonc*nonsepar
+
+
+def _separatevars_dict(expr, symbols):
+    if symbols:
+        if not all(t.is_Atom for t in symbols):
+            raise ValueError("symbols must be Atoms.")
+        symbols = list(symbols)
+    elif symbols is None:
+        return {'coeff': expr}
+    else:
+        symbols = list(expr.free_symbols)
+        if not symbols:
+            return None
+
+    ret = {i: [] for i in symbols + ['coeff']}
+
+    for i in Mul.make_args(expr):
+        expsym = i.free_symbols
+        intersection = set(symbols).intersection(expsym)
+        if len(intersection) > 1:
+            return None
+        if len(intersection) == 0:
+            # There are no symbols, so it is part of the coefficient
+            ret['coeff'].append(i)
+        else:
+            ret[intersection.pop()].append(i)
+
+    # rebuild
+    for k, v in ret.items():
+        ret[k] = Mul(*v)
+
+    return ret
+
+
+def posify(eq):
+    """Return ``eq`` (with generic symbols made positive) and a
+    dictionary containing the mapping between the old and new
+    symbols.
+
+    Explanation
+    ===========
+
+    Any symbol that has positive=None will be replaced with a positive dummy
+    symbol having the same name. This replacement will allow more symbolic
+    processing of expressions, especially those involving powers and
+    logarithms.
+
+    A dictionary that can be sent to subs to restore ``eq`` to its original
+    symbols is also returned.
+
+    >>> from sympy import posify, Symbol, log, solve
+    >>> from sympy.abc import x
+    >>> posify(x + Symbol('p', positive=True) + Symbol('n', negative=True))
+    (_x + n + p, {_x: x})
+
+    >>> eq = 1/x
+    >>> log(eq).expand()
+    log(1/x)
+    >>> log(posify(eq)[0]).expand()
+    -log(_x)
+    >>> p, rep = posify(eq)
+    >>> log(p).expand().subs(rep)
+    -log(x)
+
+    It is possible to apply the same transformations to an iterable
+    of expressions:
+
+    >>> eq = x**2 - 4
+    >>> solve(eq, x)
+    [-2, 2]
+    >>> eq_x, reps = posify([eq, x]); eq_x
+    [_x**2 - 4, _x]
+    >>> solve(*eq_x)
+    [2]
+    """
+    eq = sympify(eq)
+    if iterable(eq):
+        f = type(eq)
+        eq = list(eq)
+        syms = set()
+        for e in eq:
+            syms = syms.union(e.atoms(Symbol))
+        reps = {}
+        for s in syms:
+            reps.update({v: k for k, v in posify(s)[1].items()})
+        for i, e in enumerate(eq):
+            eq[i] = e.subs(reps)
+        return f(eq), {r: s for s, r in reps.items()}
+
+    reps = {s: Dummy(s.name, positive=True, **s.assumptions0)
+                 for s in eq.free_symbols if s.is_positive is None}
+    eq = eq.subs(reps)
+    return eq, {r: s for s, r in reps.items()}
+
+
+def hypersimp(f, k):
+    """Given combinatorial term f(k) simplify its consecutive term ratio
+       i.e. f(k+1)/f(k).  The input term can be composed of functions and
+       integer sequences which have equivalent representation in terms
+       of gamma special function.
+
+       Explanation
+       ===========
+
+       The algorithm performs three basic steps:
+
+       1. Rewrite all functions in terms of gamma, if possible.
+
+       2. Rewrite all occurrences of gamma in terms of products
+          of gamma and rising factorial with integer,  absolute
+          constant exponent.
+
+       3. Perform simplification of nested fractions, powers
+          and if the resulting expression is a quotient of
+          polynomials, reduce their total degree.
+
+       If f(k) is hypergeometric then as result we arrive with a
+       quotient of polynomials of minimal degree. Otherwise None
+       is returned.
+
+       For more information on the implemented algorithm refer to:
+
+       1. W. Koepf, Algorithms for m-fold Hypergeometric Summation,
+          Journal of Symbolic Computation (1995) 20, 399-417
+    """
+    f = sympify(f)
+
+    g = f.subs(k, k + 1) / f
+
+    g = g.rewrite(gamma)
+    if g.has(Piecewise):
+        g = piecewise_fold(g)
+        g = g.args[-1][0]
+    g = expand_func(g)
+    g = powsimp(g, deep=True, combine='exp')
+
+    if g.is_rational_function(k):
+        return simplify(g, ratio=S.Infinity)
+    else:
+        return None
+
+
+def hypersimilar(f, g, k):
+    """
+    Returns True if ``f`` and ``g`` are hyper-similar.
+
+    Explanation
+    ===========
+
+    Similarity in hypergeometric sense means that a quotient of
+    f(k) and g(k) is a rational function in ``k``. This procedure
+    is useful in solving recurrence relations.
+
+    For more information see hypersimp().
+
+    """
+    f, g = list(map(sympify, (f, g)))
+
+    h = (f/g).rewrite(gamma)
+    h = h.expand(func=True, basic=False)
+
+    return h.is_rational_function(k)
+
+
+def signsimp(expr, evaluate=None):
+    """Make all Add sub-expressions canonical wrt sign.
+
+    Explanation
+    ===========
+
+    If an Add subexpression, ``a``, can have a sign extracted,
+    as determined by could_extract_minus_sign, it is replaced
+    with Mul(-1, a, evaluate=False). This allows signs to be
+    extracted from powers and products.
+
+    Examples
+    ========
+
+    >>> from sympy import signsimp, exp, symbols
+    >>> from sympy.abc import x, y
+    >>> i = symbols('i', odd=True)
+    >>> n = -1 + 1/x
+    >>> n/x/(-n)**2 - 1/n/x
+    (-1 + 1/x)/(x*(1 - 1/x)**2) - 1/(x*(-1 + 1/x))
+    >>> signsimp(_)
+    0
+    >>> x*n + x*-n
+    x*(-1 + 1/x) + x*(1 - 1/x)
+    >>> signsimp(_)
+    0
+
+    Since powers automatically handle leading signs
+
+    >>> (-2)**i
+    -2**i
+
+    signsimp can be used to put the base of a power with an integer
+    exponent into canonical form:
+
+    >>> n**i
+    (-1 + 1/x)**i
+
+    By default, signsimp does not leave behind any hollow simplification:
+    if making an Add canonical wrt sign didn't change the expression, the
+    original Add is restored. If this is not desired then the keyword
+    ``evaluate`` can be set to False:
+
+    >>> e = exp(y - x)
+    >>> signsimp(e) == e
+    True
+    >>> signsimp(e, evaluate=False)
+    exp(-(x - y))
+
+    """
+    if evaluate is None:
+        evaluate = global_parameters.evaluate
+    expr = sympify(expr)
+    if not isinstance(expr, (Expr, Relational)) or expr.is_Atom:
+        return expr
+    # get rid of an pre-existing unevaluation regarding sign
+    e = expr.replace(lambda x: x.is_Mul and -(-x) != x, lambda x: -(-x))
+    e = sub_post(sub_pre(e))
+    if not isinstance(e, (Expr, Relational)) or e.is_Atom:
+        return e
+    if e.is_Add:
+        rv = e.func(*[signsimp(a) for a in e.args])
+        if not evaluate and isinstance(rv, Add
+                ) and rv.could_extract_minus_sign():
+            return Mul(S.NegativeOne, -rv, evaluate=False)
+        return rv
+    if evaluate:
+        e = e.replace(lambda x: x.is_Mul and -(-x) != x, lambda x: -(-x))
+    return e
+
+
+def simplify(expr, ratio=1.7, measure=count_ops, rational=False, inverse=False, doit=True, **kwargs):
+    """Simplifies the given expression.
+
+    Explanation
+    ===========
+
+    Simplification is not a well defined term and the exact strategies
+    this function tries can change in the future versions of SymPy. If
+    your algorithm relies on "simplification" (whatever it is), try to
+    determine what you need exactly  -  is it powsimp()?, radsimp()?,
+    together()?, logcombine()?, or something else? And use this particular
+    function directly, because those are well defined and thus your algorithm
+    will be robust.
+
+    Nonetheless, especially for interactive use, or when you do not know
+    anything about the structure of the expression, simplify() tries to apply
+    intelligent heuristics to make the input expression "simpler".  For
+    example:
+
+    >>> from sympy import simplify, cos, sin
+    >>> from sympy.abc import x, y
+    >>> a = (x + x**2)/(x*sin(y)**2 + x*cos(y)**2)
+    >>> a
+    (x**2 + x)/(x*sin(y)**2 + x*cos(y)**2)
+    >>> simplify(a)
+    x + 1
+
+    Note that we could have obtained the same result by using specific
+    simplification functions:
+
+    >>> from sympy import trigsimp, cancel
+    >>> trigsimp(a)
+    (x**2 + x)/x
+    >>> cancel(_)
+    x + 1
+
+    In some cases, applying :func:`simplify` may actually result in some more
+    complicated expression. The default ``ratio=1.7`` prevents more extreme
+    cases: if (result length)/(input length) > ratio, then input is returned
+    unmodified.  The ``measure`` parameter lets you specify the function used
+    to determine how complex an expression is.  The function should take a
+    single argument as an expression and return a number such that if
+    expression ``a`` is more complex than expression ``b``, then
+    ``measure(a) > measure(b)``.  The default measure function is
+    :func:`~.count_ops`, which returns the total number of operations in the
+    expression.
+
+    For example, if ``ratio=1``, ``simplify`` output cannot be longer
+    than input.
+
+    ::
+
+        >>> from sympy import sqrt, simplify, count_ops, oo
+        >>> root = 1/(sqrt(2)+3)
+
+    Since ``simplify(root)`` would result in a slightly longer expression,
+    root is returned unchanged instead::
+
+       >>> simplify(root, ratio=1) == root
+       True
+
+    If ``ratio=oo``, simplify will be applied anyway::
+
+        >>> count_ops(simplify(root, ratio=oo)) > count_ops(root)
+        True
+
+    Note that the shortest expression is not necessary the simplest, so
+    setting ``ratio`` to 1 may not be a good idea.
+    Heuristically, the default value ``ratio=1.7`` seems like a reasonable
+    choice.
+
+    You can easily define your own measure function based on what you feel
+    should represent the "size" or "complexity" of the input expression.  Note
+    that some choices, such as ``lambda expr: len(str(expr))`` may appear to be
+    good metrics, but have other problems (in this case, the measure function
+    may slow down simplify too much for very large expressions).  If you do not
+    know what a good metric would be, the default, ``count_ops``, is a good
+    one.
+
+    For example:
+
+    >>> from sympy import symbols, log
+    >>> a, b = symbols('a b', positive=True)
+    >>> g = log(a) + log(b) + log(a)*log(1/b)
+    >>> h = simplify(g)
+    >>> h
+    log(a*b**(1 - log(a)))
+    >>> count_ops(g)
+    8
+    >>> count_ops(h)
+    5
+
+    So you can see that ``h`` is simpler than ``g`` using the count_ops metric.
+    However, we may not like how ``simplify`` (in this case, using
+    ``logcombine``) has created the ``b**(log(1/a) + 1)`` term.  A simple way
+    to reduce this would be to give more weight to powers as operations in
+    ``count_ops``.  We can do this by using the ``visual=True`` option:
+
+    >>> print(count_ops(g, visual=True))
+    2*ADD + DIV + 4*LOG + MUL
+    >>> print(count_ops(h, visual=True))
+    2*LOG + MUL + POW + SUB
+
+    >>> from sympy import Symbol, S
+    >>> def my_measure(expr):
+    ...     POW = Symbol('POW')
+    ...     # Discourage powers by giving POW a weight of 10
+    ...     count = count_ops(expr, visual=True).subs(POW, 10)
+    ...     # Every other operation gets a weight of 1 (the default)
+    ...     count = count.replace(Symbol, type(S.One))
+    ...     return count
+    >>> my_measure(g)
+    8
+    >>> my_measure(h)
+    14
+    >>> 15./8 > 1.7 # 1.7 is the default ratio
+    True
+    >>> simplify(g, measure=my_measure)
+    -log(a)*log(b) + log(a) + log(b)
+
+    Note that because ``simplify()`` internally tries many different
+    simplification strategies and then compares them using the measure
+    function, we get a completely different result that is still different
+    from the input expression by doing this.
+
+    If ``rational=True``, Floats will be recast as Rationals before simplification.
+    If ``rational=None``, Floats will be recast as Rationals but the result will
+    be recast as Floats. If rational=False(default) then nothing will be done
+    to the Floats.
+
+    If ``inverse=True``, it will be assumed that a composition of inverse
+    functions, such as sin and asin, can be cancelled in any order.
+    For example, ``asin(sin(x))`` will yield ``x`` without checking whether
+    x belongs to the set where this relation is true. The default is
+    False.
+
+    Note that ``simplify()`` automatically calls ``doit()`` on the final
+    expression. You can avoid this behavior by passing ``doit=False`` as
+    an argument.
+
+    Also, it should be noted that simplifying a boolean expression is not
+    well defined. If the expression prefers automatic evaluation (such as
+    :obj:`~.Eq()` or :obj:`~.Or()`), simplification will return ``True`` or
+    ``False`` if truth value can be determined. If the expression is not
+    evaluated by default (such as :obj:`~.Predicate()`), simplification will
+    not reduce it and you should use :func:`~.refine()` or :func:`~.ask()`
+    function. This inconsistency will be resolved in future version.
+
+    See Also
+    ========
+
+    sympy.assumptions.refine.refine : Simplification using assumptions.
+    sympy.assumptions.ask.ask : Query for boolean expressions using assumptions.
+    """
+
+    def shorter(*choices):
+        """
+        Return the choice that has the fewest ops. In case of a tie,
+        the expression listed first is selected.
+        """
+        if not has_variety(choices):
+            return choices[0]
+        return min(choices, key=measure)
+
+    def done(e):
+        rv = e.doit() if doit else e
+        return shorter(rv, collect_abs(rv))
+
+    expr = sympify(expr, rational=rational)
+    kwargs = {
+        "ratio": kwargs.get('ratio', ratio),
+        "measure": kwargs.get('measure', measure),
+        "rational": kwargs.get('rational', rational),
+        "inverse": kwargs.get('inverse', inverse),
+        "doit": kwargs.get('doit', doit)}
+    # no routine for Expr needs to check for is_zero
+    if isinstance(expr, Expr) and expr.is_zero:
+        return S.Zero if not expr.is_Number else expr
+
+    _eval_simplify = getattr(expr, '_eval_simplify', None)
+    if _eval_simplify is not None:
+        return _eval_simplify(**kwargs)
+
+    original_expr = expr = collect_abs(signsimp(expr))
+
+    if not isinstance(expr, Basic) or not expr.args:  # XXX: temporary hack
+        return expr
+
+    if inverse and expr.has(Function):
+        expr = inversecombine(expr)
+        if not expr.args:  # simplified to atomic
+            return expr
+
+    # do deep simplification
+    handled = Add, Mul, Pow, ExpBase
+    expr = expr.replace(
+        # here, checking for x.args is not enough because Basic has
+        # args but Basic does not always play well with replace, e.g.
+        # when simultaneous is True found expressions will be masked
+        # off with a Dummy but not all Basic objects in an expression
+        # can be replaced with a Dummy
+        lambda x: isinstance(x, Expr) and x.args and not isinstance(
+            x, handled),
+        lambda x: x.func(*[simplify(i, **kwargs) for i in x.args]),
+        simultaneous=False)
+    if not isinstance(expr, handled):
+        return done(expr)
+
+    if not expr.is_commutative:
+        expr = nc_simplify(expr)
+
+    # TODO: Apply different strategies, considering expression pattern:
+    # is it a purely rational function? Is there any trigonometric function?...
+    # See also https://github.com/sympy/sympy/pull/185.
+
+
+    # rationalize Floats
+    floats = False
+    if rational is not False and expr.has(Float):
+        floats = True
+        expr = nsimplify(expr, rational=True)
+
+    expr = _bottom_up(expr, lambda w: getattr(w, 'normal', lambda: w)())
+    expr = Mul(*powsimp(expr).as_content_primitive())
+    _e = cancel(expr)
+    expr1 = shorter(_e, _mexpand(_e).cancel())  # issue 6829
+    expr2 = shorter(together(expr, deep=True), together(expr1, deep=True))
+
+    if ratio is S.Infinity:
+        expr = expr2
+    else:
+        expr = shorter(expr2, expr1, expr)
+    if not isinstance(expr, Basic):  # XXX: temporary hack
+        return expr
+
+    expr = factor_terms(expr, sign=False)
+
+    # must come before `Piecewise` since this introduces more `Piecewise` terms
+    if expr.has(sign):
+        expr = expr.rewrite(Abs)
+
+    # Deal with Piecewise separately to avoid recursive growth of expressions
+    if expr.has(Piecewise):
+        # Fold into a single Piecewise
+        expr = piecewise_fold(expr)
+        # Apply doit, if doit=True
+        expr = done(expr)
+        # Still a Piecewise?
+        if expr.has(Piecewise):
+            # Fold into a single Piecewise, in case doit lead to some
+            # expressions being Piecewise
+            expr = piecewise_fold(expr)
+            # kroneckersimp also affects Piecewise
+            if expr.has(KroneckerDelta):
+                expr = kroneckersimp(expr)
+            # Still a Piecewise?
+            if expr.has(Piecewise):
+                # Do not apply doit on the segments as it has already
+                # been done above, but simplify
+                expr = piecewise_simplify(expr, deep=True, doit=False)
+                # Still a Piecewise?
+                if expr.has(Piecewise):
+                    # Try factor common terms
+                    expr = shorter(expr, factor_terms(expr))
+                    # As all expressions have been simplified above with the
+                    # complete simplify, nothing more needs to be done here
+                    return expr
+
+    # hyperexpand automatically only works on hypergeometric terms
+    # Do this after the Piecewise part to avoid recursive expansion
+    expr = hyperexpand(expr)
+
+    if expr.has(KroneckerDelta):
+        expr = kroneckersimp(expr)
+
+    if expr.has(BesselBase):
+        expr = besselsimp(expr)
+
+    if expr.has(TrigonometricFunction, HyperbolicFunction):
+        expr = trigsimp(expr, deep=True)
+
+    if expr.has(log):
+        expr = shorter(expand_log(expr, deep=True), logcombine(expr))
+
+    if expr.has(CombinatorialFunction, gamma):
+        # expression with gamma functions or non-integer arguments is
+        # automatically passed to gammasimp
+        expr = combsimp(expr)
+
+    if expr.has(Sum):
+        expr = sum_simplify(expr, **kwargs)
+
+    if expr.has(Integral):
+        expr = expr.xreplace({
+            i: factor_terms(i) for i in expr.atoms(Integral)})
+
+    if expr.has(Product):
+        expr = product_simplify(expr, **kwargs)
+
+    from sympy.physics.units import Quantity
+
+    if expr.has(Quantity):
+        from sympy.physics.units.util import quantity_simplify
+        expr = quantity_simplify(expr)
+
+    short = shorter(powsimp(expr, combine='exp', deep=True), powsimp(expr), expr)
+    short = shorter(short, cancel(short))
+    short = shorter(short, factor_terms(short), expand_power_exp(expand_mul(short)))
+    if short.has(TrigonometricFunction, HyperbolicFunction, ExpBase, exp):
+        short = exptrigsimp(short)
+
+    # get rid of hollow 2-arg Mul factorization
+    hollow_mul = Transform(
+        lambda x: Mul(*x.args),
+        lambda x:
+        x.is_Mul and
+        len(x.args) == 2 and
+        x.args[0].is_Number and
+        x.args[1].is_Add and
+        x.is_commutative)
+    expr = short.xreplace(hollow_mul)
+
+    numer, denom = expr.as_numer_denom()
+    if denom.is_Add:
+        n, d = fraction(radsimp(1/denom, symbolic=False, max_terms=1))
+        if n is not S.One:
+            expr = (numer*n).expand()/d
+
+    if expr.could_extract_minus_sign():
+        n, d = fraction(expr)
+        if d != 0:
+            expr = signsimp(-n/(-d))
+
+    if measure(expr) > ratio*measure(original_expr):
+        expr = original_expr
+
+    # restore floats
+    if floats and rational is None:
+        expr = nfloat(expr, exponent=False)
+
+    return done(expr)
+
+
+def sum_simplify(s, **kwargs):
+    """Main function for Sum simplification"""
+    if not isinstance(s, Add):
+        s = s.xreplace({a: sum_simplify(a, **kwargs)
+            for a in s.atoms(Add) if a.has(Sum)})
+    s = expand(s)
+    if not isinstance(s, Add):
+        return s
+
+    terms = s.args
+    s_t = [] # Sum Terms
+    o_t = [] # Other Terms
+
+    for term in terms:
+        sum_terms, other = sift(Mul.make_args(term),
+            lambda i: isinstance(i, Sum), binary=True)
+        if not sum_terms:
+            o_t.append(term)
+            continue
+        other = [Mul(*other)]
+        s_t.append(Mul(*(other + [s._eval_simplify(**kwargs) for s in sum_terms])))
+
+    result = Add(sum_combine(s_t), *o_t)
+
+    return result
+
+
+def sum_combine(s_t):
+    """Helper function for Sum simplification
+
+       Attempts to simplify a list of sums, by combining limits / sum function's
+       returns the simplified sum
+    """
+    used = [False] * len(s_t)
+
+    for method in range(2):
+        for i, s_term1 in enumerate(s_t):
+            if not used[i]:
+                for j, s_term2 in enumerate(s_t):
+                    if not used[j] and i != j:
+                        temp = sum_add(s_term1, s_term2, method)
+                        if isinstance(temp, (Sum, Mul)):
+                            s_t[i] = temp
+                            s_term1 = s_t[i]
+                            used[j] = True
+
+    result = S.Zero
+    for i, s_term in enumerate(s_t):
+        if not used[i]:
+            result = Add(result, s_term)
+
+    return result
+
+
+def factor_sum(self, limits=None, radical=False, clear=False, fraction=False, sign=True):
+    """Return Sum with constant factors extracted.
+
+    If ``limits`` is specified then ``self`` is the summand; the other
+    keywords are passed to ``factor_terms``.
+
+    Examples
+    ========
+
+    >>> from sympy import Sum
+    >>> from sympy.abc import x, y
+    >>> from sympy.simplify.simplify import factor_sum
+    >>> s = Sum(x*y, (x, 1, 3))
+    >>> factor_sum(s)
+    y*Sum(x, (x, 1, 3))
+    >>> factor_sum(s.function, s.limits)
+    y*Sum(x, (x, 1, 3))
+    """
+    # XXX deprecate in favor of direct call to factor_terms
+    kwargs = {"radical": radical, "clear": clear,
+        "fraction": fraction, "sign": sign}
+    expr = Sum(self, *limits) if limits else self
+    return factor_terms(expr, **kwargs)
+
+
+def sum_add(self, other, method=0):
+    """Helper function for Sum simplification"""
+    #we know this is something in terms of a constant * a sum
+    #so we temporarily put the constants inside for simplification
+    #then simplify the result
+    def __refactor(val):
+        args = Mul.make_args(val)
+        sumv = next(x for x in args if isinstance(x, Sum))
+        constant = Mul(*[x for x in args if x != sumv])
+        return Sum(constant * sumv.function, *sumv.limits)
+
+    if isinstance(self, Mul):
+        rself = __refactor(self)
+    else:
+        rself = self
+
+    if isinstance(other, Mul):
+        rother = __refactor(other)
+    else:
+        rother = other
+
+    if type(rself) is type(rother):
+        if method == 0:
+            if rself.limits == rother.limits:
+                return factor_sum(Sum(rself.function + rother.function, *rself.limits))
+        elif method == 1:
+            if simplify(rself.function - rother.function) == 0:
+                if len(rself.limits) == len(rother.limits) == 1:
+                    i = rself.limits[0][0]
+                    x1 = rself.limits[0][1]
+                    y1 = rself.limits[0][2]
+                    j = rother.limits[0][0]
+                    x2 = rother.limits[0][1]
+                    y2 = rother.limits[0][2]
+
+                    if i == j:
+                        if x2 == y1 + 1:
+                            return factor_sum(Sum(rself.function, (i, x1, y2)))
+                        elif x1 == y2 + 1:
+                            return factor_sum(Sum(rself.function, (i, x2, y1)))
+
+    return Add(self, other)
+
+
+def product_simplify(s, **kwargs):
+    """Main function for Product simplification"""
+    terms = Mul.make_args(s)
+    p_t = [] # Product Terms
+    o_t = [] # Other Terms
+
+    deep = kwargs.get('deep', True)
+    for term in terms:
+        if isinstance(term, Product):
+            if deep:
+                p_t.append(Product(term.function.simplify(**kwargs),
+                                   *term.limits))
+            else:
+                p_t.append(term)
+        else:
+            o_t.append(term)
+
+    used = [False] * len(p_t)
+
+    for method in range(2):
+        for i, p_term1 in enumerate(p_t):
+            if not used[i]:
+                for j, p_term2 in enumerate(p_t):
+                    if not used[j] and i != j:
+                        tmp_prod = product_mul(p_term1, p_term2, method)
+                        if isinstance(tmp_prod, Product):
+                            p_t[i] = tmp_prod
+                            used[j] = True
+
+    result = Mul(*o_t)
+
+    for i, p_term in enumerate(p_t):
+        if not used[i]:
+            result = Mul(result, p_term)
+
+    return result
+
+
+def product_mul(self, other, method=0):
+    """Helper function for Product simplification"""
+    if type(self) is type(other):
+        if method == 0:
+            if self.limits == other.limits:
+                return Product(self.function * other.function, *self.limits)
+        elif method == 1:
+            if simplify(self.function - other.function) == 0:
+                if len(self.limits) == len(other.limits) == 1:
+                    i = self.limits[0][0]
+                    x1 = self.limits[0][1]
+                    y1 = self.limits[0][2]
+                    j = other.limits[0][0]
+                    x2 = other.limits[0][1]
+                    y2 = other.limits[0][2]
+
+                    if i == j:
+                        if x2 == y1 + 1:
+                            return Product(self.function, (i, x1, y2))
+                        elif x1 == y2 + 1:
+                            return Product(self.function, (i, x2, y1))
+
+    return Mul(self, other)
+
+
+def _nthroot_solve(p, n, prec):
+    """
+     helper function for ``nthroot``
+     It denests ``p**Rational(1, n)`` using its minimal polynomial
+    """
+    from sympy.solvers import solve
+    while n % 2 == 0:
+        p = sqrtdenest(sqrt(p))
+        n = n // 2
+    if n == 1:
+        return p
+    pn = p**Rational(1, n)
+    x = Symbol('x')
+    f = _minimal_polynomial_sq(p, n, x)
+    if f is None:
+        return None
+    sols = solve(f, x)
+    for sol in sols:
+        if abs(sol - pn).n() < 1./10**prec:
+            sol = sqrtdenest(sol)
+            if _mexpand(sol**n) == p:
+                return sol
+
+
+def logcombine(expr, force=False):
+    """
+    Takes logarithms and combines them using the following rules:
+
+    - log(x) + log(y) == log(x*y) if both are positive
+    - a*log(x) == log(x**a) if x is positive and a is real
+
+    If ``force`` is ``True`` then the assumptions above will be assumed to hold if
+    there is no assumption already in place on a quantity. For example, if
+    ``a`` is imaginary or the argument negative, force will not perform a
+    combination but if ``a`` is a symbol with no assumptions the change will
+    take place.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, symbols, log, logcombine, I
+    >>> from sympy.abc import a, x, y, z
+    >>> logcombine(a*log(x) + log(y) - log(z))
+    a*log(x) + log(y) - log(z)
+    >>> logcombine(a*log(x) + log(y) - log(z), force=True)
+    log(x**a*y/z)
+    >>> x,y,z = symbols('x,y,z', positive=True)
+    >>> a = Symbol('a', real=True)
+    >>> logcombine(a*log(x) + log(y) - log(z))
+    log(x**a*y/z)
+
+    The transformation is limited to factors and/or terms that
+    contain logs, so the result depends on the initial state of
+    expansion:
+
+    >>> eq = (2 + 3*I)*log(x)
+    >>> logcombine(eq, force=True) == eq
+    True
+    >>> logcombine(eq.expand(), force=True)
+    log(x**2) + I*log(x**3)
+
+    See Also
+    ========
+
+    posify: replace all symbols with symbols having positive assumptions
+    sympy.core.function.expand_log: expand the logarithms of products
+        and powers; the opposite of logcombine
+
+    """
+
+    def f(rv):
+        if not (rv.is_Add or rv.is_Mul):
+            return rv
+
+        def gooda(a):
+            # bool to tell whether the leading ``a`` in ``a*log(x)``
+            # could appear as log(x**a)
+            return (a is not S.NegativeOne and  # -1 *could* go, but we disallow
+                (a.is_extended_real or force and a.is_extended_real is not False))
+
+        def goodlog(l):
+            # bool to tell whether log ``l``'s argument can combine with others
+            a = l.args[0]
+            return a.is_positive or force and a.is_nonpositive is not False
+
+        other = []
+        logs = []
+        log1 = defaultdict(list)
+        for a in Add.make_args(rv):
+            if isinstance(a, log) and goodlog(a):
+                log1[()].append(([], a))
+            elif not a.is_Mul:
+                other.append(a)
+            else:
+                ot = []
+                co = []
+                lo = []
+                for ai in a.args:
+                    if ai.is_Rational and ai < 0:
+                        ot.append(S.NegativeOne)
+                        co.append(-ai)
+                    elif isinstance(ai, log) and goodlog(ai):
+                        lo.append(ai)
+                    elif gooda(ai):
+                        co.append(ai)
+                    else:
+                        ot.append(ai)
+                if len(lo) > 1:
+                    logs.append((ot, co, lo))
+                elif lo:
+                    log1[tuple(ot)].append((co, lo[0]))
+                else:
+                    other.append(a)
+
+        # if there is only one log in other, put it with the
+        # good logs
+        if len(other) == 1 and isinstance(other[0], log):
+            log1[()].append(([], other.pop()))
+        # if there is only one log at each coefficient and none have
+        # an exponent to place inside the log then there is nothing to do
+        if not logs and all(len(log1[k]) == 1 and log1[k][0] == [] for k in log1):
+            return rv
+
+        # collapse multi-logs as far as possible in a canonical way
+        # TODO: see if x*log(a)+x*log(a)*log(b) -> x*log(a)*(1+log(b))?
+        # -- in this case, it's unambiguous, but if it were were a log(c) in
+        # each term then it's arbitrary whether they are grouped by log(a) or
+        # by log(c). So for now, just leave this alone; it's probably better to
+        # let the user decide
+        for o, e, l in logs:
+            l = list(ordered(l))
+            e = log(l.pop(0).args[0]**Mul(*e))
+            while l:
+                li = l.pop(0)
+                e = log(li.args[0]**e)
+            c, l = Mul(*o), e
+            if isinstance(l, log):  # it should be, but check to be sure
+                log1[(c,)].append(([], l))
+            else:
+                other.append(c*l)
+
+        # logs that have the same coefficient can multiply
+        for k in list(log1.keys()):
+            log1[Mul(*k)] = log(logcombine(Mul(*[
+                l.args[0]**Mul(*c) for c, l in log1.pop(k)]),
+                force=force), evaluate=False)
+
+        # logs that have oppositely signed coefficients can divide
+        for k in ordered(list(log1.keys())):
+            if k not in log1:  # already popped as -k
+                continue
+            if -k in log1:
+                # figure out which has the minus sign; the one with
+                # more op counts should be the one
+                num, den = k, -k
+                if num.count_ops() > den.count_ops():
+                    num, den = den, num
+                other.append(
+                    num*log(log1.pop(num).args[0]/log1.pop(den).args[0],
+                            evaluate=False))
+            else:
+                other.append(k*log1.pop(k))
+
+        return Add(*other)
+
+    return _bottom_up(expr, f)
+
+
+def inversecombine(expr):
+    """Simplify the composition of a function and its inverse.
+
+    Explanation
+    ===========
+
+    No attention is paid to whether the inverse is a left inverse or a
+    right inverse; thus, the result will in general not be equivalent
+    to the original expression.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.simplify import inversecombine
+    >>> from sympy import asin, sin, log, exp
+    >>> from sympy.abc import x
+    >>> inversecombine(asin(sin(x)))
+    x
+    >>> inversecombine(2*log(exp(3*x)))
+    6*x
+    """
+
+    def f(rv):
+        if isinstance(rv, log):
+            if isinstance(rv.args[0], exp) or (rv.args[0].is_Pow and rv.args[0].base == S.Exp1):
+                rv = rv.args[0].exp
+        elif rv.is_Function and hasattr(rv, "inverse"):
+            if (len(rv.args) == 1 and len(rv.args[0].args) == 1 and
+               isinstance(rv.args[0], rv.inverse(argindex=1))):
+                rv = rv.args[0].args[0]
+        if rv.is_Pow and rv.base == S.Exp1:
+            if isinstance(rv.exp, log):
+                rv = rv.exp.args[0]
+        return rv
+
+    return _bottom_up(expr, f)
+
+
+def kroneckersimp(expr):
+    """
+    Simplify expressions with KroneckerDelta.
+
+    The only simplification currently attempted is to identify multiplicative cancellation:
+
+    Examples
+    ========
+
+    >>> from sympy import KroneckerDelta, kroneckersimp
+    >>> from sympy.abc import i
+    >>> kroneckersimp(1 + KroneckerDelta(0, i) * KroneckerDelta(1, i))
+    1
+    """
+    def args_cancel(args1, args2):
+        for i1 in range(2):
+            for i2 in range(2):
+                a1 = args1[i1]
+                a2 = args2[i2]
+                a3 = args1[(i1 + 1) % 2]
+                a4 = args2[(i2 + 1) % 2]
+                if Eq(a1, a2) is S.true and Eq(a3, a4) is S.false:
+                    return True
+        return False
+
+    def cancel_kronecker_mul(m):
+        args = m.args
+        deltas = [a for a in args if isinstance(a, KroneckerDelta)]
+        for delta1, delta2 in subsets(deltas, 2):
+            args1 = delta1.args
+            args2 = delta2.args
+            if args_cancel(args1, args2):
+                return S.Zero * m # In case of oo etc
+        return m
+
+    if not expr.has(KroneckerDelta):
+        return expr
+
+    if expr.has(Piecewise):
+        expr = expr.rewrite(KroneckerDelta)
+
+    newexpr = expr
+    expr = None
+
+    while newexpr != expr:
+        expr = newexpr
+        newexpr = expr.replace(lambda e: isinstance(e, Mul), cancel_kronecker_mul)
+
+    return expr
+
+
+def besselsimp(expr):
+    """
+    Simplify bessel-type functions.
+
+    Explanation
+    ===========
+
+    This routine tries to simplify bessel-type functions. Currently it only
+    works on the Bessel J and I functions, however. It works by looking at all
+    such functions in turn, and eliminating factors of "I" and "-1" (actually
+    their polar equivalents) in front of the argument. Then, functions of
+    half-integer order are rewritten using trigonometric functions and
+    functions of integer order (> 1) are rewritten using functions
+    of low order.  Finally, if the expression was changed, compute
+    factorization of the result with factor().
+
+    >>> from sympy import besselj, besseli, besselsimp, polar_lift, I, S
+    >>> from sympy.abc import z, nu
+    >>> besselsimp(besselj(nu, z*polar_lift(-1)))
+    exp(I*pi*nu)*besselj(nu, z)
+    >>> besselsimp(besseli(nu, z*polar_lift(-I)))
+    exp(-I*pi*nu/2)*besselj(nu, z)
+    >>> besselsimp(besseli(S(-1)/2, z))
+    sqrt(2)*cosh(z)/(sqrt(pi)*sqrt(z))
+    >>> besselsimp(z*besseli(0, z) + z*(besseli(2, z))/2 + besseli(1, z))
+    3*z*besseli(0, z)/2
+    """
+    # TODO
+    # - better algorithm?
+    # - simplify (cos(pi*b)*besselj(b,z) - besselj(-b,z))/sin(pi*b) ...
+    # - use contiguity relations?
+
+    def replacer(fro, to, factors):
+        factors = set(factors)
+
+        def repl(nu, z):
+            if factors.intersection(Mul.make_args(z)):
+                return to(nu, z)
+            return fro(nu, z)
+        return repl
+
+    def torewrite(fro, to):
+        def tofunc(nu, z):
+            return fro(nu, z).rewrite(to)
+        return tofunc
+
+    def tominus(fro):
+        def tofunc(nu, z):
+            return exp(I*pi*nu)*fro(nu, exp_polar(-I*pi)*z)
+        return tofunc
+
+    orig_expr = expr
+
+    ifactors = [I, exp_polar(I*pi/2), exp_polar(-I*pi/2)]
+    expr = expr.replace(
+        besselj, replacer(besselj,
+        torewrite(besselj, besseli), ifactors))
+    expr = expr.replace(
+        besseli, replacer(besseli,
+        torewrite(besseli, besselj), ifactors))
+
+    minusfactors = [-1, exp_polar(I*pi)]
+    expr = expr.replace(
+        besselj, replacer(besselj, tominus(besselj), minusfactors))
+    expr = expr.replace(
+        besseli, replacer(besseli, tominus(besseli), minusfactors))
+
+    z0 = Dummy('z')
+
+    def expander(fro):
+        def repl(nu, z):
+            if (nu % 1) == S.Half:
+                return simplify(trigsimp(unpolarify(
+                        fro(nu, z0).rewrite(besselj).rewrite(jn).expand(
+                            func=True)).subs(z0, z)))
+            elif nu.is_Integer and nu > 1:
+                return fro(nu, z).expand(func=True)
+            return fro(nu, z)
+        return repl
+
+    expr = expr.replace(besselj, expander(besselj))
+    expr = expr.replace(bessely, expander(bessely))
+    expr = expr.replace(besseli, expander(besseli))
+    expr = expr.replace(besselk, expander(besselk))
+
+    def _bessel_simp_recursion(expr):
+
+        def _use_recursion(bessel, expr):
+            while True:
+                bessels = expr.find(lambda x: isinstance(x, bessel))
+                try:
+                    for ba in sorted(bessels, key=lambda x: re(x.args[0])):
+                        a, x = ba.args
+                        bap1 = bessel(a+1, x)
+                        bap2 = bessel(a+2, x)
+                        if expr.has(bap1) and expr.has(bap2):
+                            expr = expr.subs(ba, 2*(a+1)/x*bap1 - bap2)
+                            break
+                    else:
+                        return expr
+                except (ValueError, TypeError):
+                    return expr
+        if expr.has(besselj):
+            expr = _use_recursion(besselj, expr)
+        if expr.has(bessely):
+            expr = _use_recursion(bessely, expr)
+        return expr
+
+    expr = _bessel_simp_recursion(expr)
+    if expr != orig_expr:
+        expr = expr.factor()
+
+    return expr
+
+
+def nthroot(expr, n, max_len=4, prec=15):
+    """
+    Compute a real nth-root of a sum of surds.
+
+    Parameters
+    ==========
+
+    expr : sum of surds
+    n : integer
+    max_len : maximum number of surds passed as constants to ``nsimplify``
+
+    Algorithm
+    =========
+
+    First ``nsimplify`` is used to get a candidate root; if it is not a
+    root the minimal polynomial is computed; the answer is one of its
+    roots.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.simplify import nthroot
+    >>> from sympy import sqrt
+    >>> nthroot(90 + 34*sqrt(7), 3)
+    sqrt(7) + 3
+
+    """
+    expr = sympify(expr)
+    n = sympify(n)
+    p = expr**Rational(1, n)
+    if not n.is_integer:
+        return p
+    if not _is_sum_surds(expr):
+        return p
+    surds = []
+    coeff_muls = [x.as_coeff_Mul() for x in expr.args]
+    for x, y in coeff_muls:
+        if not x.is_rational:
+            return p
+        if y is S.One:
+            continue
+        if not (y.is_Pow and y.exp == S.Half and y.base.is_integer):
+            return p
+        surds.append(y)
+    surds.sort()
+    surds = surds[:max_len]
+    if expr < 0 and n % 2 == 1:
+        p = (-expr)**Rational(1, n)
+        a = nsimplify(p, constants=surds)
+        res = a if _mexpand(a**n) == _mexpand(-expr) else p
+        return -res
+    a = nsimplify(p, constants=surds)
+    if _mexpand(a) is not _mexpand(p) and _mexpand(a**n) == _mexpand(expr):
+        return _mexpand(a)
+    expr = _nthroot_solve(expr, n, prec)
+    if expr is None:
+        return p
+    return expr
+
+
+def nsimplify(expr, constants=(), tolerance=None, full=False, rational=None,
+    rational_conversion='base10'):
+    """
+    Find a simple representation for a number or, if there are free symbols or
+    if ``rational=True``, then replace Floats with their Rational equivalents. If
+    no change is made and rational is not False then Floats will at least be
+    converted to Rationals.
+
+    Explanation
+    ===========
+
+    For numerical expressions, a simple formula that numerically matches the
+    given numerical expression is sought (and the input should be possible
+    to evalf to a precision of at least 30 digits).
+
+    Optionally, a list of (rationally independent) constants to
+    include in the formula may be given.
+
+    A lower tolerance may be set to find less exact matches. If no tolerance
+    is given then the least precise value will set the tolerance (e.g. Floats
+    default to 15 digits of precision, so would be tolerance=10**-15).
+
+    With ``full=True``, a more extensive search is performed
+    (this is useful to find simpler numbers when the tolerance
+    is set low).
+
+    When converting to rational, if rational_conversion='base10' (the default), then
+    convert floats to rationals using their base-10 (string) representation.
+    When rational_conversion='exact' it uses the exact, base-2 representation.
+
+    Examples
+    ========
+
+    >>> from sympy import nsimplify, sqrt, GoldenRatio, exp, I, pi
+    >>> nsimplify(4/(1+sqrt(5)), [GoldenRatio])
+    -2 + 2*GoldenRatio
+    >>> nsimplify((1/(exp(3*pi*I/5)+1)))
+    1/2 - I*sqrt(sqrt(5)/10 + 1/4)
+    >>> nsimplify(I**I, [pi])
+    exp(-pi/2)
+    >>> nsimplify(pi, tolerance=0.01)
+    22/7
+
+    >>> nsimplify(0.333333333333333, rational=True, rational_conversion='exact')
+    6004799503160655/18014398509481984
+    >>> nsimplify(0.333333333333333, rational=True)
+    1/3
+
+    See Also
+    ========
+
+    sympy.core.function.nfloat
+
+    """
+    try:
+        return sympify(as_int(expr))
+    except (TypeError, ValueError):
+        pass
+    expr = sympify(expr).xreplace({
+        Float('inf'): S.Infinity,
+        Float('-inf'): S.NegativeInfinity,
+        })
+    if expr is S.Infinity or expr is S.NegativeInfinity:
+        return expr
+    if rational or expr.free_symbols:
+        return _real_to_rational(expr, tolerance, rational_conversion)
+
+    # SymPy's default tolerance for Rationals is 15; other numbers may have
+    # lower tolerances set, so use them to pick the largest tolerance if None
+    # was given
+    if tolerance is None:
+        tolerance = 10**-min([15] +
+             [mpmath.libmp.libmpf.prec_to_dps(n._prec)
+             for n in expr.atoms(Float)])
+    # XXX should prec be set independent of tolerance or should it be computed
+    # from tolerance?
+    prec = 30
+    bprec = int(prec*3.33)
+
+    constants_dict = {}
+    for constant in constants:
+        constant = sympify(constant)
+        v = constant.evalf(prec)
+        if not v.is_Float:
+            raise ValueError("constants must be real-valued")
+        constants_dict[str(constant)] = v._to_mpmath(bprec)
+
+    exprval = expr.evalf(prec, chop=True)
+    re, im = exprval.as_real_imag()
+
+    # safety check to make sure that this evaluated to a number
+    if not (re.is_Number and im.is_Number):
+        return expr
+
+    def nsimplify_real(x):
+        orig = mpmath.mp.dps
+        xv = x._to_mpmath(bprec)
+        try:
+            # We'll be happy with low precision if a simple fraction
+            if not (tolerance or full):
+                mpmath.mp.dps = 15
+                rat = mpmath.pslq([xv, 1])
+                if rat is not None:
+                    return Rational(-int(rat[1]), int(rat[0]))
+            mpmath.mp.dps = prec
+            newexpr = mpmath.identify(xv, constants=constants_dict,
+                tol=tolerance, full=full)
+            if not newexpr:
+                raise ValueError
+            if full:
+                newexpr = newexpr[0]
+            expr = sympify(newexpr)
+            if x and not expr:  # don't let x become 0
+                raise ValueError
+            if expr.is_finite is False and xv not in [mpmath.inf, mpmath.ninf]:
+                raise ValueError
+            return expr
+        finally:
+            # even though there are returns above, this is executed
+            # before leaving
+            mpmath.mp.dps = orig
+    try:
+        if re:
+            re = nsimplify_real(re)
+        if im:
+            im = nsimplify_real(im)
+    except ValueError:
+        if rational is None:
+            return _real_to_rational(expr, rational_conversion=rational_conversion)
+        return expr
+
+    rv = re + im*S.ImaginaryUnit
+    # if there was a change or rational is explicitly not wanted
+    # return the value, else return the Rational representation
+    if rv != expr or rational is False:
+        return rv
+    return _real_to_rational(expr, rational_conversion=rational_conversion)
+
+
+def _real_to_rational(expr, tolerance=None, rational_conversion='base10'):
+    """
+    Replace all reals in expr with rationals.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.simplify import _real_to_rational
+    >>> from sympy.abc import x
+
+    >>> _real_to_rational(.76 + .1*x**.5)
+    sqrt(x)/10 + 19/25
+
+    If rational_conversion='base10', this uses the base-10 string. If
+    rational_conversion='exact', the exact, base-2 representation is used.
+
+    >>> _real_to_rational(0.333333333333333, rational_conversion='exact')
+    6004799503160655/18014398509481984
+    >>> _real_to_rational(0.333333333333333)
+    1/3
+
+    """
+    expr = _sympify(expr)
+    inf = Float('inf')
+    p = expr
+    reps = {}
+    reduce_num = None
+    if tolerance is not None and tolerance < 1:
+        reduce_num = ceiling(1/tolerance)
+    for fl in p.atoms(Float):
+        key = fl
+        if reduce_num is not None:
+            r = Rational(fl).limit_denominator(reduce_num)
+        elif (tolerance is not None and tolerance >= 1 and
+                fl.is_Integer is False):
+            r = Rational(tolerance*round(fl/tolerance)
+                ).limit_denominator(int(tolerance))
+        else:
+            if rational_conversion == 'exact':
+                r = Rational(fl)
+                reps[key] = r
+                continue
+            elif rational_conversion != 'base10':
+                raise ValueError("rational_conversion must be 'base10' or 'exact'")
+
+            r = nsimplify(fl, rational=False)
+            # e.g. log(3).n() -> log(3) instead of a Rational
+            if fl and not r:
+                r = Rational(fl)
+            elif not r.is_Rational:
+                if fl in (inf, -inf):
+                    r = S.ComplexInfinity
+                elif fl < 0:
+                    fl = -fl
+                    d = Pow(10, int(mpmath.log(fl)/mpmath.log(10)))
+                    r = -Rational(str(fl/d))*d
+                elif fl > 0:
+                    d = Pow(10, int(mpmath.log(fl)/mpmath.log(10)))
+                    r = Rational(str(fl/d))*d
+                else:
+                    r = S.Zero
+        reps[key] = r
+    return p.subs(reps, simultaneous=True)
+
+
+def clear_coefficients(expr, rhs=S.Zero):
+    """Return `p, r` where `p` is the expression obtained when Rational
+    additive and multiplicative coefficients of `expr` have been stripped
+    away in a naive fashion (i.e. without simplification). The operations
+    needed to remove the coefficients will be applied to `rhs` and returned
+    as `r`.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.simplify import clear_coefficients
+    >>> from sympy.abc import x, y
+    >>> from sympy import Dummy
+    >>> expr = 4*y*(6*x + 3)
+    >>> clear_coefficients(expr - 2)
+    (y*(2*x + 1), 1/6)
+
+    When solving 2 or more expressions like `expr = a`,
+    `expr = b`, etc..., it is advantageous to provide a Dummy symbol
+    for `rhs` and  simply replace it with `a`, `b`, etc... in `r`.
+
+    >>> rhs = Dummy('rhs')
+    >>> clear_coefficients(expr, rhs)
+    (y*(2*x + 1), _rhs/12)
+    >>> _[1].subs(rhs, 2)
+    1/6
+    """
+    was = None
+    free = expr.free_symbols
+    if expr.is_Rational:
+        return (S.Zero, rhs - expr)
+    while expr and was != expr:
+        was = expr
+        m, expr = (
+            expr.as_content_primitive()
+            if free else
+            factor_terms(expr).as_coeff_Mul(rational=True))
+        rhs /= m
+        c, expr = expr.as_coeff_Add(rational=True)
+        rhs -= c
+    expr = signsimp(expr, evaluate = False)
+    if expr.could_extract_minus_sign():
+        expr = -expr
+        rhs = -rhs
+    return expr, rhs
+
+def nc_simplify(expr, deep=True):
+    '''
+    Simplify a non-commutative expression composed of multiplication
+    and raising to a power by grouping repeated subterms into one power.
+    Priority is given to simplifications that give the fewest number
+    of arguments in the end (for example, in a*b*a*b*c*a*b*c simplifying
+    to (a*b)**2*c*a*b*c gives 5 arguments while a*b*(a*b*c)**2 has 3).
+    If ``expr`` is a sum of such terms, the sum of the simplified terms
+    is returned.
+
+    Keyword argument ``deep`` controls whether or not subexpressions
+    nested deeper inside the main expression are simplified. See examples
+    below. Setting `deep` to `False` can save time on nested expressions
+    that do not need simplifying on all levels.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols
+    >>> from sympy.simplify.simplify import nc_simplify
+    >>> a, b, c = symbols("a b c", commutative=False)
+    >>> nc_simplify(a*b*a*b*c*a*b*c)
+    a*b*(a*b*c)**2
+    >>> expr = a**2*b*a**4*b*a**4
+    >>> nc_simplify(expr)
+    a**2*(b*a**4)**2
+    >>> nc_simplify(a*b*a*b*c**2*(a*b)**2*c**2)
+    ((a*b)**2*c**2)**2
+    >>> nc_simplify(a*b*a*b + 2*a*c*a**2*c*a**2*c*a)
+    (a*b)**2 + 2*(a*c*a)**3
+    >>> nc_simplify(b**-1*a**-1*(a*b)**2)
+    a*b
+    >>> nc_simplify(a**-1*b**-1*c*a)
+    (b*a)**(-1)*c*a
+    >>> expr = (a*b*a*b)**2*a*c*a*c
+    >>> nc_simplify(expr)
+    (a*b)**4*(a*c)**2
+    >>> nc_simplify(expr, deep=False)
+    (a*b*a*b)**2*(a*c)**2
+
+    '''
+    if isinstance(expr, MatrixExpr):
+        expr = expr.doit(inv_expand=False)
+        _Add, _Mul, _Pow, _Symbol = MatAdd, MatMul, MatPow, MatrixSymbol
+    else:
+        _Add, _Mul, _Pow, _Symbol = Add, Mul, Pow, Symbol
+
+    # =========== Auxiliary functions ========================
+    def _overlaps(args):
+        # Calculate a list of lists m such that m[i][j] contains the lengths
+        # of all possible overlaps between args[:i+1] and args[i+1+j:].
+        # An overlap is a suffix of the prefix that matches a prefix
+        # of the suffix.
+        # For example, let expr=c*a*b*a*b*a*b*a*b. Then m[3][0] contains
+        # the lengths of overlaps of c*a*b*a*b with a*b*a*b. The overlaps
+        # are a*b*a*b, a*b and the empty word so that m[3][0]=[4,2,0].
+        # All overlaps rather than only the longest one are recorded
+        # because this information helps calculate other overlap lengths.
+        m = [[([1, 0] if a == args[0] else [0]) for a in args[1:]]]
+        for i in range(1, len(args)):
+            overlaps = []
+            j = 0
+            for j in range(len(args) - i - 1):
+                overlap = []
+                for v in m[i-1][j+1]:
+                    if j + i + 1 + v < len(args) and args[i] == args[j+i+1+v]:
+                        overlap.append(v + 1)
+                overlap += [0]
+                overlaps.append(overlap)
+            m.append(overlaps)
+        return m
+
+    def _reduce_inverses(_args):
+        # replace consecutive negative powers by an inverse
+        # of a product of positive powers, e.g. a**-1*b**-1*c
+        # will simplify to (a*b)**-1*c;
+        # return that new args list and the number of negative
+        # powers in it (inv_tot)
+        inv_tot = 0 # total number of inverses
+        inverses = []
+        args = []
+        for arg in _args:
+            if isinstance(arg, _Pow) and arg.args[1].is_extended_negative:
+                inverses = [arg**-1] + inverses
+                inv_tot += 1
+            else:
+                if len(inverses) == 1:
+                    args.append(inverses[0]**-1)
+                elif len(inverses) > 1:
+                    args.append(_Pow(_Mul(*inverses), -1))
+                    inv_tot -= len(inverses) - 1
+                inverses = []
+                args.append(arg)
+        if inverses:
+            args.append(_Pow(_Mul(*inverses), -1))
+            inv_tot -= len(inverses) - 1
+        return inv_tot, tuple(args)
+
+    def get_score(s):
+        # compute the number of arguments of s
+        # (including in nested expressions) overall
+        # but ignore exponents
+        if isinstance(s, _Pow):
+            return get_score(s.args[0])
+        elif isinstance(s, (_Add, _Mul)):
+            return sum(get_score(a) for a in s.args)
+        return 1
+
+    def compare(s, alt_s):
+        # compare two possible simplifications and return a
+        # "better" one
+        if s != alt_s and get_score(alt_s) < get_score(s):
+            return alt_s
+        return s
+    # ========================================================
+
+    if not isinstance(expr, (_Add, _Mul, _Pow)) or expr.is_commutative:
+        return expr
+    args = expr.args[:]
+    if isinstance(expr, _Pow):
+        if deep:
+            return _Pow(nc_simplify(args[0]), args[1]).doit()
+        else:
+            return expr
+    elif isinstance(expr, _Add):
+        return _Add(*[nc_simplify(a, deep=deep) for a in args]).doit()
+    else:
+        # get the non-commutative part
+        c_args, args = expr.args_cnc()
+        com_coeff = Mul(*c_args)
+        if not equal_valued(com_coeff, 1):
+            return com_coeff*nc_simplify(expr/com_coeff, deep=deep)
+
+    inv_tot, args = _reduce_inverses(args)
+    # if most arguments are negative, work with the inverse
+    # of the expression, e.g. a**-1*b*a**-1*c**-1 will become
+    # (c*a*b**-1*a)**-1 at the end so can work with c*a*b**-1*a
+    invert = False
+    if inv_tot > len(args)/2:
+        invert = True
+        args = [a**-1 for a in args[::-1]]
+
+    if deep:
+        args = tuple(nc_simplify(a) for a in args)
+
+    m = _overlaps(args)
+
+    # simps will be {subterm: end} where `end` is the ending
+    # index of a sequence of repetitions of subterm;
+    # this is for not wasting time with subterms that are part
+    # of longer, already considered sequences
+    simps = {}
+
+    post = 1
+    pre = 1
+
+    # the simplification coefficient is the number of
+    # arguments by which contracting a given sequence
+    # would reduce the word; e.g. in a*b*a*b*c*a*b*c,
+    # contracting a*b*a*b to (a*b)**2 removes 3 arguments
+    # while a*b*c*a*b*c to (a*b*c)**2 removes 6. It's
+    # better to contract the latter so simplification
+    # with a maximum simplification coefficient will be chosen
+    max_simp_coeff = 0
+    simp = None # information about future simplification
+
+    for i in range(1, len(args)):
+        simp_coeff = 0
+        l = 0 # length of a subterm
+        p = 0 # the power of a subterm
+        if i < len(args) - 1:
+            rep = m[i][0]
+        start = i # starting index of the repeated sequence
+        end = i+1 # ending index of the repeated sequence
+        if i == len(args)-1 or rep == [0]:
+            # no subterm is repeated at this stage, at least as
+            # far as the arguments are concerned - there may be
+            # a repetition if powers are taken into account
+            if (isinstance(args[i], _Pow) and
+                            not isinstance(args[i].args[0], _Symbol)):
+                subterm = args[i].args[0].args
+                l = len(subterm)
+                if args[i-l:i] == subterm:
+                    # e.g. a*b in a*b*(a*b)**2 is not repeated
+                    # in args (= [a, b, (a*b)**2]) but it
+                    # can be matched here
+                    p += 1
+                    start -= l
+                if args[i+1:i+1+l] == subterm:
+                    # e.g. a*b in (a*b)**2*a*b
+                    p += 1
+                    end += l
+            if p:
+                p += args[i].args[1]
+            else:
+                continue
+        else:
+            l = rep[0] # length of the longest repeated subterm at this point
+            start -= l - 1
+            subterm = args[start:end]
+            p = 2
+            end += l
+
+        if subterm in simps and simps[subterm] >= start:
+            # the subterm is part of a sequence that
+            # has already been considered
+            continue
+
+        # count how many times it's repeated
+        while end < len(args):
+            if l in m[end-1][0]:
+                p += 1
+                end += l
+            elif isinstance(args[end], _Pow) and args[end].args[0].args == subterm:
+                # for cases like a*b*a*b*(a*b)**2*a*b
+                p += args[end].args[1]
+                end += 1
+            else:
+                break
+
+        # see if another match can be made, e.g.
+        # for b*a**2 in b*a**2*b*a**3 or a*b in
+        # a**2*b*a*b
+
+        pre_exp = 0
+        pre_arg = 1
+        if start - l >= 0 and args[start-l+1:start] == subterm[1:]:
+            if isinstance(subterm[0], _Pow):
+                pre_arg = subterm[0].args[0]
+                exp = subterm[0].args[1]
+            else:
+                pre_arg = subterm[0]
+                exp = 1
+            if isinstance(args[start-l], _Pow) and args[start-l].args[0] == pre_arg:
+                pre_exp = args[start-l].args[1] - exp
+                start -= l
+                p += 1
+            elif args[start-l] == pre_arg:
+                pre_exp = 1 - exp
+                start -= l
+                p += 1
+
+        post_exp = 0
+        post_arg = 1
+        if end + l - 1 < len(args) and args[end:end+l-1] == subterm[:-1]:
+            if isinstance(subterm[-1], _Pow):
+                post_arg = subterm[-1].args[0]
+                exp = subterm[-1].args[1]
+            else:
+                post_arg = subterm[-1]
+                exp = 1
+            if isinstance(args[end+l-1], _Pow) and args[end+l-1].args[0] == post_arg:
+                post_exp = args[end+l-1].args[1] - exp
+                end += l
+                p += 1
+            elif args[end+l-1] == post_arg:
+                post_exp = 1 - exp
+                end += l
+                p += 1
+
+        # Consider a*b*a**2*b*a**2*b*a:
+        # b*a**2 is explicitly repeated, but note
+        # that in this case a*b*a is also repeated
+        # so there are two possible simplifications:
+        # a*(b*a**2)**3*a**-1 or (a*b*a)**3
+        # The latter is obviously simpler.
+        # But in a*b*a**2*b**2*a**2 the simplifications are
+        # a*(b*a**2)**2 and (a*b*a)**3*a in which case
+        # it's better to stick with the shorter subterm
+        if post_exp and exp % 2 == 0 and start > 0:
+            exp = exp/2
+            _pre_exp = 1
+            _post_exp = 1
+            if isinstance(args[start-1], _Pow) and args[start-1].args[0] == post_arg:
+                _post_exp = post_exp + exp
+                _pre_exp = args[start-1].args[1] - exp
+            elif args[start-1] == post_arg:
+                _post_exp = post_exp + exp
+                _pre_exp = 1 - exp
+            if _pre_exp == 0 or _post_exp == 0:
+                if not pre_exp:
+                    start -= 1
+                post_exp = _post_exp
+                pre_exp = _pre_exp
+                pre_arg = post_arg
+                subterm = (post_arg**exp,) + subterm[:-1] + (post_arg**exp,)
+
+        simp_coeff += end-start
+
+        if post_exp:
+            simp_coeff -= 1
+        if pre_exp:
+            simp_coeff -= 1
+
+        simps[subterm] = end
+
+        if simp_coeff > max_simp_coeff:
+            max_simp_coeff = simp_coeff
+            simp = (start, _Mul(*subterm), p, end, l)
+            pre = pre_arg**pre_exp
+            post = post_arg**post_exp
+
+    if simp:
+        subterm = _Pow(nc_simplify(simp[1], deep=deep), simp[2])
+        pre = nc_simplify(_Mul(*args[:simp[0]])*pre, deep=deep)
+        post = post*nc_simplify(_Mul(*args[simp[3]:]), deep=deep)
+        simp = pre*subterm*post
+        if pre != 1 or post != 1:
+            # new simplifications may be possible but no need
+            # to recurse over arguments
+            simp = nc_simplify(simp, deep=False)
+    else:
+        simp = _Mul(*args)
+
+    if invert:
+        simp = _Pow(simp, -1)
+
+    # see if factor_nc(expr) is simplified better
+    if not isinstance(expr, MatrixExpr):
+        f_expr = factor_nc(expr)
+        if f_expr != expr:
+            alt_simp = nc_simplify(f_expr, deep=deep)
+            simp = compare(simp, alt_simp)
+    else:
+        simp = simp.doit(inv_expand=False)
+    return simp
+
+
+def dotprodsimp(expr, withsimp=False):
+    """Simplification for a sum of products targeted at the kind of blowup that
+    occurs during summation of products. Intended to reduce expression blowup
+    during matrix multiplication or other similar operations. Only works with
+    algebraic expressions and does not recurse into non.
+
+    Parameters
+    ==========
+
+    withsimp : bool, optional
+        Specifies whether a flag should be returned along with the expression
+        to indicate roughly whether simplification was successful. It is used
+        in ``MatrixArithmetic._eval_pow_by_recursion`` to avoid attempting to
+        simplify an expression repetitively which does not simplify.
+    """
+
+    def count_ops_alg(expr):
+        """Optimized count algebraic operations with no recursion into
+        non-algebraic args that ``core.function.count_ops`` does. Also returns
+        whether rational functions may be present according to negative
+        exponents of powers or non-number fractions.
+
+        Returns
+        =======
+
+        ops, ratfunc : int, bool
+            ``ops`` is the number of algebraic operations starting at the top
+            level expression (not recursing into non-alg children). ``ratfunc``
+            specifies whether the expression MAY contain rational functions
+            which ``cancel`` MIGHT optimize.
+        """
+
+        ops     = 0
+        args    = [expr]
+        ratfunc = False
+
+        while args:
+            a = args.pop()
+
+            if not isinstance(a, Basic):
+                continue
+
+            if a.is_Rational:
+                if a is not S.One: # -1/3 = NEG + DIV
+                    ops += bool (a.p < 0) + bool (a.q != 1)
+
+            elif a.is_Mul:
+                if a.could_extract_minus_sign():
+                    ops += 1
+                    if a.args[0] is S.NegativeOne:
+                        a = a.as_two_terms()[1]
+                    else:
+                        a = -a
+
+                n, d = fraction(a)
+
+                if n.is_Integer:
+                    ops += 1 + bool (n < 0)
+                    args.append(d) # won't be -Mul but could be Add
+
+                elif d is not S.One:
+                    if not d.is_Integer:
+                        args.append(d)
+                        ratfunc=True
+
+                    ops += 1
+                    args.append(n) # could be -Mul
+
+                else:
+                    ops += len(a.args) - 1
+                    args.extend(a.args)
+
+            elif a.is_Add:
+                laargs = len(a.args)
+                negs   = 0
+
+                for ai in a.args:
+                    if ai.could_extract_minus_sign():
+                        negs += 1
+                        ai    = -ai
+                    args.append(ai)
+
+                ops += laargs - (negs != laargs) # -x - y = NEG + SUB
+
+            elif a.is_Pow:
+                ops += 1
+                args.append(a.base)
+
+                if not ratfunc:
+                    ratfunc = a.exp.is_negative is not False
+
+        return ops, ratfunc
+
+    def nonalg_subs_dummies(expr, dummies):
+        """Substitute dummy variables for non-algebraic expressions to avoid
+        evaluation of non-algebraic terms that ``polys.polytools.cancel`` does.
+        """
+
+        if not expr.args:
+            return expr
+
+        if expr.is_Add or expr.is_Mul or expr.is_Pow:
+            args = None
+
+            for i, a in enumerate(expr.args):
+                c = nonalg_subs_dummies(a, dummies)
+
+                if c is a:
+                    continue
+
+                if args is None:
+                    args = list(expr.args)
+
+                args[i] = c
+
+            if args is None:
+                return expr
+
+            return expr.func(*args)
+
+        return dummies.setdefault(expr, Dummy())
+
+    simplified = False # doesn't really mean simplified, rather "can simplify again"
+
+    if isinstance(expr, Basic) and (expr.is_Add or expr.is_Mul or expr.is_Pow):
+        expr2 = expr.expand(deep=True, modulus=None, power_base=False,
+            power_exp=False, mul=True, log=False, multinomial=True, basic=False)
+
+        if expr2 != expr:
+            expr       = expr2
+            simplified = True
+
+        exprops, ratfunc = count_ops_alg(expr)
+
+        if exprops >= 6: # empirically tested cutoff for expensive simplification
+            if ratfunc:
+                dummies = {}
+                expr2   = nonalg_subs_dummies(expr, dummies)
+
+                if expr2 is expr or count_ops_alg(expr2)[0] >= 6: # check again after substitution
+                    expr3 = cancel(expr2)
+
+                    if expr3 != expr2:
+                        expr       = expr3.subs([(d, e) for e, d in dummies.items()])
+                        simplified = True
+
+        # very special case: x/(x-1) - 1/(x-1) -> 1
+        elif (exprops == 5 and expr.is_Add and expr.args [0].is_Mul and
+                expr.args [1].is_Mul and expr.args [0].args [-1].is_Pow and
+                expr.args [1].args [-1].is_Pow and
+                expr.args [0].args [-1].exp is S.NegativeOne and
+                expr.args [1].args [-1].exp is S.NegativeOne):
+
+            expr2    = together (expr)
+            expr2ops = count_ops_alg(expr2)[0]
+
+            if expr2ops < exprops:
+                expr       = expr2
+                simplified = True
+
+        else:
+            simplified = True
+
+    return (expr, simplified) if withsimp else expr
+
+
+bottom_up = deprecated(
+    """
+    Using bottom_up from the sympy.simplify.simplify submodule is
+    deprecated.
+
+    Instead, use bottom_up from the top-level sympy namespace, like
+
+        sympy.bottom_up
+    """,
+    deprecated_since_version="1.10",
+    active_deprecations_target="deprecated-traversal-functions-moved",
+)(_bottom_up)
+
+
+# XXX: This function really should either be private API or exported in the
+# top-level sympy/__init__.py
+walk = deprecated(
+    """
+    Using walk from the sympy.simplify.simplify submodule is
+    deprecated.
+
+    Instead, use walk from sympy.core.traversal.walk
+    """,
+    deprecated_since_version="1.10",
+    active_deprecations_target="deprecated-traversal-functions-moved",
+)(_walk)

lib/python3.12/site-packages/sympy/simplify/sqrtdenest.py

@@ -0,0 +1,678 @@
+from sympy.core import Add, Expr, Mul, S, sympify
+from sympy.core.function import _mexpand, count_ops, expand_mul
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Dummy
+from sympy.functions import root, sign, sqrt
+from sympy.polys import Poly, PolynomialError
+
+
+def is_sqrt(expr):
+    """Return True if expr is a sqrt, otherwise False."""
+
+    return expr.is_Pow and expr.exp.is_Rational and abs(expr.exp) is S.Half
+
+
+def sqrt_depth(p) -> int:
+    """Return the maximum depth of any square root argument of p.
+
+    >>> from sympy.functions.elementary.miscellaneous import sqrt
+    >>> from sympy.simplify.sqrtdenest import sqrt_depth
+
+    Neither of these square roots contains any other square roots
+    so the depth is 1:
+
+    >>> sqrt_depth(1 + sqrt(2)*(1 + sqrt(3)))
+    1
+
+    The sqrt(3) is contained within a square root so the depth is
+    2:
+
+    >>> sqrt_depth(1 + sqrt(2)*sqrt(1 + sqrt(3)))
+    2
+    """
+    if p is S.ImaginaryUnit:
+        return 1
+    if p.is_Atom:
+        return 0
+    if p.is_Add or p.is_Mul:
+        return max(sqrt_depth(x) for x in p.args)
+    if is_sqrt(p):
+        return sqrt_depth(p.base) + 1
+    return 0
+
+
+def is_algebraic(p):
+    """Return True if p is comprised of only Rationals or square roots
+    of Rationals and algebraic operations.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.miscellaneous import sqrt
+    >>> from sympy.simplify.sqrtdenest import is_algebraic
+    >>> from sympy import cos
+    >>> is_algebraic(sqrt(2)*(3/(sqrt(7) + sqrt(5)*sqrt(2))))
+    True
+    >>> is_algebraic(sqrt(2)*(3/(sqrt(7) + sqrt(5)*cos(2))))
+    False
+    """
+
+    if p.is_Rational:
+        return True
+    elif p.is_Atom:
+        return False
+    elif is_sqrt(p) or p.is_Pow and p.exp.is_Integer:
+        return is_algebraic(p.base)
+    elif p.is_Add or p.is_Mul:
+        return all(is_algebraic(x) for x in p.args)
+    else:
+        return False
+
+
+def _subsets(n):
+    """
+    Returns all possible subsets of the set (0, 1, ..., n-1) except the
+    empty set, listed in reversed lexicographical order according to binary
+    representation, so that the case of the fourth root is treated last.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.sqrtdenest import _subsets
+    >>> _subsets(2)
+    [[1, 0], [0, 1], [1, 1]]
+
+    """
+    if n == 1:
+        a = [[1]]
+    elif n == 2:
+        a = [[1, 0], [0, 1], [1, 1]]
+    elif n == 3:
+        a = [[1, 0, 0], [0, 1, 0], [1, 1, 0],
+             [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]]
+    else:
+        b = _subsets(n - 1)
+        a0 = [x + [0] for x in b]
+        a1 = [x + [1] for x in b]
+        a = a0 + [[0]*(n - 1) + [1]] + a1
+    return a
+
+
+def sqrtdenest(expr, max_iter=3):
+    """Denests sqrts in an expression that contain other square roots
+    if possible, otherwise returns the expr unchanged. This is based on the
+    algorithms of [1].
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.sqrtdenest import sqrtdenest
+    >>> from sympy import sqrt
+    >>> sqrtdenest(sqrt(5 + 2 * sqrt(6)))
+    sqrt(2) + sqrt(3)
+
+    See Also
+    ========
+
+    sympy.solvers.solvers.unrad
+
+    References
+    ==========
+
+    .. [1] https://web.archive.org/web/20210806201615/https://researcher.watson.ibm.com/researcher/files/us-fagin/symb85.pdf
+
+    .. [2] D. J. Jeffrey and A. D. Rich, 'Symplifying Square Roots of Square Roots
+           by Denesting' (available at https://www.cybertester.com/data/denest.pdf)
+
+    """
+    expr = expand_mul(expr)
+    for i in range(max_iter):
+        z = _sqrtdenest0(expr)
+        if expr == z:
+            return expr
+        expr = z
+    return expr
+
+
+def _sqrt_match(p):
+    """Return [a, b, r] for p.match(a + b*sqrt(r)) where, in addition to
+    matching, sqrt(r) also has then maximal sqrt_depth among addends of p.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.miscellaneous import sqrt
+    >>> from sympy.simplify.sqrtdenest import _sqrt_match
+    >>> _sqrt_match(1 + sqrt(2) + sqrt(2)*sqrt(3) +  2*sqrt(1+sqrt(5)))
+    [1 + sqrt(2) + sqrt(6), 2, 1 + sqrt(5)]
+    """
+    from sympy.simplify.radsimp import split_surds
+
+    p = _mexpand(p)
+    if p.is_Number:
+        res = (p, S.Zero, S.Zero)
+    elif p.is_Add:
+        pargs = sorted(p.args, key=default_sort_key)
+        sqargs = [x**2 for x in pargs]
+        if all(sq.is_Rational and sq.is_positive for sq in sqargs):
+            r, b, a = split_surds(p)
+            res = a, b, r
+            return list(res)
+        # to make the process canonical, the argument is included in the tuple
+        # so when the max is selected, it will be the largest arg having a
+        # given depth
+        v = [(sqrt_depth(x), x, i) for i, x in enumerate(pargs)]
+        nmax = max(v, key=default_sort_key)
+        if nmax[0] == 0:
+            res = []
+        else:
+            # select r
+            depth, _, i = nmax
+            r = pargs.pop(i)
+            v.pop(i)
+            b = S.One
+            if r.is_Mul:
+                bv = []
+                rv = []
+                for x in r.args:
+                    if sqrt_depth(x) < depth:
+                        bv.append(x)
+                    else:
+                        rv.append(x)
+                b = Mul._from_args(bv)
+                r = Mul._from_args(rv)
+            # collect terms comtaining r
+            a1 = []
+            b1 = [b]
+            for x in v:
+                if x[0] < depth:
+                    a1.append(x[1])
+                else:
+                    x1 = x[1]
+                    if x1 == r:
+                        b1.append(1)
+                    else:
+                        if x1.is_Mul:
+                            x1args = list(x1.args)
+                            if r in x1args:
+                                x1args.remove(r)
+                                b1.append(Mul(*x1args))
+                            else:
+                                a1.append(x[1])
+                        else:
+                            a1.append(x[1])
+            a = Add(*a1)
+            b = Add(*b1)
+            res = (a, b, r**2)
+    else:
+        b, r = p.as_coeff_Mul()
+        if is_sqrt(r):
+            res = (S.Zero, b, r**2)
+        else:
+            res = []
+    return list(res)
+
+
+class SqrtdenestStopIteration(StopIteration):
+    pass
+
+
+def _sqrtdenest0(expr):
+    """Returns expr after denesting its arguments."""
+
+    if is_sqrt(expr):
+        n, d = expr.as_numer_denom()
+        if d is S.One:  # n is a square root
+            if n.base.is_Add:
+                args = sorted(n.base.args, key=default_sort_key)
+                if len(args) > 2 and all((x**2).is_Integer for x in args):
+                    try:
+                        return _sqrtdenest_rec(n)
+                    except SqrtdenestStopIteration:
+                        pass
+                expr = sqrt(_mexpand(Add(*[_sqrtdenest0(x) for x in args])))
+            return _sqrtdenest1(expr)
+        else:
+            n, d = [_sqrtdenest0(i) for i in (n, d)]
+            return n/d
+
+    if isinstance(expr, Add):
+        cs = []
+        args = []
+        for arg in expr.args:
+            c, a = arg.as_coeff_Mul()
+            cs.append(c)
+            args.append(a)
+
+        if all(c.is_Rational for c in cs) and all(is_sqrt(arg) for arg in args):
+            return _sqrt_ratcomb(cs, args)
+
+    if isinstance(expr, Expr):
+        args = expr.args
+        if args:
+            return expr.func(*[_sqrtdenest0(a) for a in args])
+    return expr
+
+
+def _sqrtdenest_rec(expr):
+    """Helper that denests the square root of three or more surds.
+
+    Explanation
+    ===========
+
+    It returns the denested expression; if it cannot be denested it
+    throws SqrtdenestStopIteration
+
+    Algorithm: expr.base is in the extension Q_m = Q(sqrt(r_1),..,sqrt(r_k));
+    split expr.base = a + b*sqrt(r_k), where `a` and `b` are on
+    Q_(m-1) = Q(sqrt(r_1),..,sqrt(r_(k-1))); then a**2 - b**2*r_k is
+    on Q_(m-1); denest sqrt(a**2 - b**2*r_k) and so on.
+    See [1], section 6.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt
+    >>> from sympy.simplify.sqrtdenest import _sqrtdenest_rec
+    >>> _sqrtdenest_rec(sqrt(-72*sqrt(2) + 158*sqrt(5) + 498))
+    -sqrt(10) + sqrt(2) + 9 + 9*sqrt(5)
+    >>> w=-6*sqrt(55)-6*sqrt(35)-2*sqrt(22)-2*sqrt(14)+2*sqrt(77)+6*sqrt(10)+65
+    >>> _sqrtdenest_rec(sqrt(w))
+    -sqrt(11) - sqrt(7) + sqrt(2) + 3*sqrt(5)
+    """
+    from sympy.simplify.radsimp import radsimp, rad_rationalize, split_surds
+    if not expr.is_Pow:
+        return sqrtdenest(expr)
+    if expr.base < 0:
+        return sqrt(-1)*_sqrtdenest_rec(sqrt(-expr.base))
+    g, a, b = split_surds(expr.base)
+    a = a*sqrt(g)
+    if a < b:
+        a, b = b, a
+    c2 = _mexpand(a**2 - b**2)
+    if len(c2.args) > 2:
+        g, a1, b1 = split_surds(c2)
+        a1 = a1*sqrt(g)
+        if a1 < b1:
+            a1, b1 = b1, a1
+        c2_1 = _mexpand(a1**2 - b1**2)
+        c_1 = _sqrtdenest_rec(sqrt(c2_1))
+        d_1 = _sqrtdenest_rec(sqrt(a1 + c_1))
+        num, den = rad_rationalize(b1, d_1)
+        c = _mexpand(d_1/sqrt(2) + num/(den*sqrt(2)))
+    else:
+        c = _sqrtdenest1(sqrt(c2))
+
+    if sqrt_depth(c) > 1:
+        raise SqrtdenestStopIteration
+    ac = a + c
+    if len(ac.args) >= len(expr.args):
+        if count_ops(ac) >= count_ops(expr.base):
+            raise SqrtdenestStopIteration
+    d = sqrtdenest(sqrt(ac))
+    if sqrt_depth(d) > 1:
+        raise SqrtdenestStopIteration
+    num, den = rad_rationalize(b, d)
+    r = d/sqrt(2) + num/(den*sqrt(2))
+    r = radsimp(r)
+    return _mexpand(r)
+
+
+def _sqrtdenest1(expr, denester=True):
+    """Return denested expr after denesting with simpler methods or, that
+    failing, using the denester."""
+
+    from sympy.simplify.simplify import radsimp
+
+    if not is_sqrt(expr):
+        return expr
+
+    a = expr.base
+    if a.is_Atom:
+        return expr
+    val = _sqrt_match(a)
+    if not val:
+        return expr
+
+    a, b, r = val
+    # try a quick numeric denesting
+    d2 = _mexpand(a**2 - b**2*r)
+    if d2.is_Rational:
+        if d2.is_positive:
+            z = _sqrt_numeric_denest(a, b, r, d2)
+            if z is not None:
+                return z
+        else:
+            # fourth root case
+            # sqrtdenest(sqrt(3 + 2*sqrt(3))) =
+            # sqrt(2)*3**(1/4)/2 + sqrt(2)*3**(3/4)/2
+            dr2 = _mexpand(-d2*r)
+            dr = sqrt(dr2)
+            if dr.is_Rational:
+                z = _sqrt_numeric_denest(_mexpand(b*r), a, r, dr2)
+                if z is not None:
+                    return z/root(r, 4)
+
+    else:
+        z = _sqrt_symbolic_denest(a, b, r)
+        if z is not None:
+            return z
+
+    if not denester or not is_algebraic(expr):
+        return expr
+
+    res = sqrt_biquadratic_denest(expr, a, b, r, d2)
+    if res:
+        return res
+
+    # now call to the denester
+    av0 = [a, b, r, d2]
+    z = _denester([radsimp(expr**2)], av0, 0, sqrt_depth(expr))[0]
+    if av0[1] is None:
+        return expr
+    if z is not None:
+        if sqrt_depth(z) == sqrt_depth(expr) and count_ops(z) > count_ops(expr):
+            return expr
+        return z
+    return expr
+
+
+def _sqrt_symbolic_denest(a, b, r):
+    """Given an expression, sqrt(a + b*sqrt(b)), return the denested
+    expression or None.
+
+    Explanation
+    ===========
+
+    If r = ra + rb*sqrt(rr), try replacing sqrt(rr) in ``a`` with
+    (y**2 - ra)/rb, and if the result is a quadratic, ca*y**2 + cb*y + cc, and
+    (cb + b)**2 - 4*ca*cc is 0, then sqrt(a + b*sqrt(r)) can be rewritten as
+    sqrt(ca*(sqrt(r) + (cb + b)/(2*ca))**2).
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.sqrtdenest import _sqrt_symbolic_denest, sqrtdenest
+    >>> from sympy import sqrt, Symbol
+    >>> from sympy.abc import x
+
+    >>> a, b, r = 16 - 2*sqrt(29), 2, -10*sqrt(29) + 55
+    >>> _sqrt_symbolic_denest(a, b, r)
+    sqrt(11 - 2*sqrt(29)) + sqrt(5)
+
+    If the expression is numeric, it will be simplified:
+
+    >>> w = sqrt(sqrt(sqrt(3) + 1) + 1) + 1 + sqrt(2)
+    >>> sqrtdenest(sqrt((w**2).expand()))
+    1 + sqrt(2) + sqrt(1 + sqrt(1 + sqrt(3)))
+
+    Otherwise, it will only be simplified if assumptions allow:
+
+    >>> w = w.subs(sqrt(3), sqrt(x + 3))
+    >>> sqrtdenest(sqrt((w**2).expand()))
+    sqrt((sqrt(sqrt(sqrt(x + 3) + 1) + 1) + 1 + sqrt(2))**2)
+
+    Notice that the argument of the sqrt is a square. If x is made positive
+    then the sqrt of the square is resolved:
+
+    >>> _.subs(x, Symbol('x', positive=True))
+    sqrt(sqrt(sqrt(x + 3) + 1) + 1) + 1 + sqrt(2)
+    """
+
+    a, b, r = map(sympify, (a, b, r))
+    rval = _sqrt_match(r)
+    if not rval:
+        return None
+    ra, rb, rr = rval
+    if rb:
+        y = Dummy('y', positive=True)
+        try:
+            newa = Poly(a.subs(sqrt(rr), (y**2 - ra)/rb), y)
+        except PolynomialError:
+            return None
+        if newa.degree() == 2:
+            ca, cb, cc = newa.all_coeffs()
+            cb += b
+            if _mexpand(cb**2 - 4*ca*cc).equals(0):
+                z = sqrt(ca*(sqrt(r) + cb/(2*ca))**2)
+                if z.is_number:
+                    z = _mexpand(Mul._from_args(z.as_content_primitive()))
+                return z
+
+
+def _sqrt_numeric_denest(a, b, r, d2):
+    r"""Helper that denest
+    $\sqrt{a + b \sqrt{r}}, d^2 = a^2 - b^2 r > 0$
+
+    If it cannot be denested, it returns ``None``.
+    """
+    d = sqrt(d2)
+    s = a + d
+    # sqrt_depth(res) <= sqrt_depth(s) + 1
+    # sqrt_depth(expr) = sqrt_depth(r) + 2
+    # there is denesting if sqrt_depth(s) + 1 < sqrt_depth(r) + 2
+    # if s**2 is Number there is a fourth root
+    if sqrt_depth(s) < sqrt_depth(r) + 1 or (s**2).is_Rational:
+        s1, s2 = sign(s), sign(b)
+        if s1 == s2 == -1:
+            s1 = s2 = 1
+        res = (s1 * sqrt(a + d) + s2 * sqrt(a - d)) * sqrt(2) / 2
+        return res.expand()
+
+
+def sqrt_biquadratic_denest(expr, a, b, r, d2):
+    """denest expr = sqrt(a + b*sqrt(r))
+    where a, b, r are linear combinations of square roots of
+    positive rationals on the rationals (SQRR) and r > 0, b != 0,
+    d2 = a**2 - b**2*r > 0
+
+    If it cannot denest it returns None.
+
+    Explanation
+    ===========
+
+    Search for a solution A of type SQRR of the biquadratic equation
+    4*A**4 - 4*a*A**2 + b**2*r = 0                               (1)
+    sqd = sqrt(a**2 - b**2*r)
+    Choosing the sqrt to be positive, the possible solutions are
+    A = sqrt(a/2 +/- sqd/2)
+    Since a, b, r are SQRR, then a**2 - b**2*r is a SQRR,
+    so if sqd can be denested, it is done by
+    _sqrtdenest_rec, and the result is a SQRR.
+    Similarly for A.
+    Examples of solutions (in both cases a and sqd are positive):
+
+      Example of expr with solution sqrt(a/2 + sqd/2) but not
+      solution sqrt(a/2 - sqd/2):
+      expr = sqrt(-sqrt(15) - sqrt(2)*sqrt(-sqrt(5) + 5) - sqrt(3) + 8)
+      a = -sqrt(15) - sqrt(3) + 8; sqd = -2*sqrt(5) - 2 + 4*sqrt(3)
+
+      Example of expr with solution sqrt(a/2 - sqd/2) but not
+      solution sqrt(a/2 + sqd/2):
+      w = 2 + r2 + r3 + (1 + r3)*sqrt(2 + r2 + 5*r3)
+      expr = sqrt((w**2).expand())
+      a = 4*sqrt(6) + 8*sqrt(2) + 47 + 28*sqrt(3)
+      sqd = 29 + 20*sqrt(3)
+
+    Define B = b/2*A; eq.(1) implies a = A**2 + B**2*r; then
+    expr**2 = a + b*sqrt(r) = (A + B*sqrt(r))**2
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt
+    >>> from sympy.simplify.sqrtdenest import _sqrt_match, sqrt_biquadratic_denest
+    >>> z = sqrt((2*sqrt(2) + 4)*sqrt(2 + sqrt(2)) + 5*sqrt(2) + 8)
+    >>> a, b, r = _sqrt_match(z**2)
+    >>> d2 = a**2 - b**2*r
+    >>> sqrt_biquadratic_denest(z, a, b, r, d2)
+    sqrt(2) + sqrt(sqrt(2) + 2) + 2
+    """
+    from sympy.simplify.radsimp import radsimp, rad_rationalize
+    if r <= 0 or d2 < 0 or not b or sqrt_depth(expr.base) < 2:
+        return None
+    for x in (a, b, r):
+        for y in x.args:
+            y2 = y**2
+            if not y2.is_Integer or not y2.is_positive:
+                return None
+    sqd = _mexpand(sqrtdenest(sqrt(radsimp(d2))))
+    if sqrt_depth(sqd) > 1:
+        return None
+    x1, x2 = [a/2 + sqd/2, a/2 - sqd/2]
+    # look for a solution A with depth 1
+    for x in (x1, x2):
+        A = sqrtdenest(sqrt(x))
+        if sqrt_depth(A) > 1:
+            continue
+        Bn, Bd = rad_rationalize(b, _mexpand(2*A))
+        B = Bn/Bd
+        z = A + B*sqrt(r)
+        if z < 0:
+            z = -z
+        return _mexpand(z)
+    return None
+
+
+def _denester(nested, av0, h, max_depth_level):
+    """Denests a list of expressions that contain nested square roots.
+
+    Explanation
+    ===========
+
+    Algorithm based on <http://www.almaden.ibm.com/cs/people/fagin/symb85.pdf>.
+
+    It is assumed that all of the elements of 'nested' share the same
+    bottom-level radicand. (This is stated in the paper, on page 177, in
+    the paragraph immediately preceding the algorithm.)
+
+    When evaluating all of the arguments in parallel, the bottom-level
+    radicand only needs to be denested once. This means that calling
+    _denester with x arguments results in a recursive invocation with x+1
+    arguments; hence _denester has polynomial complexity.
+
+    However, if the arguments were evaluated separately, each call would
+    result in two recursive invocations, and the algorithm would have
+    exponential complexity.
+
+    This is discussed in the paper in the middle paragraph of page 179.
+    """
+    from sympy.simplify.simplify import radsimp
+    if h > max_depth_level:
+        return None, None
+    if av0[1] is None:
+        return None, None
+    if (av0[0] is None and
+            all(n.is_Number for n in nested)):  # no arguments are nested
+        for f in _subsets(len(nested)):  # test subset 'f' of nested
+            p = _mexpand(Mul(*[nested[i] for i in range(len(f)) if f[i]]))
+            if f.count(1) > 1 and f[-1]:
+                p = -p
+            sqp = sqrt(p)
+            if sqp.is_Rational:
+                return sqp, f  # got a perfect square so return its square root.
+        # Otherwise, return the radicand from the previous invocation.
+        return sqrt(nested[-1]), [0]*len(nested)
+    else:
+        R = None
+        if av0[0] is not None:
+            values = [av0[:2]]
+            R = av0[2]
+            nested2 = [av0[3], R]
+            av0[0] = None
+        else:
+            values = list(filter(None, [_sqrt_match(expr) for expr in nested]))
+            for v in values:
+                if v[2]:  # Since if b=0, r is not defined
+                    if R is not None:
+                        if R != v[2]:
+                            av0[1] = None
+                            return None, None
+                    else:
+                        R = v[2]
+            if R is None:
+                # return the radicand from the previous invocation
+                return sqrt(nested[-1]), [0]*len(nested)
+            nested2 = [_mexpand(v[0]**2) -
+                       _mexpand(R*v[1]**2) for v in values] + [R]
+        d, f = _denester(nested2, av0, h + 1, max_depth_level)
+        if not f:
+            return None, None
+        if not any(f[i] for i in range(len(nested))):
+            v = values[-1]
+            return sqrt(v[0] + _mexpand(v[1]*d)), f
+        else:
+            p = Mul(*[nested[i] for i in range(len(nested)) if f[i]])
+            v = _sqrt_match(p)
+            if 1 in f and f.index(1) < len(nested) - 1 and f[len(nested) - 1]:
+                v[0] = -v[0]
+                v[1] = -v[1]
+            if not f[len(nested)]:  # Solution denests with square roots
+                vad = _mexpand(v[0] + d)
+                if vad <= 0:
+                    # return the radicand from the previous invocation.
+                    return sqrt(nested[-1]), [0]*len(nested)
+                if not(sqrt_depth(vad) <= sqrt_depth(R) + 1 or
+                       (vad**2).is_Number):
+                    av0[1] = None
+                    return None, None
+
+                sqvad = _sqrtdenest1(sqrt(vad), denester=False)
+                if not (sqrt_depth(sqvad) <= sqrt_depth(R) + 1):
+                    av0[1] = None
+                    return None, None
+                sqvad1 = radsimp(1/sqvad)
+                res = _mexpand(sqvad/sqrt(2) + (v[1]*sqrt(R)*sqvad1/sqrt(2)))
+                return res, f
+
+                      #          sign(v[1])*sqrt(_mexpand(v[1]**2*R*vad1/2))), f
+            else:  # Solution requires a fourth root
+                s2 = _mexpand(v[1]*R) + d
+                if s2 <= 0:
+                    return sqrt(nested[-1]), [0]*len(nested)
+                FR, s = root(_mexpand(R), 4), sqrt(s2)
+                return _mexpand(s/(sqrt(2)*FR) + v[0]*FR/(sqrt(2)*s)), f
+
+
+def _sqrt_ratcomb(cs, args):
+    """Denest rational combinations of radicals.
+
+    Based on section 5 of [1].
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt
+    >>> from sympy.simplify.sqrtdenest import sqrtdenest
+    >>> z = sqrt(1+sqrt(3)) + sqrt(3+3*sqrt(3)) - sqrt(10+6*sqrt(3))
+    >>> sqrtdenest(z)
+    0
+    """
+    from sympy.simplify.radsimp import radsimp
+
+    # check if there exists a pair of sqrt that can be denested
+    def find(a):
+        n = len(a)
+        for i in range(n - 1):
+            for j in range(i + 1, n):
+                s1 = a[i].base
+                s2 = a[j].base
+                p = _mexpand(s1 * s2)
+                s = sqrtdenest(sqrt(p))
+                if s != sqrt(p):
+                    return s, i, j
+
+    indices = find(args)
+    if indices is None:
+        return Add(*[c * arg for c, arg in zip(cs, args)])
+
+    s, i1, i2 = indices
+
+    c2 = cs.pop(i2)
+    args.pop(i2)
+    a1 = args[i1]
+
+    # replace a2 by s/a1
+    cs[i1] += radsimp(c2 * s / a1.base)
+
+    return _sqrt_ratcomb(cs, args)

lib/python3.12/site-packages/sympy/simplify/tests/test_combsimp.py

@@ -0,0 +1,75 @@
+from sympy.core.numbers import Rational
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import (FallingFactorial, RisingFactorial, binomial, factorial)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.simplify.combsimp import combsimp
+from sympy.abc import x
+
+
+def test_combsimp():
+    k, m, n = symbols('k m n', integer = True)
+
+    assert combsimp(factorial(n)) == factorial(n)
+    assert combsimp(binomial(n, k)) == binomial(n, k)
+
+    assert combsimp(factorial(n)/factorial(n - 3)) == n*(-1 + n)*(-2 + n)
+    assert combsimp(binomial(n + 1, k + 1)/binomial(n, k)) == (1 + n)/(1 + k)
+
+    assert combsimp(binomial(3*n + 4, n + 1)/binomial(3*n + 1, n)) == \
+        Rational(3, 2)*((3*n + 2)*(3*n + 4)/((n + 1)*(2*n + 3)))
+
+    assert combsimp(factorial(n)**2/factorial(n - 3)) == \
+        factorial(n)*n*(-1 + n)*(-2 + n)
+    assert combsimp(factorial(n)*binomial(n + 1, k + 1)/binomial(n, k)) == \
+        factorial(n + 1)/(1 + k)
+
+    assert combsimp(gamma(n + 3)) == factorial(n + 2)
+
+    assert combsimp(factorial(x)) == gamma(x + 1)
+
+    # issue 9699
+    assert combsimp((n + 1)*factorial(n)) == factorial(n + 1)
+    assert combsimp(factorial(n)/n) == factorial(n-1)
+
+    # issue 6658
+    assert combsimp(binomial(n, n - k)) == binomial(n, k)
+
+    # issue 6341, 7135
+    assert combsimp(factorial(n)/(factorial(k)*factorial(n - k))) == \
+        binomial(n, k)
+    assert combsimp(factorial(k)*factorial(n - k)/factorial(n)) == \
+        1/binomial(n, k)
+    assert combsimp(factorial(2*n)/factorial(n)**2) == binomial(2*n, n)
+    assert combsimp(factorial(2*n)*factorial(k)*factorial(n - k)/
+        factorial(n)**3) == binomial(2*n, n)/binomial(n, k)
+
+    assert combsimp(factorial(n*(1 + n) - n**2 - n)) == 1
+
+    assert combsimp(6*FallingFactorial(-4, n)/factorial(n)) == \
+        (-1)**n*(n + 1)*(n + 2)*(n + 3)
+    assert combsimp(6*FallingFactorial(-4, n - 1)/factorial(n - 1)) == \
+        (-1)**(n - 1)*n*(n + 1)*(n + 2)
+    assert combsimp(6*FallingFactorial(-4, n - 3)/factorial(n - 3)) == \
+        (-1)**(n - 3)*n*(n - 1)*(n - 2)
+    assert combsimp(6*FallingFactorial(-4, -n - 1)/factorial(-n - 1)) == \
+        -(-1)**(-n - 1)*n*(n - 1)*(n - 2)
+
+    assert combsimp(6*RisingFactorial(4, n)/factorial(n)) == \
+        (n + 1)*(n + 2)*(n + 3)
+    assert combsimp(6*RisingFactorial(4, n - 1)/factorial(n - 1)) == \
+        n*(n + 1)*(n + 2)
+    assert combsimp(6*RisingFactorial(4, n - 3)/factorial(n - 3)) == \
+        n*(n - 1)*(n - 2)
+    assert combsimp(6*RisingFactorial(4, -n - 1)/factorial(-n - 1)) == \
+        -n*(n - 1)*(n - 2)
+
+
+def test_issue_6878():
+    n = symbols('n', integer=True)
+    assert combsimp(RisingFactorial(-10, n)) == 3628800*(-1)**n/factorial(10 - n)
+
+
+def test_issue_14528():
+    p = symbols("p", integer=True, positive=True)
+    assert combsimp(binomial(1,p)) == 1/(factorial(p)*factorial(1-p))
+    assert combsimp(factorial(2-p)) == factorial(2-p)

lib/python3.12/site-packages/sympy/simplify/tests/test_cse.py

@@ -0,0 +1,758 @@
+from functools import reduce
+import itertools
+from operator import add
+
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.expr import UnevaluatedExpr
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions import Inverse, MatAdd, MatMul, Transpose
+from sympy.polys.rootoftools import CRootOf
+from sympy.series.order import O
+from sympy.simplify.cse_main import cse
+from sympy.simplify.simplify import signsimp
+from sympy.tensor.indexed import (Idx, IndexedBase)
+
+from sympy.core.function import count_ops
+from sympy.simplify.cse_opts import sub_pre, sub_post
+from sympy.functions.special.hyper import meijerg
+from sympy.simplify import cse_main, cse_opts
+from sympy.utilities.iterables import subsets
+from sympy.testing.pytest import XFAIL, raises
+from sympy.matrices import (MutableDenseMatrix, MutableSparseMatrix,
+        ImmutableDenseMatrix, ImmutableSparseMatrix)
+from sympy.matrices.expressions import MatrixSymbol
+
+
+w, x, y, z = symbols('w,x,y,z')
+x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12 = symbols('x:13')
+
+
+def test_numbered_symbols():
+    ns = cse_main.numbered_symbols(prefix='y')
+    assert list(itertools.islice(
+        ns, 0, 10)) == [Symbol('y%s' % i) for i in range(0, 10)]
+    ns = cse_main.numbered_symbols(prefix='y')
+    assert list(itertools.islice(
+        ns, 10, 20)) == [Symbol('y%s' % i) for i in range(10, 20)]
+    ns = cse_main.numbered_symbols()
+    assert list(itertools.islice(
+        ns, 0, 10)) == [Symbol('x%s' % i) for i in range(0, 10)]
+
+# Dummy "optimization" functions for testing.
+
+
+def opt1(expr):
+    return expr + y
+
+
+def opt2(expr):
+    return expr*z
+
+
+def test_preprocess_for_cse():
+    assert cse_main.preprocess_for_cse(x, [(opt1, None)]) == x + y
+    assert cse_main.preprocess_for_cse(x, [(None, opt1)]) == x
+    assert cse_main.preprocess_for_cse(x, [(None, None)]) == x
+    assert cse_main.preprocess_for_cse(x, [(opt1, opt2)]) == x + y
+    assert cse_main.preprocess_for_cse(
+        x, [(opt1, None), (opt2, None)]) == (x + y)*z
+
+
+def test_postprocess_for_cse():
+    assert cse_main.postprocess_for_cse(x, [(opt1, None)]) == x
+    assert cse_main.postprocess_for_cse(x, [(None, opt1)]) == x + y
+    assert cse_main.postprocess_for_cse(x, [(None, None)]) == x
+    assert cse_main.postprocess_for_cse(x, [(opt1, opt2)]) == x*z
+    # Note the reverse order of application.
+    assert cse_main.postprocess_for_cse(
+        x, [(None, opt1), (None, opt2)]) == x*z + y
+
+
+def test_cse_single():
+    # Simple substitution.
+    e = Add(Pow(x + y, 2), sqrt(x + y))
+    substs, reduced = cse([e])
+    assert substs == [(x0, x + y)]
+    assert reduced == [sqrt(x0) + x0**2]
+
+    subst42, (red42,) = cse([42])  # issue_15082
+    assert len(subst42) == 0 and red42 == 42
+    subst_half, (red_half,) = cse([0.5])
+    assert len(subst_half) == 0 and red_half == 0.5
+
+
+def test_cse_single2():
+    # Simple substitution, test for being able to pass the expression directly
+    e = Add(Pow(x + y, 2), sqrt(x + y))
+    substs, reduced = cse(e)
+    assert substs == [(x0, x + y)]
+    assert reduced == [sqrt(x0) + x0**2]
+    substs, reduced = cse(Matrix([[1]]))
+    assert isinstance(reduced[0], Matrix)
+
+    subst42, (red42,) = cse(42)  # issue 15082
+    assert len(subst42) == 0 and red42 == 42
+    subst_half, (red_half,) = cse(0.5)  # issue 15082
+    assert len(subst_half) == 0 and red_half == 0.5
+
+
+def test_cse_not_possible():
+    # No substitution possible.
+    e = Add(x, y)
+    substs, reduced = cse([e])
+    assert substs == []
+    assert reduced == [x + y]
+    # issue 6329
+    eq = (meijerg((1, 2), (y, 4), (5,), [], x) +
+          meijerg((1, 3), (y, 4), (5,), [], x))
+    assert cse(eq) == ([], [eq])
+
+
+def test_nested_substitution():
+    # Substitution within a substitution.
+    e = Add(Pow(w*x + y, 2), sqrt(w*x + y))
+    substs, reduced = cse([e])
+    assert substs == [(x0, w*x + y)]
+    assert reduced == [sqrt(x0) + x0**2]
+
+
+def test_subtraction_opt():
+    # Make sure subtraction is optimized.
+    e = (x - y)*(z - y) + exp((x - y)*(z - y))
+    substs, reduced = cse(
+        [e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
+    assert substs == [(x0, (x - y)*(y - z))]
+    assert reduced == [-x0 + exp(-x0)]
+    e = -(x - y)*(z - y) + exp(-(x - y)*(z - y))
+    substs, reduced = cse(
+        [e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
+    assert substs == [(x0, (x - y)*(y - z))]
+    assert reduced == [x0 + exp(x0)]
+    # issue 4077
+    n = -1 + 1/x
+    e = n/x/(-n)**2 - 1/n/x
+    assert cse(e, optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)]) == \
+        ([], [0])
+    assert cse(((w + x + y + z)*(w - y - z))/(w + x)**3) == \
+        ([(x0, w + x), (x1, y + z)], [(w - x1)*(x0 + x1)/x0**3])
+
+
+def test_multiple_expressions():
+    e1 = (x + y)*z
+    e2 = (x + y)*w
+    substs, reduced = cse([e1, e2])
+    assert substs == [(x0, x + y)]
+    assert reduced == [x0*z, x0*w]
+    l = [w*x*y + z, w*y]
+    substs, reduced = cse(l)
+    rsubsts, _ = cse(reversed(l))
+    assert substs == rsubsts
+    assert reduced == [z + x*x0, x0]
+    l = [w*x*y, w*x*y + z, w*y]
+    substs, reduced = cse(l)
+    rsubsts, _ = cse(reversed(l))
+    assert substs == rsubsts
+    assert reduced == [x1, x1 + z, x0]
+    l = [(x - z)*(y - z), x - z, y - z]
+    substs, reduced = cse(l)
+    rsubsts, _ = cse(reversed(l))
+    assert substs == [(x0, -z), (x1, x + x0), (x2, x0 + y)]
+    assert rsubsts == [(x0, -z), (x1, x0 + y), (x2, x + x0)]
+    assert reduced == [x1*x2, x1, x2]
+    l = [w*y + w + x + y + z, w*x*y]
+    assert cse(l) == ([(x0, w*y)], [w + x + x0 + y + z, x*x0])
+    assert cse([x + y, x + y + z]) == ([(x0, x + y)], [x0, z + x0])
+    assert cse([x + y, x + z]) == ([], [x + y, x + z])
+    assert cse([x*y, z + x*y, x*y*z + 3]) == \
+        ([(x0, x*y)], [x0, z + x0, 3 + x0*z])
+
+
+@XFAIL # CSE of non-commutative Mul terms is disabled
+def test_non_commutative_cse():
+    A, B, C = symbols('A B C', commutative=False)
+    l = [A*B*C, A*C]
+    assert cse(l) == ([], l)
+    l = [A*B*C, A*B]
+    assert cse(l) == ([(x0, A*B)], [x0*C, x0])
+
+
+# Test if CSE of non-commutative Mul terms is disabled
+def test_bypass_non_commutatives():
+    A, B, C = symbols('A B C', commutative=False)
+    l = [A*B*C, A*C]
+    assert cse(l) == ([], l)
+    l = [A*B*C, A*B]
+    assert cse(l) == ([], l)
+    l = [B*C, A*B*C]
+    assert cse(l) == ([], l)
+
+
+@XFAIL # CSE fails when replacing non-commutative sub-expressions
+def test_non_commutative_order():
+    A, B, C = symbols('A B C', commutative=False)
+    x0 = symbols('x0', commutative=False)
+    l = [B+C, A*(B+C)]
+    assert cse(l) == ([(x0, B+C)], [x0, A*x0])
+
+
+@XFAIL # Worked in gh-11232, but was reverted due to performance considerations
+def test_issue_10228():
+    assert cse([x*y**2 + x*y]) == ([(x0, x*y)], [x0*y + x0])
+    assert cse([x + y, 2*x + y]) == ([(x0, x + y)], [x0, x + x0])
+    assert cse((w + 2*x + y + z, w + x + 1)) == (
+        [(x0, w + x)], [x0 + x + y + z, x0 + 1])
+    assert cse(((w + x + y + z)*(w - x))/(w + x)) == (
+        [(x0, w + x)], [(x0 + y + z)*(w - x)/x0])
+    a, b, c, d, f, g, j, m = symbols('a, b, c, d, f, g, j, m')
+    exprs = (d*g**2*j*m, 4*a*f*g*m, a*b*c*f**2)
+    assert cse(exprs) == (
+        [(x0, g*m), (x1, a*f)], [d*g*j*x0, 4*x0*x1, b*c*f*x1]
+)
+
+@XFAIL
+def test_powers():
+    assert cse(x*y**2 + x*y) == ([(x0, x*y)], [x0*y + x0])
+
+
+def test_issue_4498():
+    assert cse(w/(x - y) + z/(y - x), optimizations='basic') == \
+        ([], [(w - z)/(x - y)])
+
+
+def test_issue_4020():
+    assert cse(x**5 + x**4 + x**3 + x**2, optimizations='basic') \
+        == ([(x0, x**2)], [x0*(x**3 + x + x0 + 1)])
+
+
+def test_issue_4203():
+    assert cse(sin(x**x)/x**x) == ([(x0, x**x)], [sin(x0)/x0])
+
+
+def test_issue_6263():
+    e = Eq(x*(-x + 1) + x*(x - 1), 0)
+    assert cse(e, optimizations='basic') == ([], [True])
+
+
+def test_issue_25043():
+    c = symbols("c")
+    x = symbols("x0", real=True)
+    cse_expr = cse(c*x**2 + c*(x**4 - x**2))[-1][-1]
+    free = cse_expr.free_symbols
+    assert len(free) == len({i.name for i in free})
+
+
+def test_dont_cse_tuples():
+    from sympy.core.function import Subs
+    f = Function("f")
+    g = Function("g")
+
+    name_val, (expr,) = cse(
+        Subs(f(x, y), (x, y), (0, 1))
+        + Subs(g(x, y), (x, y), (0, 1)))
+
+    assert name_val == []
+    assert expr == (Subs(f(x, y), (x, y), (0, 1))
+            + Subs(g(x, y), (x, y), (0, 1)))
+
+    name_val, (expr,) = cse(
+        Subs(f(x, y), (x, y), (0, x + y))
+        + Subs(g(x, y), (x, y), (0, x + y)))
+
+    assert name_val == [(x0, x + y)]
+    assert expr == Subs(f(x, y), (x, y), (0, x0)) + \
+        Subs(g(x, y), (x, y), (0, x0))
+
+
+def test_pow_invpow():
+    assert cse(1/x**2 + x**2) == \
+        ([(x0, x**2)], [x0 + 1/x0])
+    assert cse(x**2 + (1 + 1/x**2)/x**2) == \
+        ([(x0, x**2), (x1, 1/x0)], [x0 + x1*(x1 + 1)])
+    assert cse(1/x**2 + (1 + 1/x**2)*x**2) == \
+        ([(x0, x**2), (x1, 1/x0)], [x0*(x1 + 1) + x1])
+    assert cse(cos(1/x**2) + sin(1/x**2)) == \
+        ([(x0, x**(-2))], [sin(x0) + cos(x0)])
+    assert cse(cos(x**2) + sin(x**2)) == \
+        ([(x0, x**2)], [sin(x0) + cos(x0)])
+    assert cse(y/(2 + x**2) + z/x**2/y) == \
+        ([(x0, x**2)], [y/(x0 + 2) + z/(x0*y)])
+    assert cse(exp(x**2) + x**2*cos(1/x**2)) == \
+        ([(x0, x**2)], [x0*cos(1/x0) + exp(x0)])
+    assert cse((1 + 1/x**2)/x**2) == \
+        ([(x0, x**(-2))], [x0*(x0 + 1)])
+    assert cse(x**(2*y) + x**(-2*y)) == \
+        ([(x0, x**(2*y))], [x0 + 1/x0])
+
+
+def test_postprocess():
+    eq = (x + 1 + exp((x + 1)/(y + 1)) + cos(y + 1))
+    assert cse([eq, Eq(x, z + 1), z - 2, (z + 1)*(x + 1)],
+        postprocess=cse_main.cse_separate) == \
+        [[(x0, y + 1), (x2, z + 1), (x, x2), (x1, x + 1)],
+        [x1 + exp(x1/x0) + cos(x0), z - 2, x1*x2]]
+
+
+def test_issue_4499():
+    # previously, this gave 16 constants
+    from sympy.abc import a, b
+    B = Function('B')
+    G = Function('G')
+    t = Tuple(*
+        (a, a + S.Half, 2*a, b, 2*a - b + 1, (sqrt(z)/2)**(-2*a + 1)*B(2*a -
+        b, sqrt(z))*B(b - 1, sqrt(z))*G(b)*G(2*a - b + 1),
+        sqrt(z)*(sqrt(z)/2)**(-2*a + 1)*B(b, sqrt(z))*B(2*a - b,
+        sqrt(z))*G(b)*G(2*a - b + 1), sqrt(z)*(sqrt(z)/2)**(-2*a + 1)*B(b - 1,
+        sqrt(z))*B(2*a - b + 1, sqrt(z))*G(b)*G(2*a - b + 1),
+        (sqrt(z)/2)**(-2*a + 1)*B(b, sqrt(z))*B(2*a - b + 1,
+        sqrt(z))*G(b)*G(2*a - b + 1), 1, 0, S.Half, z/2, -b + 1, -2*a + b,
+        -2*a))
+    c = cse(t)
+    ans = (
+        [(x0, 2*a), (x1, -b + x0), (x2, x1 + 1), (x3, b - 1), (x4, sqrt(z)),
+         (x5, B(x3, x4)), (x6, (x4/2)**(1 - x0)*G(b)*G(x2)), (x7, x6*B(x1, x4)),
+         (x8, B(b, x4)), (x9, x6*B(x2, x4))],
+        [(a, a + S.Half, x0, b, x2, x5*x7, x4*x7*x8, x4*x5*x9, x8*x9,
+          1, 0, S.Half, z/2, -x3, -x1, -x0)])
+    assert ans == c
+
+
+def test_issue_6169():
+    r = CRootOf(x**6 - 4*x**5 - 2, 1)
+    assert cse(r) == ([], [r])
+    # and a check that the right thing is done with the new
+    # mechanism
+    assert sub_post(sub_pre((-x - y)*z - x - y)) == -z*(x + y) - x - y
+
+
+def test_cse_Indexed():
+    len_y = 5
+    y = IndexedBase('y', shape=(len_y,))
+    x = IndexedBase('x', shape=(len_y,))
+    i = Idx('i', len_y-1)
+
+    expr1 = (y[i+1]-y[i])/(x[i+1]-x[i])
+    expr2 = 1/(x[i+1]-x[i])
+    replacements, reduced_exprs = cse([expr1, expr2])
+    assert len(replacements) > 0
+
+
+def test_cse_MatrixSymbol():
+    # MatrixSymbols have non-Basic args, so make sure that works
+    A = MatrixSymbol("A", 3, 3)
+    assert cse(A) == ([], [A])
+
+    n = symbols('n', integer=True)
+    B = MatrixSymbol("B", n, n)
+    assert cse(B) == ([], [B])
+
+    assert cse(A[0] * A[0]) == ([], [A[0]*A[0]])
+
+    assert cse(A[0,0]*A[0,1] + A[0,0]*A[0,1]*A[0,2]) == ([(x0, A[0, 0]*A[0, 1])], [x0*A[0, 2] + x0])
+
+def test_cse_MatrixExpr():
+    A = MatrixSymbol('A', 3, 3)
+    y = MatrixSymbol('y', 3, 1)
+
+    expr1 = (A.T*A).I * A * y
+    expr2 = (A.T*A) * A * y
+    replacements, reduced_exprs = cse([expr1, expr2])
+    assert len(replacements) > 0
+
+    replacements, reduced_exprs = cse([expr1 + expr2, expr1])
+    assert replacements
+
+    replacements, reduced_exprs = cse([A**2, A + A**2])
+    assert replacements
+
+
+def test_Piecewise():
+    f = Piecewise((-z + x*y, Eq(y, 0)), (-z - x*y, True))
+    ans = cse(f)
+    actual_ans = ([(x0, x*y)],
+        [Piecewise((x0 - z, Eq(y, 0)), (-z - x0, True))])
+    assert ans == actual_ans
+
+
+def test_ignore_order_terms():
+    eq = exp(x).series(x,0,3) + sin(y+x**3) - 1
+    assert cse(eq) == ([], [sin(x**3 + y) + x + x**2/2 + O(x**3)])
+
+
+def test_name_conflict():
+    z1 = x0 + y
+    z2 = x2 + x3
+    l = [cos(z1) + z1, cos(z2) + z2, x0 + x2]
+    substs, reduced = cse(l)
+    assert [e.subs(reversed(substs)) for e in reduced] == l
+
+
+def test_name_conflict_cust_symbols():
+    z1 = x0 + y
+    z2 = x2 + x3
+    l = [cos(z1) + z1, cos(z2) + z2, x0 + x2]
+    substs, reduced = cse(l, symbols("x:10"))
+    assert [e.subs(reversed(substs)) for e in reduced] == l
+
+
+def test_symbols_exhausted_error():
+    l = cos(x+y)+x+y+cos(w+y)+sin(w+y)
+    sym = [x, y, z]
+    with raises(ValueError):
+        cse(l, symbols=sym)
+
+
+def test_issue_7840():
+    # daveknippers' example
+    C393 = sympify( \
+        'Piecewise((C391 - 1.65, C390 < 0.5), (Piecewise((C391 - 1.65, \
+        C391 > 2.35), (C392, True)), True))'
+    )
+    C391 = sympify( \
+        'Piecewise((2.05*C390**(-1.03), C390 < 0.5), (2.5*C390**(-0.625), True))'
+    )
+    C393 = C393.subs('C391',C391)
+    # simple substitution
+    sub = {}
+    sub['C390'] = 0.703451854
+    sub['C392'] = 1.01417794
+    ss_answer = C393.subs(sub)
+    # cse
+    substitutions,new_eqn = cse(C393)
+    for pair in substitutions:
+        sub[pair[0].name] = pair[1].subs(sub)
+    cse_answer = new_eqn[0].subs(sub)
+    # both methods should be the same
+    assert ss_answer == cse_answer
+
+    # GitRay's example
+    expr = sympify(
+        "Piecewise((Symbol('ON'), Equality(Symbol('mode'), Symbol('ON'))), \
+        (Piecewise((Piecewise((Symbol('OFF'), StrictLessThan(Symbol('x'), \
+        Symbol('threshold'))), (Symbol('ON'), true)), Equality(Symbol('mode'), \
+        Symbol('AUTO'))), (Symbol('OFF'), true)), true))"
+    )
+    substitutions, new_eqn = cse(expr)
+    # this Piecewise should be exactly the same
+    assert new_eqn[0] == expr
+    # there should not be any replacements
+    assert len(substitutions) < 1
+
+
+def test_issue_8891():
+    for cls in (MutableDenseMatrix, MutableSparseMatrix,
+            ImmutableDenseMatrix, ImmutableSparseMatrix):
+        m = cls(2, 2, [x + y, 0, 0, 0])
+        res = cse([x + y, m])
+        ans = ([(x0, x + y)], [x0, cls([[x0, 0], [0, 0]])])
+        assert res == ans
+        assert isinstance(res[1][-1], cls)
+
+
+def test_issue_11230():
+    # a specific test that always failed
+    a, b, f, k, l, i = symbols('a b f k l i')
+    p = [a*b*f*k*l, a*i*k**2*l, f*i*k**2*l]
+    R, C = cse(p)
+    assert not any(i.is_Mul for a in C for i in a.args)
+
+    # random tests for the issue
+    from sympy.core.random import choice
+    from sympy.core.function import expand_mul
+    s = symbols('a:m')
+    # 35 Mul tests, none of which should ever fail
+    ex = [Mul(*[choice(s) for i in range(5)]) for i in range(7)]
+    for p in subsets(ex, 3):
+        p = list(p)
+        R, C = cse(p)
+        assert not any(i.is_Mul for a in C for i in a.args)
+        for ri in reversed(R):
+            for i in range(len(C)):
+                C[i] = C[i].subs(*ri)
+        assert p == C
+    # 35 Add tests, none of which should ever fail
+    ex = [Add(*[choice(s[:7]) for i in range(5)]) for i in range(7)]
+    for p in subsets(ex, 3):
+        p = list(p)
+        R, C = cse(p)
+        assert not any(i.is_Add for a in C for i in a.args)
+        for ri in reversed(R):
+            for i in range(len(C)):
+                C[i] = C[i].subs(*ri)
+        # use expand_mul to handle cases like this:
+        # p = [a + 2*b + 2*e, 2*b + c + 2*e, b + 2*c + 2*g]
+        # x0 = 2*(b + e) is identified giving a rebuilt p that
+        # is now `[a + 2*(b + e), c + 2*(b + e), b + 2*c + 2*g]`
+        assert p == [expand_mul(i) for i in C]
+
+
+@XFAIL
+def test_issue_11577():
+    def check(eq):
+        r, c = cse(eq)
+        assert eq.count_ops() >= \
+            len(r) + sum(i[1].count_ops() for i in r) + \
+            count_ops(c)
+
+    eq = x**5*y**2 + x**5*y + x**5
+    assert cse(eq) == (
+        [(x0, x**4), (x1, x*y)], [x**5 + x0*x1*y + x0*x1])
+        # ([(x0, x**5*y)], [x0*y + x0 + x**5]) or
+        # ([(x0, x**5)], [x0*y**2 + x0*y + x0])
+    check(eq)
+
+    eq = x**2/(y + 1)**2 + x/(y + 1)
+    assert cse(eq) == (
+        [(x0, y + 1)], [x**2/x0**2 + x/x0])
+        # ([(x0, x/(y + 1))], [x0**2 + x0])
+    check(eq)
+
+
+def test_hollow_rejection():
+    eq = [x + 3, x + 4]
+    assert cse(eq) == ([], eq)
+
+
+def test_cse_ignore():
+    exprs = [exp(y)*(3*y + 3*sqrt(x+1)), exp(y)*(5*y + 5*sqrt(x+1))]
+    subst1, red1 = cse(exprs)
+    assert any(y in sub.free_symbols for _, sub in subst1), "cse failed to identify any term with y"
+
+    subst2, red2 = cse(exprs, ignore=(y,))  # y is not allowed in substitutions
+    assert not any(y in sub.free_symbols for _, sub in subst2), "Sub-expressions containing y must be ignored"
+    assert any(sub - sqrt(x + 1) == 0 for _, sub in subst2), "cse failed to identify sqrt(x + 1) as sub-expression"
+
+def test_cse_ignore_issue_15002():
+    l = [
+        w*exp(x)*exp(-z),
+        exp(y)*exp(x)*exp(-z)
+    ]
+    substs, reduced = cse(l, ignore=(x,))
+    rl = [e.subs(reversed(substs)) for e in reduced]
+    assert rl == l
+
+
+def test_cse_unevaluated():
+    xp1 = UnevaluatedExpr(x + 1)
+    # This used to cause RecursionError
+    [(x0, ue)], [red] = cse([(-1 - xp1) / (1 - xp1)])
+    if ue == xp1:
+        assert red == (-1 - x0) / (1 - x0)
+    elif ue == -xp1:
+        assert red == (-1 + x0) / (1 + x0)
+    else:
+        msg = f'Expected common subexpression {xp1} or {-xp1}, instead got {ue}'
+        assert False, msg
+
+
+def test_cse__performance():
+    nexprs, nterms = 3, 20
+    x = symbols('x:%d' % nterms)
+    exprs = [
+        reduce(add, [x[j]*(-1)**(i+j) for j in range(nterms)])
+        for i in range(nexprs)
+    ]
+    assert (exprs[0] + exprs[1]).simplify() == 0
+    subst, red = cse(exprs)
+    assert len(subst) > 0, "exprs[0] == -exprs[2], i.e. a CSE"
+    for i, e in enumerate(red):
+        assert (e.subs(reversed(subst)) - exprs[i]).simplify() == 0
+
+
+def test_issue_12070():
+    exprs = [x + y, 2 + x + y, x + y + z, 3 + x + y + z]
+    subst, red = cse(exprs)
+    assert 6 >= (len(subst) + sum(v.count_ops() for k, v in subst) +
+                 count_ops(red))
+
+
+def test_issue_13000():
+    eq = x/(-4*x**2 + y**2)
+    cse_eq = cse(eq)[1][0]
+    assert cse_eq == eq
+
+
+def test_issue_18203():
+    eq = CRootOf(x**5 + 11*x - 2, 0) + CRootOf(x**5 + 11*x - 2, 1)
+    assert cse(eq) == ([], [eq])
+
+
+def test_unevaluated_mul():
+    eq = Mul(x + y, x + y, evaluate=False)
+    assert cse(eq) == ([(x0, x + y)], [x0**2])
+
+def test_cse_release_variables():
+    from sympy.simplify.cse_main import cse_release_variables
+    _0, _1, _2, _3, _4 = symbols('_:5')
+    eqs = [(x + y - 1)**2, x,
+        x + y, (x + y)/(2*x + 1) + (x + y - 1)**2,
+        (2*x + 1)**(x + y)]
+    r, e = cse(eqs, postprocess=cse_release_variables)
+    # this can change in keeping with the intention of the function
+    assert r, e == ([
+    (x0, x + y), (x1, (x0 - 1)**2), (x2, 2*x + 1),
+    (_3, x0/x2 + x1), (_4, x2**x0), (x2, None), (_0, x1),
+    (x1, None), (_2, x0), (x0, None), (_1, x)], (_0, _1, _2, _3, _4))
+    r.reverse()
+    r = [(s, v) for s, v in r if v is not None]
+    assert eqs == [i.subs(r) for i in e]
+
+def test_cse_list():
+    _cse = lambda x: cse(x, list=False)
+    assert _cse(x) == ([], x)
+    assert _cse('x') == ([], 'x')
+    it = [x]
+    for c in (list, tuple, set):
+        assert _cse(c(it)) == ([], c(it))
+    #Tuple works different from tuple:
+    assert _cse(Tuple(*it)) == ([], Tuple(*it))
+    d = {x: 1}
+    assert _cse(d) == ([], d)
+
+def test_issue_18991():
+    A = MatrixSymbol('A', 2, 2)
+    assert signsimp(-A * A - A) == -A * A - A
+
+
+def test_unevaluated_Mul():
+    m = [Mul(1, 2, evaluate=False)]
+    assert cse(m) == ([], m)
+
+
+def test_cse_matrix_expression_inverse():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = Inverse(A)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [Inverse(A)])
+
+
+def test_cse_matrix_expression_matmul_inverse():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    b = ImmutableDenseMatrix(symbols('b:2'))
+    x = MatMul(Inverse(A), b)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_negate_matrix():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = MatMul(S.NegativeOne, A)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_negate_matmul_not_extracted():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    B = ImmutableDenseMatrix(symbols('B:4')).reshape(2, 2)
+    x = MatMul(S.NegativeOne, A, B)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [x])
+
+
+@XFAIL  # No simplification rule for nested associative operations
+def test_cse_matrix_nested_matmul_collapsed():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    B = ImmutableDenseMatrix(symbols('B:4')).reshape(2, 2)
+    x = MatMul(S.NegativeOne, MatMul(A, B))
+    cse_expr = cse(x)
+    assert cse_expr == ([], [MatMul(S.NegativeOne, A, B)])
+
+
+def test_cse_matrix_optimize_out_single_argument_mul():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = MatMul(MatMul(MatMul(A)))
+    cse_expr = cse(x)
+    assert cse_expr == ([], [A])
+
+
+@XFAIL  # Multiple simplification passed not supported in CSE
+def test_cse_matrix_optimize_out_single_argument_mul_combined():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = MatAdd(MatMul(MatMul(MatMul(A))), MatMul(MatMul(A)), MatMul(A), A)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [MatMul(4, A)])
+
+
+def test_cse_matrix_optimize_out_single_argument_add():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = MatAdd(MatAdd(MatAdd(MatAdd(A))))
+    cse_expr = cse(x)
+    assert cse_expr == ([], [A])
+
+
+@XFAIL  # Multiple simplification passed not supported in CSE
+def test_cse_matrix_optimize_out_single_argument_add_combined():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = MatMul(MatAdd(MatAdd(MatAdd(A))), MatAdd(MatAdd(A)), MatAdd(A), A)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [MatMul(4, A)])
+
+
+def test_cse_matrix_expression_matrix_solve():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    b = ImmutableDenseMatrix(symbols('b:2'))
+    x = MatrixSolve(A, b)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_matrix_expression():
+    X = ImmutableDenseMatrix(symbols('X:4')).reshape(2, 2)
+    y = ImmutableDenseMatrix(symbols('y:2'))
+    b = MatMul(Inverse(MatMul(Transpose(X), X)), Transpose(X), y)
+    cse_expr = cse(b)
+    x0 = MatrixSymbol('x0', 2, 2)
+    reduced_expr_expected = MatMul(Inverse(MatMul(x0, X)), x0, y)
+    assert cse_expr == ([(x0, Transpose(X))], [reduced_expr_expected])
+
+
+def test_cse_matrix_kalman_filter():
+    """Kalman Filter example from Matthew Rocklin's SciPy 2013 talk.
+
+    Talk titled: "Matrix Expressions and BLAS/LAPACK; SciPy 2013 Presentation"
+
+    Video: https://pyvideo.org/scipy-2013/matrix-expressions-and-blaslapack-scipy-2013-pr.html
+
+    Notes
+    =====
+
+    Equations are:
+
+    new_mu = mu + Sigma*H.T * (R + H*Sigma*H.T).I * (H*mu - data)
+           = MatAdd(mu, MatMul(Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data))))
+    new_Sigma = Sigma - Sigma*H.T * (R + H*Sigma*H.T).I * H * Sigma
+              = MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, Transpose(H)), Inverse(MatAdd(R, MatMul(H*Sigma*Transpose(H)))), H, Sigma))
+
+    """
+    N = 2
+    mu = ImmutableDenseMatrix(symbols(f'mu:{N}'))
+    Sigma = ImmutableDenseMatrix(symbols(f'Sigma:{N * N}')).reshape(N, N)
+    H = ImmutableDenseMatrix(symbols(f'H:{N * N}')).reshape(N, N)
+    R = ImmutableDenseMatrix(symbols(f'R:{N * N}')).reshape(N, N)
+    data = ImmutableDenseMatrix(symbols(f'data:{N}'))
+    new_mu = MatAdd(mu, MatMul(Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data))))
+    new_Sigma = MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), H, Sigma))
+    cse_expr = cse([new_mu, new_Sigma])
+    x0 = MatrixSymbol('x0', N, N)
+    x1 = MatrixSymbol('x1', N, N)
+    replacements_expected = [
+        (x0, Transpose(H)),
+        (x1, Inverse(MatAdd(R, MatMul(H, Sigma, x0)))),
+    ]
+    reduced_exprs_expected = [
+        MatAdd(mu, MatMul(Sigma, x0, x1, MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data)))),
+        MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, x0, x1, H, Sigma)),
+    ]
+    assert cse_expr == (replacements_expected, reduced_exprs_expected)

lib/python3.12/site-packages/sympy/simplify/tests/test_epathtools.py

@@ -0,0 +1,90 @@
+"""Tests for tools for manipulation of expressions using paths. """
+
+from sympy.simplify.epathtools import epath, EPath
+from sympy.testing.pytest import raises
+
+from sympy.core.numbers import E
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.abc import x, y, z, t
+
+
+def test_epath_select():
+    expr = [((x, 1, t), 2), ((3, y, 4), z)]
+
+    assert epath("/*", expr) == [((x, 1, t), 2), ((3, y, 4), z)]
+    assert epath("/*/*", expr) == [(x, 1, t), 2, (3, y, 4), z]
+    assert epath("/*/*/*", expr) == [x, 1, t, 3, y, 4]
+    assert epath("/*/*/*/*", expr) == []
+
+    assert epath("/[:]", expr) == [((x, 1, t), 2), ((3, y, 4), z)]
+    assert epath("/[:]/[:]", expr) == [(x, 1, t), 2, (3, y, 4), z]
+    assert epath("/[:]/[:]/[:]", expr) == [x, 1, t, 3, y, 4]
+    assert epath("/[:]/[:]/[:]/[:]", expr) == []
+
+    assert epath("/*/[:]", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+    assert epath("/*/[0]", expr) == [(x, 1, t), (3, y, 4)]
+    assert epath("/*/[1]", expr) == [2, z]
+    assert epath("/*/[2]", expr) == []
+
+    assert epath("/*/int", expr) == [2]
+    assert epath("/*/Symbol", expr) == [z]
+    assert epath("/*/tuple", expr) == [(x, 1, t), (3, y, 4)]
+    assert epath("/*/__iter__?", expr) == [(x, 1, t), (3, y, 4)]
+
+    assert epath("/*/int|tuple", expr) == [(x, 1, t), 2, (3, y, 4)]
+    assert epath("/*/Symbol|tuple", expr) == [(x, 1, t), (3, y, 4), z]
+    assert epath("/*/int|Symbol|tuple", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+    assert epath("/*/int|__iter__?", expr) == [(x, 1, t), 2, (3, y, 4)]
+    assert epath("/*/Symbol|__iter__?", expr) == [(x, 1, t), (3, y, 4), z]
+    assert epath(
+        "/*/int|Symbol|__iter__?", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+    assert epath("/*/[0]/int", expr) == [1, 3, 4]
+    assert epath("/*/[0]/Symbol", expr) == [x, t, y]
+
+    assert epath("/*/[0]/int[1:]", expr) == [1, 4]
+    assert epath("/*/[0]/Symbol[1:]", expr) == [t, y]
+
+    assert epath("/Symbol", x + y + z + 1) == [x, y, z]
+    assert epath("/*/*/Symbol", t + sin(x + 1) + cos(x + y + E)) == [x, x, y]
+
+
+def test_epath_apply():
+    expr = [((x, 1, t), 2), ((3, y, 4), z)]
+    func = lambda expr: expr**2
+
+    assert epath("/*", expr, list) == [[(x, 1, t), 2], [(3, y, 4), z]]
+
+    assert epath("/*/[0]", expr, list) == [([x, 1, t], 2), ([3, y, 4], z)]
+    assert epath("/*/[1]", expr, func) == [((x, 1, t), 4), ((3, y, 4), z**2)]
+    assert epath("/*/[2]", expr, list) == expr
+
+    assert epath("/*/[0]/int", expr, func) == [((x, 1, t), 2), ((9, y, 16), z)]
+    assert epath("/*/[0]/Symbol", expr, func) == [((x**2, 1, t**2), 2),
+                 ((3, y**2, 4), z)]
+    assert epath(
+        "/*/[0]/int[1:]", expr, func) == [((x, 1, t), 2), ((3, y, 16), z)]
+    assert epath("/*/[0]/Symbol[1:]", expr, func) == [((x, 1, t**2),
+                 2), ((3, y**2, 4), z)]
+
+    assert epath("/Symbol", x + y + z + 1, func) == x**2 + y**2 + z**2 + 1
+    assert epath("/*/*/Symbol", t + sin(x + 1) + cos(x + y + E), func) == \
+        t + sin(x**2 + 1) + cos(x**2 + y**2 + E)
+
+
+def test_EPath():
+    assert EPath("/*/[0]")._path == "/*/[0]"
+    assert EPath(EPath("/*/[0]"))._path == "/*/[0]"
+    assert isinstance(epath("/*/[0]"), EPath) is True
+
+    assert repr(EPath("/*/[0]")) == "EPath('/*/[0]')"
+
+    raises(ValueError, lambda: EPath(""))
+    raises(ValueError, lambda: EPath("/"))
+    raises(ValueError, lambda: EPath("/|x"))
+    raises(ValueError, lambda: EPath("/["))
+    raises(ValueError, lambda: EPath("/[0]%"))
+
+    raises(NotImplementedError, lambda: EPath("Symbol"))

lib/python3.12/site-packages/sympy/simplify/tests/test_fu.py

@@ -0,0 +1,492 @@
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.parameters import evaluate
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.hyperbolic import (cosh, coth, csch, sech, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, cot, csc, sec, sin, tan)
+from sympy.simplify.powsimp import powsimp
+from sympy.simplify.fu import (
+    L, TR1, TR10, TR10i, TR11, _TR11, TR12, TR12i, TR13, TR14, TR15, TR16,
+    TR111, TR2, TR2i, TR3, TR4, TR5, TR6, TR7, TR8, TR9, TRmorrie, _TR56 as T,
+    TRpower, hyper_as_trig, fu, process_common_addends, trig_split,
+    as_f_sign_1)
+from sympy.core.random import verify_numerically
+from sympy.abc import a, b, c, x, y, z
+
+
+def test_TR1():
+    assert TR1(2*csc(x) + sec(x)) == 1/cos(x) + 2/sin(x)
+
+
+def test_TR2():
+    assert TR2(tan(x)) == sin(x)/cos(x)
+    assert TR2(cot(x)) == cos(x)/sin(x)
+    assert TR2(tan(tan(x) - sin(x)/cos(x))) == 0
+
+
+def test_TR2i():
+    # just a reminder that ratios of powers only simplify if both
+    # numerator and denominator satisfy the condition that each
+    # has a positive base or an integer exponent; e.g. the following,
+    # at y=-1, x=1/2 gives sqrt(2)*I != -sqrt(2)*I
+    assert powsimp(2**x/y**x) != (2/y)**x
+
+    assert TR2i(sin(x)/cos(x)) == tan(x)
+    assert TR2i(sin(x)*sin(y)/cos(x)) == tan(x)*sin(y)
+    assert TR2i(1/(sin(x)/cos(x))) == 1/tan(x)
+    assert TR2i(1/(sin(x)*sin(y)/cos(x))) == 1/tan(x)/sin(y)
+    assert TR2i(sin(x)/2/(cos(x) + 1)) == sin(x)/(cos(x) + 1)/2
+
+    assert TR2i(sin(x)/2/(cos(x) + 1), half=True) == tan(x/2)/2
+    assert TR2i(sin(1)/(cos(1) + 1), half=True) == tan(S.Half)
+    assert TR2i(sin(2)/(cos(2) + 1), half=True) == tan(1)
+    assert TR2i(sin(4)/(cos(4) + 1), half=True) == tan(2)
+    assert TR2i(sin(5)/(cos(5) + 1), half=True) == tan(5*S.Half)
+    assert TR2i((cos(1) + 1)/sin(1), half=True) == 1/tan(S.Half)
+    assert TR2i((cos(2) + 1)/sin(2), half=True) == 1/tan(1)
+    assert TR2i((cos(4) + 1)/sin(4), half=True) == 1/tan(2)
+    assert TR2i((cos(5) + 1)/sin(5), half=True) == 1/tan(5*S.Half)
+    assert TR2i((cos(1) + 1)**(-a)*sin(1)**a, half=True) == tan(S.Half)**a
+    assert TR2i((cos(2) + 1)**(-a)*sin(2)**a, half=True) == tan(1)**a
+    assert TR2i((cos(4) + 1)**(-a)*sin(4)**a, half=True) == (cos(4) + 1)**(-a)*sin(4)**a
+    assert TR2i((cos(5) + 1)**(-a)*sin(5)**a, half=True) == (cos(5) + 1)**(-a)*sin(5)**a
+    assert TR2i((cos(1) + 1)**a*sin(1)**(-a), half=True) == tan(S.Half)**(-a)
+    assert TR2i((cos(2) + 1)**a*sin(2)**(-a), half=True) == tan(1)**(-a)
+    assert TR2i((cos(4) + 1)**a*sin(4)**(-a), half=True) == (cos(4) + 1)**a*sin(4)**(-a)
+    assert TR2i((cos(5) + 1)**a*sin(5)**(-a), half=True) == (cos(5) + 1)**a*sin(5)**(-a)
+
+    i = symbols('i', integer=True)
+    assert TR2i(((cos(5) + 1)**i*sin(5)**(-i)), half=True) == tan(5*S.Half)**(-i)
+    assert TR2i(1/((cos(5) + 1)**i*sin(5)**(-i)), half=True) == tan(5*S.Half)**i
+
+
+def test_TR3():
+    assert TR3(cos(y - x*(y - x))) == cos(x*(x - y) + y)
+    assert cos(pi/2 + x) == -sin(x)
+    assert cos(30*pi/2 + x) == -cos(x)
+
+    for f in (cos, sin, tan, cot, csc, sec):
+        i = f(pi*Rational(3, 7))
+        j = TR3(i)
+        assert verify_numerically(i, j) and i.func != j.func
+
+    with evaluate(False):
+        eq = cos(9*pi/22)
+    assert eq.has(9*pi) and TR3(eq) == sin(pi/11)
+
+
+def test_TR4():
+    for i in [0, pi/6, pi/4, pi/3, pi/2]:
+        with evaluate(False):
+            eq = cos(i)
+        assert isinstance(eq, cos) and TR4(eq) == cos(i)
+
+
+def test__TR56():
+    h = lambda x: 1 - x
+    assert T(sin(x)**3, sin, cos, h, 4, False) == sin(x)*(-cos(x)**2 + 1)
+    assert T(sin(x)**10, sin, cos, h, 4, False) == sin(x)**10
+    assert T(sin(x)**6, sin, cos, h, 6, False) == (-cos(x)**2 + 1)**3
+    assert T(sin(x)**6, sin, cos, h, 6, True) == sin(x)**6
+    assert T(sin(x)**8, sin, cos, h, 10, True) == (-cos(x)**2 + 1)**4
+
+    # issue 17137
+    assert T(sin(x)**I, sin, cos, h, 4, True) == sin(x)**I
+    assert T(sin(x)**(2*I + 1), sin, cos, h, 4, True) == sin(x)**(2*I + 1)
+
+
+def test_TR5():
+    assert TR5(sin(x)**2) == -cos(x)**2 + 1
+    assert TR5(sin(x)**-2) == sin(x)**(-2)
+    assert TR5(sin(x)**4) == (-cos(x)**2 + 1)**2
+
+
+def test_TR6():
+    assert TR6(cos(x)**2) == -sin(x)**2 + 1
+    assert TR6(cos(x)**-2) == cos(x)**(-2)
+    assert TR6(cos(x)**4) == (-sin(x)**2 + 1)**2
+
+
+def test_TR7():
+    assert TR7(cos(x)**2) == cos(2*x)/2 + S.Half
+    assert TR7(cos(x)**2 + 1) == cos(2*x)/2 + Rational(3, 2)
+
+
+def test_TR8():
+    assert TR8(cos(2)*cos(3)) == cos(5)/2 + cos(1)/2
+    assert TR8(cos(2)*sin(3)) == sin(5)/2 + sin(1)/2
+    assert TR8(sin(2)*sin(3)) == -cos(5)/2 + cos(1)/2
+    assert TR8(sin(1)*sin(2)*sin(3)) == sin(4)/4 - sin(6)/4 + sin(2)/4
+    assert TR8(cos(2)*cos(3)*cos(4)*cos(5)) == \
+        cos(4)/4 + cos(10)/8 + cos(2)/8 + cos(8)/8 + cos(14)/8 + \
+        cos(6)/8 + Rational(1, 8)
+    assert TR8(cos(2)*cos(3)*cos(4)*cos(5)*cos(6)) == \
+        cos(10)/8 + cos(4)/8 + 3*cos(2)/16 + cos(16)/16 + cos(8)/8 + \
+        cos(14)/16 + cos(20)/16 + cos(12)/16 + Rational(1, 16) + cos(6)/8
+    assert TR8(sin(pi*Rational(3, 7))**2*cos(pi*Rational(3, 7))**2/(16*sin(pi/7)**2)) == Rational(1, 64)
+
+def test_TR9():
+    a = S.Half
+    b = 3*a
+    assert TR9(a) == a
+    assert TR9(cos(1) + cos(2)) == 2*cos(a)*cos(b)
+    assert TR9(cos(1) - cos(2)) == 2*sin(a)*sin(b)
+    assert TR9(sin(1) - sin(2)) == -2*sin(a)*cos(b)
+    assert TR9(sin(1) + sin(2)) == 2*sin(b)*cos(a)
+    assert TR9(cos(1) + 2*sin(1) + 2*sin(2)) == cos(1) + 4*sin(b)*cos(a)
+    assert TR9(cos(4) + cos(2) + 2*cos(1)*cos(3)) == 4*cos(1)*cos(3)
+    assert TR9((cos(4) + cos(2))/cos(3)/2 + cos(3)) == 2*cos(1)*cos(2)
+    assert TR9(cos(3) + cos(4) + cos(5) + cos(6)) == \
+        4*cos(S.Half)*cos(1)*cos(Rational(9, 2))
+    assert TR9(cos(3) + cos(3)*cos(2)) == cos(3) + cos(2)*cos(3)
+    assert TR9(-cos(y) + cos(x*y)) == -2*sin(x*y/2 - y/2)*sin(x*y/2 + y/2)
+    assert TR9(-sin(y) + sin(x*y)) == 2*sin(x*y/2 - y/2)*cos(x*y/2 + y/2)
+    c = cos(x)
+    s = sin(x)
+    for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
+        for a in ((c, s), (s, c), (cos(x), cos(x*y)), (sin(x), sin(x*y))):
+            args = zip(si, a)
+            ex = Add(*[Mul(*ai) for ai in args])
+            t = TR9(ex)
+            assert not (a[0].func == a[1].func and (
+                not verify_numerically(ex, t.expand(trig=True)) or t.is_Add)
+                or a[1].func != a[0].func and ex != t)
+
+
+def test_TR10():
+    assert TR10(cos(a + b)) == -sin(a)*sin(b) + cos(a)*cos(b)
+    assert TR10(sin(a + b)) == sin(a)*cos(b) + sin(b)*cos(a)
+    assert TR10(sin(a + b + c)) == \
+        (-sin(a)*sin(b) + cos(a)*cos(b))*sin(c) + \
+        (sin(a)*cos(b) + sin(b)*cos(a))*cos(c)
+    assert TR10(cos(a + b + c)) == \
+        (-sin(a)*sin(b) + cos(a)*cos(b))*cos(c) - \
+        (sin(a)*cos(b) + sin(b)*cos(a))*sin(c)
+
+
+def test_TR10i():
+    assert TR10i(cos(1)*cos(3) + sin(1)*sin(3)) == cos(2)
+    assert TR10i(cos(1)*cos(3) - sin(1)*sin(3)) == cos(4)
+    assert TR10i(cos(1)*sin(3) - sin(1)*cos(3)) == sin(2)
+    assert TR10i(cos(1)*sin(3) + sin(1)*cos(3)) == sin(4)
+    assert TR10i(cos(1)*sin(3) + sin(1)*cos(3) + 7) == sin(4) + 7
+    assert TR10i(cos(1)*sin(3) + sin(1)*cos(3) + cos(3)) == cos(3) + sin(4)
+    assert TR10i(2*cos(1)*sin(3) + 2*sin(1)*cos(3) + cos(3)) == \
+        2*sin(4) + cos(3)
+    assert TR10i(cos(2)*cos(3) + sin(2)*(cos(1)*sin(2) + cos(2)*sin(1))) == \
+        cos(1)
+    eq = (cos(2)*cos(3) + sin(2)*(
+        cos(1)*sin(2) + cos(2)*sin(1)))*cos(5) + sin(1)*sin(5)
+    assert TR10i(eq) == TR10i(eq.expand()) == cos(4)
+    assert TR10i(sqrt(2)*cos(x)*x + sqrt(6)*sin(x)*x) == \
+        2*sqrt(2)*x*sin(x + pi/6)
+    assert TR10i(cos(x)/sqrt(6) + sin(x)/sqrt(2) +
+            cos(x)/sqrt(6)/3 + sin(x)/sqrt(2)/3) == 4*sqrt(6)*sin(x + pi/6)/9
+    assert TR10i(cos(x)/sqrt(6) + sin(x)/sqrt(2) +
+            cos(y)/sqrt(6)/3 + sin(y)/sqrt(2)/3) == \
+        sqrt(6)*sin(x + pi/6)/3 + sqrt(6)*sin(y + pi/6)/9
+    assert TR10i(cos(x) + sqrt(3)*sin(x) + 2*sqrt(3)*cos(x + pi/6)) == 4*cos(x)
+    assert TR10i(cos(x) + sqrt(3)*sin(x) +
+            2*sqrt(3)*cos(x + pi/6) + 4*sin(x)) == 4*sqrt(2)*sin(x + pi/4)
+    assert TR10i(cos(2)*sin(3) + sin(2)*cos(4)) == \
+        sin(2)*cos(4) + sin(3)*cos(2)
+
+    A = Symbol('A', commutative=False)
+    assert TR10i(sqrt(2)*cos(x)*A + sqrt(6)*sin(x)*A) == \
+        2*sqrt(2)*sin(x + pi/6)*A
+
+
+    c = cos(x)
+    s = sin(x)
+    h = sin(y)
+    r = cos(y)
+    for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
+        for argsi in ((c*r, s*h), (c*h, s*r)): # explicit 2-args
+            args = zip(si, argsi)
+            ex = Add(*[Mul(*ai) for ai in args])
+            t = TR10i(ex)
+            assert not (ex - t.expand(trig=True) or t.is_Add)
+
+    c = cos(x)
+    s = sin(x)
+    h = sin(pi/6)
+    r = cos(pi/6)
+    for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
+        for argsi in ((c*r, s*h), (c*h, s*r)): # induced
+            args = zip(si, argsi)
+            ex = Add(*[Mul(*ai) for ai in args])
+            t = TR10i(ex)
+            assert not (ex - t.expand(trig=True) or t.is_Add)
+
+
+def test_TR11():
+
+    assert TR11(sin(2*x)) == 2*sin(x)*cos(x)
+    assert TR11(sin(4*x)) == 4*((-sin(x)**2 + cos(x)**2)*sin(x)*cos(x))
+    assert TR11(sin(x*Rational(4, 3))) == \
+        4*((-sin(x/3)**2 + cos(x/3)**2)*sin(x/3)*cos(x/3))
+
+    assert TR11(cos(2*x)) == -sin(x)**2 + cos(x)**2
+    assert TR11(cos(4*x)) == \
+        (-sin(x)**2 + cos(x)**2)**2 - 4*sin(x)**2*cos(x)**2
+
+    assert TR11(cos(2)) == cos(2)
+
+    assert TR11(cos(pi*Rational(3, 7)), pi*Rational(2, 7)) == -cos(pi*Rational(2, 7))**2 + sin(pi*Rational(2, 7))**2
+    assert TR11(cos(4), 2) == -sin(2)**2 + cos(2)**2
+    assert TR11(cos(6), 2) == cos(6)
+    assert TR11(sin(x)/cos(x/2), x/2) == 2*sin(x/2)
+
+def test__TR11():
+
+    assert _TR11(sin(x/3)*sin(2*x)*sin(x/4)/(cos(x/6)*cos(x/8))) == \
+        4*sin(x/8)*sin(x/6)*sin(2*x),_TR11(sin(x/3)*sin(2*x)*sin(x/4)/(cos(x/6)*cos(x/8)))
+    assert _TR11(sin(x/3)/cos(x/6)) == 2*sin(x/6)
+
+    assert _TR11(cos(x/6)/sin(x/3)) == 1/(2*sin(x/6))
+    assert _TR11(sin(2*x)*cos(x/8)/sin(x/4)) == sin(2*x)/(2*sin(x/8)), _TR11(sin(2*x)*cos(x/8)/sin(x/4))
+    assert _TR11(sin(x)/sin(x/2)) == 2*cos(x/2)
+
+
+def test_TR12():
+    assert TR12(tan(x + y)) == (tan(x) + tan(y))/(-tan(x)*tan(y) + 1)
+    assert TR12(tan(x + y + z)) ==\
+        (tan(z) + (tan(x) + tan(y))/(-tan(x)*tan(y) + 1))/(
+        1 - (tan(x) + tan(y))*tan(z)/(-tan(x)*tan(y) + 1))
+    assert TR12(tan(x*y)) == tan(x*y)
+
+
+def test_TR13():
+    assert TR13(tan(3)*tan(2)) == -tan(2)/tan(5) - tan(3)/tan(5) + 1
+    assert TR13(cot(3)*cot(2)) == 1 + cot(3)*cot(5) + cot(2)*cot(5)
+    assert TR13(tan(1)*tan(2)*tan(3)) == \
+        (-tan(2)/tan(5) - tan(3)/tan(5) + 1)*tan(1)
+    assert TR13(tan(1)*tan(2)*cot(3)) == \
+        (-tan(2)/tan(3) + 1 - tan(1)/tan(3))*cot(3)
+
+
+def test_L():
+    assert L(cos(x) + sin(x)) == 2
+
+
+def test_fu():
+
+    assert fu(sin(50)**2 + cos(50)**2 + sin(pi/6)) == Rational(3, 2)
+    assert fu(sqrt(6)*cos(x) + sqrt(2)*sin(x)) == 2*sqrt(2)*sin(x + pi/3)
+
+
+    eq = sin(x)**4 - cos(y)**2 + sin(y)**2 + 2*cos(x)**2
+    assert fu(eq) == cos(x)**4 - 2*cos(y)**2 + 2
+
+    assert fu(S.Half - cos(2*x)/2) == sin(x)**2
+
+    assert fu(sin(a)*(cos(b) - sin(b)) + cos(a)*(sin(b) + cos(b))) == \
+        sqrt(2)*sin(a + b + pi/4)
+
+    assert fu(sqrt(3)*cos(x)/2 + sin(x)/2) == sin(x + pi/3)
+
+    assert fu(1 - sin(2*x)**2/4 - sin(y)**2 - cos(x)**4) == \
+        -cos(x)**2 + cos(y)**2
+
+    assert fu(cos(pi*Rational(4, 9))) == sin(pi/18)
+    assert fu(cos(pi/9)*cos(pi*Rational(2, 9))*cos(pi*Rational(3, 9))*cos(pi*Rational(4, 9))) == Rational(1, 16)
+
+    assert fu(
+        tan(pi*Rational(7, 18)) + tan(pi*Rational(5, 18)) - sqrt(3)*tan(pi*Rational(5, 18))*tan(pi*Rational(7, 18))) == \
+        -sqrt(3)
+
+    assert fu(tan(1)*tan(2)) == tan(1)*tan(2)
+
+    expr = Mul(*[cos(2**i) for i in range(10)])
+    assert fu(expr) == sin(1024)/(1024*sin(1))
+
+    # issue #18059:
+    assert fu(cos(x) + sqrt(sin(x)**2)) == cos(x) + sqrt(sin(x)**2)
+
+    assert fu((-14*sin(x)**3 + 35*sin(x) + 6*sqrt(3)*cos(x)**3 + 9*sqrt(3)*cos(x))/((cos(2*x) + 4))) == \
+        7*sin(x) + 3*sqrt(3)*cos(x)
+
+
+def test_objective():
+    assert fu(sin(x)/cos(x), measure=lambda x: x.count_ops()) == \
+            tan(x)
+    assert fu(sin(x)/cos(x), measure=lambda x: -x.count_ops()) == \
+            sin(x)/cos(x)
+
+
+def test_process_common_addends():
+    # this tests that the args are not evaluated as they are given to do
+    # and that key2 works when key1 is False
+    do = lambda x: Add(*[i**(i%2) for i in x.args])
+    assert process_common_addends(Add(*[1, 2, 3, 4], evaluate=False), do,
+        key2=lambda x: x%2, key1=False) == 1**1 + 3**1 + 2**0 + 4**0
+
+
+def test_trig_split():
+    assert trig_split(cos(x), cos(y)) == (1, 1, 1, x, y, True)
+    assert trig_split(2*cos(x), -2*cos(y)) == (2, 1, -1, x, y, True)
+    assert trig_split(cos(x)*sin(y), cos(y)*sin(y)) == \
+        (sin(y), 1, 1, x, y, True)
+
+    assert trig_split(cos(x), -sqrt(3)*sin(x), two=True) == \
+        (2, 1, -1, x, pi/6, False)
+    assert trig_split(cos(x), sin(x), two=True) == \
+        (sqrt(2), 1, 1, x, pi/4, False)
+    assert trig_split(cos(x), -sin(x), two=True) == \
+        (sqrt(2), 1, -1, x, pi/4, False)
+    assert trig_split(sqrt(2)*cos(x), -sqrt(6)*sin(x), two=True) == \
+        (2*sqrt(2), 1, -1, x, pi/6, False)
+    assert trig_split(-sqrt(6)*cos(x), -sqrt(2)*sin(x), two=True) == \
+        (-2*sqrt(2), 1, 1, x, pi/3, False)
+    assert trig_split(cos(x)/sqrt(6), sin(x)/sqrt(2), two=True) == \
+        (sqrt(6)/3, 1, 1, x, pi/6, False)
+    assert trig_split(-sqrt(6)*cos(x)*sin(y),
+            -sqrt(2)*sin(x)*sin(y), two=True) == \
+        (-2*sqrt(2)*sin(y), 1, 1, x, pi/3, False)
+
+    assert trig_split(cos(x), sin(x)) is None
+    assert trig_split(cos(x), sin(z)) is None
+    assert trig_split(2*cos(x), -sin(x)) is None
+    assert trig_split(cos(x), -sqrt(3)*sin(x)) is None
+    assert trig_split(cos(x)*cos(y), sin(x)*sin(z)) is None
+    assert trig_split(cos(x)*cos(y), sin(x)*sin(y)) is None
+    assert trig_split(-sqrt(6)*cos(x), sqrt(2)*sin(x)*sin(y), two=True) is \
+        None
+
+    assert trig_split(sqrt(3)*sqrt(x), cos(3), two=True) is None
+    assert trig_split(sqrt(3)*root(x, 3), sin(3)*cos(2), two=True) is None
+    assert trig_split(cos(5)*cos(6), cos(7)*sin(5), two=True) is None
+
+
+def test_TRmorrie():
+    assert TRmorrie(7*Mul(*[cos(i) for i in range(10)])) == \
+        7*sin(12)*sin(16)*cos(5)*cos(7)*cos(9)/(64*sin(1)*sin(3))
+    assert TRmorrie(x) == x
+    assert TRmorrie(2*x) == 2*x
+    e = cos(pi/7)*cos(pi*Rational(2, 7))*cos(pi*Rational(4, 7))
+    assert TR8(TRmorrie(e)) == Rational(-1, 8)
+    e = Mul(*[cos(2**i*pi/17) for i in range(1, 17)])
+    assert TR8(TR3(TRmorrie(e))) == Rational(1, 65536)
+    # issue 17063
+    eq = cos(x)/cos(x/2)
+    assert TRmorrie(eq) == eq
+    # issue #20430
+    eq = cos(x/2)*sin(x/2)*cos(x)**3
+    assert TRmorrie(eq) == sin(2*x)*cos(x)**2/4
+
+
+def test_TRpower():
+    assert TRpower(1/sin(x)**2) == 1/sin(x)**2
+    assert TRpower(cos(x)**3*sin(x/2)**4) == \
+        (3*cos(x)/4 + cos(3*x)/4)*(-cos(x)/2 + cos(2*x)/8 + Rational(3, 8))
+    for k in range(2, 8):
+        assert verify_numerically(sin(x)**k, TRpower(sin(x)**k))
+        assert verify_numerically(cos(x)**k, TRpower(cos(x)**k))
+
+
+def test_hyper_as_trig():
+    from sympy.simplify.fu import _osborne, _osbornei
+
+    eq = sinh(x)**2 + cosh(x)**2
+    t, f = hyper_as_trig(eq)
+    assert f(fu(t)) == cosh(2*x)
+    e, f = hyper_as_trig(tanh(x + y))
+    assert f(TR12(e)) == (tanh(x) + tanh(y))/(tanh(x)*tanh(y) + 1)
+
+    d = Dummy()
+    assert _osborne(sinh(x), d) == I*sin(x*d)
+    assert _osborne(tanh(x), d) == I*tan(x*d)
+    assert _osborne(coth(x), d) == cot(x*d)/I
+    assert _osborne(cosh(x), d) == cos(x*d)
+    assert _osborne(sech(x), d) == sec(x*d)
+    assert _osborne(csch(x), d) == csc(x*d)/I
+    for func in (sinh, cosh, tanh, coth, sech, csch):
+        h = func(pi)
+        assert _osbornei(_osborne(h, d), d) == h
+    # /!\ the _osborne functions are not meant to work
+    # in the o(i(trig, d), d) direction so we just check
+    # that they work as they are supposed to work
+    assert _osbornei(cos(x*y + z), y) == cosh(x + z*I)
+    assert _osbornei(sin(x*y + z), y) == sinh(x + z*I)/I
+    assert _osbornei(tan(x*y + z), y) == tanh(x + z*I)/I
+    assert _osbornei(cot(x*y + z), y) == coth(x + z*I)*I
+    assert _osbornei(sec(x*y + z), y) == sech(x + z*I)
+    assert _osbornei(csc(x*y + z), y) == csch(x + z*I)*I
+
+
+def test_TR12i():
+    ta, tb, tc = [tan(i) for i in (a, b, c)]
+    assert TR12i((ta + tb)/(-ta*tb + 1)) == tan(a + b)
+    assert TR12i((ta + tb)/(ta*tb - 1)) == -tan(a + b)
+    assert TR12i((-ta - tb)/(ta*tb - 1)) == tan(a + b)
+    eq = (ta + tb)/(-ta*tb + 1)**2*(-3*ta - 3*tc)/(2*(ta*tc - 1))
+    assert TR12i(eq.expand()) == \
+        -3*tan(a + b)*tan(a + c)/(tan(a) + tan(b) - 1)/2
+    assert TR12i(tan(x)/sin(x)) == tan(x)/sin(x)
+    eq = (ta + cos(2))/(-ta*tb + 1)
+    assert TR12i(eq) == eq
+    eq = (ta + tb + 2)**2/(-ta*tb + 1)
+    assert TR12i(eq) == eq
+    eq = ta/(-ta*tb + 1)
+    assert TR12i(eq) == eq
+    eq = (((ta + tb)*(a + 1)).expand())**2/(ta*tb - 1)
+    assert TR12i(eq) == -(a + 1)**2*tan(a + b)
+
+
+def test_TR14():
+    eq = (cos(x) - 1)*(cos(x) + 1)
+    ans = -sin(x)**2
+    assert TR14(eq) == ans
+    assert TR14(1/eq) == 1/ans
+    assert TR14((cos(x) - 1)**2*(cos(x) + 1)**2) == ans**2
+    assert TR14((cos(x) - 1)**2*(cos(x) + 1)**3) == ans**2*(cos(x) + 1)
+    assert TR14((cos(x) - 1)**3*(cos(x) + 1)**2) == ans**2*(cos(x) - 1)
+    eq = (cos(x) - 1)**y*(cos(x) + 1)**y
+    assert TR14(eq) == eq
+    eq = (cos(x) - 2)**y*(cos(x) + 1)
+    assert TR14(eq) == eq
+    eq = (tan(x) - 2)**2*(cos(x) + 1)
+    assert TR14(eq) == eq
+    i = symbols('i', integer=True)
+    assert TR14((cos(x) - 1)**i*(cos(x) + 1)**i) == ans**i
+    assert TR14((sin(x) - 1)**i*(sin(x) + 1)**i) == (-cos(x)**2)**i
+    # could use extraction in this case
+    eq = (cos(x) - 1)**(i + 1)*(cos(x) + 1)**i
+    assert TR14(eq) in [(cos(x) - 1)*ans**i, eq]
+
+    assert TR14((sin(x) - 1)*(sin(x) + 1)) == -cos(x)**2
+    p1 = (cos(x) + 1)*(cos(x) - 1)
+    p2 = (cos(y) - 1)*2*(cos(y) + 1)
+    p3 = (3*(cos(y) - 1))*(3*(cos(y) + 1))
+    assert TR14(p1*p2*p3*(x - 1)) == -18*((x - 1)*sin(x)**2*sin(y)**4)
+
+
+def test_TR15_16_17():
+    assert TR15(1 - 1/sin(x)**2) == -cot(x)**2
+    assert TR16(1 - 1/cos(x)**2) == -tan(x)**2
+    assert TR111(1 - 1/tan(x)**2) == 1 - cot(x)**2
+
+
+def test_as_f_sign_1():
+    assert as_f_sign_1(x + 1) == (1, x, 1)
+    assert as_f_sign_1(x - 1) == (1, x, -1)
+    assert as_f_sign_1(-x + 1) == (-1, x, -1)
+    assert as_f_sign_1(-x - 1) == (-1, x, 1)
+    assert as_f_sign_1(2*x + 2) == (2, x, 1)
+    assert as_f_sign_1(x*y - y) == (y, x, -1)
+    assert as_f_sign_1(-x*y + y) == (-y, x, -1)
+
+
+def test_issue_25590():
+    A = Symbol('A', commutative=False)
+    B = Symbol('B', commutative=False)
+
+    assert TR8(2*cos(x)*sin(x)*B*A) == sin(2*x)*B*A
+    assert TR13(tan(2)*tan(3)*B*A) == (-tan(2)/tan(5) - tan(3)/tan(5) + 1)*B*A
+
+    # XXX The result may not be optimal than
+    # sin(2*x)*B*A + cos(x)**2 and may change in the future
+    assert (2*cos(x)*sin(x)*B*A + cos(x)**2).simplify() == sin(2*x)*B*A + cos(2*x)/2 + S.One/2

lib/python3.12/site-packages/sympy/simplify/tests/test_function.py

@@ -0,0 +1,54 @@
+""" Unit tests for Hyper_Function"""
+from sympy.core import symbols, Dummy, Tuple, S, Rational
+from sympy.functions import hyper
+
+from sympy.simplify.hyperexpand import Hyper_Function
+
+def test_attrs():
+    a, b = symbols('a, b', cls=Dummy)
+    f = Hyper_Function([2, a], [b])
+    assert f.ap == Tuple(2, a)
+    assert f.bq == Tuple(b)
+    assert f.args == (Tuple(2, a), Tuple(b))
+    assert f.sizes == (2, 1)
+
+def test_call():
+    a, b, x = symbols('a, b, x', cls=Dummy)
+    f = Hyper_Function([2, a], [b])
+    assert f(x) == hyper([2, a], [b], x)
+
+def test_has():
+    a, b, c = symbols('a, b, c', cls=Dummy)
+    f = Hyper_Function([2, -a], [b])
+    assert f.has(a)
+    assert f.has(Tuple(b))
+    assert not f.has(c)
+
+def test_eq():
+    assert Hyper_Function([1], []) == Hyper_Function([1], [])
+    assert (Hyper_Function([1], []) != Hyper_Function([1], [])) is False
+    assert Hyper_Function([1], []) != Hyper_Function([2], [])
+    assert Hyper_Function([1], []) != Hyper_Function([1, 2], [])
+    assert Hyper_Function([1], []) != Hyper_Function([1], [2])
+
+def test_gamma():
+    assert Hyper_Function([2, 3], [-1]).gamma == 0
+    assert Hyper_Function([-2, -3], [-1]).gamma == 2
+    n = Dummy(integer=True)
+    assert Hyper_Function([-1, n, 1], []).gamma == 1
+    assert Hyper_Function([-1, -n, 1], []).gamma == 1
+    p = Dummy(integer=True, positive=True)
+    assert Hyper_Function([-1, p, 1], []).gamma == 1
+    assert Hyper_Function([-1, -p, 1], []).gamma == 2
+
+def test_suitable_origin():
+    assert Hyper_Function((S.Half,), (Rational(3, 2),))._is_suitable_origin() is True
+    assert Hyper_Function((S.Half,), (S.Half,))._is_suitable_origin() is False
+    assert Hyper_Function((S.Half,), (Rational(-1, 2),))._is_suitable_origin() is False
+    assert Hyper_Function((S.Half,), (0,))._is_suitable_origin() is False
+    assert Hyper_Function((S.Half,), (-1, 1,))._is_suitable_origin() is False
+    assert Hyper_Function((S.Half, 0), (1,))._is_suitable_origin() is False
+    assert Hyper_Function((S.Half, 1),
+            (2, Rational(-2, 3)))._is_suitable_origin() is True
+    assert Hyper_Function((S.Half, 1),
+            (2, Rational(-2, 3), Rational(3, 2)))._is_suitable_origin() is True

lib/python3.12/site-packages/sympy/simplify/tests/test_gammasimp.py

@@ -0,0 +1,127 @@
+from sympy.core.function import Function
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import (rf, binomial, factorial)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.simplify.gammasimp import gammasimp
+from sympy.simplify.powsimp import powsimp
+from sympy.simplify.simplify import simplify
+
+from sympy.abc import x, y, n, k
+
+
+def test_gammasimp():
+    R = Rational
+
+    # was part of test_combsimp_gamma() in test_combsimp.py
+    assert gammasimp(gamma(x)) == gamma(x)
+    assert gammasimp(gamma(x + 1)/x) == gamma(x)
+    assert gammasimp(gamma(x)/(x - 1)) == gamma(x - 1)
+    assert gammasimp(x*gamma(x)) == gamma(x + 1)
+    assert gammasimp((x + 1)*gamma(x + 1)) == gamma(x + 2)
+    assert gammasimp(gamma(x + y)*(x + y)) == gamma(x + y + 1)
+    assert gammasimp(x/gamma(x + 1)) == 1/gamma(x)
+    assert gammasimp((x + 1)**2/gamma(x + 2)) == (x + 1)/gamma(x + 1)
+    assert gammasimp(x*gamma(x) + gamma(x + 3)/(x + 2)) == \
+        (x + 2)*gamma(x + 1)
+
+    assert gammasimp(gamma(2*x)*x) == gamma(2*x + 1)/2
+    assert gammasimp(gamma(2*x)/(x - S.Half)) == 2*gamma(2*x - 1)
+
+    assert gammasimp(gamma(x)*gamma(1 - x)) == pi/sin(pi*x)
+    assert gammasimp(gamma(x)*gamma(-x)) == -pi/(x*sin(pi*x))
+    assert gammasimp(1/gamma(x + 3)/gamma(1 - x)) == \
+        sin(pi*x)/(pi*x*(x + 1)*(x + 2))
+
+    assert gammasimp(factorial(n + 2)) == gamma(n + 3)
+    assert gammasimp(binomial(n, k)) == \
+        gamma(n + 1)/(gamma(k + 1)*gamma(-k + n + 1))
+
+    assert powsimp(gammasimp(
+        gamma(x)*gamma(x + S.Half)*gamma(y)/gamma(x + y))) == \
+        2**(-2*x + 1)*sqrt(pi)*gamma(2*x)*gamma(y)/gamma(x + y)
+    assert gammasimp(1/gamma(x)/gamma(x - Rational(1, 3))/gamma(x + Rational(1, 3))) == \
+        3**(3*x - Rational(3, 2))/(2*pi*gamma(3*x - 1))
+    assert simplify(
+        gamma(S.Half + x/2)*gamma(1 + x/2)/gamma(1 + x)/sqrt(pi)*2**x) == 1
+    assert gammasimp(gamma(Rational(-1, 4))*gamma(Rational(-3, 4))) == 16*sqrt(2)*pi/3
+
+    assert powsimp(gammasimp(gamma(2*x)/gamma(x))) == \
+        2**(2*x - 1)*gamma(x + S.Half)/sqrt(pi)
+
+    # issue 6792
+    e = (-gamma(k)*gamma(k + 2) + gamma(k + 1)**2)/gamma(k)**2
+    assert gammasimp(e) == -k
+    assert gammasimp(1/e) == -1/k
+    e = (gamma(x) + gamma(x + 1))/gamma(x)
+    assert gammasimp(e) == x + 1
+    assert gammasimp(1/e) == 1/(x + 1)
+    e = (gamma(x) + gamma(x + 2))*(gamma(x - 1) + gamma(x))/gamma(x)
+    assert gammasimp(e) == (x**2 + x + 1)*gamma(x + 1)/(x - 1)
+    e = (-gamma(k)*gamma(k + 2) + gamma(k + 1)**2)/gamma(k)**2
+    assert gammasimp(e**2) == k**2
+    assert gammasimp(e**2/gamma(k + 1)) == k/gamma(k)
+    a = R(1, 2) + R(1, 3)
+    b = a + R(1, 3)
+    assert gammasimp(gamma(2*k)/gamma(k)*gamma(k + a)*gamma(k + b)
+        ) == 3*2**(2*k + 1)*3**(-3*k - 2)*sqrt(pi)*gamma(3*k + R(3, 2))/2
+
+    # issue 9699
+    assert gammasimp((x + 1)*factorial(x)/gamma(y)) == gamma(x + 2)/gamma(y)
+    assert gammasimp(rf(x + n, k)*binomial(n, k)).simplify() == Piecewise(
+        (gamma(n + 1)*gamma(k + n + x)/(gamma(k + 1)*gamma(n + x)*gamma(-k + n + 1)), n > -x),
+        ((-1)**k*gamma(n + 1)*gamma(-n - x + 1)/(gamma(k + 1)*gamma(-k + n + 1)*gamma(-k - n - x + 1)), True))
+
+    A, B = symbols('A B', commutative=False)
+    assert gammasimp(e*B*A) == gammasimp(e)*B*A
+
+    # check iteration
+    assert gammasimp(gamma(2*k)/gamma(k)*gamma(-k - R(1, 2))) == (
+        -2**(2*k + 1)*sqrt(pi)/(2*((2*k + 1)*cos(pi*k))))
+    assert gammasimp(
+        gamma(k)*gamma(k + R(1, 3))*gamma(k + R(2, 3))/gamma(k*R(3, 2))) == (
+        3*2**(3*k + 1)*3**(-3*k - S.Half)*sqrt(pi)*gamma(k*R(3, 2) + S.Half)/2)
+
+    # issue 6153
+    assert gammasimp(gamma(Rational(1, 4))/gamma(Rational(5, 4))) == 4
+
+    # was part of test_combsimp() in test_combsimp.py
+    assert gammasimp(binomial(n + 2, k + S.Half)) == gamma(n + 3)/ \
+        (gamma(k + R(3, 2))*gamma(-k + n + R(5, 2)))
+    assert gammasimp(binomial(n + 2, k + 2.0)) == \
+        gamma(n + 3)/(gamma(k + 3.0)*gamma(-k + n + 1))
+
+    # issue 11548
+    assert gammasimp(binomial(0, x)) == sin(pi*x)/(pi*x)
+
+    e = gamma(n + Rational(1, 3))*gamma(n + R(2, 3))
+    assert gammasimp(e) == e
+    assert gammasimp(gamma(4*n + S.Half)/gamma(2*n - R(3, 4))) == \
+        2**(4*n - R(5, 2))*(8*n - 3)*gamma(2*n + R(3, 4))/sqrt(pi)
+
+    i, m = symbols('i m', integer = True)
+    e = gamma(exp(i))
+    assert gammasimp(e) == e
+    e = gamma(m + 3)
+    assert gammasimp(e) == e
+    e = gamma(m + 1)/(gamma(i + 1)*gamma(-i + m + 1))
+    assert gammasimp(e) == e
+
+    p = symbols("p", integer=True, positive=True)
+    assert gammasimp(gamma(-p + 4)) == gamma(-p + 4)
+
+
+def test_issue_22606():
+    fx = Function('f')(x)
+    eq = x + gamma(y)
+    # seems like ans should be `eq`, not `(x*y + gamma(y + 1))/y`
+    ans = gammasimp(eq)
+    assert gammasimp(eq.subs(x, fx)).subs(fx, x) == ans
+    assert gammasimp(eq.subs(x, cos(x))).subs(cos(x), x) == ans
+    assert 1/gammasimp(1/eq) == ans
+    assert gammasimp(fx.subs(x, eq)).args[0] == ans

lib/python3.12/site-packages/sympy/simplify/tests/test_hyperexpand.py

@@ -0,0 +1,1063 @@
+from sympy.core.random import randrange
+
+from sympy.simplify.hyperexpand import (ShiftA, ShiftB, UnShiftA, UnShiftB,
+                       MeijerShiftA, MeijerShiftB, MeijerShiftC, MeijerShiftD,
+                       MeijerUnShiftA, MeijerUnShiftB, MeijerUnShiftC,
+                       MeijerUnShiftD,
+                       ReduceOrder, reduce_order, apply_operators,
+                       devise_plan, make_derivative_operator, Formula,
+                       hyperexpand, Hyper_Function, G_Function,
+                       reduce_order_meijer,
+                       build_hypergeometric_formula)
+from sympy.concrete.summations import Sum
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.numbers import I
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.hyper import (hyper, meijerg)
+from sympy.abc import z, a, b, c
+from sympy.testing.pytest import XFAIL, raises, slow, tooslow
+from sympy.core.random import verify_numerically as tn
+
+from sympy.core.numbers import (Rational, pi)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import atanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (asin, cos, sin)
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import (gamma, lowergamma)
+
+
+def test_branch_bug():
+    assert hyperexpand(hyper((Rational(-1, 3), S.Half), (Rational(2, 3), Rational(3, 2)), -z)) == \
+        -z**S('1/3')*lowergamma(exp_polar(I*pi)/3, z)/5 \
+        + sqrt(pi)*erf(sqrt(z))/(5*sqrt(z))
+    assert hyperexpand(meijerg([Rational(7, 6), 1], [], [Rational(2, 3)], [Rational(1, 6), 0], z)) == \
+        2*z**S('2/3')*(2*sqrt(pi)*erf(sqrt(z))/sqrt(z) - 2*lowergamma(
+                       Rational(2, 3), z)/z**S('2/3'))*gamma(Rational(2, 3))/gamma(Rational(5, 3))
+
+
+def test_hyperexpand():
+    # Luke, Y. L. (1969), The Special Functions and Their Approximations,
+    # Volume 1, section 6.2
+
+    assert hyperexpand(hyper([], [], z)) == exp(z)
+    assert hyperexpand(hyper([1, 1], [2], -z)*z) == log(1 + z)
+    assert hyperexpand(hyper([], [S.Half], -z**2/4)) == cos(z)
+    assert hyperexpand(z*hyper([], [S('3/2')], -z**2/4)) == sin(z)
+    assert hyperexpand(hyper([S('1/2'), S('1/2')], [S('3/2')], z**2)*z) \
+        == asin(z)
+    assert isinstance(Sum(binomial(2, z)*z**2, (z, 0, a)).doit(), Expr)
+
+
+def can_do(ap, bq, numerical=True, div=1, lowerplane=False):
+    r = hyperexpand(hyper(ap, bq, z))
+    if r.has(hyper):
+        return False
+    if not numerical:
+        return True
+    repl = {}
+    randsyms = r.free_symbols - {z}
+    while randsyms:
+        # Only randomly generated parameters are checked.
+        for n, ai in enumerate(randsyms):
+            repl[ai] = randcplx(n)/div
+        if not any(b.is_Integer and b <= 0 for b in Tuple(*bq).subs(repl)):
+            break
+    [a, b, c, d] = [2, -1, 3, 1]
+    if lowerplane:
+        [a, b, c, d] = [2, -2, 3, -1]
+    return tn(
+        hyper(ap, bq, z).subs(repl),
+        r.replace(exp_polar, exp).subs(repl),
+        z, a=a, b=b, c=c, d=d)
+
+
+def test_roach():
+    # Kelly B. Roach.  Meijer G Function Representations.
+    # Section "Gallery"
+    assert can_do([S.Half], [Rational(9, 2)])
+    assert can_do([], [1, Rational(5, 2), 4])
+    assert can_do([Rational(-1, 2), 1, 2], [3, 4])
+    assert can_do([Rational(1, 3)], [Rational(-2, 3), Rational(-1, 2), S.Half, 1])
+    assert can_do([Rational(-3, 2), Rational(-1, 2)], [Rational(-5, 2), 1])
+    assert can_do([Rational(-3, 2), ], [Rational(-1, 2), S.Half])  # shine-integral
+    assert can_do([Rational(-3, 2), Rational(-1, 2)], [2])  # elliptic integrals
+
+
+@XFAIL
+def test_roach_fail():
+    assert can_do([Rational(-1, 2), 1], [Rational(1, 4), S.Half, Rational(3, 4)])  # PFDD
+    assert can_do([Rational(3, 2)], [Rational(5, 2), 5])  # struve function
+    assert can_do([Rational(-1, 2), S.Half, 1], [Rational(3, 2), Rational(5, 2)])  # polylog, pfdd
+    assert can_do([1, 2, 3], [S.Half, 4])  # XXX ?
+    assert can_do([S.Half], [Rational(-1, 3), Rational(-1, 2), Rational(-2, 3)])  # PFDD ?
+
+# For the long table tests, see end of file
+
+
+def test_polynomial():
+    from sympy.core.numbers import oo
+    assert hyperexpand(hyper([], [-1], z)) is oo
+    assert hyperexpand(hyper([-2], [-1], z)) is oo
+    assert hyperexpand(hyper([0, 0], [-1], z)) == 1
+    assert can_do([-5, -2, randcplx(), randcplx()], [-10, randcplx()])
+    assert hyperexpand(hyper((-1, 1), (-2,), z)) == 1 + z/2
+
+
+def test_hyperexpand_bases():
+    assert hyperexpand(hyper([2], [a], z)) == \
+        a + z**(-a + 1)*(-a**2 + 3*a + z*(a - 1) - 2)*exp(z)* \
+        lowergamma(a - 1, z) - 1
+    # TODO [a+1, aRational(-1, 2)], [2*a]
+    assert hyperexpand(hyper([1, 2], [3], z)) == -2/z - 2*log(-z + 1)/z**2
+    assert hyperexpand(hyper([S.Half, 2], [Rational(3, 2)], z)) == \
+        -1/(2*z - 2) + atanh(sqrt(z))/sqrt(z)/2
+    assert hyperexpand(hyper([S.Half, S.Half], [Rational(5, 2)], z)) == \
+        (-3*z + 3)/4/(z*sqrt(-z + 1)) \
+        + (6*z - 3)*asin(sqrt(z))/(4*z**Rational(3, 2))
+    assert hyperexpand(hyper([1, 2], [Rational(3, 2)], z)) == -1/(2*z - 2) \
+        - asin(sqrt(z))/(sqrt(z)*(2*z - 2)*sqrt(-z + 1))
+    assert hyperexpand(hyper([Rational(-1, 2) - 1, 1, 2], [S.Half, 3], z)) == \
+        sqrt(z)*(z*Rational(6, 7) - Rational(6, 5))*atanh(sqrt(z)) \
+        + (-30*z**2 + 32*z - 6)/35/z - 6*log(-z + 1)/(35*z**2)
+    assert hyperexpand(hyper([1 + S.Half, 1, 1], [2, 2], z)) == \
+        -4*log(sqrt(-z + 1)/2 + S.Half)/z
+    # TODO hyperexpand(hyper([a], [2*a + 1], z))
+    # TODO [S.Half, a], [Rational(3, 2), a+1]
+    assert hyperexpand(hyper([2], [b, 1], z)) == \
+        z**(-b/2 + S.Half)*besseli(b - 1, 2*sqrt(z))*gamma(b) \
+        + z**(-b/2 + 1)*besseli(b, 2*sqrt(z))*gamma(b)
+    # TODO [a], [a - S.Half, 2*a]
+
+
+def test_hyperexpand_parametric():
+    assert hyperexpand(hyper([a, S.Half + a], [S.Half], z)) \
+        == (1 + sqrt(z))**(-2*a)/2 + (1 - sqrt(z))**(-2*a)/2
+    assert hyperexpand(hyper([a, Rational(-1, 2) + a], [2*a], z)) \
+        == 2**(2*a - 1)*((-z + 1)**S.Half + 1)**(-2*a + 1)
+
+
+def test_shifted_sum():
+    from sympy.simplify.simplify import simplify
+    assert simplify(hyperexpand(z**4*hyper([2], [3, S('3/2')], -z**2))) \
+        == z*sin(2*z) + (-z**2 + S.Half)*cos(2*z) - S.Half
+
+
+def _randrat():
+    """ Steer clear of integers. """
+    return S(randrange(25) + 10)/50
+
+
+def randcplx(offset=-1):
+    """ Polys is not good with real coefficients. """
+    return _randrat() + I*_randrat() + I*(1 + offset)
+
+
+@slow
+def test_formulae():
+    from sympy.simplify.hyperexpand import FormulaCollection
+    formulae = FormulaCollection().formulae
+    for formula in formulae:
+        h = formula.func(formula.z)
+        rep = {}
+        for n, sym in enumerate(formula.symbols):
+            rep[sym] = randcplx(n)
+
+        # NOTE hyperexpand returns truly branched functions. We know we are
+        #      on the main sheet, but numerical evaluation can still go wrong
+        #      (e.g. if exp_polar cannot be evalf'd).
+        #      Just replace all exp_polar by exp, this usually works.
+
+        # first test if the closed-form is actually correct
+        h = h.subs(rep)
+        closed_form = formula.closed_form.subs(rep).rewrite('nonrepsmall')
+        z = formula.z
+        assert tn(h, closed_form.replace(exp_polar, exp), z)
+
+        # now test the computed matrix
+        cl = (formula.C * formula.B)[0].subs(rep).rewrite('nonrepsmall')
+        assert tn(closed_form.replace(
+            exp_polar, exp), cl.replace(exp_polar, exp), z)
+        deriv1 = z*formula.B.applyfunc(lambda t: t.rewrite(
+            'nonrepsmall')).diff(z)
+        deriv2 = formula.M * formula.B
+        for d1, d2 in zip(deriv1, deriv2):
+            assert tn(d1.subs(rep).replace(exp_polar, exp),
+                      d2.subs(rep).rewrite('nonrepsmall').replace(exp_polar, exp), z)
+
+
+def test_meijerg_formulae():
+    from sympy.simplify.hyperexpand import MeijerFormulaCollection
+    formulae = MeijerFormulaCollection().formulae
+    for sig in formulae:
+        for formula in formulae[sig]:
+            g = meijerg(formula.func.an, formula.func.ap,
+                        formula.func.bm, formula.func.bq,
+                        formula.z)
+            rep = {}
+            for sym in formula.symbols:
+                rep[sym] = randcplx()
+
+            # first test if the closed-form is actually correct
+            g = g.subs(rep)
+            closed_form = formula.closed_form.subs(rep)
+            z = formula.z
+            assert tn(g, closed_form, z)
+
+            # now test the computed matrix
+            cl = (formula.C * formula.B)[0].subs(rep)
+            assert tn(closed_form, cl, z)
+            deriv1 = z*formula.B.diff(z)
+            deriv2 = formula.M * formula.B
+            for d1, d2 in zip(deriv1, deriv2):
+                assert tn(d1.subs(rep), d2.subs(rep), z)
+
+
+def op(f):
+    return z*f.diff(z)
+
+
+def test_plan():
+    assert devise_plan(Hyper_Function([0], ()),
+            Hyper_Function([0], ()), z) == []
+    with raises(ValueError):
+        devise_plan(Hyper_Function([1], ()), Hyper_Function((), ()), z)
+    with raises(ValueError):
+        devise_plan(Hyper_Function([2], [1]), Hyper_Function([2], [2]), z)
+    with raises(ValueError):
+        devise_plan(Hyper_Function([2], []), Hyper_Function([S("1/2")], []), z)
+
+    # We cannot use pi/(10000 + n) because polys is insanely slow.
+    a1, a2, b1 = (randcplx(n) for n in range(3))
+    b1 += 2*I
+    h = hyper([a1, a2], [b1], z)
+
+    h2 = hyper((a1 + 1, a2), [b1], z)
+    assert tn(apply_operators(h,
+        devise_plan(Hyper_Function((a1 + 1, a2), [b1]),
+            Hyper_Function((a1, a2), [b1]), z), op),
+        h2, z)
+
+    h2 = hyper((a1 + 1, a2 - 1), [b1], z)
+    assert tn(apply_operators(h,
+        devise_plan(Hyper_Function((a1 + 1, a2 - 1), [b1]),
+            Hyper_Function((a1, a2), [b1]), z), op),
+        h2, z)
+
+
+def test_plan_derivatives():
+    a1, a2, a3 = 1, 2, S('1/2')
+    b1, b2 = 3, S('5/2')
+    h = Hyper_Function((a1, a2, a3), (b1, b2))
+    h2 = Hyper_Function((a1 + 1, a2 + 1, a3 + 2), (b1 + 1, b2 + 1))
+    ops = devise_plan(h2, h, z)
+    f = Formula(h, z, h(z), [])
+    deriv = make_derivative_operator(f.M, z)
+    assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
+
+    h2 = Hyper_Function((a1, a2 - 1, a3 - 2), (b1 - 1, b2 - 1))
+    ops = devise_plan(h2, h, z)
+    assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
+
+
+def test_reduction_operators():
+    a1, a2, b1 = (randcplx(n) for n in range(3))
+    h = hyper([a1], [b1], z)
+
+    assert ReduceOrder(2, 0) is None
+    assert ReduceOrder(2, -1) is None
+    assert ReduceOrder(1, S('1/2')) is None
+
+    h2 = hyper((a1, a2), (b1, a2), z)
+    assert tn(ReduceOrder(a2, a2).apply(h, op), h2, z)
+
+    h2 = hyper((a1, a2 + 1), (b1, a2), z)
+    assert tn(ReduceOrder(a2 + 1, a2).apply(h, op), h2, z)
+
+    h2 = hyper((a2 + 4, a1), (b1, a2), z)
+    assert tn(ReduceOrder(a2 + 4, a2).apply(h, op), h2, z)
+
+    # test several step order reduction
+    ap = (a2 + 4, a1, b1 + 1)
+    bq = (a2, b1, b1)
+    func, ops = reduce_order(Hyper_Function(ap, bq))
+    assert func.ap == (a1,)
+    assert func.bq == (b1,)
+    assert tn(apply_operators(h, ops, op), hyper(ap, bq, z), z)
+
+
+def test_shift_operators():
+    a1, a2, b1, b2, b3 = (randcplx(n) for n in range(5))
+    h = hyper((a1, a2), (b1, b2, b3), z)
+
+    raises(ValueError, lambda: ShiftA(0))
+    raises(ValueError, lambda: ShiftB(1))
+
+    assert tn(ShiftA(a1).apply(h, op), hyper((a1 + 1, a2), (b1, b2, b3), z), z)
+    assert tn(ShiftA(a2).apply(h, op), hyper((a1, a2 + 1), (b1, b2, b3), z), z)
+    assert tn(ShiftB(b1).apply(h, op), hyper((a1, a2), (b1 - 1, b2, b3), z), z)
+    assert tn(ShiftB(b2).apply(h, op), hyper((a1, a2), (b1, b2 - 1, b3), z), z)
+    assert tn(ShiftB(b3).apply(h, op), hyper((a1, a2), (b1, b2, b3 - 1), z), z)
+
+
+def test_ushift_operators():
+    a1, a2, b1, b2, b3 = (randcplx(n) for n in range(5))
+    h = hyper((a1, a2), (b1, b2, b3), z)
+
+    raises(ValueError, lambda: UnShiftA((1,), (), 0, z))
+    raises(ValueError, lambda: UnShiftB((), (-1,), 0, z))
+    raises(ValueError, lambda: UnShiftA((1,), (0, -1, 1), 0, z))
+    raises(ValueError, lambda: UnShiftB((0, 1), (1,), 0, z))
+
+    s = UnShiftA((a1, a2), (b1, b2, b3), 0, z)
+    assert tn(s.apply(h, op), hyper((a1 - 1, a2), (b1, b2, b3), z), z)
+    s = UnShiftA((a1, a2), (b1, b2, b3), 1, z)
+    assert tn(s.apply(h, op), hyper((a1, a2 - 1), (b1, b2, b3), z), z)
+
+    s = UnShiftB((a1, a2), (b1, b2, b3), 0, z)
+    assert tn(s.apply(h, op), hyper((a1, a2), (b1 + 1, b2, b3), z), z)
+    s = UnShiftB((a1, a2), (b1, b2, b3), 1, z)
+    assert tn(s.apply(h, op), hyper((a1, a2), (b1, b2 + 1, b3), z), z)
+    s = UnShiftB((a1, a2), (b1, b2, b3), 2, z)
+    assert tn(s.apply(h, op), hyper((a1, a2), (b1, b2, b3 + 1), z), z)
+
+
+def can_do_meijer(a1, a2, b1, b2, numeric=True):
+    """
+    This helper function tries to hyperexpand() the meijer g-function
+    corresponding to the parameters a1, a2, b1, b2.
+    It returns False if this expansion still contains g-functions.
+    If numeric is True, it also tests the so-obtained formula numerically
+    (at random values) and returns False if the test fails.
+    Else it returns True.
+    """
+    from sympy.core.function import expand
+    from sympy.functions.elementary.complexes import unpolarify
+    r = hyperexpand(meijerg(a1, a2, b1, b2, z))
+    if r.has(meijerg):
+        return False
+    # NOTE hyperexpand() returns a truly branched function, whereas numerical
+    #      evaluation only works on the main branch. Since we are evaluating on
+    #      the main branch, this should not be a problem, but expressions like
+    #      exp_polar(I*pi/2*x)**a are evaluated incorrectly. We thus have to get
+    #      rid of them. The expand heuristically does this...
+    r = unpolarify(expand(r, force=True, power_base=True, power_exp=False,
+                          mul=False, log=False, multinomial=False, basic=False))
+
+    if not numeric:
+        return True
+
+    repl = {}
+    for n, ai in enumerate(meijerg(a1, a2, b1, b2, z).free_symbols - {z}):
+        repl[ai] = randcplx(n)
+    return tn(meijerg(a1, a2, b1, b2, z).subs(repl), r.subs(repl), z)
+
+
+@slow
+def test_meijerg_expand():
+    from sympy.simplify.gammasimp import gammasimp
+    from sympy.simplify.simplify import simplify
+    # from mpmath docs
+    assert hyperexpand(meijerg([[], []], [[0], []], -z)) == exp(z)
+
+    assert hyperexpand(meijerg([[1, 1], []], [[1], [0]], z)) == \
+        log(z + 1)
+    assert hyperexpand(meijerg([[1, 1], []], [[1], [1]], z)) == \
+        z/(z + 1)
+    assert hyperexpand(meijerg([[], []], [[S.Half], [0]], (z/2)**2)) \
+        == sin(z)/sqrt(pi)
+    assert hyperexpand(meijerg([[], []], [[0], [S.Half]], (z/2)**2)) \
+        == cos(z)/sqrt(pi)
+    assert can_do_meijer([], [a], [a - 1, a - S.Half], [])
+    assert can_do_meijer([], [], [a/2], [-a/2], False)  # branches...
+    assert can_do_meijer([a], [b], [a], [b, a - 1])
+
+    # wikipedia
+    assert hyperexpand(meijerg([1], [], [], [0], z)) == \
+        Piecewise((0, abs(z) < 1), (1, abs(1/z) < 1),
+                 (meijerg([1], [], [], [0], z), True))
+    assert hyperexpand(meijerg([], [1], [0], [], z)) == \
+        Piecewise((1, abs(z) < 1), (0, abs(1/z) < 1),
+                 (meijerg([], [1], [0], [], z), True))
+
+    # The Special Functions and their Approximations
+    assert can_do_meijer([], [], [a + b/2], [a, a - b/2, a + S.Half])
+    assert can_do_meijer(
+        [], [], [a], [b], False)  # branches only agree for small z
+    assert can_do_meijer([], [S.Half], [a], [-a])
+    assert can_do_meijer([], [], [a, b], [])
+    assert can_do_meijer([], [], [a, b], [])
+    assert can_do_meijer([], [], [a, a + S.Half], [b, b + S.Half])
+    assert can_do_meijer([], [], [a, -a], [0, S.Half], False)  # dito
+    assert can_do_meijer([], [], [a, a + S.Half, b, b + S.Half], [])
+    assert can_do_meijer([S.Half], [], [0], [a, -a])
+    assert can_do_meijer([S.Half], [], [a], [0, -a], False)  # dito
+    assert can_do_meijer([], [a - S.Half], [a, b], [a - S.Half], False)
+    assert can_do_meijer([], [a + S.Half], [a + b, a - b, a], [], False)
+    assert can_do_meijer([a + S.Half], [], [b, 2*a - b, a], [], False)
+
+    # This for example is actually zero.
+    assert can_do_meijer([], [], [], [a, b])
+
+    # Testing a bug:
+    assert hyperexpand(meijerg([0, 2], [], [], [-1, 1], z)) == \
+        Piecewise((0, abs(z) < 1),
+                  (z*(1 - 1/z**2)/2, abs(1/z) < 1),
+                  (meijerg([0, 2], [], [], [-1, 1], z), True))
+
+    # Test that the simplest possible answer is returned:
+    assert gammasimp(simplify(hyperexpand(
+        meijerg([1], [1 - a], [-a/2, -a/2 + S.Half], [], 1/z)))) == \
+        -2*sqrt(pi)*(sqrt(z + 1) + 1)**a/a
+
+    # Test that hyper is returned
+    assert hyperexpand(meijerg([1], [], [a], [0, 0], z)) == hyper(
+        (a,), (a + 1, a + 1), z*exp_polar(I*pi))*z**a*gamma(a)/gamma(a + 1)**2
+
+    # Test place option
+    f = meijerg(((0, 1), ()), ((S.Half,), (0,)), z**2)
+    assert hyperexpand(f) == sqrt(pi)/sqrt(1 + z**(-2))
+    assert hyperexpand(f, place=0) == sqrt(pi)*z/sqrt(z**2 + 1)
+
+
+def test_meijerg_lookup():
+    from sympy.functions.special.error_functions import (Ci, Si)
+    from sympy.functions.special.gamma_functions import uppergamma
+    assert hyperexpand(meijerg([a], [], [b, a], [], z)) == \
+        z**b*exp(z)*gamma(-a + b + 1)*uppergamma(a - b, z)
+    assert hyperexpand(meijerg([0], [], [0, 0], [], z)) == \
+        exp(z)*uppergamma(0, z)
+    assert can_do_meijer([a], [], [b, a + 1], [])
+    assert can_do_meijer([a], [], [b + 2, a], [])
+    assert can_do_meijer([a], [], [b - 2, a], [])
+
+    assert hyperexpand(meijerg([a], [], [a, a, a - S.Half], [], z)) == \
+        -sqrt(pi)*z**(a - S.Half)*(2*cos(2*sqrt(z))*(Si(2*sqrt(z)) - pi/2)
+                                   - 2*sin(2*sqrt(z))*Ci(2*sqrt(z))) == \
+        hyperexpand(meijerg([a], [], [a, a - S.Half, a], [], z)) == \
+        hyperexpand(meijerg([a], [], [a - S.Half, a, a], [], z))
+    assert can_do_meijer([a - 1], [], [a + 2, a - Rational(3, 2), a + 1], [])
+
+
+@XFAIL
+def test_meijerg_expand_fail():
+    # These basically test hyper([], [1/2 - a, 1/2 + 1, 1/2], z),
+    # which is *very* messy. But since the meijer g actually yields a
+    # sum of bessel functions, things can sometimes be simplified a lot and
+    # are then put into tables...
+    assert can_do_meijer([], [], [a + S.Half], [a, a - b/2, a + b/2])
+    assert can_do_meijer([], [], [0, S.Half], [a, -a])
+    assert can_do_meijer([], [], [3*a - S.Half, a, -a - S.Half], [a - S.Half])
+    assert can_do_meijer([], [], [0, a - S.Half, -a - S.Half], [S.Half])
+    assert can_do_meijer([], [], [a, b + S.Half, b], [2*b - a])
+    assert can_do_meijer([], [], [a, b + S.Half, b, 2*b - a])
+    assert can_do_meijer([S.Half], [], [-a, a], [0])
+
+
+@slow
+def test_meijerg():
+    # carefully set up the parameters.
+    # NOTE: this used to fail sometimes. I believe it is fixed, but if you
+    #       hit an inexplicable test failure here, please let me know the seed.
+    a1, a2 = (randcplx(n) - 5*I - n*I for n in range(2))
+    b1, b2 = (randcplx(n) + 5*I + n*I for n in range(2))
+    b3, b4, b5, a3, a4, a5 = (randcplx() for n in range(6))
+    g = meijerg([a1], [a3, a4], [b1], [b3, b4], z)
+
+    assert ReduceOrder.meijer_minus(3, 4) is None
+    assert ReduceOrder.meijer_plus(4, 3) is None
+
+    g2 = meijerg([a1, a2], [a3, a4], [b1], [b3, b4, a2], z)
+    assert tn(ReduceOrder.meijer_plus(a2, a2).apply(g, op), g2, z)
+
+    g2 = meijerg([a1, a2], [a3, a4], [b1], [b3, b4, a2 + 1], z)
+    assert tn(ReduceOrder.meijer_plus(a2, a2 + 1).apply(g, op), g2, z)
+
+    g2 = meijerg([a1, a2 - 1], [a3, a4], [b1], [b3, b4, a2 + 2], z)
+    assert tn(ReduceOrder.meijer_plus(a2 - 1, a2 + 2).apply(g, op), g2, z)
+
+    g2 = meijerg([a1], [a3, a4, b2 - 1], [b1, b2 + 2], [b3, b4], z)
+    assert tn(ReduceOrder.meijer_minus(
+        b2 + 2, b2 - 1).apply(g, op), g2, z, tol=1e-6)
+
+    # test several-step reduction
+    an = [a1, a2]
+    bq = [b3, b4, a2 + 1]
+    ap = [a3, a4, b2 - 1]
+    bm = [b1, b2 + 1]
+    niq, ops = reduce_order_meijer(G_Function(an, ap, bm, bq))
+    assert niq.an == (a1,)
+    assert set(niq.ap) == {a3, a4}
+    assert niq.bm == (b1,)
+    assert set(niq.bq) == {b3, b4}
+    assert tn(apply_operators(g, ops, op), meijerg(an, ap, bm, bq, z), z)
+
+
+def test_meijerg_shift_operators():
+    # carefully set up the parameters. XXX this still fails sometimes
+    a1, a2, a3, a4, a5, b1, b2, b3, b4, b5 = (randcplx(n) for n in range(10))
+    g = meijerg([a1], [a3, a4], [b1], [b3, b4], z)
+
+    assert tn(MeijerShiftA(b1).apply(g, op),
+              meijerg([a1], [a3, a4], [b1 + 1], [b3, b4], z), z)
+    assert tn(MeijerShiftB(a1).apply(g, op),
+              meijerg([a1 - 1], [a3, a4], [b1], [b3, b4], z), z)
+    assert tn(MeijerShiftC(b3).apply(g, op),
+              meijerg([a1], [a3, a4], [b1], [b3 + 1, b4], z), z)
+    assert tn(MeijerShiftD(a3).apply(g, op),
+              meijerg([a1], [a3 - 1, a4], [b1], [b3, b4], z), z)
+
+    s = MeijerUnShiftA([a1], [a3, a4], [b1], [b3, b4], 0, z)
+    assert tn(
+        s.apply(g, op), meijerg([a1], [a3, a4], [b1 - 1], [b3, b4], z), z)
+
+    s = MeijerUnShiftC([a1], [a3, a4], [b1], [b3, b4], 0, z)
+    assert tn(
+        s.apply(g, op), meijerg([a1], [a3, a4], [b1], [b3 - 1, b4], z), z)
+
+    s = MeijerUnShiftB([a1], [a3, a4], [b1], [b3, b4], 0, z)
+    assert tn(
+        s.apply(g, op), meijerg([a1 + 1], [a3, a4], [b1], [b3, b4], z), z)
+
+    s = MeijerUnShiftD([a1], [a3, a4], [b1], [b3, b4], 0, z)
+    assert tn(
+        s.apply(g, op), meijerg([a1], [a3 + 1, a4], [b1], [b3, b4], z), z)
+
+
+@slow
+def test_meijerg_confluence():
+    def t(m, a, b):
+        from sympy.core.sympify import sympify
+        a, b = sympify([a, b])
+        m_ = m
+        m = hyperexpand(m)
+        if not m == Piecewise((a, abs(z) < 1), (b, abs(1/z) < 1), (m_, True)):
+            return False
+        if not (m.args[0].args[0] == a and m.args[1].args[0] == b):
+            return False
+        z0 = randcplx()/10
+        if abs(m.subs(z, z0).n() - a.subs(z, z0).n()).n() > 1e-10:
+            return False
+        if abs(m.subs(z, 1/z0).n() - b.subs(z, 1/z0).n()).n() > 1e-10:
+            return False
+        return True
+
+    assert t(meijerg([], [1, 1], [0, 0], [], z), -log(z), 0)
+    assert t(meijerg(
+        [], [3, 1], [0, 0], [], z), -z**2/4 + z - log(z)/2 - Rational(3, 4), 0)
+    assert t(meijerg([], [3, 1], [-1, 0], [], z),
+             z**2/12 - z/2 + log(z)/2 + Rational(1, 4) + 1/(6*z), 0)
+    assert t(meijerg([], [1, 1, 1, 1], [0, 0, 0, 0], [], z), -log(z)**3/6, 0)
+    assert t(meijerg([1, 1], [], [], [0, 0], z), 0, -log(1/z))
+    assert t(meijerg([1, 1], [2, 2], [1, 1], [0, 0], z),
+             -z*log(z) + 2*z, -log(1/z) + 2)
+    assert t(meijerg([S.Half], [1, 1], [0, 0], [Rational(3, 2)], z), log(z)/2 - 1, 0)
+
+    def u(an, ap, bm, bq):
+        m = meijerg(an, ap, bm, bq, z)
+        m2 = hyperexpand(m, allow_hyper=True)
+        if m2.has(meijerg) and not (m2.is_Piecewise and len(m2.args) == 3):
+            return False
+        return tn(m, m2, z)
+    assert u([], [1], [0, 0], [])
+    assert u([1, 1], [], [], [0])
+    assert u([1, 1], [2, 2, 5], [1, 1, 6], [0, 0])
+    assert u([1, 1], [2, 2, 5], [1, 1, 6], [0])
+
+
+def test_meijerg_with_Floats():
+    # see issue #10681
+    from sympy.polys.domains.realfield import RR
+    f = meijerg(((3.0, 1), ()), ((Rational(3, 2),), (0,)), z)
+    a = -2.3632718012073
+    g = a*z**Rational(3, 2)*hyper((-0.5, Rational(3, 2)), (Rational(5, 2),), z*exp_polar(I*pi))
+    assert RR.almosteq((hyperexpand(f)/g).n(), 1.0, 1e-12)
+
+
+def test_lerchphi():
+    from sympy.functions.special.zeta_functions import (lerchphi, polylog)
+    from sympy.simplify.gammasimp import gammasimp
+    assert hyperexpand(hyper([1, a], [a + 1], z)/a) == lerchphi(z, 1, a)
+    assert hyperexpand(
+        hyper([1, a, a], [a + 1, a + 1], z)/a**2) == lerchphi(z, 2, a)
+    assert hyperexpand(hyper([1, a, a, a], [a + 1, a + 1, a + 1], z)/a**3) == \
+        lerchphi(z, 3, a)
+    assert hyperexpand(hyper([1] + [a]*10, [a + 1]*10, z)/a**10) == \
+        lerchphi(z, 10, a)
+    assert gammasimp(hyperexpand(meijerg([0, 1 - a], [], [0],
+        [-a], exp_polar(-I*pi)*z))) == lerchphi(z, 1, a)
+    assert gammasimp(hyperexpand(meijerg([0, 1 - a, 1 - a], [], [0],
+        [-a, -a], exp_polar(-I*pi)*z))) == lerchphi(z, 2, a)
+    assert gammasimp(hyperexpand(meijerg([0, 1 - a, 1 - a, 1 - a], [], [0],
+        [-a, -a, -a], exp_polar(-I*pi)*z))) == lerchphi(z, 3, a)
+
+    assert hyperexpand(z*hyper([1, 1], [2], z)) == -log(1 + -z)
+    assert hyperexpand(z*hyper([1, 1, 1], [2, 2], z)) == polylog(2, z)
+    assert hyperexpand(z*hyper([1, 1, 1, 1], [2, 2, 2], z)) == polylog(3, z)
+
+    assert hyperexpand(hyper([1, a, 1 + S.Half], [a + 1, S.Half], z)) == \
+        -2*a/(z - 1) + (-2*a**2 + a)*lerchphi(z, 1, a)
+
+    # Now numerical tests. These make sure reductions etc are carried out
+    # correctly
+
+    # a rational function (polylog at negative integer order)
+    assert can_do([2, 2, 2], [1, 1])
+
+    # NOTE these contain log(1-x) etc ... better make sure we have |z| < 1
+    # reduction of order for polylog
+    assert can_do([1, 1, 1, b + 5], [2, 2, b], div=10)
+
+    # reduction of order for lerchphi
+    # XXX lerchphi in mpmath is flaky
+    assert can_do(
+        [1, a, a, a, b + 5], [a + 1, a + 1, a + 1, b], numerical=False)
+
+    # test a bug
+    from sympy.functions.elementary.complexes import Abs
+    assert hyperexpand(hyper([S.Half, S.Half, S.Half, 1],
+                             [Rational(3, 2), Rational(3, 2), Rational(3, 2)], Rational(1, 4))) == \
+        Abs(-polylog(3, exp_polar(I*pi)/2) + polylog(3, S.Half))
+
+
+def test_partial_simp():
+    # First test that hypergeometric function formulae work.
+    a, b, c, d, e = (randcplx() for _ in range(5))
+    for func in [Hyper_Function([a, b, c], [d, e]),
+            Hyper_Function([], [a, b, c, d, e])]:
+        f = build_hypergeometric_formula(func)
+        z = f.z
+        assert f.closed_form == func(z)
+        deriv1 = f.B.diff(z)*z
+        deriv2 = f.M*f.B
+        for func1, func2 in zip(deriv1, deriv2):
+            assert tn(func1, func2, z)
+
+    # Now test that formulae are partially simplified.
+    a, b, z = symbols('a b z')
+    assert hyperexpand(hyper([3, a], [1, b], z)) == \
+        (-a*b/2 + a*z/2 + 2*a)*hyper([a + 1], [b], z) \
+        + (a*b/2 - 2*a + 1)*hyper([a], [b], z)
+    assert tn(
+        hyperexpand(hyper([3, d], [1, e], z)), hyper([3, d], [1, e], z), z)
+    assert hyperexpand(hyper([3], [1, a, b], z)) == \
+        hyper((), (a, b), z) \
+        + z*hyper((), (a + 1, b), z)/(2*a) \
+        - z*(b - 4)*hyper((), (a + 1, b + 1), z)/(2*a*b)
+    assert tn(
+        hyperexpand(hyper([3], [1, d, e], z)), hyper([3], [1, d, e], z), z)
+
+
+def test_hyperexpand_special():
+    assert hyperexpand(hyper([a, b], [c], 1)) == \
+        gamma(c)*gamma(c - a - b)/gamma(c - a)/gamma(c - b)
+    assert hyperexpand(hyper([a, b], [1 + a - b], -1)) == \
+        gamma(1 + a/2)*gamma(1 + a - b)/gamma(1 + a)/gamma(1 + a/2 - b)
+    assert hyperexpand(hyper([a, b], [1 + b - a], -1)) == \
+        gamma(1 + b/2)*gamma(1 + b - a)/gamma(1 + b)/gamma(1 + b/2 - a)
+    assert hyperexpand(meijerg([1 - z - a/2], [1 - z + a/2], [b/2], [-b/2], 1)) == \
+        gamma(1 - 2*z)*gamma(z + a/2 + b/2)/gamma(1 - z + a/2 - b/2) \
+        /gamma(1 - z - a/2 + b/2)/gamma(1 - z + a/2 + b/2)
+    assert hyperexpand(hyper([a], [b], 0)) == 1
+    assert hyper([a], [b], 0) != 0
+
+
+def test_Mod1_behavior():
+    from sympy.core.symbol import Symbol
+    from sympy.simplify.simplify import simplify
+    n = Symbol('n', integer=True)
+    # Note: this should not hang.
+    assert simplify(hyperexpand(meijerg([1], [], [n + 1], [0], z))) == \
+        lowergamma(n + 1, z)
+
+
+@slow
+def test_prudnikov_misc():
+    assert can_do([1, (3 + I)/2, (3 - I)/2], [Rational(3, 2), 2])
+    assert can_do([S.Half, a - 1], [Rational(3, 2), a + 1], lowerplane=True)
+    assert can_do([], [b + 1])
+    assert can_do([a], [a - 1, b + 1])
+
+    assert can_do([a], [a - S.Half, 2*a])
+    assert can_do([a], [a - S.Half, 2*a + 1])
+    assert can_do([a], [a - S.Half, 2*a - 1])
+    assert can_do([a], [a + S.Half, 2*a])
+    assert can_do([a], [a + S.Half, 2*a + 1])
+    assert can_do([a], [a + S.Half, 2*a - 1])
+    assert can_do([S.Half], [b, 2 - b])
+    assert can_do([S.Half], [b, 3 - b])
+    assert can_do([1], [2, b])
+
+    assert can_do([a, a + S.Half], [2*a, b, 2*a - b + 1])
+    assert can_do([a, a + S.Half], [S.Half, 2*a, 2*a + S.Half])
+    assert can_do([a], [a + 1], lowerplane=True)  # lowergamma
+
+
+def test_prudnikov_1():
+    # A. P. Prudnikov, Yu. A. Brychkov and O. I. Marichev (1990).
+    # Integrals and Series: More Special Functions, Vol. 3,.
+    # Gordon and Breach Science Publisher
+
+    # 7.3.1
+    assert can_do([a, -a], [S.Half])
+    assert can_do([a, 1 - a], [S.Half])
+    assert can_do([a, 1 - a], [Rational(3, 2)])
+    assert can_do([a, 2 - a], [S.Half])
+    assert can_do([a, 2 - a], [Rational(3, 2)])
+    assert can_do([a, 2 - a], [Rational(3, 2)])
+    assert can_do([a, a + S.Half], [2*a - 1])
+    assert can_do([a, a + S.Half], [2*a])
+    assert can_do([a, a + S.Half], [2*a + 1])
+    assert can_do([a, a + S.Half], [S.Half])
+    assert can_do([a, a + S.Half], [Rational(3, 2)])
+    assert can_do([a, a/2 + 1], [a/2])
+    assert can_do([1, b], [2])
+    assert can_do([1, b], [b + 1], numerical=False)  # Lerch Phi
+             # NOTE: branches are complicated for |z| > 1
+
+    assert can_do([a], [2*a])
+    assert can_do([a], [2*a + 1])
+    assert can_do([a], [2*a - 1])
+
+
+@slow
+def test_prudnikov_2():
+    h = S.Half
+    assert can_do([-h, -h], [h])
+    assert can_do([-h, h], [3*h])
+    assert can_do([-h, h], [5*h])
+    assert can_do([-h, h], [7*h])
+    assert can_do([-h, 1], [h])
+
+    for p in [-h, h]:
+        for n in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]:
+            for m in [-h, h, 3*h, 5*h, 7*h]:
+                assert can_do([p, n], [m])
+        for n in [1, 2, 3, 4]:
+            for m in [1, 2, 3, 4]:
+                assert can_do([p, n], [m])
+
+
+def test_prudnikov_3():
+    h = S.Half
+    assert can_do([Rational(1, 4), Rational(3, 4)], [h])
+    assert can_do([Rational(1, 4), Rational(3, 4)], [3*h])
+    assert can_do([Rational(1, 3), Rational(2, 3)], [3*h])
+    assert can_do([Rational(3, 4), Rational(5, 4)], [h])
+    assert can_do([Rational(3, 4), Rational(5, 4)], [3*h])
+
+
+@tooslow
+def test_prudnikov_3_slow():
+    # XXX: This is marked as tooslow and hence skipped in CI. None of the
+    # individual cases below fails or hangs. Some cases are slow and the loops
+    # below generate 280 different cases. Is it really necessary to test all
+    # 280 cases here?
+    h = S.Half
+    for p in [1, 2, 3, 4]:
+        for n in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4, 9*h]:
+            for m in [1, 3*h, 2, 5*h, 3, 7*h, 4]:
+                assert can_do([p, m], [n])
+
+
+@slow
+def test_prudnikov_4():
+    h = S.Half
+    for p in [3*h, 5*h, 7*h]:
+        for n in [-h, h, 3*h, 5*h, 7*h]:
+            for m in [3*h, 2, 5*h, 3, 7*h, 4]:
+                assert can_do([p, m], [n])
+        for n in [1, 2, 3, 4]:
+            for m in [2, 3, 4]:
+                assert can_do([p, m], [n])
+
+
+@slow
+def test_prudnikov_5():
+    h = S.Half
+
+    for p in [1, 2, 3]:
+        for q in range(p, 4):
+            for r in [1, 2, 3]:
+                for s in range(r, 4):
+                    assert can_do([-h, p, q], [r, s])
+
+    for p in [h, 1, 3*h, 2, 5*h, 3]:
+        for q in [h, 3*h, 5*h]:
+            for r in [h, 3*h, 5*h]:
+                for s in [h, 3*h, 5*h]:
+                    if s <= q and s <= r:
+                        assert can_do([-h, p, q], [r, s])
+
+    for p in [h, 1, 3*h, 2, 5*h, 3]:
+        for q in [1, 2, 3]:
+            for r in [h, 3*h, 5*h]:
+                for s in [1, 2, 3]:
+                    assert can_do([-h, p, q], [r, s])
+
+
+@slow
+def test_prudnikov_6():
+    h = S.Half
+
+    for m in [3*h, 5*h]:
+        for n in [1, 2, 3]:
+            for q in [h, 1, 2]:
+                for p in [1, 2, 3]:
+                    assert can_do([h, q, p], [m, n])
+            for q in [1, 2, 3]:
+                for p in [3*h, 5*h]:
+                    assert can_do([h, q, p], [m, n])
+
+    for q in [1, 2]:
+        for p in [1, 2, 3]:
+            for m in [1, 2, 3]:
+                for n in [1, 2, 3]:
+                    assert can_do([h, q, p], [m, n])
+
+    assert can_do([h, h, 5*h], [3*h, 3*h])
+    assert can_do([h, 1, 5*h], [3*h, 3*h])
+    assert can_do([h, 2, 2], [1, 3])
+
+    # pages 435 to 457 contain more PFDD and stuff like this
+
+
+@slow
+def test_prudnikov_7():
+    assert can_do([3], [6])
+
+    h = S.Half
+    for n in [h, 3*h, 5*h, 7*h]:
+        assert can_do([-h], [n])
+    for m in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]:  # HERE
+        for n in [-h, h, 3*h, 5*h, 7*h, 1, 2, 3, 4]:
+            assert can_do([m], [n])
+
+
+@slow
+def test_prudnikov_8():
+    h = S.Half
+
+    # 7.12.2
+    for ai in [1, 2, 3]:
+        for bi in [1, 2, 3]:
+            for ci in range(1, ai + 1):
+                for di in [h, 1, 3*h, 2, 5*h, 3]:
+                    assert can_do([ai, bi], [ci, di])
+        for bi in [3*h, 5*h]:
+            for ci in [h, 1, 3*h, 2, 5*h, 3]:
+                for di in [1, 2, 3]:
+                    assert can_do([ai, bi], [ci, di])
+
+    for ai in [-h, h, 3*h, 5*h]:
+        for bi in [1, 2, 3]:
+            for ci in [h, 1, 3*h, 2, 5*h, 3]:
+                for di in [1, 2, 3]:
+                    assert can_do([ai, bi], [ci, di])
+        for bi in [h, 3*h, 5*h]:
+            for ci in [h, 3*h, 5*h, 3]:
+                for di in [h, 1, 3*h, 2, 5*h, 3]:
+                    if ci <= bi:
+                        assert can_do([ai, bi], [ci, di])
+
+
+def test_prudnikov_9():
+    # 7.13.1 [we have a general formula ... so this is a bit pointless]
+    for i in range(9):
+        assert can_do([], [(S(i) + 1)/2])
+    for i in range(5):
+        assert can_do([], [-(2*S(i) + 1)/2])
+
+
+@slow
+def test_prudnikov_10():
+    # 7.14.2
+    h = S.Half
+    for p in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]:
+        for m in [1, 2, 3, 4]:
+            for n in range(m, 5):
+                assert can_do([p], [m, n])
+
+    for p in [1, 2, 3, 4]:
+        for n in [h, 3*h, 5*h, 7*h]:
+            for m in [1, 2, 3, 4]:
+                assert can_do([p], [n, m])
+
+    for p in [3*h, 5*h, 7*h]:
+        for m in [h, 1, 2, 5*h, 3, 7*h, 4]:
+            assert can_do([p], [h, m])
+            assert can_do([p], [3*h, m])
+
+    for m in [h, 1, 2, 5*h, 3, 7*h, 4]:
+        assert can_do([7*h], [5*h, m])
+
+    assert can_do([Rational(-1, 2)], [S.Half, S.Half])  # shine-integral shi
+
+
+def test_prudnikov_11():
+    # 7.15
+    assert can_do([a, a + S.Half], [2*a, b, 2*a - b])
+    assert can_do([a, a + S.Half], [Rational(3, 2), 2*a, 2*a - S.Half])
+
+    assert can_do([Rational(1, 4), Rational(3, 4)], [S.Half, S.Half, 1])
+    assert can_do([Rational(5, 4), Rational(3, 4)], [Rational(3, 2), S.Half, 2])
+    assert can_do([Rational(5, 4), Rational(3, 4)], [Rational(3, 2), Rational(3, 2), 1])
+    assert can_do([Rational(5, 4), Rational(7, 4)], [Rational(3, 2), Rational(5, 2), 2])
+
+    assert can_do([1, 1], [Rational(3, 2), 2, 2])  # cosh-integral chi
+
+
+def test_prudnikov_12():
+    # 7.16
+    assert can_do(
+        [], [a, a + S.Half, 2*a], False)  # branches only agree for some z!
+    assert can_do([], [a, a + S.Half, 2*a + 1], False)  # dito
+    assert can_do([], [S.Half, a, a + S.Half])
+    assert can_do([], [Rational(3, 2), a, a + S.Half])
+
+    assert can_do([], [Rational(1, 4), S.Half, Rational(3, 4)])
+    assert can_do([], [S.Half, S.Half, 1])
+    assert can_do([], [S.Half, Rational(3, 2), 1])
+    assert can_do([], [Rational(3, 4), Rational(3, 2), Rational(5, 4)])
+    assert can_do([], [1, 1, Rational(3, 2)])
+    assert can_do([], [1, 2, Rational(3, 2)])
+    assert can_do([], [1, Rational(3, 2), Rational(3, 2)])
+    assert can_do([], [Rational(5, 4), Rational(3, 2), Rational(7, 4)])
+    assert can_do([], [2, Rational(3, 2), Rational(3, 2)])
+
+
+@slow
+def test_prudnikov_2F1():
+    h = S.Half
+    # Elliptic integrals
+    for p in [-h, h]:
+        for m in [h, 3*h, 5*h, 7*h]:
+            for n in [1, 2, 3, 4]:
+                assert can_do([p, m], [n])
+
+
+@XFAIL
+def test_prudnikov_fail_2F1():
+    assert can_do([a, b], [b + 1])  # incomplete beta function
+    assert can_do([-1, b], [c])    # Poly. also -2, -3 etc
+
+    # TODO polys
+
+    # Legendre functions:
+    assert can_do([a, b], [a + b + S.Half])
+    assert can_do([a, b], [a + b - S.Half])
+    assert can_do([a, b], [a + b + Rational(3, 2)])
+    assert can_do([a, b], [(a + b + 1)/2])
+    assert can_do([a, b], [(a + b)/2 + 1])
+    assert can_do([a, b], [a - b + 1])
+    assert can_do([a, b], [a - b + 2])
+    assert can_do([a, b], [2*b])
+    assert can_do([a, b], [S.Half])
+    assert can_do([a, b], [Rational(3, 2)])
+    assert can_do([a, 1 - a], [c])
+    assert can_do([a, 2 - a], [c])
+    assert can_do([a, 3 - a], [c])
+    assert can_do([a, a + S.Half], [c])
+    assert can_do([1, b], [c])
+    assert can_do([1, b], [Rational(3, 2)])
+
+    assert can_do([Rational(1, 4), Rational(3, 4)], [1])
+
+    # PFDD
+    o = S.One
+    assert can_do([o/8, 1], [o/8*9])
+    assert can_do([o/6, 1], [o/6*7])
+    assert can_do([o/6, 1], [o/6*13])
+    assert can_do([o/5, 1], [o/5*6])
+    assert can_do([o/5, 1], [o/5*11])
+    assert can_do([o/4, 1], [o/4*5])
+    assert can_do([o/4, 1], [o/4*9])
+    assert can_do([o/3, 1], [o/3*4])
+    assert can_do([o/3, 1], [o/3*7])
+    assert can_do([o/8*3, 1], [o/8*11])
+    assert can_do([o/5*2, 1], [o/5*7])
+    assert can_do([o/5*2, 1], [o/5*12])
+    assert can_do([o/5*3, 1], [o/5*8])
+    assert can_do([o/5*3, 1], [o/5*13])
+    assert can_do([o/8*5, 1], [o/8*13])
+    assert can_do([o/4*3, 1], [o/4*7])
+    assert can_do([o/4*3, 1], [o/4*11])
+    assert can_do([o/3*2, 1], [o/3*5])
+    assert can_do([o/3*2, 1], [o/3*8])
+    assert can_do([o/5*4, 1], [o/5*9])
+    assert can_do([o/5*4, 1], [o/5*14])
+    assert can_do([o/6*5, 1], [o/6*11])
+    assert can_do([o/6*5, 1], [o/6*17])
+    assert can_do([o/8*7, 1], [o/8*15])
+
+
+@XFAIL
+def test_prudnikov_fail_3F2():
+    assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(1, 3), Rational(2, 3)])
+    assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(2, 3), Rational(4, 3)])
+    assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(4, 3), Rational(5, 3)])
+
+    # page 421
+    assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [a*Rational(3, 2), (3*a + 1)/2])
+
+    # pages 422 ...
+    assert can_do([Rational(-1, 2), S.Half, S.Half], [1, 1])  # elliptic integrals
+    assert can_do([Rational(-1, 2), S.Half, 1], [Rational(3, 2), Rational(3, 2)])
+    # TODO LOTS more
+
+    # PFDD
+    assert can_do([Rational(1, 8), Rational(3, 8), 1], [Rational(9, 8), Rational(11, 8)])
+    assert can_do([Rational(1, 8), Rational(5, 8), 1], [Rational(9, 8), Rational(13, 8)])
+    assert can_do([Rational(1, 8), Rational(7, 8), 1], [Rational(9, 8), Rational(15, 8)])
+    assert can_do([Rational(1, 6), Rational(1, 3), 1], [Rational(7, 6), Rational(4, 3)])
+    assert can_do([Rational(1, 6), Rational(2, 3), 1], [Rational(7, 6), Rational(5, 3)])
+    assert can_do([Rational(1, 6), Rational(2, 3), 1], [Rational(5, 3), Rational(13, 6)])
+    assert can_do([S.Half, 1, 1], [Rational(1, 4), Rational(3, 4)])
+    # LOTS more
+
+
+@XFAIL
+def test_prudnikov_fail_other():
+    # 7.11.2
+
+    # 7.12.1
+    assert can_do([1, a], [b, 1 - 2*a + b])  # ???
+
+    # 7.14.2
+    assert can_do([Rational(-1, 2)], [S.Half, 1])  # struve
+    assert can_do([1], [S.Half, S.Half])  # struve
+    assert can_do([Rational(1, 4)], [S.Half, Rational(5, 4)])  # PFDD
+    assert can_do([Rational(3, 4)], [Rational(3, 2), Rational(7, 4)])  # PFDD
+    assert can_do([1], [Rational(1, 4), Rational(3, 4)])  # PFDD
+    assert can_do([1], [Rational(3, 4), Rational(5, 4)])  # PFDD
+    assert can_do([1], [Rational(5, 4), Rational(7, 4)])  # PFDD
+    # TODO LOTS more
+
+    # 7.15.2
+    assert can_do([S.Half, 1], [Rational(3, 4), Rational(5, 4), Rational(3, 2)])  # PFDD
+    assert can_do([S.Half, 1], [Rational(7, 4), Rational(5, 4), Rational(3, 2)])  # PFDD
+
+    # 7.16.1
+    assert can_do([], [Rational(1, 3), S(2/3)])  # PFDD
+    assert can_do([], [Rational(2, 3), S(4/3)])  # PFDD
+    assert can_do([], [Rational(5, 3), S(4/3)])  # PFDD
+
+    # XXX this does not *evaluate* right??
+    assert can_do([], [a, a + S.Half, 2*a - 1])
+
+
+def test_bug():
+    h = hyper([-1, 1], [z], -1)
+    assert hyperexpand(h) == (z + 1)/z
+
+
+def test_omgissue_203():
+    h = hyper((-5, -3, -4), (-6, -6), 1)
+    assert hyperexpand(h) == Rational(1, 30)
+    h = hyper((-6, -7, -5), (-6, -6), 1)
+    assert hyperexpand(h) == Rational(-1, 6)

lib/python3.12/site-packages/sympy/simplify/tests/test_powsimp.py

@@ -0,0 +1,366 @@
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.numbers import (E, I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import sin
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.simplify.powsimp import (powdenest, powsimp)
+from sympy.simplify.simplify import (signsimp, simplify)
+from sympy.core.symbol import Str
+
+from sympy.abc import x, y, z, a, b
+
+
+def test_powsimp():
+    x, y, z, n = symbols('x,y,z,n')
+    f = Function('f')
+    assert powsimp( 4**x * 2**(-x) * 2**(-x) ) == 1
+    assert powsimp( (-4)**x * (-2)**(-x) * 2**(-x) ) == 1
+
+    assert powsimp(
+        f(4**x * 2**(-x) * 2**(-x)) ) == f(4**x * 2**(-x) * 2**(-x))
+    assert powsimp( f(4**x * 2**(-x) * 2**(-x)), deep=True ) == f(1)
+    assert exp(x)*exp(y) == exp(x)*exp(y)
+    assert powsimp(exp(x)*exp(y)) == exp(x + y)
+    assert powsimp(exp(x)*exp(y)*2**x*2**y) == (2*E)**(x + y)
+    assert powsimp(exp(x)*exp(y)*2**x*2**y, combine='exp') == \
+        exp(x + y)*2**(x + y)
+    assert powsimp(exp(x)*exp(y)*exp(2)*sin(x) + sin(y) + 2**x*2**y) == \
+        exp(2 + x + y)*sin(x) + sin(y) + 2**(x + y)
+    assert powsimp(sin(exp(x)*exp(y))) == sin(exp(x)*exp(y))
+    assert powsimp(sin(exp(x)*exp(y)), deep=True) == sin(exp(x + y))
+    assert powsimp(x**2*x**y) == x**(2 + y)
+    # This should remain factored, because 'exp' with deep=True is supposed
+    # to act like old automatic exponent combining.
+    assert powsimp((1 + E*exp(E))*exp(-E), combine='exp', deep=True) == \
+        (1 + exp(1 + E))*exp(-E)
+    assert powsimp((1 + E*exp(E))*exp(-E), deep=True) == \
+        (1 + exp(1 + E))*exp(-E)
+    assert powsimp((1 + E*exp(E))*exp(-E)) == (1 + exp(1 + E))*exp(-E)
+    assert powsimp((1 + E*exp(E))*exp(-E), combine='exp') == \
+        (1 + exp(1 + E))*exp(-E)
+    assert powsimp((1 + E*exp(E))*exp(-E), combine='base') == \
+        (1 + E*exp(E))*exp(-E)
+    x, y = symbols('x,y', nonnegative=True)
+    n = Symbol('n', real=True)
+    assert powsimp(y**n * (y/x)**(-n)) == x**n
+    assert powsimp(x**(x**(x*y)*y**(x*y))*y**(x**(x*y)*y**(x*y)), deep=True) \
+        == (x*y)**(x*y)**(x*y)
+    assert powsimp(2**(2**(2*x)*x), deep=False) == 2**(2**(2*x)*x)
+    assert powsimp(2**(2**(2*x)*x), deep=True) == 2**(x*4**x)
+    assert powsimp(
+        exp(-x + exp(-x)*exp(-x*log(x))), deep=False, combine='exp') == \
+        exp(-x + exp(-x)*exp(-x*log(x)))
+    assert powsimp(
+        exp(-x + exp(-x)*exp(-x*log(x))), deep=False, combine='exp') == \
+        exp(-x + exp(-x)*exp(-x*log(x)))
+    assert powsimp((x + y)/(3*z), deep=False, combine='exp') == (x + y)/(3*z)
+    assert powsimp((x/3 + y/3)/z, deep=True, combine='exp') == (x/3 + y/3)/z
+    assert powsimp(exp(x)/(1 + exp(x)*exp(y)), deep=True) == \
+        exp(x)/(1 + exp(x + y))
+    assert powsimp(x*y**(z**x*z**y), deep=True) == x*y**(z**(x + y))
+    assert powsimp((z**x*z**y)**x, deep=True) == (z**(x + y))**x
+    assert powsimp(x*(z**x*z**y)**x, deep=True) == x*(z**(x + y))**x
+    p = symbols('p', positive=True)
+    assert powsimp((1/x)**log(2)/x) == (1/x)**(1 + log(2))
+    assert powsimp((1/p)**log(2)/p) == p**(-1 - log(2))
+
+    # coefficient of exponent can only be simplified for positive bases
+    assert powsimp(2**(2*x)) == 4**x
+    assert powsimp((-1)**(2*x)) == (-1)**(2*x)
+    i = symbols('i', integer=True)
+    assert powsimp((-1)**(2*i)) == 1
+    assert powsimp((-1)**(-x)) != (-1)**x  # could be 1/((-1)**x), but is not
+    # force=True overrides assumptions
+    assert powsimp((-1)**(2*x), force=True) == 1
+
+    # rational exponents allow combining of negative terms
+    w, n, m = symbols('w n m', negative=True)
+    e = i/a  # not a rational exponent if `a` is unknown
+    ex = w**e*n**e*m**e
+    assert powsimp(ex) == m**(i/a)*n**(i/a)*w**(i/a)
+    e = i/3
+    ex = w**e*n**e*m**e
+    assert powsimp(ex) == (-1)**i*(-m*n*w)**(i/3)
+    e = (3 + i)/i
+    ex = w**e*n**e*m**e
+    assert powsimp(ex) == (-1)**(3*e)*(-m*n*w)**e
+
+    eq = x**(a*Rational(2, 3))
+    # eq != (x**a)**(2/3) (try x = -1 and a = 3 to see)
+    assert powsimp(eq).exp == eq.exp == a*Rational(2, 3)
+    # powdenest goes the other direction
+    assert powsimp(2**(2*x)) == 4**x
+
+    assert powsimp(exp(p/2)) == exp(p/2)
+
+    # issue 6368
+    eq = Mul(*[sqrt(Dummy(imaginary=True)) for i in range(3)])
+    assert powsimp(eq) == eq and eq.is_Mul
+
+    assert all(powsimp(e) == e for e in (sqrt(x**a), sqrt(x**2)))
+
+    # issue 8836
+    assert str( powsimp(exp(I*pi/3)*root(-1,3)) ) == '(-1)**(2/3)'
+
+    # issue 9183
+    assert powsimp(-0.1**x) == -0.1**x
+
+    # issue 10095
+    assert powsimp((1/(2*E))**oo) == (exp(-1)/2)**oo
+
+    # PR 13131
+    eq = sin(2*x)**2*sin(2.0*x)**2
+    assert powsimp(eq) == eq
+
+    # issue 14615
+    assert powsimp(x**2*y**3*(x*y**2)**Rational(3, 2)
+        ) == x*y*(x*y**2)**Rational(5, 2)
+
+
+def test_powsimp_negated_base():
+    assert powsimp((-x + y)/sqrt(x - y)) == -sqrt(x - y)
+    assert powsimp((-x + y)*(-z + y)/sqrt(x - y)/sqrt(z - y)) == sqrt(x - y)*sqrt(z - y)
+    p = symbols('p', positive=True)
+    reps = {p: 2, a: S.Half}
+    assert powsimp((-p)**a/p**a).subs(reps) == ((-1)**a).subs(reps)
+    assert powsimp((-p)**a*p**a).subs(reps) == ((-p**2)**a).subs(reps)
+    n = symbols('n', negative=True)
+    reps = {p: -2, a: S.Half}
+    assert powsimp((-n)**a/n**a).subs(reps) == (-1)**(-a).subs(a, S.Half)
+    assert powsimp((-n)**a*n**a).subs(reps) == ((-n**2)**a).subs(reps)
+    # if x is 0 then the lhs is 0**a*oo**a which is not (-1)**a
+    eq = (-x)**a/x**a
+    assert powsimp(eq) == eq
+
+
+def test_powsimp_nc():
+    x, y, z = symbols('x,y,z')
+    A, B, C = symbols('A B C', commutative=False)
+
+    assert powsimp(A**x*A**y, combine='all') == A**(x + y)
+    assert powsimp(A**x*A**y, combine='base') == A**x*A**y
+    assert powsimp(A**x*A**y, combine='exp') == A**(x + y)
+
+    assert powsimp(A**x*B**x, combine='all') == A**x*B**x
+    assert powsimp(A**x*B**x, combine='base') == A**x*B**x
+    assert powsimp(A**x*B**x, combine='exp') == A**x*B**x
+
+    assert powsimp(B**x*A**x, combine='all') == B**x*A**x
+    assert powsimp(B**x*A**x, combine='base') == B**x*A**x
+    assert powsimp(B**x*A**x, combine='exp') == B**x*A**x
+
+    assert powsimp(A**x*A**y*A**z, combine='all') == A**(x + y + z)
+    assert powsimp(A**x*A**y*A**z, combine='base') == A**x*A**y*A**z
+    assert powsimp(A**x*A**y*A**z, combine='exp') == A**(x + y + z)
+
+    assert powsimp(A**x*B**x*C**x, combine='all') == A**x*B**x*C**x
+    assert powsimp(A**x*B**x*C**x, combine='base') == A**x*B**x*C**x
+    assert powsimp(A**x*B**x*C**x, combine='exp') == A**x*B**x*C**x
+
+    assert powsimp(B**x*A**x*C**x, combine='all') == B**x*A**x*C**x
+    assert powsimp(B**x*A**x*C**x, combine='base') == B**x*A**x*C**x
+    assert powsimp(B**x*A**x*C**x, combine='exp') == B**x*A**x*C**x
+
+
+def test_issue_6440():
+    assert powsimp(16*2**a*8**b) == 2**(a + 3*b + 4)
+
+
+def test_powdenest():
+    x, y = symbols('x,y')
+    p, q = symbols('p q', positive=True)
+    i, j = symbols('i,j', integer=True)
+
+    assert powdenest(x) == x
+    assert powdenest(x + 2*(x**(a*Rational(2, 3)))**(3*x)) == (x + 2*(x**(a*Rational(2, 3)))**(3*x))
+    assert powdenest((exp(a*Rational(2, 3)))**(3*x))  # -X-> (exp(a/3))**(6*x)
+    assert powdenest((x**(a*Rational(2, 3)))**(3*x)) == ((x**(a*Rational(2, 3)))**(3*x))
+    assert powdenest(exp(3*x*log(2))) == 2**(3*x)
+    assert powdenest(sqrt(p**2)) == p
+    eq = p**(2*i)*q**(4*i)
+    assert powdenest(eq) == (p*q**2)**(2*i)
+    # -X-> (x**x)**i*(x**x)**j == x**(x*(i + j))
+    assert powdenest((x**x)**(i + j))
+    assert powdenest(exp(3*y*log(x))) == x**(3*y)
+    assert powdenest(exp(y*(log(a) + log(b)))) == (a*b)**y
+    assert powdenest(exp(3*(log(a) + log(b)))) == a**3*b**3
+    assert powdenest(((x**(2*i))**(3*y))**x) == ((x**(2*i))**(3*y))**x
+    assert powdenest(((x**(2*i))**(3*y))**x, force=True) == x**(6*i*x*y)
+    assert powdenest(((x**(a*Rational(2, 3)))**(3*y/i))**x) == \
+        (((x**(a*Rational(2, 3)))**(3*y/i))**x)
+    assert powdenest((x**(2*i)*y**(4*i))**z, force=True) == (x*y**2)**(2*i*z)
+    assert powdenest((p**(2*i)*q**(4*i))**j) == (p*q**2)**(2*i*j)
+    e = ((p**(2*a))**(3*y))**x
+    assert powdenest(e) == e
+    e = ((x**2*y**4)**a)**(x*y)
+    assert powdenest(e) == e
+    e = (((x**2*y**4)**a)**(x*y))**3
+    assert powdenest(e) == ((x**2*y**4)**a)**(3*x*y)
+    assert powdenest((((x**2*y**4)**a)**(x*y)), force=True) == \
+        (x*y**2)**(2*a*x*y)
+    assert powdenest((((x**2*y**4)**a)**(x*y))**3, force=True) == \
+        (x*y**2)**(6*a*x*y)
+    assert powdenest((x**2*y**6)**i) != (x*y**3)**(2*i)
+    x, y = symbols('x,y', positive=True)
+    assert powdenest((x**2*y**6)**i) == (x*y**3)**(2*i)
+
+    assert powdenest((x**(i*Rational(2, 3))*y**(i/2))**(2*i)) == (x**Rational(4, 3)*y)**(i**2)
+    assert powdenest(sqrt(x**(2*i)*y**(6*i))) == (x*y**3)**i
+
+    assert powdenest(4**x) == 2**(2*x)
+    assert powdenest((4**x)**y) == 2**(2*x*y)
+    assert powdenest(4**x*y) == 2**(2*x)*y
+
+
+def test_powdenest_polar():
+    x, y, z = symbols('x y z', polar=True)
+    a, b, c = symbols('a b c')
+    assert powdenest((x*y*z)**a) == x**a*y**a*z**a
+    assert powdenest((x**a*y**b)**c) == x**(a*c)*y**(b*c)
+    assert powdenest(((x**a)**b*y**c)**c) == x**(a*b*c)*y**(c**2)
+
+
+def test_issue_5805():
+    arg = ((gamma(x)*hyper((), (), x))*pi)**2
+    assert powdenest(arg) == (pi*gamma(x)*hyper((), (), x))**2
+    assert arg.is_positive is None
+
+
+def test_issue_9324_powsimp_on_matrix_symbol():
+    M = MatrixSymbol('M', 10, 10)
+    expr = powsimp(M, deep=True)
+    assert expr == M
+    assert expr.args[0] == Str('M')
+
+
+def test_issue_6367():
+    z = -5*sqrt(2)/(2*sqrt(2*sqrt(29) + 29)) + sqrt(-sqrt(29)/29 + S.Half)
+    assert Mul(*[powsimp(a) for a in Mul.make_args(z.normal())]) == 0
+    assert powsimp(z.normal()) == 0
+    assert simplify(z) == 0
+    assert powsimp(sqrt(2 + sqrt(3))*sqrt(2 - sqrt(3)) + 1) == 2
+    assert powsimp(z) != 0
+
+
+def test_powsimp_polar():
+    from sympy.functions.elementary.complexes import polar_lift
+    from sympy.functions.elementary.exponential import exp_polar
+    x, y, z = symbols('x y z')
+    p, q, r = symbols('p q r', polar=True)
+
+    assert (polar_lift(-1))**(2*x) == exp_polar(2*pi*I*x)
+    assert powsimp(p**x * q**x) == (p*q)**x
+    assert p**x * (1/p)**x == 1
+    assert (1/p)**x == p**(-x)
+
+    assert exp_polar(x)*exp_polar(y) == exp_polar(x)*exp_polar(y)
+    assert powsimp(exp_polar(x)*exp_polar(y)) == exp_polar(x + y)
+    assert powsimp(exp_polar(x)*exp_polar(y)*p**x*p**y) == \
+        (p*exp_polar(1))**(x + y)
+    assert powsimp(exp_polar(x)*exp_polar(y)*p**x*p**y, combine='exp') == \
+        exp_polar(x + y)*p**(x + y)
+    assert powsimp(
+        exp_polar(x)*exp_polar(y)*exp_polar(2)*sin(x) + sin(y) + p**x*p**y) \
+        == p**(x + y) + sin(x)*exp_polar(2 + x + y) + sin(y)
+    assert powsimp(sin(exp_polar(x)*exp_polar(y))) == \
+        sin(exp_polar(x)*exp_polar(y))
+    assert powsimp(sin(exp_polar(x)*exp_polar(y)), deep=True) == \
+        sin(exp_polar(x + y))
+
+
+def test_issue_5728():
+    b = x*sqrt(y)
+    a = sqrt(b)
+    c = sqrt(sqrt(x)*y)
+    assert powsimp(a*b) == sqrt(b)**3
+    assert powsimp(a*b**2*sqrt(y)) == sqrt(y)*a**5
+    assert powsimp(a*x**2*c**3*y) == c**3*a**5
+    assert powsimp(a*x*c**3*y**2) == c**7*a
+    assert powsimp(x*c**3*y**2) == c**7
+    assert powsimp(x*c**3*y) == x*y*c**3
+    assert powsimp(sqrt(x)*c**3*y) == c**5
+    assert powsimp(sqrt(x)*a**3*sqrt(y)) == sqrt(x)*sqrt(y)*a**3
+    assert powsimp(Mul(sqrt(x)*c**3*sqrt(y), y, evaluate=False)) == \
+        sqrt(x)*sqrt(y)**3*c**3
+    assert powsimp(a**2*a*x**2*y) == a**7
+
+    # symbolic powers work, too
+    b = x**y*y
+    a = b*sqrt(b)
+    assert a.is_Mul is True
+    assert powsimp(a) == sqrt(b)**3
+
+    # as does exp
+    a = x*exp(y*Rational(2, 3))
+    assert powsimp(a*sqrt(a)) == sqrt(a)**3
+    assert powsimp(a**2*sqrt(a)) == sqrt(a)**5
+    assert powsimp(a**2*sqrt(sqrt(a))) == sqrt(sqrt(a))**9
+
+
+def test_issue_from_PR1599():
+    n1, n2, n3, n4 = symbols('n1 n2 n3 n4', negative=True)
+    assert (powsimp(sqrt(n1)*sqrt(n2)*sqrt(n3)) ==
+        -I*sqrt(-n1)*sqrt(-n2)*sqrt(-n3))
+    assert (powsimp(root(n1, 3)*root(n2, 3)*root(n3, 3)*root(n4, 3)) ==
+        -(-1)**Rational(1, 3)*
+        (-n1)**Rational(1, 3)*(-n2)**Rational(1, 3)*(-n3)**Rational(1, 3)*(-n4)**Rational(1, 3))
+
+
+def test_issue_10195():
+    a = Symbol('a', integer=True)
+    l = Symbol('l', even=True, nonzero=True)
+    n = Symbol('n', odd=True)
+    e_x = (-1)**(n/2 - S.Half) - (-1)**(n*Rational(3, 2) - S.Half)
+    assert powsimp((-1)**(l/2)) == I**l
+    assert powsimp((-1)**(n/2)) == I**n
+    assert powsimp((-1)**(n*Rational(3, 2))) == -I**n
+    assert powsimp(e_x) == (-1)**(n/2 - S.Half) + (-1)**(n*Rational(3, 2) +
+            S.Half)
+    assert powsimp((-1)**(a*Rational(3, 2))) == (-I)**a
+
+def test_issue_15709():
+    assert powsimp(3**x*Rational(2, 3)) == 2*3**(x-1)
+    assert powsimp(2*3**x/3) == 2*3**(x-1)
+
+
+def test_issue_11981():
+    x, y = symbols('x y', commutative=False)
+    assert powsimp((x*y)**2 * (y*x)**2) == (x*y)**2 * (y*x)**2
+
+
+def test_issue_17524():
+    a = symbols("a", real=True)
+    e = (-1 - a**2)*sqrt(1 + a**2)
+    assert signsimp(powsimp(e)) == signsimp(e) == -(a**2 + 1)**(S(3)/2)
+
+
+def test_issue_19627():
+    # if you use force the user must verify
+    assert powdenest(sqrt(sin(x)**2), force=True) == sin(x)
+    assert powdenest((x**(S.Half/y))**(2*y), force=True) == x
+    from sympy.core.function import expand_power_base
+    e = 1 - a
+    expr = (exp(z/e)*x**(b/e)*y**((1 - b)/e))**e
+    assert powdenest(expand_power_base(expr, force=True), force=True
+        ) == x**b*y**(1 - b)*exp(z)
+
+
+def test_issue_22546():
+    p1, p2 = symbols('p1, p2', positive=True)
+    ref = powsimp(p1**z/p2**z)
+    e = z + 1
+    ans = ref.subs(z, e)
+    assert ans.is_Pow
+    assert powsimp(p1**e/p2**e) == ans
+    i = symbols('i', integer=True)
+    ref = powsimp(x**i/y**i)
+    e = i + 1
+    ans = ref.subs(i, e)
+    assert ans.is_Pow
+    assert powsimp(x**e/y**e) == ans

lib/python3.12/site-packages/sympy/simplify/tests/test_radsimp.py

@@ -0,0 +1,490 @@
+from sympy.core.add import Add
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, Wild, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.polys.polytools import factor
+from sympy.series.order import O
+from sympy.simplify.radsimp import (collect, collect_const, fraction, radsimp, rcollect)
+
+from sympy.core.expr import unchanged
+from sympy.core.mul import _unevaluated_Mul as umul
+from sympy.simplify.radsimp import (_unevaluated_Add,
+    collect_sqrt, fraction_expand, collect_abs)
+from sympy.testing.pytest import raises
+
+from sympy.abc import x, y, z, a, b, c, d
+
+
+def test_radsimp():
+    r2 = sqrt(2)
+    r3 = sqrt(3)
+    r5 = sqrt(5)
+    r7 = sqrt(7)
+    assert fraction(radsimp(1/r2)) == (sqrt(2), 2)
+    assert radsimp(1/(1 + r2)) == \
+        -1 + sqrt(2)
+    assert radsimp(1/(r2 + r3)) == \
+        -sqrt(2) + sqrt(3)
+    assert fraction(radsimp(1/(1 + r2 + r3))) == \
+        (-sqrt(6) + sqrt(2) + 2, 4)
+    assert fraction(radsimp(1/(r2 + r3 + r5))) == \
+        (-sqrt(30) + 2*sqrt(3) + 3*sqrt(2), 12)
+    assert fraction(radsimp(1/(1 + r2 + r3 + r5))) == (
+        (-34*sqrt(10) - 26*sqrt(15) - 55*sqrt(3) - 61*sqrt(2) + 14*sqrt(30) +
+        93 + 46*sqrt(6) + 53*sqrt(5), 71))
+    assert fraction(radsimp(1/(r2 + r3 + r5 + r7))) == (
+        (-50*sqrt(42) - 133*sqrt(5) - 34*sqrt(70) - 145*sqrt(3) + 22*sqrt(105)
+        + 185*sqrt(2) + 62*sqrt(30) + 135*sqrt(7), 215))
+    z = radsimp(1/(1 + r2/3 + r3/5 + r5 + r7))
+    assert len((3616791619821680643598*z).args) == 16
+    assert radsimp(1/z) == 1/z
+    assert radsimp(1/z, max_terms=20).expand() == 1 + r2/3 + r3/5 + r5 + r7
+    assert radsimp(1/(r2*3)) == \
+        sqrt(2)/6
+    assert radsimp(1/(r2*a + r3 + r5 + r7)) == (
+        (8*sqrt(2)*a**7 - 8*sqrt(7)*a**6 - 8*sqrt(5)*a**6 - 8*sqrt(3)*a**6 -
+        180*sqrt(2)*a**5 + 8*sqrt(30)*a**5 + 8*sqrt(42)*a**5 + 8*sqrt(70)*a**5
+        - 24*sqrt(105)*a**4 + 84*sqrt(3)*a**4 + 100*sqrt(5)*a**4 +
+        116*sqrt(7)*a**4 - 72*sqrt(70)*a**3 - 40*sqrt(42)*a**3 -
+        8*sqrt(30)*a**3 + 782*sqrt(2)*a**3 - 462*sqrt(3)*a**2 -
+        302*sqrt(7)*a**2 - 254*sqrt(5)*a**2 + 120*sqrt(105)*a**2 -
+        795*sqrt(2)*a - 62*sqrt(30)*a + 82*sqrt(42)*a + 98*sqrt(70)*a -
+        118*sqrt(105) + 59*sqrt(7) + 295*sqrt(5) + 531*sqrt(3))/(16*a**8 -
+        480*a**6 + 3128*a**4 - 6360*a**2 + 3481))
+    assert radsimp(1/(r2*a + r2*b + r3 + r7)) == (
+        (sqrt(2)*a*(a + b)**2 - 5*sqrt(2)*a + sqrt(42)*a + sqrt(2)*b*(a +
+        b)**2 - 5*sqrt(2)*b + sqrt(42)*b - sqrt(7)*(a + b)**2 - sqrt(3)*(a +
+        b)**2 - 2*sqrt(3) + 2*sqrt(7))/(2*a**4 + 8*a**3*b + 12*a**2*b**2 -
+        20*a**2 + 8*a*b**3 - 40*a*b + 2*b**4 - 20*b**2 + 8))
+    assert radsimp(1/(r2*a + r2*b + r2*c + r2*d)) == \
+        sqrt(2)/(2*a + 2*b + 2*c + 2*d)
+    assert radsimp(1/(1 + r2*a + r2*b + r2*c + r2*d)) == (
+        (sqrt(2)*a + sqrt(2)*b + sqrt(2)*c + sqrt(2)*d - 1)/(2*a**2 + 4*a*b +
+        4*a*c + 4*a*d + 2*b**2 + 4*b*c + 4*b*d + 2*c**2 + 4*c*d + 2*d**2 - 1))
+    assert radsimp((y**2 - x)/(y - sqrt(x))) == \
+        sqrt(x) + y
+    assert radsimp(-(y**2 - x)/(y - sqrt(x))) == \
+        -(sqrt(x) + y)
+    assert radsimp(1/(1 - I + a*I)) == \
+        (-I*a + 1 + I)/(a**2 - 2*a + 2)
+    assert radsimp(1/((-x + y)*(x - sqrt(y)))) == \
+        (-x - sqrt(y))/((x - y)*(x**2 - y))
+    e = (3 + 3*sqrt(2))*x*(3*x - 3*sqrt(y))
+    assert radsimp(e) == x*(3 + 3*sqrt(2))*(3*x - 3*sqrt(y))
+    assert radsimp(1/e) == (
+        (-9*x + 9*sqrt(2)*x - 9*sqrt(y) + 9*sqrt(2)*sqrt(y))/(9*x*(9*x**2 -
+        9*y)))
+    assert radsimp(1 + 1/(1 + sqrt(3))) == \
+        Mul(S.Half, -1 + sqrt(3), evaluate=False) + 1
+    A = symbols("A", commutative=False)
+    assert radsimp(x**2 + sqrt(2)*x**2 - sqrt(2)*x*A) == \
+        x**2 + sqrt(2)*x**2 - sqrt(2)*x*A
+    assert radsimp(1/sqrt(5 + 2 * sqrt(6))) == -sqrt(2) + sqrt(3)
+    assert radsimp(1/sqrt(5 + 2 * sqrt(6))**3) == -(-sqrt(3) + sqrt(2))**3
+
+    # issue 6532
+    assert fraction(radsimp(1/sqrt(x))) == (sqrt(x), x)
+    assert fraction(radsimp(1/sqrt(2*x + 3))) == (sqrt(2*x + 3), 2*x + 3)
+    assert fraction(radsimp(1/sqrt(2*(x + 3)))) == (sqrt(2*x + 6), 2*x + 6)
+
+    # issue 5994
+    e = S('-(2 + 2*sqrt(2) + 4*2**(1/4))/'
+        '(1 + 2**(3/4) + 3*2**(1/4) + 3*sqrt(2))')
+    assert radsimp(e).expand() == -2*2**Rational(3, 4) - 2*2**Rational(1, 4) + 2 + 2*sqrt(2)
+
+    # issue 5986 (modifications to radimp didn't initially recognize this so
+    # the test is included here)
+    assert radsimp(1/(-sqrt(5)/2 - S.Half + (-sqrt(5)/2 - S.Half)**2)) == 1
+
+    # from issue 5934
+    eq = (
+        (-240*sqrt(2)*sqrt(sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) -
+        360*sqrt(2)*sqrt(-8*sqrt(5) + 40)*sqrt(-sqrt(5) + 5) -
+        120*sqrt(10)*sqrt(-8*sqrt(5) + 40)*sqrt(-sqrt(5) + 5) +
+        120*sqrt(2)*sqrt(-sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) +
+        120*sqrt(2)*sqrt(-8*sqrt(5) + 40)*sqrt(sqrt(5) + 5) +
+        120*sqrt(10)*sqrt(-sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) +
+        120*sqrt(10)*sqrt(-8*sqrt(5) + 40)*sqrt(sqrt(5) + 5))/(-36000 -
+        7200*sqrt(5) + (12*sqrt(10)*sqrt(sqrt(5) + 5) +
+        24*sqrt(10)*sqrt(-sqrt(5) + 5))**2))
+    assert radsimp(eq) is S.NaN  # it's 0/0
+
+    # work with normal form
+    e = 1/sqrt(sqrt(7)/7 + 2*sqrt(2) + 3*sqrt(3) + 5*sqrt(5)) + 3
+    assert radsimp(e) == (
+        -sqrt(sqrt(7) + 14*sqrt(2) + 21*sqrt(3) +
+        35*sqrt(5))*(-11654899*sqrt(35) - 1577436*sqrt(210) - 1278438*sqrt(15)
+        - 1346996*sqrt(10) + 1635060*sqrt(6) + 5709765 + 7539830*sqrt(14) +
+        8291415*sqrt(21))/1300423175 + 3)
+
+    # obey power rules
+    base = sqrt(3) - sqrt(2)
+    assert radsimp(1/base**3) == (sqrt(3) + sqrt(2))**3
+    assert radsimp(1/(-base)**3) == -(sqrt(2) + sqrt(3))**3
+    assert radsimp(1/(-base)**x) == (-base)**(-x)
+    assert radsimp(1/base**x) == (sqrt(2) + sqrt(3))**x
+    assert radsimp(root(1/(-1 - sqrt(2)), -x)) == (-1)**(-1/x)*(1 + sqrt(2))**(1/x)
+
+    # recurse
+    e = cos(1/(1 + sqrt(2)))
+    assert radsimp(e) == cos(-sqrt(2) + 1)
+    assert radsimp(e/2) == cos(-sqrt(2) + 1)/2
+    assert radsimp(1/e) == 1/cos(-sqrt(2) + 1)
+    assert radsimp(2/e) == 2/cos(-sqrt(2) + 1)
+    assert fraction(radsimp(e/sqrt(x))) == (sqrt(x)*cos(-sqrt(2)+1), x)
+
+    # test that symbolic denominators are not processed
+    r = 1 + sqrt(2)
+    assert radsimp(x/r, symbolic=False) == -x*(-sqrt(2) + 1)
+    assert radsimp(x/(y + r), symbolic=False) == x/(y + 1 + sqrt(2))
+    assert radsimp(x/(y + r)/r, symbolic=False) == \
+        -x*(-sqrt(2) + 1)/(y + 1 + sqrt(2))
+
+    # issue 7408
+    eq = sqrt(x)/sqrt(y)
+    assert radsimp(eq) == umul(sqrt(x), sqrt(y), 1/y)
+    assert radsimp(eq, symbolic=False) == eq
+
+    # issue 7498
+    assert radsimp(sqrt(x)/sqrt(y)**3) == umul(sqrt(x), sqrt(y**3), 1/y**3)
+
+    # for coverage
+    eq = sqrt(x)/y**2
+    assert radsimp(eq) == eq
+
+
+def test_radsimp_issue_3214():
+    c, p = symbols('c p', positive=True)
+    s = sqrt(c**2 - p**2)
+    b = (c + I*p - s)/(c + I*p + s)
+    assert radsimp(b) == -I*(c + I*p - sqrt(c**2 - p**2))**2/(2*c*p)
+
+
+def test_collect_1():
+    """Collect with respect to Symbol"""
+    x, y, z, n = symbols('x,y,z,n')
+    assert collect(1, x) == 1
+    assert collect( x + y*x, x ) == x * (1 + y)
+    assert collect( x + x**2, x ) == x + x**2
+    assert collect( x**2 + y*x**2, x ) == (x**2)*(1 + y)
+    assert collect( x**2 + y*x, x ) == x*y + x**2
+    assert collect( 2*x**2 + y*x**2 + 3*x*y, [x] ) == x**2*(2 + y) + 3*x*y
+    assert collect( 2*x**2 + y*x**2 + 3*x*y, [y] ) == 2*x**2 + y*(x**2 + 3*x)
+
+    assert collect( ((1 + y + x)**4).expand(), x) == ((1 + y)**4).expand() + \
+        x*(4*(1 + y)**3).expand() + x**2*(6*(1 + y)**2).expand() + \
+        x**3*(4*(1 + y)).expand() + x**4
+    # symbols can be given as any iterable
+    expr = x + y
+    assert collect(expr, expr.free_symbols) == expr
+    assert collect(x*exp(x) + sin(x)*y + sin(x)*2 + 3*x, x, exact=None
+        ) == x*exp(x) + 3*x + (y + 2)*sin(x)
+    assert collect(x*exp(x) + sin(x)*y + sin(x)*2 + 3*x + y*x +
+        y*x*exp(x), x, exact=None
+        ) == x*exp(x)*(y + 1) + (3 + y)*x + (y + 2)*sin(x)
+
+
+def test_collect_2():
+    """Collect with respect to a sum"""
+    a, b, x = symbols('a,b,x')
+    assert collect(a*(cos(x) + sin(x)) + b*(cos(x) + sin(x)),
+        sin(x) + cos(x)) == (a + b)*(cos(x) + sin(x))
+
+
+def test_collect_3():
+    """Collect with respect to a product"""
+    a, b, c = symbols('a,b,c')
+    f = Function('f')
+    x, y, z, n = symbols('x,y,z,n')
+
+    assert collect(-x/8 + x*y, -x) == x*(y - Rational(1, 8))
+
+    assert collect( 1 + x*(y**2), x*y ) == 1 + x*(y**2)
+    assert collect( x*y + a*x*y, x*y) == x*y*(1 + a)
+    assert collect( 1 + x*y + a*x*y, x*y) == 1 + x*y*(1 + a)
+    assert collect(a*x*f(x) + b*(x*f(x)), x*f(x)) == x*(a + b)*f(x)
+
+    assert collect(a*x*log(x) + b*(x*log(x)), x*log(x)) == x*(a + b)*log(x)
+    assert collect(a*x**2*log(x)**2 + b*(x*log(x))**2, x*log(x)) == \
+        x**2*log(x)**2*(a + b)
+
+    # with respect to a product of three symbols
+    assert collect(y*x*z + a*x*y*z, x*y*z) == (1 + a)*x*y*z
+
+
+def test_collect_4():
+    """Collect with respect to a power"""
+    a, b, c, x = symbols('a,b,c,x')
+
+    assert collect(a*x**c + b*x**c, x**c) == x**c*(a + b)
+    # issue 6096: 2 stays with c (unless c is integer or x is positive0
+    assert collect(a*x**(2*c) + b*x**(2*c), x**c) == x**(2*c)*(a + b)
+
+
+def test_collect_5():
+    """Collect with respect to a tuple"""
+    a, x, y, z, n = symbols('a,x,y,z,n')
+    assert collect(x**2*y**4 + z*(x*y**2)**2 + z + a*z, [x*y**2, z]) in [
+        z*(1 + a + x**2*y**4) + x**2*y**4,
+        z*(1 + a) + x**2*y**4*(1 + z) ]
+    assert collect((1 + (x + y) + (x + y)**2).expand(),
+                   [x, y]) == 1 + y + x*(1 + 2*y) + x**2 + y**2
+
+
+def test_collect_pr19431():
+    """Unevaluated collect with respect to a product"""
+    a = symbols('a')
+    assert collect(a**2*(a**2 + 1), a**2, evaluate=False)[a**2] == (a**2 + 1)
+
+
+def test_collect_D():
+    D = Derivative
+    f = Function('f')
+    x, a, b = symbols('x,a,b')
+    fx = D(f(x), x)
+    fxx = D(f(x), x, x)
+
+    assert collect(a*fx + b*fx, fx) == (a + b)*fx
+    assert collect(a*D(fx, x) + b*D(fx, x), fx) == (a + b)*D(fx, x)
+    assert collect(a*fxx + b*fxx, fx) == (a + b)*D(fx, x)
+    # issue 4784
+    assert collect(5*f(x) + 3*fx, fx) == 5*f(x) + 3*fx
+    assert collect(f(x) + f(x)*diff(f(x), x) + x*diff(f(x), x)*f(x), f(x).diff(x)) == \
+        (x*f(x) + f(x))*D(f(x), x) + f(x)
+    assert collect(f(x) + f(x)*diff(f(x), x) + x*diff(f(x), x)*f(x), f(x).diff(x), exact=True) == \
+        (x*f(x) + f(x))*D(f(x), x) + f(x)
+    assert collect(1/f(x) + 1/f(x)*diff(f(x), x) + x*diff(f(x), x)/f(x), f(x).diff(x), exact=True) == \
+        (1/f(x) + x/f(x))*D(f(x), x) + 1/f(x)
+    e = (1 + x*fx + fx)/f(x)
+    assert collect(e.expand(), fx) == fx*(x/f(x) + 1/f(x)) + 1/f(x)
+
+
+def test_collect_func():
+    f = ((x + a + 1)**3).expand()
+
+    assert collect(f, x) == a**3 + 3*a**2 + 3*a + x**3 + x**2*(3*a + 3) + \
+        x*(3*a**2 + 6*a + 3) + 1
+    assert collect(f, x, factor) == x**3 + 3*x**2*(a + 1) + 3*x*(a + 1)**2 + \
+        (a + 1)**3
+
+    assert collect(f, x, evaluate=False) == {
+        S.One: a**3 + 3*a**2 + 3*a + 1,
+        x: 3*a**2 + 6*a + 3, x**2: 3*a + 3,
+        x**3: 1
+    }
+
+    assert collect(f, x, factor, evaluate=False) == {
+        S.One: (a + 1)**3, x: 3*(a + 1)**2,
+        x**2: umul(S(3), a + 1), x**3: 1}
+
+
+def test_collect_order():
+    a, b, x, t = symbols('a,b,x,t')
+
+    assert collect(t + t*x + t*x**2 + O(x**3), t) == t*(1 + x + x**2 + O(x**3))
+    assert collect(t + t*x + x**2 + O(x**3), t) == \
+        t*(1 + x + O(x**3)) + x**2 + O(x**3)
+
+    f = a*x + b*x + c*x**2 + d*x**2 + O(x**3)
+    g = x*(a + b) + x**2*(c + d) + O(x**3)
+
+    assert collect(f, x) == g
+    assert collect(f, x, distribute_order_term=False) == g
+
+    f = sin(a + b).series(b, 0, 10)
+
+    assert collect(f, [sin(a), cos(a)]) == \
+        sin(a)*cos(b).series(b, 0, 10) + cos(a)*sin(b).series(b, 0, 10)
+    assert collect(f, [sin(a), cos(a)], distribute_order_term=False) == \
+        sin(a)*cos(b).series(b, 0, 10).removeO() + \
+        cos(a)*sin(b).series(b, 0, 10).removeO() + O(b**10)
+
+
+def test_rcollect():
+    assert rcollect((x**2*y + x*y + x + y)/(x + y), y) == \
+        (x + y*(1 + x + x**2))/(x + y)
+    assert rcollect(sqrt(-((x + 1)*(y + 1))), z) == sqrt(-((x + 1)*(y + 1)))
+
+
+def test_collect_D_0():
+    D = Derivative
+    f = Function('f')
+    x, a, b = symbols('x,a,b')
+    fxx = D(f(x), x, x)
+
+    assert collect(a*fxx + b*fxx, fxx) == (a + b)*fxx
+
+
+def test_collect_Wild():
+    """Collect with respect to functions with Wild argument"""
+    a, b, x, y = symbols('a b x y')
+    f = Function('f')
+    w1 = Wild('.1')
+    w2 = Wild('.2')
+    assert collect(f(x) + a*f(x), f(w1)) == (1 + a)*f(x)
+    assert collect(f(x, y) + a*f(x, y), f(w1)) == f(x, y) + a*f(x, y)
+    assert collect(f(x, y) + a*f(x, y), f(w1, w2)) == (1 + a)*f(x, y)
+    assert collect(f(x, y) + a*f(x, y), f(w1, w1)) == f(x, y) + a*f(x, y)
+    assert collect(f(x, x) + a*f(x, x), f(w1, w1)) == (1 + a)*f(x, x)
+    assert collect(a*(x + 1)**y + (x + 1)**y, w1**y) == (1 + a)*(x + 1)**y
+    assert collect(a*(x + 1)**y + (x + 1)**y, w1**b) == \
+        a*(x + 1)**y + (x + 1)**y
+    assert collect(a*(x + 1)**y + (x + 1)**y, (x + 1)**w2) == \
+        (1 + a)*(x + 1)**y
+    assert collect(a*(x + 1)**y + (x + 1)**y, w1**w2) == (1 + a)*(x + 1)**y
+
+
+def test_collect_const():
+    # coverage not provided by above tests
+    assert collect_const(2*sqrt(3) + 4*a*sqrt(5)) == \
+        2*(2*sqrt(5)*a + sqrt(3))  # let the primitive reabsorb
+    assert collect_const(2*sqrt(3) + 4*a*sqrt(5), sqrt(3)) == \
+        2*sqrt(3) + 4*a*sqrt(5)
+    assert collect_const(sqrt(2)*(1 + sqrt(2)) + sqrt(3) + x*sqrt(2)) == \
+        sqrt(2)*(x + 1 + sqrt(2)) + sqrt(3)
+
+    # issue 5290
+    assert collect_const(2*x + 2*y + 1, 2) == \
+        collect_const(2*x + 2*y + 1) == \
+        Add(S.One, Mul(2, x + y, evaluate=False), evaluate=False)
+    assert collect_const(-y - z) == Mul(-1, y + z, evaluate=False)
+    assert collect_const(2*x - 2*y - 2*z, 2) == \
+        Mul(2, x - y - z, evaluate=False)
+    assert collect_const(2*x - 2*y - 2*z, -2) == \
+        _unevaluated_Add(2*x, Mul(-2, y + z, evaluate=False))
+
+    # this is why the content_primitive is used
+    eq = (sqrt(15 + 5*sqrt(2))*x + sqrt(3 + sqrt(2))*y)*2
+    assert collect_sqrt(eq + 2) == \
+        2*sqrt(sqrt(2) + 3)*(sqrt(5)*x + y) + 2
+
+    # issue 16296
+    assert collect_const(a + b + x/2 + y/2) == a + b + Mul(S.Half, x + y, evaluate=False)
+
+
+def test_issue_13143():
+    f = Function('f')
+    fx = f(x).diff(x)
+    e = f(x) + fx + f(x)*fx
+    # collect function before derivative
+    assert collect(e, Wild('w')) == f(x)*(fx + 1) + fx
+    e = f(x) + f(x)*fx + x*fx*f(x)
+    assert collect(e, fx) == (x*f(x) + f(x))*fx + f(x)
+    assert collect(e, f(x)) == (x*fx + fx + 1)*f(x)
+    e = f(x) + fx + f(x)*fx
+    assert collect(e, [f(x), fx]) == f(x)*(1 + fx) + fx
+    assert collect(e, [fx, f(x)]) == fx*(1 + f(x)) + f(x)
+
+
+def test_issue_6097():
+    assert collect(a*y**(2.0*x) + b*y**(2.0*x), y**x) == (a + b)*(y**x)**2.0
+    assert collect(a*2**(2.0*x) + b*2**(2.0*x), 2**x) == (a + b)*(2**x)**2.0
+
+
+def test_fraction_expand():
+    eq = (x + y)*y/x
+    assert eq.expand(frac=True) == fraction_expand(eq) == (x*y + y**2)/x
+    assert eq.expand() == y + y**2/x
+
+
+def test_fraction():
+    x, y, z = map(Symbol, 'xyz')
+    A = Symbol('A', commutative=False)
+
+    assert fraction(S.Half) == (1, 2)
+
+    assert fraction(x) == (x, 1)
+    assert fraction(1/x) == (1, x)
+    assert fraction(x/y) == (x, y)
+    assert fraction(x/2) == (x, 2)
+
+    assert fraction(x*y/z) == (x*y, z)
+    assert fraction(x/(y*z)) == (x, y*z)
+
+    assert fraction(1/y**2) == (1, y**2)
+    assert fraction(x/y**2) == (x, y**2)
+
+    assert fraction((x**2 + 1)/y) == (x**2 + 1, y)
+    assert fraction(x*(y + 1)/y**7) == (x*(y + 1), y**7)
+
+    assert fraction(exp(-x), exact=True) == (exp(-x), 1)
+    assert fraction((1/(x + y))/2, exact=True) == (1, Mul(2,(x + y), evaluate=False))
+
+    assert fraction(x*A/y) == (x*A, y)
+    assert fraction(x*A**-1/y) == (x*A**-1, y)
+
+    n = symbols('n', negative=True)
+    assert fraction(exp(n)) == (1, exp(-n))
+    assert fraction(exp(-n)) == (exp(-n), 1)
+
+    p = symbols('p', positive=True)
+    assert fraction(exp(-p)*log(p), exact=True) == (exp(-p)*log(p), 1)
+
+    m = Mul(1, 1, S.Half, evaluate=False)
+    assert fraction(m) == (1, 2)
+    assert fraction(m, exact=True) == (Mul(1, 1, evaluate=False), 2)
+
+    m = Mul(1, 1, S.Half, S.Half, Pow(1, -1, evaluate=False), evaluate=False)
+    assert fraction(m) == (1, 4)
+    assert fraction(m, exact=True) == \
+            (Mul(1, 1, evaluate=False), Mul(2, 2, 1, evaluate=False))
+
+
+def test_issue_5615():
+    aA, Re, a, b, D = symbols('aA Re a b D')
+    e = ((D**3*a + b*aA**3)/Re).expand()
+    assert collect(e, [aA**3/Re, a]) == e
+
+
+def test_issue_5933():
+    from sympy.geometry.polygon import (Polygon, RegularPolygon)
+    from sympy.simplify.radsimp import denom
+    x = Polygon(*RegularPolygon((0, 0), 1, 5).vertices).centroid.x
+    assert abs(denom(x).n()) > 1e-12
+    assert abs(denom(radsimp(x))) > 1e-12  # in case simplify didn't handle it
+
+
+def test_issue_14608():
+    a, b = symbols('a b', commutative=False)
+    x, y = symbols('x y')
+    raises(AttributeError, lambda: collect(a*b + b*a, a))
+    assert collect(x*y + y*(x+1), a) == x*y + y*(x+1)
+    assert collect(x*y + y*(x+1) + a*b + b*a, y) == y*(2*x + 1) + a*b + b*a
+
+
+def test_collect_abs():
+    s = abs(x) + abs(y)
+    assert collect_abs(s) == s
+    assert unchanged(Mul, abs(x), abs(y))
+    ans = Abs(x*y)
+    assert isinstance(ans, Abs)
+    assert collect_abs(abs(x)*abs(y)) == ans
+    assert collect_abs(1 + exp(abs(x)*abs(y))) == 1 + exp(ans)
+
+    # See https://github.com/sympy/sympy/issues/12910
+    p = Symbol('p', positive=True)
+    assert collect_abs(p/abs(1-p)).is_commutative is True
+
+
+def test_issue_19149():
+    eq = exp(3*x/4)
+    assert collect(eq, exp(x)) == eq
+
+def test_issue_19719():
+    a, b = symbols('a, b')
+    expr = a**2 * (b + 1) + (7 + 1/b)/a
+    collected = collect(expr, (a**2, 1/a), evaluate=False)
+    # Would return {_Dummy_20**(-2): b + 1, 1/a: 7 + 1/b} without xreplace
+    assert collected == {a**2: b + 1, 1/a: 7 + 1/b}
+
+
+def test_issue_21355():
+    assert radsimp(1/(x + sqrt(x**2))) == 1/(x + sqrt(x**2))
+    assert radsimp(1/(x - sqrt(x**2))) == 1/(x - sqrt(x**2))

lib/python3.12/site-packages/sympy/simplify/tests/test_ratsimp.py

@@ -0,0 +1,78 @@
+from sympy.core.numbers import (Rational, pi)
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.error_functions import erf
+from sympy.polys.domains import GF
+from sympy.simplify.ratsimp import (ratsimp, ratsimpmodprime)
+
+from sympy.abc import x, y, z, t, a, b, c, d, e
+
+
+def test_ratsimp():
+    f, g = 1/x + 1/y, (x + y)/(x*y)
+
+    assert f != g and ratsimp(f) == g
+
+    f, g = 1/(1 + 1/x), 1 - 1/(x + 1)
+
+    assert f != g and ratsimp(f) == g
+
+    f, g = x/(x + y) + y/(x + y), 1
+
+    assert f != g and ratsimp(f) == g
+
+    f, g = -x - y - y**2/(x + y) + x**2/(x + y), -2*y
+
+    assert f != g and ratsimp(f) == g
+
+    f = (a*c*x*y + a*c*z - b*d*x*y - b*d*z - b*t*x*y - b*t*x - b*t*z +
+         e*x)/(x*y + z)
+    G = [a*c - b*d - b*t + (-b*t*x + e*x)/(x*y + z),
+         a*c - b*d - b*t - ( b*t*x - e*x)/(x*y + z)]
+
+    assert f != g and ratsimp(f) in G
+
+    A = sqrt(pi)
+
+    B = log(erf(x) - 1)
+    C = log(erf(x) + 1)
+
+    D = 8 - 8*erf(x)
+
+    f = A*B/D - A*C/D + A*C*erf(x)/D - A*B*erf(x)/D + 2*A/D
+
+    assert ratsimp(f) == A*B/8 - A*C/8 - A/(4*erf(x) - 4)
+
+
+def test_ratsimpmodprime():
+    a = y**5 + x + y
+    b = x - y
+    F = [x*y**5 - x - y]
+    assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+        (-x**2 - x*y - x - y) / (-x**2 + x*y)
+
+    a = x + y**2 - 2
+    b = x + y**2 - y - 1
+    F = [x*y - 1]
+    assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+        (1 + y - x)/(y - x)
+
+    a = 5*x**3 + 21*x**2 + 4*x*y + 23*x + 12*y + 15
+    b = 7*x**3 - y*x**2 + 31*x**2 + 2*x*y + 15*y + 37*x + 21
+    F = [x**2 + y**2 - 1]
+    assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+        (1 + 5*y - 5*x)/(8*y - 6*x)
+
+    a = x*y - x - 2*y + 4
+    b = x + y**2 - 2*y
+    F = [x - 2, y - 3]
+    assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+        Rational(2, 5)
+
+    # Test a bug where denominators would be dropped
+    assert ratsimpmodprime(x, [y - 2*x], order='lex') == \
+        y/2
+
+    a = (x**5 + 2*x**4 + 2*x**3 + 2*x**2 + x + 2/x + x**(-2))
+    assert ratsimpmodprime(a, [x + 1], domain=GF(2)) == 1
+    assert ratsimpmodprime(a, [x + 1], domain=GF(3)) == -1

lib/python3.12/site-packages/sympy/simplify/tests/test_rewrite.py

@@ -0,0 +1,31 @@
+from sympy.core.numbers import I
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.trigonometric import (cos, cot, sin)
+from sympy.testing.pytest import _both_exp_pow
+
+x, y, z, n = symbols('x,y,z,n')
+
+
+@_both_exp_pow
+def test_has():
+    assert cot(x).has(x)
+    assert cot(x).has(cot)
+    assert not cot(x).has(sin)
+    assert sin(x).has(x)
+    assert sin(x).has(sin)
+    assert not sin(x).has(cot)
+    assert exp(x).has(exp)
+
+
+@_both_exp_pow
+def test_sin_exp_rewrite():
+    assert sin(x).rewrite(sin, exp) == -I/2*(exp(I*x) - exp(-I*x))
+    assert sin(x).rewrite(sin, exp).rewrite(exp, sin) == sin(x)
+    assert cos(x).rewrite(cos, exp).rewrite(exp, cos) == cos(x)
+    assert (sin(5*y) - sin(
+        2*x)).rewrite(sin, exp).rewrite(exp, sin) == sin(5*y) - sin(2*x)
+    assert sin(x + y).rewrite(sin, exp).rewrite(exp, sin) == sin(x + y)
+    assert cos(x + y).rewrite(cos, exp).rewrite(exp, cos) == cos(x + y)
+    # This next test currently passes... not clear whether it should or not?
+    assert cos(x).rewrite(cos, exp).rewrite(exp, sin) == cos(x)

lib/python3.12/site-packages/sympy/simplify/tests/test_simplify.py

@@ -0,0 +1,1087 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.expr import unchanged
+from sympy.core.function import (count_ops, diff, expand, expand_multinomial, Function, Derivative)
+from sympy.core.mul import Mul, _keep_coeff
+from sympy.core import GoldenRatio
+from sympy.core.numbers import (E, Float, I, oo, pi, Rational, zoo)
+from sympy.core.relational import (Eq, Lt, Gt, Ge, Le)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (binomial, factorial)
+from sympy.functions.elementary.complexes import (Abs, sign)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import (cosh, csch, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin, sinc, tan)
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.geometry.polygon import rad
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.logic.boolalg import (And, Or)
+from sympy.matrices.dense import (Matrix, eye)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.polys.polytools import (factor, Poly)
+from sympy.simplify.simplify import (besselsimp, hypersimp, inversecombine, logcombine, nsimplify, nthroot, posify, separatevars, signsimp, simplify)
+from sympy.solvers.solvers import solve
+
+from sympy.testing.pytest import XFAIL, slow, _both_exp_pow
+from sympy.abc import x, y, z, t, a, b, c, d, e, f, g, h, i, n
+
+
+def test_issue_7263():
+    assert abs((simplify(30.8**2 - 82.5**2 * sin(rad(11.6))**2)).evalf() - \
+            673.447451402970) < 1e-12
+
+
+def test_factorial_simplify():
+    # There are more tests in test_factorials.py.
+    x = Symbol('x')
+    assert simplify(factorial(x)/x) == gamma(x)
+    assert simplify(factorial(factorial(x))) == factorial(factorial(x))
+
+
+def test_simplify_expr():
+    x, y, z, k, n, m, w, s, A = symbols('x,y,z,k,n,m,w,s,A')
+    f = Function('f')
+
+    assert all(simplify(tmp) == tmp for tmp in [I, E, oo, x, -x, -oo, -E, -I])
+
+    e = 1/x + 1/y
+    assert e != (x + y)/(x*y)
+    assert simplify(e) == (x + y)/(x*y)
+
+    e = A**2*s**4/(4*pi*k*m**3)
+    assert simplify(e) == e
+
+    e = (4 + 4*x - 2*(2 + 2*x))/(2 + 2*x)
+    assert simplify(e) == 0
+
+    e = (-4*x*y**2 - 2*y**3 - 2*x**2*y)/(x + y)**2
+    assert simplify(e) == -2*y
+
+    e = -x - y - (x + y)**(-1)*y**2 + (x + y)**(-1)*x**2
+    assert simplify(e) == -2*y
+
+    e = (x + x*y)/x
+    assert simplify(e) == 1 + y
+
+    e = (f(x) + y*f(x))/f(x)
+    assert simplify(e) == 1 + y
+
+    e = (2 * (1/n - cos(n * pi)/n))/pi
+    assert simplify(e) == (-cos(pi*n) + 1)/(pi*n)*2
+
+    e = integrate(1/(x**3 + 1), x).diff(x)
+    assert simplify(e) == 1/(x**3 + 1)
+
+    e = integrate(x/(x**2 + 3*x + 1), x).diff(x)
+    assert simplify(e) == x/(x**2 + 3*x + 1)
+
+    f = Symbol('f')
+    A = Matrix([[2*k - m*w**2, -k], [-k, k - m*w**2]]).inv()
+    assert simplify((A*Matrix([0, f]))[1] -
+            (-f*(2*k - m*w**2)/(k**2 - (k - m*w**2)*(2*k - m*w**2)))) == 0
+
+    f = -x + y/(z + t) + z*x/(z + t) + z*a/(z + t) + t*x/(z + t)
+    assert simplify(f) == (y + a*z)/(z + t)
+
+    # issue 10347
+    expr = -x*(y**2 - 1)*(2*y**2*(x**2 - 1)/(a*(x**2 - y**2)**2) + (x**2 - 1)
+        /(a*(x**2 - y**2)))/(a*(x**2 - y**2)) + x*(-2*x**2*sqrt(-x**2*y**2 + x**2
+        + y**2 - 1)*sin(z)/(a*(x**2 - y**2)**2) - x**2*sqrt(-x**2*y**2 + x**2 +
+        y**2 - 1)*sin(z)/(a*(x**2 - 1)*(x**2 - y**2)) + (x**2*sqrt((-x**2 + 1)*
+        (y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(x**2 - 1) + sqrt(
+        (-x**2 + 1)*(y**2 - 1))*(x*(-x*y**2 + x)/sqrt(-x**2*y**2 + x**2 + y**2 -
+        1) + sqrt(-x**2*y**2 + x**2 + y**2 - 1))*sin(z))/(a*sqrt((-x**2 + 1)*(
+        y**2 - 1))*(x**2 - y**2)))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(a*
+        (x**2 - y**2)) + x*(-2*x**2*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*
+        (x**2 - y**2)**2) - x**2*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*
+        (x**2 - 1)*(x**2 - y**2)) + (x**2*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2
+        *y**2 + x**2 + y**2 - 1)*cos(z)/(x**2 - 1) + x*sqrt((-x**2 + 1)*(y**2 -
+        1))*(-x*y**2 + x)*cos(z)/sqrt(-x**2*y**2 + x**2 + y**2 - 1) + sqrt((-x**2
+        + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z))/(a*sqrt((-x**2
+        + 1)*(y**2 - 1))*(x**2 - y**2)))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(
+        z)/(a*(x**2 - y**2)) - y*sqrt((-x**2 + 1)*(y**2 - 1))*(-x*y*sqrt(-x**2*
+        y**2 + x**2 + y**2 - 1)*sin(z)/(a*(x**2 - y**2)*(y**2 - 1)) + 2*x*y*sqrt(
+        -x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(a*(x**2 - y**2)**2) + (x*y*sqrt((
+        -x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(y**2 -
+        1) + x*sqrt((-x**2 + 1)*(y**2 - 1))*(-x**2*y + y)*sin(z)/sqrt(-x**2*y**2
+        + x**2 + y**2 - 1))/(a*sqrt((-x**2 + 1)*(y**2 - 1))*(x**2 - y**2)))*sin(
+        z)/(a*(x**2 - y**2)) + y*(x**2 - 1)*(-2*x*y*(x**2 - 1)/(a*(x**2 - y**2)
+        **2) + 2*x*y/(a*(x**2 - y**2)))/(a*(x**2 - y**2)) + y*(x**2 - 1)*(y**2 -
+        1)*(-x*y*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*(x**2 - y**2)*(y**2
+        - 1)) + 2*x*y*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*(x**2 - y**2)
+        **2) + (x*y*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 -
+        1)*cos(z)/(y**2 - 1) + x*sqrt((-x**2 + 1)*(y**2 - 1))*(-x**2*y + y)*cos(
+        z)/sqrt(-x**2*y**2 + x**2 + y**2 - 1))/(a*sqrt((-x**2 + 1)*(y**2 - 1)
+        )*(x**2 - y**2)))*cos(z)/(a*sqrt((-x**2 + 1)*(y**2 - 1))*(x**2 - y**2)
+        ) - x*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(
+        z)**2/(a**2*(x**2 - 1)*(x**2 - y**2)*(y**2 - 1)) - x*sqrt((-x**2 + 1)*(
+        y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)**2/(a**2*(x**2 - 1)*(
+        x**2 - y**2)*(y**2 - 1))
+    assert simplify(expr) == 2*x/(a**2*(x**2 - y**2))
+
+    #issue 17631
+    assert simplify('((-1/2)*Boole(True)*Boole(False)-1)*Boole(True)') == \
+            Mul(sympify('(2 + Boole(True)*Boole(False))'), sympify('-Boole(True)/2'))
+
+    A, B = symbols('A,B', commutative=False)
+
+    assert simplify(A*B - B*A) == A*B - B*A
+    assert simplify(A/(1 + y/x)) == x*A/(x + y)
+    assert simplify(A*(1/x + 1/y)) == A/x + A/y  #(x + y)*A/(x*y)
+
+    assert simplify(log(2) + log(3)) == log(6)
+    assert simplify(log(2*x) - log(2)) == log(x)
+
+    assert simplify(hyper([], [], x)) == exp(x)
+
+
+def test_issue_3557():
+    f_1 = x*a + y*b + z*c - 1
+    f_2 = x*d + y*e + z*f - 1
+    f_3 = x*g + y*h + z*i - 1
+
+    solutions = solve([f_1, f_2, f_3], x, y, z, simplify=False)
+
+    assert simplify(solutions[y]) == \
+        (a*i + c*d + f*g - a*f - c*g - d*i)/ \
+        (a*e*i + b*f*g + c*d*h - a*f*h - b*d*i - c*e*g)
+
+
+def test_simplify_other():
+    assert simplify(sin(x)**2 + cos(x)**2) == 1
+    assert simplify(gamma(x + 1)/gamma(x)) == x
+    assert simplify(sin(x)**2 + cos(x)**2 + factorial(x)/gamma(x)) == 1 + x
+    assert simplify(
+        Eq(sin(x)**2 + cos(x)**2, factorial(x)/gamma(x))) == Eq(x, 1)
+    nc = symbols('nc', commutative=False)
+    assert simplify(x + x*nc) == x*(1 + nc)
+    # issue 6123
+    # f = exp(-I*(k*sqrt(t) + x/(2*sqrt(t)))**2)
+    # ans = integrate(f, (k, -oo, oo), conds='none')
+    ans = I*(-pi*x*exp(I*pi*Rational(-3, 4) + I*x**2/(4*t))*erf(x*exp(I*pi*Rational(-3, 4))/
+        (2*sqrt(t)))/(2*sqrt(t)) + pi*x*exp(I*pi*Rational(-3, 4) + I*x**2/(4*t))/
+        (2*sqrt(t)))*exp(-I*x**2/(4*t))/(sqrt(pi)*x) - I*sqrt(pi) * \
+        (-erf(x*exp(I*pi/4)/(2*sqrt(t))) + 1)*exp(I*pi/4)/(2*sqrt(t))
+    assert simplify(ans) == -(-1)**Rational(3, 4)*sqrt(pi)/sqrt(t)
+    # issue 6370
+    assert simplify(2**(2 + x)/4) == 2**x
+
+
+@_both_exp_pow
+def test_simplify_complex():
+    cosAsExp = cos(x)._eval_rewrite_as_exp(x)
+    tanAsExp = tan(x)._eval_rewrite_as_exp(x)
+    assert simplify(cosAsExp*tanAsExp) == sin(x) # issue 4341
+
+    # issue 10124
+    assert simplify(exp(Matrix([[0, -1], [1, 0]]))) == Matrix([[cos(1),
+        -sin(1)], [sin(1), cos(1)]])
+
+
+def test_simplify_ratio():
+    # roots of x**3-3*x+5
+    roots = ['(1/2 - sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3) + 1/((1/2 - '
+             'sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3))',
+             '1/((1/2 + sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3)) + '
+             '(1/2 + sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3)',
+             '-(sqrt(21)/2 + 5/2)**(1/3) - 1/(sqrt(21)/2 + 5/2)**(1/3)']
+
+    for r in roots:
+        r = S(r)
+        assert count_ops(simplify(r, ratio=1)) <= count_ops(r)
+        # If ratio=oo, simplify() is always applied:
+        assert simplify(r, ratio=oo) is not r
+
+
+def test_simplify_measure():
+    measure1 = lambda expr: len(str(expr))
+    measure2 = lambda expr: -count_ops(expr)
+                                       # Return the most complicated result
+    expr = (x + 1)/(x + sin(x)**2 + cos(x)**2)
+    assert measure1(simplify(expr, measure=measure1)) <= measure1(expr)
+    assert measure2(simplify(expr, measure=measure2)) <= measure2(expr)
+
+    expr2 = Eq(sin(x)**2 + cos(x)**2, 1)
+    assert measure1(simplify(expr2, measure=measure1)) <= measure1(expr2)
+    assert measure2(simplify(expr2, measure=measure2)) <= measure2(expr2)
+
+
+def test_simplify_rational():
+    expr = 2**x*2.**y
+    assert simplify(expr, rational = True) == 2**(x+y)
+    assert simplify(expr, rational = None) == 2.0**(x+y)
+    assert simplify(expr, rational = False) == expr
+    assert simplify('0.9 - 0.8 - 0.1', rational = True) == 0
+
+
+def test_simplify_issue_1308():
+    assert simplify(exp(Rational(-1, 2)) + exp(Rational(-3, 2))) == \
+        (1 + E)*exp(Rational(-3, 2))
+
+
+def test_issue_5652():
+    assert simplify(E + exp(-E)) == exp(-E) + E
+    n = symbols('n', commutative=False)
+    assert simplify(n + n**(-n)) == n + n**(-n)
+
+
+def test_simplify_fail1():
+    x = Symbol('x')
+    y = Symbol('y')
+    e = (x + y)**2/(-4*x*y**2 - 2*y**3 - 2*x**2*y)
+    assert simplify(e) == 1 / (-2*y)
+
+
+def test_nthroot():
+    assert nthroot(90 + 34*sqrt(7), 3) == sqrt(7) + 3
+    q = 1 + sqrt(2) - 2*sqrt(3) + sqrt(6) + sqrt(7)
+    assert nthroot(expand_multinomial(q**3), 3) == q
+    assert nthroot(41 + 29*sqrt(2), 5) == 1 + sqrt(2)
+    assert nthroot(-41 - 29*sqrt(2), 5) == -1 - sqrt(2)
+    expr = 1320*sqrt(10) + 4216 + 2576*sqrt(6) + 1640*sqrt(15)
+    assert nthroot(expr, 5) == 1 + sqrt(6) + sqrt(15)
+    q = 1 + sqrt(2) + sqrt(3) + sqrt(5)
+    assert expand_multinomial(nthroot(expand_multinomial(q**5), 5)) == q
+    q = 1 + sqrt(2) + 7*sqrt(6) + 2*sqrt(10)
+    assert nthroot(expand_multinomial(q**5), 5, 8) == q
+    q = 1 + sqrt(2) - 2*sqrt(3) + 1171*sqrt(6)
+    assert nthroot(expand_multinomial(q**3), 3) == q
+    assert nthroot(expand_multinomial(q**6), 6) == q
+
+
+def test_nthroot1():
+    q = 1 + sqrt(2) + sqrt(3) + S.One/10**20
+    p = expand_multinomial(q**5)
+    assert nthroot(p, 5) == q
+    q = 1 + sqrt(2) + sqrt(3) + S.One/10**30
+    p = expand_multinomial(q**5)
+    assert nthroot(p, 5) == q
+
+
+@_both_exp_pow
+def test_separatevars():
+    x, y, z, n = symbols('x,y,z,n')
+    assert separatevars(2*n*x*z + 2*x*y*z) == 2*x*z*(n + y)
+    assert separatevars(x*z + x*y*z) == x*z*(1 + y)
+    assert separatevars(pi*x*z + pi*x*y*z) == pi*x*z*(1 + y)
+    assert separatevars(x*y**2*sin(x) + x*sin(x)*sin(y)) == \
+        x*(sin(y) + y**2)*sin(x)
+    assert separatevars(x*exp(x + y) + x*exp(x)) == x*(1 + exp(y))*exp(x)
+    assert separatevars((x*(y + 1))**z).is_Pow  # != x**z*(1 + y)**z
+    assert separatevars(1 + x + y + x*y) == (x + 1)*(y + 1)
+    assert separatevars(y/pi*exp(-(z - x)/cos(n))) == \
+        y*exp(x/cos(n))*exp(-z/cos(n))/pi
+    assert separatevars((x + y)*(x - y) + y**2 + 2*x + 1) == (x + 1)**2
+    # issue 4858
+    p = Symbol('p', positive=True)
+    assert separatevars(sqrt(p**2 + x*p**2)) == p*sqrt(1 + x)
+    assert separatevars(sqrt(y*(p**2 + x*p**2))) == p*sqrt(y*(1 + x))
+    assert separatevars(sqrt(y*(p**2 + x*p**2)), force=True) == \
+        p*sqrt(y)*sqrt(1 + x)
+    # issue 4865
+    assert separatevars(sqrt(x*y)).is_Pow
+    assert separatevars(sqrt(x*y), force=True) == sqrt(x)*sqrt(y)
+    # issue 4957
+    # any type sequence for symbols is fine
+    assert separatevars(((2*x + 2)*y), dict=True, symbols=()) == \
+        {'coeff': 1, x: 2*x + 2, y: y}
+    # separable
+    assert separatevars(((2*x + 2)*y), dict=True, symbols=[x]) == \
+        {'coeff': y, x: 2*x + 2}
+    assert separatevars(((2*x + 2)*y), dict=True, symbols=[]) == \
+        {'coeff': 1, x: 2*x + 2, y: y}
+    assert separatevars(((2*x + 2)*y), dict=True) == \
+        {'coeff': 1, x: 2*x + 2, y: y}
+    assert separatevars(((2*x + 2)*y), dict=True, symbols=None) == \
+        {'coeff': y*(2*x + 2)}
+    # not separable
+    assert separatevars(3, dict=True) is None
+    assert separatevars(2*x + y, dict=True, symbols=()) is None
+    assert separatevars(2*x + y, dict=True) is None
+    assert separatevars(2*x + y, dict=True, symbols=None) == {'coeff': 2*x + y}
+    # issue 4808
+    n, m = symbols('n,m', commutative=False)
+    assert separatevars(m + n*m) == (1 + n)*m
+    assert separatevars(x + x*n) == x*(1 + n)
+    # issue 4910
+    f = Function('f')
+    assert separatevars(f(x) + x*f(x)) == f(x) + x*f(x)
+    # a noncommutable object present
+    eq = x*(1 + hyper((), (), y*z))
+    assert separatevars(eq) == eq
+
+    s = separatevars(abs(x*y))
+    assert s == abs(x)*abs(y) and s.is_Mul
+    z = cos(1)**2 + sin(1)**2 - 1
+    a = abs(x*z)
+    s = separatevars(a)
+    assert not a.is_Mul and s.is_Mul and s == abs(x)*abs(z)
+    s = separatevars(abs(x*y*z))
+    assert s == abs(x)*abs(y)*abs(z)
+
+    # abs(x+y)/abs(z) would be better but we test this here to
+    # see that it doesn't raise
+    assert separatevars(abs((x+y)/z)) == abs((x+y)/z)
+
+
+def test_separatevars_advanced_factor():
+    x, y, z = symbols('x,y,z')
+    assert separatevars(1 + log(x)*log(y) + log(x) + log(y)) == \
+        (log(x) + 1)*(log(y) + 1)
+    assert separatevars(1 + x - log(z) - x*log(z) - exp(y)*log(z) -
+        x*exp(y)*log(z) + x*exp(y) + exp(y)) == \
+        -((x + 1)*(log(z) - 1)*(exp(y) + 1))
+    x, y = symbols('x,y', positive=True)
+    assert separatevars(1 + log(x**log(y)) + log(x*y)) == \
+        (log(x) + 1)*(log(y) + 1)
+
+
+def test_hypersimp():
+    n, k = symbols('n,k', integer=True)
+
+    assert hypersimp(factorial(k), k) == k + 1
+    assert hypersimp(factorial(k**2), k) is None
+
+    assert hypersimp(1/factorial(k), k) == 1/(k + 1)
+
+    assert hypersimp(2**k/factorial(k)**2, k) == 2/(k + 1)**2
+
+    assert hypersimp(binomial(n, k), k) == (n - k)/(k + 1)
+    assert hypersimp(binomial(n + 1, k), k) == (n - k + 1)/(k + 1)
+
+    term = (4*k + 1)*factorial(k)/factorial(2*k + 1)
+    assert hypersimp(term, k) == S.Half*((4*k + 5)/(3 + 14*k + 8*k**2))
+
+    term = 1/((2*k - 1)*factorial(2*k + 1))
+    assert hypersimp(term, k) == (k - S.Half)/((k + 1)*(2*k + 1)*(2*k + 3))
+
+    term = binomial(n, k)*(-1)**k/factorial(k)
+    assert hypersimp(term, k) == (k - n)/(k + 1)**2
+
+
+def test_nsimplify():
+    x = Symbol("x")
+    assert nsimplify(0) == 0
+    assert nsimplify(-1) == -1
+    assert nsimplify(1) == 1
+    assert nsimplify(1 + x) == 1 + x
+    assert nsimplify(2.7) == Rational(27, 10)
+    assert nsimplify(1 - GoldenRatio) == (1 - sqrt(5))/2
+    assert nsimplify((1 + sqrt(5))/4, [GoldenRatio]) == GoldenRatio/2
+    assert nsimplify(2/GoldenRatio, [GoldenRatio]) == 2*GoldenRatio - 2
+    assert nsimplify(exp(pi*I*Rational(5, 3), evaluate=False)) == \
+        sympify('1/2 - sqrt(3)*I/2')
+    assert nsimplify(sin(pi*Rational(3, 5), evaluate=False)) == \
+        sympify('sqrt(sqrt(5)/8 + 5/8)')
+    assert nsimplify(sqrt(atan('1', evaluate=False))*(2 + I), [pi]) == \
+        sqrt(pi) + sqrt(pi)/2*I
+    assert nsimplify(2 + exp(2*atan('1/4')*I)) == sympify('49/17 + 8*I/17')
+    assert nsimplify(pi, tolerance=0.01) == Rational(22, 7)
+    assert nsimplify(pi, tolerance=0.001) == Rational(355, 113)
+    assert nsimplify(0.33333, tolerance=1e-4) == Rational(1, 3)
+    assert nsimplify(2.0**(1/3.), tolerance=0.001) == Rational(635, 504)
+    assert nsimplify(2.0**(1/3.), tolerance=0.001, full=True) == \
+        2**Rational(1, 3)
+    assert nsimplify(x + .5, rational=True) == S.Half + x
+    assert nsimplify(1/.3 + x, rational=True) == Rational(10, 3) + x
+    assert nsimplify(log(3).n(), rational=True) == \
+        sympify('109861228866811/100000000000000')
+    assert nsimplify(Float(0.272198261287950), [pi, log(2)]) == pi*log(2)/8
+    assert nsimplify(Float(0.272198261287950).n(3), [pi, log(2)]) == \
+        -pi/4 - log(2) + Rational(7, 4)
+    assert nsimplify(x/7.0) == x/7
+    assert nsimplify(pi/1e2) == pi/100
+    assert nsimplify(pi/1e2, rational=False) == pi/100.0
+    assert nsimplify(pi/1e-7) == 10000000*pi
+    assert not nsimplify(
+        factor(-3.0*z**2*(z**2)**(-2.5) + 3*(z**2)**(-1.5))).atoms(Float)
+    e = x**0.0
+    assert e.is_Pow and nsimplify(x**0.0) == 1
+    assert nsimplify(3.333333, tolerance=0.1, rational=True) == Rational(10, 3)
+    assert nsimplify(3.333333, tolerance=0.01, rational=True) == Rational(10, 3)
+    assert nsimplify(3.666666, tolerance=0.1, rational=True) == Rational(11, 3)
+    assert nsimplify(3.666666, tolerance=0.01, rational=True) == Rational(11, 3)
+    assert nsimplify(33, tolerance=10, rational=True) == Rational(33)
+    assert nsimplify(33.33, tolerance=10, rational=True) == Rational(30)
+    assert nsimplify(37.76, tolerance=10, rational=True) == Rational(40)
+    assert nsimplify(-203.1) == Rational(-2031, 10)
+    assert nsimplify(.2, tolerance=0) == Rational(1, 5)
+    assert nsimplify(-.2, tolerance=0) == Rational(-1, 5)
+    assert nsimplify(.2222, tolerance=0) == Rational(1111, 5000)
+    assert nsimplify(-.2222, tolerance=0) == Rational(-1111, 5000)
+    # issue 7211, PR 4112
+    assert nsimplify(S(2e-8)) == Rational(1, 50000000)
+    # issue 7322 direct test
+    assert nsimplify(1e-42, rational=True) != 0
+    # issue 10336
+    inf = Float('inf')
+    infs = (-oo, oo, inf, -inf)
+    for zi in infs:
+        ans = sign(zi)*oo
+        assert nsimplify(zi) == ans
+        assert nsimplify(zi + x) == x + ans
+
+    assert nsimplify(0.33333333, rational=True, rational_conversion='exact') == Rational(0.33333333)
+
+    # Make sure nsimplify on expressions uses full precision
+    assert nsimplify(pi.evalf(100)*x, rational_conversion='exact').evalf(100) == pi.evalf(100)*x
+
+
+def test_issue_9448():
+    tmp = sympify("1/(1 - (-1)**(2/3) - (-1)**(1/3)) + 1/(1 + (-1)**(2/3) + (-1)**(1/3))")
+    assert nsimplify(tmp) == S.Half
+
+
+def test_extract_minus_sign():
+    x = Symbol("x")
+    y = Symbol("y")
+    a = Symbol("a")
+    b = Symbol("b")
+    assert simplify(-x/-y) == x/y
+    assert simplify(-x/y) == -x/y
+    assert simplify(x/y) == x/y
+    assert simplify(x/-y) == -x/y
+    assert simplify(-x/0) == zoo*x
+    assert simplify(Rational(-5, 0)) is zoo
+    assert simplify(-a*x/(-y - b)) == a*x/(b + y)
+
+
+def test_diff():
+    x = Symbol("x")
+    y = Symbol("y")
+    f = Function("f")
+    g = Function("g")
+    assert simplify(g(x).diff(x)*f(x).diff(x) - f(x).diff(x)*g(x).diff(x)) == 0
+    assert simplify(2*f(x)*f(x).diff(x) - diff(f(x)**2, x)) == 0
+    assert simplify(diff(1/f(x), x) + f(x).diff(x)/f(x)**2) == 0
+    assert simplify(f(x).diff(x, y) - f(x).diff(y, x)) == 0
+
+
+def test_logcombine_1():
+    x, y = symbols("x,y")
+    a = Symbol("a")
+    z, w = symbols("z,w", positive=True)
+    b = Symbol("b", real=True)
+    assert logcombine(log(x) + 2*log(y)) == log(x) + 2*log(y)
+    assert logcombine(log(x) + 2*log(y), force=True) == log(x*y**2)
+    assert logcombine(a*log(w) + log(z)) == a*log(w) + log(z)
+    assert logcombine(b*log(z) + b*log(x)) == log(z**b) + b*log(x)
+    assert logcombine(b*log(z) - log(w)) == log(z**b/w)
+    assert logcombine(log(x)*log(z)) == log(x)*log(z)
+    assert logcombine(log(w)*log(x)) == log(w)*log(x)
+    assert logcombine(cos(-2*log(z) + b*log(w))) in [cos(log(w**b/z**2)),
+                                                   cos(log(z**2/w**b))]
+    assert logcombine(log(log(x) - log(y)) - log(z), force=True) == \
+        log(log(x/y)/z)
+    assert logcombine((2 + I)*log(x), force=True) == (2 + I)*log(x)
+    assert logcombine((x**2 + log(x) - log(y))/(x*y), force=True) == \
+        (x**2 + log(x/y))/(x*y)
+    # the following could also give log(z*x**log(y**2)), what we
+    # are testing is that a canonical result is obtained
+    assert logcombine(log(x)*2*log(y) + log(z), force=True) == \
+        log(z*y**log(x**2))
+    assert logcombine((x*y + sqrt(x**4 + y**4) + log(x) - log(y))/(pi*x**Rational(2, 3)*
+            sqrt(y)**3), force=True) == (
+            x*y + sqrt(x**4 + y**4) + log(x/y))/(pi*x**Rational(2, 3)*y**Rational(3, 2))
+    assert logcombine(gamma(-log(x/y))*acos(-log(x/y)), force=True) == \
+        acos(-log(x/y))*gamma(-log(x/y))
+
+    assert logcombine(2*log(z)*log(w)*log(x) + log(z) + log(w)) == \
+        log(z**log(w**2))*log(x) + log(w*z)
+    assert logcombine(3*log(w) + 3*log(z)) == log(w**3*z**3)
+    assert logcombine(x*(y + 1) + log(2) + log(3)) == x*(y + 1) + log(6)
+    assert logcombine((x + y)*log(w) + (-x - y)*log(3)) == (x + y)*log(w/3)
+    # a single unknown can combine
+    assert logcombine(log(x) + log(2)) == log(2*x)
+    eq = log(abs(x)) + log(abs(y))
+    assert logcombine(eq) == eq
+    reps = {x: 0, y: 0}
+    assert log(abs(x)*abs(y)).subs(reps) != eq.subs(reps)
+
+
+def test_logcombine_complex_coeff():
+    i = Integral((sin(x**2) + cos(x**3))/x, x)
+    assert logcombine(i, force=True) == i
+    assert logcombine(i + 2*log(x), force=True) == \
+        i + log(x**2)
+
+
+def test_issue_5950():
+    x, y = symbols("x,y", positive=True)
+    assert logcombine(log(3) - log(2)) == log(Rational(3,2), evaluate=False)
+    assert logcombine(log(x) - log(y)) == log(x/y)
+    assert logcombine(log(Rational(3,2), evaluate=False) - log(2)) == \
+        log(Rational(3,4), evaluate=False)
+
+
+def test_posify():
+    x = symbols('x')
+
+    assert str(posify(
+        x +
+        Symbol('p', positive=True) +
+        Symbol('n', negative=True))) == '(_x + n + p, {_x: x})'
+
+    eq, rep = posify(1/x)
+    assert log(eq).expand().subs(rep) == -log(x)
+    assert str(posify([x, 1 + x])) == '([_x, _x + 1], {_x: x})'
+
+    p = symbols('p', positive=True)
+    n = symbols('n', negative=True)
+    orig = [x, n, p]
+    modified, reps = posify(orig)
+    assert str(modified) == '[_x, n, p]'
+    assert [w.subs(reps) for w in modified] == orig
+
+    assert str(Integral(posify(1/x + y)[0], (y, 1, 3)).expand()) == \
+        'Integral(1/_x, (y, 1, 3)) + Integral(_y, (y, 1, 3))'
+    assert str(Sum(posify(1/x**n)[0], (n,1,3)).expand()) == \
+        'Sum(_x**(-n), (n, 1, 3))'
+
+    # issue 16438
+    k = Symbol('k', finite=True)
+    eq, rep = posify(k)
+    assert eq.assumptions0 == {'positive': True, 'zero': False, 'imaginary': False,
+     'nonpositive': False, 'commutative': True, 'hermitian': True, 'real': True, 'nonzero': True,
+     'nonnegative': True, 'negative': False, 'complex': True, 'finite': True,
+     'infinite': False, 'extended_real':True, 'extended_negative': False,
+     'extended_nonnegative': True, 'extended_nonpositive': False,
+     'extended_nonzero': True, 'extended_positive': True}
+
+
+def test_issue_4194():
+    # simplify should call cancel
+    f = Function('f')
+    assert simplify((4*x + 6*f(y))/(2*x + 3*f(y))) == 2
+
+
+@XFAIL
+def test_simplify_float_vs_integer():
+    # Test for issue 4473:
+    # https://github.com/sympy/sympy/issues/4473
+    assert simplify(x**2.0 - x**2) == 0
+    assert simplify(x**2 - x**2.0) == 0
+
+
+def test_as_content_primitive():
+    assert (x/2 + y).as_content_primitive() == (S.Half, x + 2*y)
+    assert (x/2 + y).as_content_primitive(clear=False) == (S.One, x/2 + y)
+    assert (y*(x/2 + y)).as_content_primitive() == (S.Half, y*(x + 2*y))
+    assert (y*(x/2 + y)).as_content_primitive(clear=False) == (S.One, y*(x/2 + y))
+
+    # although the _as_content_primitive methods do not alter the underlying structure,
+    # the as_content_primitive function will touch up the expression and join
+    # bases that would otherwise have not been joined.
+    assert (x*(2 + 2*x)*(3*x + 3)**2).as_content_primitive() == \
+        (18, x*(x + 1)**3)
+    assert (2 + 2*x + 2*y*(3 + 3*y)).as_content_primitive() == \
+        (2, x + 3*y*(y + 1) + 1)
+    assert ((2 + 6*x)**2).as_content_primitive() == \
+        (4, (3*x + 1)**2)
+    assert ((2 + 6*x)**(2*y)).as_content_primitive() == \
+        (1, (_keep_coeff(S(2), (3*x + 1)))**(2*y))
+    assert (5 + 10*x + 2*y*(3 + 3*y)).as_content_primitive() == \
+        (1, 10*x + 6*y*(y + 1) + 5)
+    assert (5*(x*(1 + y)) + 2*x*(3 + 3*y)).as_content_primitive() == \
+        (11, x*(y + 1))
+    assert ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive() == \
+        (121, x**2*(y + 1)**2)
+    assert (y**2).as_content_primitive() == \
+        (1, y**2)
+    assert (S.Infinity).as_content_primitive() == (1, oo)
+    eq = x**(2 + y)
+    assert (eq).as_content_primitive() == (1, eq)
+    assert (S.Half**(2 + x)).as_content_primitive() == (Rational(1, 4), 2**-x)
+    assert (Rational(-1, 2)**(2 + x)).as_content_primitive() == \
+           (Rational(1, 4), (Rational(-1, 2))**x)
+    assert (Rational(-1, 2)**(2 + x)).as_content_primitive() == \
+           (Rational(1, 4), Rational(-1, 2)**x)
+    assert (4**((1 + y)/2)).as_content_primitive() == (2, 4**(y/2))
+    assert (3**((1 + y)/2)).as_content_primitive() == \
+           (1, 3**(Mul(S.Half, 1 + y, evaluate=False)))
+    assert (5**Rational(3, 4)).as_content_primitive() == (1, 5**Rational(3, 4))
+    assert (5**Rational(7, 4)).as_content_primitive() == (5, 5**Rational(3, 4))
+    assert Add(z*Rational(5, 7), 0.5*x, y*Rational(3, 2), evaluate=False).as_content_primitive() == \
+              (Rational(1, 14), 7.0*x + 21*y + 10*z)
+    assert (2**Rational(3, 4) + 2**Rational(1, 4)*sqrt(3)).as_content_primitive(radical=True) == \
+           (1, 2**Rational(1, 4)*(sqrt(2) + sqrt(3)))
+
+
+def test_signsimp():
+    e = x*(-x + 1) + x*(x - 1)
+    assert signsimp(Eq(e, 0)) is S.true
+    assert Abs(x - 1) == Abs(1 - x)
+    assert signsimp(y - x) == y - x
+    assert signsimp(y - x, evaluate=False) == Mul(-1, x - y, evaluate=False)
+
+
+def test_besselsimp():
+    from sympy.functions.special.bessel import (besseli, besselj, bessely)
+    from sympy.integrals.transforms import cosine_transform
+    assert besselsimp(exp(-I*pi*y/2)*besseli(y, z*exp_polar(I*pi/2))) == \
+        besselj(y, z)
+    assert besselsimp(exp(-I*pi*a/2)*besseli(a, 2*sqrt(x)*exp_polar(I*pi/2))) == \
+        besselj(a, 2*sqrt(x))
+    assert besselsimp(sqrt(2)*sqrt(pi)*x**Rational(1, 4)*exp(I*pi/4)*exp(-I*pi*a/2) *
+                      besseli(Rational(-1, 2), sqrt(x)*exp_polar(I*pi/2)) *
+                      besseli(a, sqrt(x)*exp_polar(I*pi/2))/2) == \
+        besselj(a, sqrt(x)) * cos(sqrt(x))
+    assert besselsimp(besseli(Rational(-1, 2), z)) == \
+        sqrt(2)*cosh(z)/(sqrt(pi)*sqrt(z))
+    assert besselsimp(besseli(a, z*exp_polar(-I*pi/2))) == \
+        exp(-I*pi*a/2)*besselj(a, z)
+    assert cosine_transform(1/t*sin(a/t), t, y) == \
+        sqrt(2)*sqrt(pi)*besselj(0, 2*sqrt(a)*sqrt(y))/2
+
+    assert besselsimp(x**2*(a*(-2*besselj(5*I, x) + besselj(-2 + 5*I, x) +
+    besselj(2 + 5*I, x)) + b*(-2*bessely(5*I, x) + bessely(-2 + 5*I, x) +
+    bessely(2 + 5*I, x)))/4 + x*(a*(besselj(-1 + 5*I, x)/2 - besselj(1 + 5*I, x)/2)
+    + b*(bessely(-1 + 5*I, x)/2 - bessely(1 + 5*I, x)/2)) + (x**2 + 25)*(a*besselj(5*I, x)
+    + b*bessely(5*I, x))) == 0
+
+    assert besselsimp(81*x**2*(a*(besselj(Rational(-5, 3), 9*x) - 2*besselj(Rational(1, 3), 9*x) + besselj(Rational(7, 3), 9*x))
+    + b*(bessely(Rational(-5, 3), 9*x) - 2*bessely(Rational(1, 3), 9*x) + bessely(Rational(7, 3), 9*x)))/4 + x*(a*(9*besselj(Rational(-2, 3), 9*x)/2
+    - 9*besselj(Rational(4, 3), 9*x)/2) + b*(9*bessely(Rational(-2, 3), 9*x)/2 - 9*bessely(Rational(4, 3), 9*x)/2)) +
+    (81*x**2 - Rational(1, 9))*(a*besselj(Rational(1, 3), 9*x) + b*bessely(Rational(1, 3), 9*x))) == 0
+
+    assert besselsimp(besselj(a-1,x) + besselj(a+1, x) - 2*a*besselj(a, x)/x) == 0
+
+    assert besselsimp(besselj(a-1,x) + besselj(a+1, x) + besselj(a, x)) == (2*a + x)*besselj(a, x)/x
+
+    assert besselsimp(x**2* besselj(a,x) + x**3*besselj(a+1, x) + besselj(a+2, x)) == \
+    2*a*x*besselj(a + 1, x) + x**3*besselj(a + 1, x) - x**2*besselj(a + 2, x) + 2*x*besselj(a + 1, x) + besselj(a + 2, x)
+
+def test_Piecewise():
+    e1 = x*(x + y) - y*(x + y)
+    e2 = sin(x)**2 + cos(x)**2
+    e3 = expand((x + y)*y/x)
+    s1 = simplify(e1)
+    s2 = simplify(e2)
+    s3 = simplify(e3)
+    assert simplify(Piecewise((e1, x < e2), (e3, True))) == \
+        Piecewise((s1, x < s2), (s3, True))
+
+
+def test_polymorphism():
+    class A(Basic):
+        def _eval_simplify(x, **kwargs):
+            return S.One
+
+    a = A(S(5), S(2))
+    assert simplify(a) == 1
+
+
+def test_issue_from_PR1599():
+    n1, n2, n3, n4 = symbols('n1 n2 n3 n4', negative=True)
+    assert simplify(I*sqrt(n1)) == -sqrt(-n1)
+
+
+def test_issue_6811():
+    eq = (x + 2*y)*(2*x + 2)
+    assert simplify(eq) == (x + 1)*(x + 2*y)*2
+    # reject the 2-arg Mul -- these are a headache for test writing
+    assert simplify(eq.expand()) == \
+        2*x**2 + 4*x*y + 2*x + 4*y
+
+
+def test_issue_6920():
+    e = [cos(x) + I*sin(x), cos(x) - I*sin(x),
+        cosh(x) - sinh(x), cosh(x) + sinh(x)]
+    ok = [exp(I*x), exp(-I*x), exp(-x), exp(x)]
+    # wrap in f to show that the change happens wherever ei occurs
+    f = Function('f')
+    assert [simplify(f(ei)).args[0] for ei in e] == ok
+
+
+def test_issue_7001():
+    from sympy.abc import r, R
+    assert simplify(-(r*Piecewise((pi*Rational(4, 3), r <= R),
+        (-8*pi*R**3/(3*r**3), True)) + 2*Piecewise((pi*r*Rational(4, 3), r <= R),
+        (4*pi*R**3/(3*r**2), True)))/(4*pi*r)) == \
+        Piecewise((-1, r <= R), (0, True))
+
+
+def test_inequality_no_auto_simplify():
+    # no simplify on creation but can be simplified
+    lhs = cos(x)**2 + sin(x)**2
+    rhs = 2
+    e = Lt(lhs, rhs, evaluate=False)
+    assert e is not S.true
+    assert simplify(e)
+
+
+def test_issue_9398():
+    from sympy.core.numbers import Number
+    from sympy.polys.polytools import cancel
+    assert cancel(1e-14) != 0
+    assert cancel(1e-14*I) != 0
+
+    assert simplify(1e-14) != 0
+    assert simplify(1e-14*I) != 0
+
+    assert (I*Number(1.)*Number(10)**Number(-14)).simplify() != 0
+
+    assert cancel(1e-20) != 0
+    assert cancel(1e-20*I) != 0
+
+    assert simplify(1e-20) != 0
+    assert simplify(1e-20*I) != 0
+
+    assert cancel(1e-100) != 0
+    assert cancel(1e-100*I) != 0
+
+    assert simplify(1e-100) != 0
+    assert simplify(1e-100*I) != 0
+
+    f = Float("1e-1000")
+    assert cancel(f) != 0
+    assert cancel(f*I) != 0
+
+    assert simplify(f) != 0
+    assert simplify(f*I) != 0
+
+
+def test_issue_9324_simplify():
+    M = MatrixSymbol('M', 10, 10)
+    e = M[0, 0] + M[5, 4] + 1304
+    assert simplify(e) == e
+
+
+def test_issue_9817_simplify():
+    # simplify on trace of substituted explicit quadratic form of matrix
+    # expressions (a scalar) should return without errors (AttributeError)
+    # See issue #9817 and #9190 for the original bug more discussion on this
+    from sympy.matrices.expressions import Identity, trace
+    v = MatrixSymbol('v', 3, 1)
+    A = MatrixSymbol('A', 3, 3)
+    x = Matrix([i + 1 for i in range(3)])
+    X = Identity(3)
+    quadratic = v.T * A * v
+    assert simplify((trace(quadratic.as_explicit())).xreplace({v:x, A:X})) == 14
+
+
+def test_issue_13474():
+    x = Symbol('x')
+    assert simplify(x + csch(sinc(1))) == x + csch(sinc(1))
+
+
+@_both_exp_pow
+def test_simplify_function_inverse():
+    # "inverse" attribute does not guarantee that f(g(x)) is x
+    # so this simplification should not happen automatically.
+    # See issue #12140
+    x, y = symbols('x, y')
+    g = Function('g')
+
+    class f(Function):
+        def inverse(self, argindex=1):
+            return g
+
+    assert simplify(f(g(x))) == f(g(x))
+    assert inversecombine(f(g(x))) == x
+    assert simplify(f(g(x)), inverse=True) == x
+    assert simplify(f(g(sin(x)**2 + cos(x)**2)), inverse=True) == 1
+    assert simplify(f(g(x, y)), inverse=True) == f(g(x, y))
+    assert unchanged(asin, sin(x))
+    assert simplify(asin(sin(x))) == asin(sin(x))
+    assert simplify(2*asin(sin(3*x)), inverse=True) == 6*x
+    assert simplify(log(exp(x))) == log(exp(x))
+    assert simplify(log(exp(x)), inverse=True) == x
+    assert simplify(exp(log(x)), inverse=True) == x
+    assert simplify(log(exp(x), 2), inverse=True) == x/log(2)
+    assert simplify(log(exp(x), 2, evaluate=False), inverse=True) == x/log(2)
+
+
+def test_clear_coefficients():
+    from sympy.simplify.simplify import clear_coefficients
+    assert clear_coefficients(4*y*(6*x + 3)) == (y*(2*x + 1), 0)
+    assert clear_coefficients(4*y*(6*x + 3) - 2) == (y*(2*x + 1), Rational(1, 6))
+    assert clear_coefficients(4*y*(6*x + 3) - 2, x) == (y*(2*x + 1), x/12 + Rational(1, 6))
+    assert clear_coefficients(sqrt(2) - 2) == (sqrt(2), 2)
+    assert clear_coefficients(4*sqrt(2) - 2) == (sqrt(2), S.Half)
+    assert clear_coefficients(S(3), x) == (0, x - 3)
+    assert clear_coefficients(S.Infinity, x) == (S.Infinity, x)
+    assert clear_coefficients(-S.Pi, x) == (S.Pi, -x)
+    assert clear_coefficients(2 - S.Pi/3, x) == (pi, -3*x + 6)
+
+def test_nc_simplify():
+    from sympy.simplify.simplify import nc_simplify
+    from sympy.matrices.expressions import MatPow, Identity
+    from sympy.core import Pow
+    from functools import reduce
+
+    a, b, c, d = symbols('a b c d', commutative = False)
+    x = Symbol('x')
+    A = MatrixSymbol("A", x, x)
+    B = MatrixSymbol("B", x, x)
+    C = MatrixSymbol("C", x, x)
+    D = MatrixSymbol("D", x, x)
+    subst = {a: A, b: B, c: C, d:D}
+    funcs = {Add: lambda x,y: x+y, Mul: lambda x,y: x*y }
+
+    def _to_matrix(expr):
+        if expr in subst:
+            return subst[expr]
+        if isinstance(expr, Pow):
+            return MatPow(_to_matrix(expr.args[0]), expr.args[1])
+        elif isinstance(expr, (Add, Mul)):
+            return reduce(funcs[expr.func],[_to_matrix(a) for a in expr.args])
+        else:
+            return expr*Identity(x)
+
+    def _check(expr, simplified, deep=True, matrix=True):
+        assert nc_simplify(expr, deep=deep) == simplified
+        assert expand(expr) == expand(simplified)
+        if matrix:
+            m_simp = _to_matrix(simplified).doit(inv_expand=False)
+            assert nc_simplify(_to_matrix(expr), deep=deep) == m_simp
+
+    _check(a*b*a*b*a*b*c*(a*b)**3*c, ((a*b)**3*c)**2)
+    _check(a*b*(a*b)**-2*a*b, 1)
+    _check(a**2*b*a*b*a*b*(a*b)**-1, a*(a*b)**2, matrix=False)
+    _check(b*a*b**2*a*b**2*a*b**2, b*(a*b**2)**3)
+    _check(a*b*a**2*b*a**2*b*a**3, (a*b*a)**3*a**2)
+    _check(a**2*b*a**4*b*a**4*b*a**2, (a**2*b*a**2)**3)
+    _check(a**3*b*a**4*b*a**4*b*a, a**3*(b*a**4)**3*a**-3)
+    _check(a*b*a*b + a*b*c*x*a*b*c, (a*b)**2 + x*(a*b*c)**2)
+    _check(a*b*a*b*c*a*b*a*b*c, ((a*b)**2*c)**2)
+    _check(b**-1*a**-1*(a*b)**2, a*b)
+    _check(a**-1*b*c**-1, (c*b**-1*a)**-1)
+    expr = a**3*b*a**4*b*a**4*b*a**2*b*a**2*(b*a**2)**2*b*a**2*b*a**2
+    for _ in range(10):
+        expr *= a*b
+    _check(expr, a**3*(b*a**4)**2*(b*a**2)**6*(a*b)**10)
+    _check((a*b*a*b)**2, (a*b*a*b)**2, deep=False)
+    _check(a*b*(c*d)**2, a*b*(c*d)**2)
+    expr = b**-1*(a**-1*b**-1 - a**-1*c*b**-1)**-1*a**-1
+    assert nc_simplify(expr) == (1-c)**-1
+    # commutative expressions should be returned without an error
+    assert nc_simplify(2*x**2) == 2*x**2
+
+def test_issue_15965():
+    A = Sum(z*x**y, (x, 1, a))
+    anew = z*Sum(x**y, (x, 1, a))
+    B = Integral(x*y, x)
+    bdo = x**2*y/2
+    assert simplify(A + B) == anew + bdo
+    assert simplify(A) == anew
+    assert simplify(B) == bdo
+    assert simplify(B, doit=False) == y*Integral(x, x)
+
+
+def test_issue_17137():
+    assert simplify(cos(x)**I) == cos(x)**I
+    assert simplify(cos(x)**(2 + 3*I)) == cos(x)**(2 + 3*I)
+
+
+def test_issue_21869():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    expr = And(Eq(x**2, 4), Le(x, y))
+    assert expr.simplify() == expr
+
+    expr = And(Eq(x**2, 4), Eq(x, 2))
+    assert expr.simplify() == Eq(x, 2)
+
+    expr = And(Eq(x**3, x**2), Eq(x, 1))
+    assert expr.simplify() == Eq(x, 1)
+
+    expr = And(Eq(sin(x), x**2), Eq(x, 0))
+    assert expr.simplify() == Eq(x, 0)
+
+    expr = And(Eq(x**3, x**2), Eq(x, 2))
+    assert expr.simplify() == S.false
+
+    expr = And(Eq(y, x**2), Eq(x, 1))
+    assert expr.simplify() == And(Eq(y,1), Eq(x, 1))
+
+    expr = And(Eq(y**2, 1), Eq(y, x**2), Eq(x, 1))
+    assert expr.simplify() == And(Eq(y,1), Eq(x, 1))
+
+    expr = And(Eq(y**2, 4), Eq(y, 2*x**2), Eq(x, 1))
+    assert expr.simplify() == And(Eq(y,2), Eq(x, 1))
+
+    expr = And(Eq(y**2, 4), Eq(y, x**2), Eq(x, 1))
+    assert expr.simplify() == S.false
+
+
+def test_issue_7971_21740():
+    z = Integral(x, (x, 1, 1))
+    assert z != 0
+    assert simplify(z) is S.Zero
+    assert simplify(S.Zero) is S.Zero
+    z = simplify(Float(0))
+    assert z is not S.Zero and z == 0.0
+
+
+@slow
+def test_issue_17141_slow():
+    # Should not give RecursionError
+    assert simplify((2**acos(I+1)**2).rewrite('log')) == 2**((pi + 2*I*log(-1 +
+                   sqrt(1 - 2*I) + I))**2/4)
+
+
+def test_issue_17141():
+    # Check that there is no RecursionError
+    assert simplify(x**(1 / acos(I))) == x**(2/(pi - 2*I*log(1 + sqrt(2))))
+    assert simplify(acos(-I)**2*acos(I)**2) == \
+           log(1 + sqrt(2))**4 + pi**2*log(1 + sqrt(2))**2/2 + pi**4/16
+    assert simplify(2**acos(I)**2) == 2**((pi - 2*I*log(1 + sqrt(2)))**2/4)
+    p = 2**acos(I+1)**2
+    assert simplify(p) == p
+
+
+def test_simplify_kroneckerdelta():
+    i, j = symbols("i j")
+    K = KroneckerDelta
+
+    assert simplify(K(i, j)) == K(i, j)
+    assert simplify(K(0, j)) == K(0, j)
+    assert simplify(K(i, 0)) == K(i, 0)
+
+    assert simplify(K(0, j).rewrite(Piecewise) * K(1, j)) == 0
+    assert simplify(K(1, i) + Piecewise((1, Eq(j, 2)), (0, True))) == K(1, i) + K(2, j)
+
+    # issue 17214
+    assert simplify(K(0, j) * K(1, j)) == 0
+
+    n = Symbol('n', integer=True)
+    assert simplify(K(0, n) * K(1, n)) == 0
+
+    M = Matrix(4, 4, lambda i, j: K(j - i, n) if i <= j else 0)
+    assert simplify(M**2) == Matrix([[K(0, n), 0, K(1, n), 0],
+                                     [0, K(0, n), 0, K(1, n)],
+                                     [0, 0, K(0, n), 0],
+                                     [0, 0, 0, K(0, n)]])
+    assert simplify(eye(1) * KroneckerDelta(0, n) *
+                    KroneckerDelta(1, n)) == Matrix([[0]])
+
+    assert simplify(S.Infinity * KroneckerDelta(0, n) *
+                    KroneckerDelta(1, n)) is S.NaN
+
+
+def test_issue_17292():
+    assert simplify(abs(x)/abs(x**2)) == 1/abs(x)
+    # this is bigger than the issue: check that deep processing works
+    assert simplify(5*abs((x**2 - 1)/(x - 1))) == 5*Abs(x + 1)
+
+
+def test_issue_19822():
+    expr = And(Gt(n-2, 1), Gt(n, 1))
+    assert simplify(expr) == Gt(n, 3)
+
+
+def test_issue_18645():
+    expr = And(Ge(x, 3), Le(x, 3))
+    assert simplify(expr) == Eq(x, 3)
+    expr = And(Eq(x, 3), Le(x, 3))
+    assert simplify(expr) == Eq(x, 3)
+
+
+@XFAIL
+def test_issue_18642():
+    i = Symbol("i", integer=True)
+    n = Symbol("n", integer=True)
+    expr = And(Eq(i, 2 * n), Le(i, 2*n -1))
+    assert simplify(expr) == S.false
+
+
+@XFAIL
+def test_issue_18389():
+    n = Symbol("n", integer=True)
+    expr = Eq(n, 0) | (n >= 1)
+    assert simplify(expr) == Ge(n, 0)
+
+
+def test_issue_8373():
+    x = Symbol('x', real=True)
+    assert simplify(Or(x < 1, x >= 1)) == S.true
+
+
+def test_issue_7950():
+    expr = And(Eq(x, 1), Eq(x, 2))
+    assert simplify(expr) == S.false
+
+
+def test_issue_22020():
+    expr = I*pi/2 -oo
+    assert simplify(expr) == expr
+    # Used to throw an error
+
+
+def test_issue_19484():
+    assert simplify(sign(x) * Abs(x)) == x
+
+    e = x + sign(x + x**3)
+    assert simplify(Abs(x + x**3)*e) == x**3 + x*Abs(x**3 + x) + x
+
+    e = x**2 + sign(x**3 + 1)
+    assert simplify(Abs(x**3 + 1) * e) == x**3 + x**2*Abs(x**3 + 1) + 1
+
+    f = Function('f')
+    e = x + sign(x + f(x)**3)
+    assert simplify(Abs(x + f(x)**3) * e) == x*Abs(x + f(x)**3) + x + f(x)**3
+
+
+def test_issue_23543():
+    # Used to give an error
+    x, y, z = symbols("x y z", commutative=False)
+    assert (x*(y + z/2)).simplify() == x*(2*y + z)/2
+
+
+def test_issue_11004():
+
+    def f(n):
+        return sqrt(2*pi*n) * (n/E)**n
+
+    def m(n, k):
+        return  f(n) / (f(n/k)**k)
+
+    def p(n,k):
+        return m(n, k) / (k**n)
+
+    N, k = symbols('N k')
+    half = Float('0.5', 4)
+    z = log(p(n, k) / p(n, k + 1)).expand(force=True)
+    r = simplify(z.subs(n, N).n(4))
+    assert r == (
+        half*k*log(k)
+        - half*k*log(k + 1)
+        + half*log(N)
+        - half*log(k + 1)
+        + Float(0.9189224, 4)
+    )
+
+
+def test_issue_19161():
+    polynomial = Poly('x**2').simplify()
+    assert (polynomial-x**2).simplify() == 0
+
+
+def test_issue_22210():
+    d = Symbol('d', integer=True)
+    expr = 2*Derivative(sin(x), (x, d))
+    assert expr.simplify() == expr
+
+
+def test_reduce_inverses_nc_pow():
+    x, y = symbols("x y", commutative=True)
+    Z = symbols("Z", commutative=False)
+    assert simplify(2**Z * y**Z) == 2**Z * y**Z
+    assert simplify(x**Z * y**Z) == x**Z * y**Z
+    x, y = symbols("x y", positive=True)
+    assert expand((x*y)**Z) == x**Z * y**Z
+    assert simplify(x**Z * y**Z) == expand((x*y)**Z)
+
+def test_nc_recursion_coeff():
+    X = symbols("X", commutative = False)
+    assert (2 * cos(pi/3) * X).simplify() == X
+    assert (2.0 * cos(pi/3) * X).simplify() == X

lib/python3.12/site-packages/sympy/simplify/tests/test_sqrtdenest.py

@@ -0,0 +1,204 @@
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Integer, Rational)
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import cos
+from sympy.integrals.integrals import Integral
+from sympy.simplify.sqrtdenest import sqrtdenest
+from sympy.simplify.sqrtdenest import (
+    _subsets as subsets, _sqrt_numeric_denest)
+
+r2, r3, r5, r6, r7, r10, r15, r29 = [sqrt(x) for x in (2, 3, 5, 6, 7, 10,
+                                          15, 29)]
+
+
+def test_sqrtdenest():
+    d = {sqrt(5 + 2 * r6): r2 + r3,
+        sqrt(5. + 2 * r6): sqrt(5. + 2 * r6),
+        sqrt(5. + 4*sqrt(5 + 2 * r6)): sqrt(5.0 + 4*r2 + 4*r3),
+        sqrt(r2): sqrt(r2),
+        sqrt(5 + r7): sqrt(5 + r7),
+        sqrt(3 + sqrt(5 + 2*r7)):
+         3*r2*(5 + 2*r7)**Rational(1, 4)/(2*sqrt(6 + 3*r7)) +
+         r2*sqrt(6 + 3*r7)/(2*(5 + 2*r7)**Rational(1, 4)),
+        sqrt(3 + 2*r3): 3**Rational(3, 4)*(r6/2 + 3*r2/2)/3}
+    for i in d:
+        assert sqrtdenest(i) == d[i], i
+
+
+def test_sqrtdenest2():
+    assert sqrtdenest(sqrt(16 - 2*r29 + 2*sqrt(55 - 10*r29))) == \
+        r5 + sqrt(11 - 2*r29)
+    e = sqrt(-r5 + sqrt(-2*r29 + 2*sqrt(-10*r29 + 55) + 16))
+    assert sqrtdenest(e) == root(-2*r29 + 11, 4)
+    r = sqrt(1 + r7)
+    assert sqrtdenest(sqrt(1 + r)) == sqrt(1 + r)
+    e = sqrt(((1 + sqrt(1 + 2*sqrt(3 + r2 + r5)))**2).expand())
+    assert sqrtdenest(e) == 1 + sqrt(1 + 2*sqrt(r2 + r5 + 3))
+
+    assert sqrtdenest(sqrt(5*r3 + 6*r2)) == \
+        sqrt(2)*root(3, 4) + root(3, 4)**3
+
+    assert sqrtdenest(sqrt(((1 + r5 + sqrt(1 + r3))**2).expand())) == \
+        1 + r5 + sqrt(1 + r3)
+
+    assert sqrtdenest(sqrt(((1 + r5 + r7 + sqrt(1 + r3))**2).expand())) == \
+        1 + sqrt(1 + r3) + r5 + r7
+
+    e = sqrt(((1 + cos(2) + cos(3) + sqrt(1 + r3))**2).expand())
+    assert sqrtdenest(e) == cos(3) + cos(2) + 1 + sqrt(1 + r3)
+
+    e = sqrt(-2*r10 + 2*r2*sqrt(-2*r10 + 11) + 14)
+    assert sqrtdenest(e) == sqrt(-2*r10 - 2*r2 + 4*r5 + 14)
+
+    # check that the result is not more complicated than the input
+    z = sqrt(-2*r29 + cos(2) + 2*sqrt(-10*r29 + 55) + 16)
+    assert sqrtdenest(z) == z
+
+    assert sqrtdenest(sqrt(r6 + sqrt(15))) == sqrt(r6 + sqrt(15))
+
+    z = sqrt(15 - 2*sqrt(31) + 2*sqrt(55 - 10*r29))
+    assert sqrtdenest(z) == z
+
+
+def test_sqrtdenest_rec():
+    assert sqrtdenest(sqrt(-4*sqrt(14) - 2*r6 + 4*sqrt(21) + 33)) == \
+        -r2 + r3 + 2*r7
+    assert sqrtdenest(sqrt(-28*r7 - 14*r5 + 4*sqrt(35) + 82)) == \
+        -7 + r5 + 2*r7
+    assert sqrtdenest(sqrt(6*r2/11 + 2*sqrt(22)/11 + 6*sqrt(11)/11 + 2)) == \
+        sqrt(11)*(r2 + 3 + sqrt(11))/11
+    assert sqrtdenest(sqrt(468*r3 + 3024*r2 + 2912*r6 + 19735)) == \
+        9*r3 + 26 + 56*r6
+    z = sqrt(-490*r3 - 98*sqrt(115) - 98*sqrt(345) - 2107)
+    assert sqrtdenest(z) == sqrt(-1)*(7*r5 + 7*r15 + 7*sqrt(23))
+    z = sqrt(-4*sqrt(14) - 2*r6 + 4*sqrt(21) + 34)
+    assert sqrtdenest(z) == z
+    assert sqrtdenest(sqrt(-8*r2 - 2*r5 + 18)) == -r10 + 1 + r2 + r5
+    assert sqrtdenest(sqrt(8*r2 + 2*r5 - 18)) == \
+        sqrt(-1)*(-r10 + 1 + r2 + r5)
+    assert sqrtdenest(sqrt(8*r2/3 + 14*r5/3 + Rational(154, 9))) == \
+        -r10/3 + r2 + r5 + 3
+    assert sqrtdenest(sqrt(sqrt(2*r6 + 5) + sqrt(2*r7 + 8))) == \
+        sqrt(1 + r2 + r3 + r7)
+    assert sqrtdenest(sqrt(4*r15 + 8*r5 + 12*r3 + 24)) == 1 + r3 + r5 + r15
+
+    w = 1 + r2 + r3 + r5 + r7
+    assert sqrtdenest(sqrt((w**2).expand())) == w
+    z = sqrt((w**2).expand() + 1)
+    assert sqrtdenest(z) == z
+
+    z = sqrt(2*r10 + 6*r2 + 4*r5 + 12 + 10*r15 + 30*r3)
+    assert sqrtdenest(z) == z
+
+
+def test_issue_6241():
+    z = sqrt( -320 + 32*sqrt(5) + 64*r15)
+    assert sqrtdenest(z) == z
+
+
+def test_sqrtdenest3():
+    z = sqrt(13 - 2*r10 + 2*r2*sqrt(-2*r10 + 11))
+    assert sqrtdenest(z) == -1 + r2 + r10
+    assert sqrtdenest(z, max_iter=1) == -1 + sqrt(2) + sqrt(10)
+    z = sqrt(sqrt(r2 + 2) + 2)
+    assert sqrtdenest(z) == z
+    assert sqrtdenest(sqrt(-2*r10 + 4*r2*sqrt(-2*r10 + 11) + 20)) == \
+        sqrt(-2*r10 - 4*r2 + 8*r5 + 20)
+    assert sqrtdenest(sqrt((112 + 70*r2) + (46 + 34*r2)*r5)) == \
+        r10 + 5 + 4*r2 + 3*r5
+    z = sqrt(5 + sqrt(2*r6 + 5)*sqrt(-2*r29 + 2*sqrt(-10*r29 + 55) + 16))
+    r = sqrt(-2*r29 + 11)
+    assert sqrtdenest(z) == sqrt(r2*r + r3*r + r10 + r15 + 5)
+
+    n = sqrt(2*r6/7 + 2*r7/7 + 2*sqrt(42)/7 + 2)
+    d = sqrt(16 - 2*r29 + 2*sqrt(55 - 10*r29))
+    assert sqrtdenest(n/d) == r7*(1 + r6 + r7)/(Mul(7, (sqrt(-2*r29 + 11) + r5),
+                                                    evaluate=False))
+
+
+def test_sqrtdenest4():
+    # see Denest_en.pdf in https://github.com/sympy/sympy/issues/3192
+    z = sqrt(8 - r2*sqrt(5 - r5) - sqrt(3)*(1 + r5))
+    z1 = sqrtdenest(z)
+    c = sqrt(-r5 + 5)
+    z1 = ((-r15*c - r3*c + c + r5*c - r6 - r2 + r10 + sqrt(30))/4).expand()
+    assert sqrtdenest(z) == z1
+
+    z = sqrt(2*r2*sqrt(r2 + 2) + 5*r2 + 4*sqrt(r2 + 2) + 8)
+    assert sqrtdenest(z) == r2 + sqrt(r2 + 2) + 2
+
+    w = 2 + r2 + r3 + (1 + r3)*sqrt(2 + r2 + 5*r3)
+    z = sqrt((w**2).expand())
+    assert sqrtdenest(z) == w.expand()
+
+
+def test_sqrt_symbolic_denest():
+    x = Symbol('x')
+    z = sqrt(((1 + sqrt(sqrt(2 + x) + 3))**2).expand())
+    assert sqrtdenest(z) == sqrt((1 + sqrt(sqrt(2 + x) + 3))**2)
+    z = sqrt(((1 + sqrt(sqrt(2 + cos(1)) + 3))**2).expand())
+    assert sqrtdenest(z) == 1 + sqrt(sqrt(2 + cos(1)) + 3)
+    z = ((1 + cos(2))**4 + 1).expand()
+    assert sqrtdenest(z) == z
+    z = sqrt(((1 + sqrt(sqrt(2 + cos(3*x)) + 3))**2 + 1).expand())
+    assert sqrtdenest(z) == z
+    c = cos(3)
+    c2 = c**2
+    assert sqrtdenest(sqrt(2*sqrt(1 + r3)*c + c2 + 1 + r3*c2)) == \
+        -1 - sqrt(1 + r3)*c
+    ra = sqrt(1 + r3)
+    z = sqrt(20*ra*sqrt(3 + 3*r3) + 12*r3*ra*sqrt(3 + 3*r3) + 64*r3 + 112)
+    assert sqrtdenest(z) == z
+
+
+def test_issue_5857():
+    from sympy.abc import x, y
+    z = sqrt(1/(4*r3 + 7) + 1)
+    ans = (r2 + r6)/(r3 + 2)
+    assert sqrtdenest(z) == ans
+    assert sqrtdenest(1 + z) == 1 + ans
+    assert sqrtdenest(Integral(z + 1, (x, 1, 2))) == \
+        Integral(1 + ans, (x, 1, 2))
+    assert sqrtdenest(x + sqrt(y)) == x + sqrt(y)
+    ans = (r2 + r6)/(r3 + 2)
+    assert sqrtdenest(z) == ans
+    assert sqrtdenest(1 + z) == 1 + ans
+    assert sqrtdenest(Integral(z + 1, (x, 1, 2))) == \
+        Integral(1 + ans, (x, 1, 2))
+    assert sqrtdenest(x + sqrt(y)) == x + sqrt(y)
+
+
+def test_subsets():
+    assert subsets(1) == [[1]]
+    assert subsets(4) == [
+        [1, 0, 0, 0], [0, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 0], [1, 0, 1, 0],
+        [0, 1, 1, 0], [1, 1, 1, 0], [0, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1],
+        [1, 1, 0, 1], [0, 0, 1, 1], [1, 0, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1]]
+
+
+def test_issue_5653():
+    assert sqrtdenest(
+        sqrt(2 + sqrt(2 + sqrt(2)))) == sqrt(2 + sqrt(2 + sqrt(2)))
+
+def test_issue_12420():
+    assert sqrtdenest((3 - sqrt(2)*sqrt(4 + 3*I) + 3*I)/2) == I
+    e = 3 - sqrt(2)*sqrt(4 + I) + 3*I
+    assert sqrtdenest(e) == e
+
+def test_sqrt_ratcomb():
+    assert sqrtdenest(sqrt(1 + r3) + sqrt(3 + 3*r3) - sqrt(10 + 6*r3)) == 0
+
+def test_issue_18041():
+    e = -sqrt(-2 + 2*sqrt(3)*I)
+    assert sqrtdenest(e) == -1 - sqrt(3)*I
+
+def test_issue_19914():
+    a = Integer(-8)
+    b = Integer(-1)
+    r = Integer(63)
+    d2 = a*a - b*b*r
+
+    assert _sqrt_numeric_denest(a, b, r, d2) == \
+        sqrt(14)*I/2 + 3*sqrt(2)*I/2
+    assert sqrtdenest(sqrt(-8-sqrt(63))) == sqrt(14)*I/2 + 3*sqrt(2)*I/2

lib/python3.12/site-packages/sympy/simplify/tests/test_trigsimp.py

@@ -0,0 +1,520 @@
+from itertools import product
+from sympy.core.function import (Subs, count_ops, diff, expand)
+from sympy.core.numbers import (E, I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (cosh, coth, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, cot, sin, tan)
+from sympy.functions.elementary.trigonometric import (acos, asin, atan2)
+from sympy.functions.elementary.trigonometric import (asec, acsc)
+from sympy.functions.elementary.trigonometric import (acot, atan)
+from sympy.integrals.integrals import integrate
+from sympy.matrices.dense import Matrix
+from sympy.simplify.simplify import simplify
+from sympy.simplify.trigsimp import (exptrigsimp, trigsimp)
+
+from sympy.testing.pytest import XFAIL
+
+from sympy.abc import x, y
+
+
+
+def test_trigsimp1():
+    x, y = symbols('x,y')
+
+    assert trigsimp(1 - sin(x)**2) == cos(x)**2
+    assert trigsimp(1 - cos(x)**2) == sin(x)**2
+    assert trigsimp(sin(x)**2 + cos(x)**2) == 1
+    assert trigsimp(1 + tan(x)**2) == 1/cos(x)**2
+    assert trigsimp(1/cos(x)**2 - 1) == tan(x)**2
+    assert trigsimp(1/cos(x)**2 - tan(x)**2) == 1
+    assert trigsimp(1 + cot(x)**2) == 1/sin(x)**2
+    assert trigsimp(1/sin(x)**2 - 1) == 1/tan(x)**2
+    assert trigsimp(1/sin(x)**2 - cot(x)**2) == 1
+
+    assert trigsimp(5*cos(x)**2 + 5*sin(x)**2) == 5
+    assert trigsimp(5*cos(x/2)**2 + 2*sin(x/2)**2) == 3*cos(x)/2 + Rational(7, 2)
+
+    assert trigsimp(sin(x)/cos(x)) == tan(x)
+    assert trigsimp(2*tan(x)*cos(x)) == 2*sin(x)
+    assert trigsimp(cot(x)**3*sin(x)**3) == cos(x)**3
+    assert trigsimp(y*tan(x)**2/sin(x)**2) == y/cos(x)**2
+    assert trigsimp(cot(x)/cos(x)) == 1/sin(x)
+
+    assert trigsimp(sin(x + y) + sin(x - y)) == 2*sin(x)*cos(y)
+    assert trigsimp(sin(x + y) - sin(x - y)) == 2*sin(y)*cos(x)
+    assert trigsimp(cos(x + y) + cos(x - y)) == 2*cos(x)*cos(y)
+    assert trigsimp(cos(x + y) - cos(x - y)) == -2*sin(x)*sin(y)
+    assert trigsimp(tan(x + y) - tan(x)/(1 - tan(x)*tan(y))) == \
+        sin(y)/(-sin(y)*tan(x) + cos(y))  # -tan(y)/(tan(x)*tan(y) - 1)
+
+    assert trigsimp(sinh(x + y) + sinh(x - y)) == 2*sinh(x)*cosh(y)
+    assert trigsimp(sinh(x + y) - sinh(x - y)) == 2*sinh(y)*cosh(x)
+    assert trigsimp(cosh(x + y) + cosh(x - y)) == 2*cosh(x)*cosh(y)
+    assert trigsimp(cosh(x + y) - cosh(x - y)) == 2*sinh(x)*sinh(y)
+    assert trigsimp(tanh(x + y) - tanh(x)/(1 + tanh(x)*tanh(y))) == \
+        sinh(y)/(sinh(y)*tanh(x) + cosh(y))
+
+    assert trigsimp(cos(0.12345)**2 + sin(0.12345)**2) == 1.0
+    e = 2*sin(x)**2 + 2*cos(x)**2
+    assert trigsimp(log(e)) == log(2)
+
+
+def test_trigsimp1a():
+    assert trigsimp(sin(2)**2*cos(3)*exp(2)/cos(2)**2) == tan(2)**2*cos(3)*exp(2)
+    assert trigsimp(tan(2)**2*cos(3)*exp(2)*cos(2)**2) == sin(2)**2*cos(3)*exp(2)
+    assert trigsimp(cot(2)*cos(3)*exp(2)*sin(2)) == cos(3)*exp(2)*cos(2)
+    assert trigsimp(tan(2)*cos(3)*exp(2)/sin(2)) == cos(3)*exp(2)/cos(2)
+    assert trigsimp(cot(2)*cos(3)*exp(2)/cos(2)) == cos(3)*exp(2)/sin(2)
+    assert trigsimp(cot(2)*cos(3)*exp(2)*tan(2)) == cos(3)*exp(2)
+    assert trigsimp(sinh(2)*cos(3)*exp(2)/cosh(2)) == tanh(2)*cos(3)*exp(2)
+    assert trigsimp(tanh(2)*cos(3)*exp(2)*cosh(2)) == sinh(2)*cos(3)*exp(2)
+    assert trigsimp(coth(2)*cos(3)*exp(2)*sinh(2)) == cosh(2)*cos(3)*exp(2)
+    assert trigsimp(tanh(2)*cos(3)*exp(2)/sinh(2)) == cos(3)*exp(2)/cosh(2)
+    assert trigsimp(coth(2)*cos(3)*exp(2)/cosh(2)) == cos(3)*exp(2)/sinh(2)
+    assert trigsimp(coth(2)*cos(3)*exp(2)*tanh(2)) == cos(3)*exp(2)
+
+
+def test_trigsimp2():
+    x, y = symbols('x,y')
+    assert trigsimp(cos(x)**2*sin(y)**2 + cos(x)**2*cos(y)**2 + sin(x)**2,
+            recursive=True) == 1
+    assert trigsimp(sin(x)**2*sin(y)**2 + sin(x)**2*cos(y)**2 + cos(x)**2,
+            recursive=True) == 1
+    assert trigsimp(
+        Subs(x, x, sin(y)**2 + cos(y)**2)) == Subs(x, x, 1)
+
+
+def test_issue_4373():
+    x = Symbol("x")
+    assert abs(trigsimp(2.0*sin(x)**2 + 2.0*cos(x)**2) - 2.0) < 1e-10
+
+
+def test_trigsimp3():
+    x, y = symbols('x,y')
+    assert trigsimp(sin(x)/cos(x)) == tan(x)
+    assert trigsimp(sin(x)**2/cos(x)**2) == tan(x)**2
+    assert trigsimp(sin(x)**3/cos(x)**3) == tan(x)**3
+    assert trigsimp(sin(x)**10/cos(x)**10) == tan(x)**10
+
+    assert trigsimp(cos(x)/sin(x)) == 1/tan(x)
+    assert trigsimp(cos(x)**2/sin(x)**2) == 1/tan(x)**2
+    assert trigsimp(cos(x)**10/sin(x)**10) == 1/tan(x)**10
+
+    assert trigsimp(tan(x)) == trigsimp(sin(x)/cos(x))
+
+
+def test_issue_4661():
+    a, x, y = symbols('a x y')
+    eq = -4*sin(x)**4 + 4*cos(x)**4 - 8*cos(x)**2
+    assert trigsimp(eq) == -4
+    n = sin(x)**6 + 4*sin(x)**4*cos(x)**2 + 5*sin(x)**2*cos(x)**4 + 2*cos(x)**6
+    d = -sin(x)**2 - 2*cos(x)**2
+    assert simplify(n/d) == -1
+    assert trigsimp(-2*cos(x)**2 + cos(x)**4 - sin(x)**4) == -1
+    eq = (- sin(x)**3/4)*cos(x) + (cos(x)**3/4)*sin(x) - sin(2*x)*cos(2*x)/8
+    assert trigsimp(eq) == 0
+
+
+def test_issue_4494():
+    a, b = symbols('a b')
+    eq = sin(a)**2*sin(b)**2 + cos(a)**2*cos(b)**2*tan(a)**2 + cos(a)**2
+    assert trigsimp(eq) == 1
+
+
+def test_issue_5948():
+    a, x, y = symbols('a x y')
+    assert trigsimp(diff(integrate(cos(x)/sin(x)**7, x), x)) == \
+           cos(x)/sin(x)**7
+
+
+def test_issue_4775():
+    a, x, y = symbols('a x y')
+    assert trigsimp(sin(x)*cos(y)+cos(x)*sin(y)) == sin(x + y)
+    assert trigsimp(sin(x)*cos(y)+cos(x)*sin(y)+3) == sin(x + y) + 3
+
+
+def test_issue_4280():
+    a, x, y = symbols('a x y')
+    assert trigsimp(cos(x)**2 + cos(y)**2*sin(x)**2 + sin(y)**2*sin(x)**2) == 1
+    assert trigsimp(a**2*sin(x)**2 + a**2*cos(y)**2*cos(x)**2 + a**2*cos(x)**2*sin(y)**2) == a**2
+    assert trigsimp(a**2*cos(y)**2*sin(x)**2 + a**2*sin(y)**2*sin(x)**2) == a**2*sin(x)**2
+
+
+def test_issue_3210():
+    eqs = (sin(2)*cos(3) + sin(3)*cos(2),
+        -sin(2)*sin(3) + cos(2)*cos(3),
+        sin(2)*cos(3) - sin(3)*cos(2),
+        sin(2)*sin(3) + cos(2)*cos(3),
+        sin(2)*sin(3) + cos(2)*cos(3) + cos(2),
+        sinh(2)*cosh(3) + sinh(3)*cosh(2),
+        sinh(2)*sinh(3) + cosh(2)*cosh(3),
+        )
+    assert [trigsimp(e) for e in eqs] == [
+        sin(5),
+        cos(5),
+        -sin(1),
+        cos(1),
+        cos(1) + cos(2),
+        sinh(5),
+        cosh(5),
+        ]
+
+
+def test_trigsimp_issues():
+    a, x, y = symbols('a x y')
+
+    # issue 4625 - factor_terms works, too
+    assert trigsimp(sin(x)**3 + cos(x)**2*sin(x)) == sin(x)
+
+    # issue 5948
+    assert trigsimp(diff(integrate(cos(x)/sin(x)**3, x), x)) == \
+        cos(x)/sin(x)**3
+    assert trigsimp(diff(integrate(sin(x)/cos(x)**3, x), x)) == \
+        sin(x)/cos(x)**3
+
+    # check integer exponents
+    e = sin(x)**y/cos(x)**y
+    assert trigsimp(e) == e
+    assert trigsimp(e.subs(y, 2)) == tan(x)**2
+    assert trigsimp(e.subs(x, 1)) == tan(1)**y
+
+    # check for multiple patterns
+    assert (cos(x)**2/sin(x)**2*cos(y)**2/sin(y)**2).trigsimp() == \
+        1/tan(x)**2/tan(y)**2
+    assert trigsimp(cos(x)/sin(x)*cos(x+y)/sin(x+y)) == \
+        1/(tan(x)*tan(x + y))
+
+    eq = cos(2)*(cos(3) + 1)**2/(cos(3) - 1)**2
+    assert trigsimp(eq) == eq.factor()  # factor makes denom (-1 + cos(3))**2
+    assert trigsimp(cos(2)*(cos(3) + 1)**2*(cos(3) - 1)**2) == \
+        cos(2)*sin(3)**4
+
+    # issue 6789; this generates an expression that formerly caused
+    # trigsimp to hang
+    assert cot(x).equals(tan(x)) is False
+
+    # nan or the unchanged expression is ok, but not sin(1)
+    z = cos(x)**2 + sin(x)**2 - 1
+    z1 = tan(x)**2 - 1/cot(x)**2
+    n = (1 + z1/z)
+    assert trigsimp(sin(n)) != sin(1)
+    eq = x*(n - 1) - x*n
+    assert trigsimp(eq) is S.NaN
+    assert trigsimp(eq, recursive=True) is S.NaN
+    assert trigsimp(1).is_Integer
+
+    assert trigsimp(-sin(x)**4 - 2*sin(x)**2*cos(x)**2 - cos(x)**4) == -1
+
+
+def test_trigsimp_issue_2515():
+    x = Symbol('x')
+    assert trigsimp(x*cos(x)*tan(x)) == x*sin(x)
+    assert trigsimp(-sin(x) + cos(x)*tan(x)) == 0
+
+
+def test_trigsimp_issue_3826():
+    assert trigsimp(tan(2*x).expand(trig=True)) == tan(2*x)
+
+
+def test_trigsimp_issue_4032():
+    n = Symbol('n', integer=True, positive=True)
+    assert trigsimp(2**(n/2)*cos(pi*n/4)/2 + 2**(n - 1)/2) == \
+        2**(n/2)*cos(pi*n/4)/2 + 2**n/4
+
+
+def test_trigsimp_issue_7761():
+    assert trigsimp(cosh(pi/4)) == cosh(pi/4)
+
+
+def test_trigsimp_noncommutative():
+    x, y = symbols('x,y')
+    A, B = symbols('A,B', commutative=False)
+
+    assert trigsimp(A - A*sin(x)**2) == A*cos(x)**2
+    assert trigsimp(A - A*cos(x)**2) == A*sin(x)**2
+    assert trigsimp(A*sin(x)**2 + A*cos(x)**2) == A
+    assert trigsimp(A + A*tan(x)**2) == A/cos(x)**2
+    assert trigsimp(A/cos(x)**2 - A) == A*tan(x)**2
+    assert trigsimp(A/cos(x)**2 - A*tan(x)**2) == A
+    assert trigsimp(A + A*cot(x)**2) == A/sin(x)**2
+    assert trigsimp(A/sin(x)**2 - A) == A/tan(x)**2
+    assert trigsimp(A/sin(x)**2 - A*cot(x)**2) == A
+
+    assert trigsimp(y*A*cos(x)**2 + y*A*sin(x)**2) == y*A
+
+    assert trigsimp(A*sin(x)/cos(x)) == A*tan(x)
+    assert trigsimp(A*tan(x)*cos(x)) == A*sin(x)
+    assert trigsimp(A*cot(x)**3*sin(x)**3) == A*cos(x)**3
+    assert trigsimp(y*A*tan(x)**2/sin(x)**2) == y*A/cos(x)**2
+    assert trigsimp(A*cot(x)/cos(x)) == A/sin(x)
+
+    assert trigsimp(A*sin(x + y) + A*sin(x - y)) == 2*A*sin(x)*cos(y)
+    assert trigsimp(A*sin(x + y) - A*sin(x - y)) == 2*A*sin(y)*cos(x)
+    assert trigsimp(A*cos(x + y) + A*cos(x - y)) == 2*A*cos(x)*cos(y)
+    assert trigsimp(A*cos(x + y) - A*cos(x - y)) == -2*A*sin(x)*sin(y)
+
+    assert trigsimp(A*sinh(x + y) + A*sinh(x - y)) == 2*A*sinh(x)*cosh(y)
+    assert trigsimp(A*sinh(x + y) - A*sinh(x - y)) == 2*A*sinh(y)*cosh(x)
+    assert trigsimp(A*cosh(x + y) + A*cosh(x - y)) == 2*A*cosh(x)*cosh(y)
+    assert trigsimp(A*cosh(x + y) - A*cosh(x - y)) == 2*A*sinh(x)*sinh(y)
+
+    assert trigsimp(A*cos(0.12345)**2 + A*sin(0.12345)**2) == 1.0*A
+
+
+def test_hyperbolic_simp():
+    x, y = symbols('x,y')
+
+    assert trigsimp(sinh(x)**2 + 1) == cosh(x)**2
+    assert trigsimp(cosh(x)**2 - 1) == sinh(x)**2
+    assert trigsimp(cosh(x)**2 - sinh(x)**2) == 1
+    assert trigsimp(1 - tanh(x)**2) == 1/cosh(x)**2
+    assert trigsimp(1 - 1/cosh(x)**2) == tanh(x)**2
+    assert trigsimp(tanh(x)**2 + 1/cosh(x)**2) == 1
+    assert trigsimp(coth(x)**2 - 1) == 1/sinh(x)**2
+    assert trigsimp(1/sinh(x)**2 + 1) == 1/tanh(x)**2
+    assert trigsimp(coth(x)**2 - 1/sinh(x)**2) == 1
+
+    assert trigsimp(5*cosh(x)**2 - 5*sinh(x)**2) == 5
+    assert trigsimp(5*cosh(x/2)**2 - 2*sinh(x/2)**2) == 3*cosh(x)/2 + Rational(7, 2)
+
+    assert trigsimp(sinh(x)/cosh(x)) == tanh(x)
+    assert trigsimp(tanh(x)) == trigsimp(sinh(x)/cosh(x))
+    assert trigsimp(cosh(x)/sinh(x)) == 1/tanh(x)
+    assert trigsimp(2*tanh(x)*cosh(x)) == 2*sinh(x)
+    assert trigsimp(coth(x)**3*sinh(x)**3) == cosh(x)**3
+    assert trigsimp(y*tanh(x)**2/sinh(x)**2) == y/cosh(x)**2
+    assert trigsimp(coth(x)/cosh(x)) == 1/sinh(x)
+
+    for a in (pi/6*I, pi/4*I, pi/3*I):
+        assert trigsimp(sinh(a)*cosh(x) + cosh(a)*sinh(x)) == sinh(x + a)
+        assert trigsimp(-sinh(a)*cosh(x) + cosh(a)*sinh(x)) == sinh(x - a)
+
+    e = 2*cosh(x)**2 - 2*sinh(x)**2
+    assert trigsimp(log(e)) == log(2)
+
+    # issue 19535:
+    assert trigsimp(sqrt(cosh(x)**2 - 1)) == sqrt(sinh(x)**2)
+
+    assert trigsimp(cosh(x)**2*cosh(y)**2 - cosh(x)**2*sinh(y)**2 - sinh(x)**2,
+            recursive=True) == 1
+    assert trigsimp(sinh(x)**2*sinh(y)**2 - sinh(x)**2*cosh(y)**2 + cosh(x)**2,
+            recursive=True) == 1
+
+    assert abs(trigsimp(2.0*cosh(x)**2 - 2.0*sinh(x)**2) - 2.0) < 1e-10
+
+    assert trigsimp(sinh(x)**2/cosh(x)**2) == tanh(x)**2
+    assert trigsimp(sinh(x)**3/cosh(x)**3) == tanh(x)**3
+    assert trigsimp(sinh(x)**10/cosh(x)**10) == tanh(x)**10
+    assert trigsimp(cosh(x)**3/sinh(x)**3) == 1/tanh(x)**3
+
+    assert trigsimp(cosh(x)/sinh(x)) == 1/tanh(x)
+    assert trigsimp(cosh(x)**2/sinh(x)**2) == 1/tanh(x)**2
+    assert trigsimp(cosh(x)**10/sinh(x)**10) == 1/tanh(x)**10
+
+    assert trigsimp(x*cosh(x)*tanh(x)) == x*sinh(x)
+    assert trigsimp(-sinh(x) + cosh(x)*tanh(x)) == 0
+
+    assert tan(x) != 1/cot(x)  # cot doesn't auto-simplify
+
+    assert trigsimp(tan(x) - 1/cot(x)) == 0
+    assert trigsimp(3*tanh(x)**7 - 2/coth(x)**7) == tanh(x)**7
+
+
+def test_trigsimp_groebner():
+    from sympy.simplify.trigsimp import trigsimp_groebner
+
+    c = cos(x)
+    s = sin(x)
+    ex = (4*s*c + 12*s + 5*c**3 + 21*c**2 + 23*c + 15)/(
+        -s*c**2 + 2*s*c + 15*s + 7*c**3 + 31*c**2 + 37*c + 21)
+    resnum = (5*s - 5*c + 1)
+    resdenom = (8*s - 6*c)
+    results = [resnum/resdenom, (-resnum)/(-resdenom)]
+    assert trigsimp_groebner(ex) in results
+    assert trigsimp_groebner(s/c, hints=[tan]) == tan(x)
+    assert trigsimp_groebner(c*s) == c*s
+    assert trigsimp((-s + 1)/c + c/(-s + 1),
+                    method='groebner') == 2/c
+    assert trigsimp((-s + 1)/c + c/(-s + 1),
+                    method='groebner', polynomial=True) == 2/c
+
+    # Test quick=False works
+    assert trigsimp_groebner(ex, hints=[2]) in results
+    assert trigsimp_groebner(ex, hints=[int(2)]) in results
+
+    # test "I"
+    assert trigsimp_groebner(sin(I*x)/cos(I*x), hints=[tanh]) == I*tanh(x)
+
+    # test hyperbolic / sums
+    assert trigsimp_groebner((tanh(x)+tanh(y))/(1+tanh(x)*tanh(y)),
+                             hints=[(tanh, x, y)]) == tanh(x + y)
+
+
+def test_issue_2827_trigsimp_methods():
+    measure1 = lambda expr: len(str(expr))
+    measure2 = lambda expr: -count_ops(expr)
+                                       # Return the most complicated result
+    expr = (x + 1)/(x + sin(x)**2 + cos(x)**2)
+    ans = Matrix([1])
+    M = Matrix([expr])
+    assert trigsimp(M, method='fu', measure=measure1) == ans
+    assert trigsimp(M, method='fu', measure=measure2) != ans
+    # all methods should work with Basic expressions even if they
+    # aren't Expr
+    M = Matrix.eye(1)
+    assert all(trigsimp(M, method=m) == M for m in
+        'fu matching groebner old'.split())
+    # watch for E in exptrigsimp, not only exp()
+    eq = 1/sqrt(E) + E
+    assert exptrigsimp(eq) == eq
+
+def test_issue_15129_trigsimp_methods():
+    t1 = Matrix([sin(Rational(1, 50)), cos(Rational(1, 50)), 0])
+    t2 = Matrix([sin(Rational(1, 25)), cos(Rational(1, 25)), 0])
+    t3 = Matrix([cos(Rational(1, 25)), sin(Rational(1, 25)), 0])
+    r1 = t1.dot(t2)
+    r2 = t1.dot(t3)
+    assert trigsimp(r1) == cos(Rational(1, 50))
+    assert trigsimp(r2) == sin(Rational(3, 50))
+
+def test_exptrigsimp():
+    def valid(a, b):
+        from sympy.core.random import verify_numerically as tn
+        if not (tn(a, b) and a == b):
+            return False
+        return True
+
+    assert exptrigsimp(exp(x) + exp(-x)) == 2*cosh(x)
+    assert exptrigsimp(exp(x) - exp(-x)) == 2*sinh(x)
+    assert exptrigsimp((2*exp(x)-2*exp(-x))/(exp(x)+exp(-x))) == 2*tanh(x)
+    assert exptrigsimp((2*exp(2*x)-2)/(exp(2*x)+1)) == 2*tanh(x)
+    e = [cos(x) + I*sin(x), cos(x) - I*sin(x),
+         cosh(x) - sinh(x), cosh(x) + sinh(x)]
+    ok = [exp(I*x), exp(-I*x), exp(-x), exp(x)]
+    assert all(valid(i, j) for i, j in zip(
+        [exptrigsimp(ei) for ei in e], ok))
+
+    ue = [cos(x) + sin(x), cos(x) - sin(x),
+          cosh(x) + I*sinh(x), cosh(x) - I*sinh(x)]
+    assert [exptrigsimp(ei) == ei for ei in ue]
+
+    res = []
+    ok = [y*tanh(1), 1/(y*tanh(1)), I*y*tan(1), -I/(y*tan(1)),
+        y*tanh(x), 1/(y*tanh(x)), I*y*tan(x), -I/(y*tan(x)),
+        y*tanh(1 + I), 1/(y*tanh(1 + I))]
+    for a in (1, I, x, I*x, 1 + I):
+        w = exp(a)
+        eq = y*(w - 1/w)/(w + 1/w)
+        res.append(simplify(eq))
+        res.append(simplify(1/eq))
+    assert all(valid(i, j) for i, j in zip(res, ok))
+
+    for a in range(1, 3):
+        w = exp(a)
+        e = w + 1/w
+        s = simplify(e)
+        assert s == exptrigsimp(e)
+        assert valid(s, 2*cosh(a))
+        e = w - 1/w
+        s = simplify(e)
+        assert s == exptrigsimp(e)
+        assert valid(s, 2*sinh(a))
+
+def test_exptrigsimp_noncommutative():
+    a,b = symbols('a b', commutative=False)
+    x = Symbol('x', commutative=True)
+    assert exp(a + x) == exptrigsimp(exp(a)*exp(x))
+    p = exp(a)*exp(b) - exp(b)*exp(a)
+    assert p == exptrigsimp(p) != 0
+
+def test_powsimp_on_numbers():
+    assert 2**(Rational(1, 3) - 2) == 2**Rational(1, 3)/4
+
+
+@XFAIL
+def test_issue_6811_fail():
+    # from doc/src/modules/physics/mechanics/examples.rst, the current `eq`
+    # at Line 576 (in different variables) was formerly the equivalent and
+    # shorter expression given below...it would be nice to get the short one
+    # back again
+    xp, y, x, z = symbols('xp, y, x, z')
+    eq = 4*(-19*sin(x)*y + 5*sin(3*x)*y + 15*cos(2*x)*z - 21*z)*xp/(9*cos(x) - 5*cos(3*x))
+    assert trigsimp(eq) == -2*(2*cos(x)*tan(x)*y + 3*z)*xp/cos(x)
+
+
+def test_Piecewise():
+    e1 = x*(x + y) - y*(x + y)
+    e2 = sin(x)**2 + cos(x)**2
+    e3 = expand((x + y)*y/x)
+    # s1 = simplify(e1)
+    s2 = simplify(e2)
+    # s3 = simplify(e3)
+
+    # trigsimp tries not to touch non-trig containing args
+    assert trigsimp(Piecewise((e1, e3 < e2), (e3, True))) == \
+        Piecewise((e1, e3 < s2), (e3, True))
+
+
+def test_issue_21594():
+    assert simplify(exp(Rational(1,2)) + exp(Rational(-1,2))) == cosh(S.Half)*2
+
+
+def test_trigsimp_old():
+    x, y = symbols('x,y')
+
+    assert trigsimp(1 - sin(x)**2, old=True) == cos(x)**2
+    assert trigsimp(1 - cos(x)**2, old=True) == sin(x)**2
+    assert trigsimp(sin(x)**2 + cos(x)**2, old=True) == 1
+    assert trigsimp(1 + tan(x)**2, old=True) == 1/cos(x)**2
+    assert trigsimp(1/cos(x)**2 - 1, old=True) == tan(x)**2
+    assert trigsimp(1/cos(x)**2 - tan(x)**2, old=True) == 1
+    assert trigsimp(1 + cot(x)**2, old=True) == 1/sin(x)**2
+    assert trigsimp(1/sin(x)**2 - cot(x)**2, old=True) == 1
+
+    assert trigsimp(5*cos(x)**2 + 5*sin(x)**2, old=True) == 5
+
+    assert trigsimp(sin(x)/cos(x), old=True) == tan(x)
+    assert trigsimp(2*tan(x)*cos(x), old=True) == 2*sin(x)
+    assert trigsimp(cot(x)**3*sin(x)**3, old=True) == cos(x)**3
+    assert trigsimp(y*tan(x)**2/sin(x)**2, old=True) == y/cos(x)**2
+    assert trigsimp(cot(x)/cos(x), old=True) == 1/sin(x)
+
+    assert trigsimp(sin(x + y) + sin(x - y), old=True) == 2*sin(x)*cos(y)
+    assert trigsimp(sin(x + y) - sin(x - y), old=True) == 2*sin(y)*cos(x)
+    assert trigsimp(cos(x + y) + cos(x - y), old=True) == 2*cos(x)*cos(y)
+    assert trigsimp(cos(x + y) - cos(x - y), old=True) == -2*sin(x)*sin(y)
+
+    assert trigsimp(sinh(x + y) + sinh(x - y), old=True) == 2*sinh(x)*cosh(y)
+    assert trigsimp(sinh(x + y) - sinh(x - y), old=True) == 2*sinh(y)*cosh(x)
+    assert trigsimp(cosh(x + y) + cosh(x - y), old=True) == 2*cosh(x)*cosh(y)
+    assert trigsimp(cosh(x + y) - cosh(x - y), old=True) == 2*sinh(x)*sinh(y)
+
+    assert trigsimp(cos(0.12345)**2 + sin(0.12345)**2, old=True) == 1.0
+
+    assert trigsimp(sin(x)/cos(x), old=True, method='combined') == tan(x)
+    assert trigsimp(sin(x)/cos(x), old=True, method='groebner') == sin(x)/cos(x)
+    assert trigsimp(sin(x)/cos(x), old=True, method='groebner', hints=[tan]) == tan(x)
+
+    assert trigsimp(1-sin(sin(x)**2+cos(x)**2)**2, old=True, deep=True) == cos(1)**2
+
+
+def test_trigsimp_inverse():
+    alpha = symbols('alpha')
+    s, c = sin(alpha), cos(alpha)
+
+    for finv in [asin, acos, asec, acsc, atan, acot]:
+        f = finv.inverse(None)
+        assert alpha == trigsimp(finv(f(alpha)), inverse=True)
+
+    # test atan2(cos, sin), atan2(sin, cos), etc...
+    for a, b in [[c, s], [s, c]]:
+        for i, j in product([-1, 1], repeat=2):
+            angle = atan2(i*b, j*a)
+            angle_inverted = trigsimp(angle, inverse=True)
+            assert angle_inverted != angle  # assures simplification happened
+            assert sin(angle_inverted) == trigsimp(sin(angle))
+            assert cos(angle_inverted) == trigsimp(cos(angle))

lib/python3.12/site-packages/sympy/simplify/trigsimp.py

@@ -0,0 +1,1253 @@
+from collections import defaultdict
+from functools import reduce
+
+from sympy.core import (sympify, Basic, S, Expr, factor_terms,
+                        Mul, Add, bottom_up)
+from sympy.core.cache import cacheit
+from sympy.core.function import (count_ops, _mexpand, FunctionClass, expand,
+                                 expand_mul, _coeff_isneg, Derivative)
+from sympy.core.numbers import I, Integer
+from sympy.core.intfunc import igcd
+from sympy.core.sorting import _nodes
+from sympy.core.symbol import Dummy, symbols, Wild
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.functions import sin, cos, exp, cosh, tanh, sinh, tan, cot, coth
+from sympy.functions import atan2
+from sympy.functions.elementary.hyperbolic import HyperbolicFunction
+from sympy.functions.elementary.trigonometric import TrigonometricFunction
+from sympy.polys import Poly, factor, cancel, parallel_poly_from_expr
+from sympy.polys.domains import ZZ
+from sympy.polys.polyerrors import PolificationFailed
+from sympy.polys.polytools import groebner
+from sympy.simplify.cse_main import cse
+from sympy.strategies.core import identity
+from sympy.strategies.tree import greedy
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import debug
+
+def trigsimp_groebner(expr, hints=[], quick=False, order="grlex",
+                      polynomial=False):
+    """
+    Simplify trigonometric expressions using a groebner basis algorithm.
+
+    Explanation
+    ===========
+
+    This routine takes a fraction involving trigonometric or hyperbolic
+    expressions, and tries to simplify it. The primary metric is the
+    total degree. Some attempts are made to choose the simplest possible
+    expression of the minimal degree, but this is non-rigorous, and also
+    very slow (see the ``quick=True`` option).
+
+    If ``polynomial`` is set to True, instead of simplifying numerator and
+    denominator together, this function just brings numerator and denominator
+    into a canonical form. This is much faster, but has potentially worse
+    results. However, if the input is a polynomial, then the result is
+    guaranteed to be an equivalent polynomial of minimal degree.
+
+    The most important option is hints. Its entries can be any of the
+    following:
+
+    - a natural number
+    - a function
+    - an iterable of the form (func, var1, var2, ...)
+    - anything else, interpreted as a generator
+
+    A number is used to indicate that the search space should be increased.
+    A function is used to indicate that said function is likely to occur in a
+    simplified expression.
+    An iterable is used indicate that func(var1 + var2 + ...) is likely to
+    occur in a simplified .
+    An additional generator also indicates that it is likely to occur.
+    (See examples below).
+
+    This routine carries out various computationally intensive algorithms.
+    The option ``quick=True`` can be used to suppress one particularly slow
+    step (at the expense of potentially more complicated results, but never at
+    the expense of increased total degree).
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import sin, tan, cos, sinh, cosh, tanh
+    >>> from sympy.simplify.trigsimp import trigsimp_groebner
+
+    Suppose you want to simplify ``sin(x)*cos(x)``. Naively, nothing happens:
+
+    >>> ex = sin(x)*cos(x)
+    >>> trigsimp_groebner(ex)
+    sin(x)*cos(x)
+
+    This is because ``trigsimp_groebner`` only looks for a simplification
+    involving just ``sin(x)`` and ``cos(x)``. You can tell it to also try
+    ``2*x`` by passing ``hints=[2]``:
+
+    >>> trigsimp_groebner(ex, hints=[2])
+    sin(2*x)/2
+    >>> trigsimp_groebner(sin(x)**2 - cos(x)**2, hints=[2])
+    -cos(2*x)
+
+    Increasing the search space this way can quickly become expensive. A much
+    faster way is to give a specific expression that is likely to occur:
+
+    >>> trigsimp_groebner(ex, hints=[sin(2*x)])
+    sin(2*x)/2
+
+    Hyperbolic expressions are similarly supported:
+
+    >>> trigsimp_groebner(sinh(2*x)/sinh(x))
+    2*cosh(x)
+
+    Note how no hints had to be passed, since the expression already involved
+    ``2*x``.
+
+    The tangent function is also supported. You can either pass ``tan`` in the
+    hints, to indicate that tan should be tried whenever cosine or sine are,
+    or you can pass a specific generator:
+
+    >>> trigsimp_groebner(sin(x)/cos(x), hints=[tan])
+    tan(x)
+    >>> trigsimp_groebner(sinh(x)/cosh(x), hints=[tanh(x)])
+    tanh(x)
+
+    Finally, you can use the iterable form to suggest that angle sum formulae
+    should be tried:
+
+    >>> ex = (tan(x) + tan(y))/(1 - tan(x)*tan(y))
+    >>> trigsimp_groebner(ex, hints=[(tan, x, y)])
+    tan(x + y)
+    """
+    # TODO
+    #  - preprocess by replacing everything by funcs we can handle
+    # - optionally use cot instead of tan
+    # - more intelligent hinting.
+    #     For example, if the ideal is small, and we have sin(x), sin(y),
+    #     add sin(x + y) automatically... ?
+    # - algebraic numbers ...
+    # - expressions of lowest degree are not distinguished properly
+    #   e.g. 1 - sin(x)**2
+    # - we could try to order the generators intelligently, so as to influence
+    #   which monomials appear in the quotient basis
+
+    # THEORY
+    # ------
+    # Ratsimpmodprime above can be used to "simplify" a rational function
+    # modulo a prime ideal. "Simplify" mainly means finding an equivalent
+    # expression of lower total degree.
+    #
+    # We intend to use this to simplify trigonometric functions. To do that,
+    # we need to decide (a) which ring to use, and (b) modulo which ideal to
+    # simplify. In practice, (a) means settling on a list of "generators"
+    # a, b, c, ..., such that the fraction we want to simplify is a rational
+    # function in a, b, c, ..., with coefficients in ZZ (integers).
+    # (2) means that we have to decide what relations to impose on the
+    # generators. There are two practical problems:
+    #   (1) The ideal has to be *prime* (a technical term).
+    #   (2) The relations have to be polynomials in the generators.
+    #
+    # We typically have two kinds of generators:
+    # - trigonometric expressions, like sin(x), cos(5*x), etc
+    # - "everything else", like gamma(x), pi, etc.
+    #
+    # Since this function is trigsimp, we will concentrate on what to do with
+    # trigonometric expressions. We can also simplify hyperbolic expressions,
+    # but the extensions should be clear.
+    #
+    # One crucial point is that all *other* generators really should behave
+    # like indeterminates. In particular if (say) "I" is one of them, then
+    # in fact I**2 + 1 = 0 and we may and will compute non-sensical
+    # expressions. However, we can work with a dummy and add the relation
+    # I**2 + 1 = 0 to our ideal, then substitute back in the end.
+    #
+    # Now regarding trigonometric generators. We split them into groups,
+    # according to the argument of the trigonometric functions. We want to
+    # organise this in such a way that most trigonometric identities apply in
+    # the same group. For example, given sin(x), cos(2*x) and cos(y), we would
+    # group as [sin(x), cos(2*x)] and [cos(y)].
+    #
+    # Our prime ideal will be built in three steps:
+    # (1) For each group, compute a "geometrically prime" ideal of relations.
+    #     Geometrically prime means that it generates a prime ideal in
+    #     CC[gens], not just ZZ[gens].
+    # (2) Take the union of all the generators of the ideals for all groups.
+    #     By the geometric primality condition, this is still prime.
+    # (3) Add further inter-group relations which preserve primality.
+    #
+    # Step (1) works as follows. We will isolate common factors in the
+    # argument, so that all our generators are of the form sin(n*x), cos(n*x)
+    # or tan(n*x), with n an integer. Suppose first there are no tan terms.
+    # The ideal [sin(x)**2 + cos(x)**2 - 1] is geometrically prime, since
+    # X**2 + Y**2 - 1 is irreducible over CC.
+    # Now, if we have a generator sin(n*x), than we can, using trig identities,
+    # express sin(n*x) as a polynomial in sin(x) and cos(x). We can add this
+    # relation to the ideal, preserving geometric primality, since the quotient
+    # ring is unchanged.
+    # Thus we have treated all sin and cos terms.
+    # For tan(n*x), we add a relation tan(n*x)*cos(n*x) - sin(n*x) = 0.
+    # (This requires of course that we already have relations for cos(n*x) and
+    # sin(n*x).) It is not obvious, but it seems that this preserves geometric
+    # primality.
+    # XXX A real proof would be nice. HELP!
+    #     Sketch that <S**2 + C**2 - 1, C*T - S> is a prime ideal of
+    #     CC[S, C, T]:
+    #     - it suffices to show that the projective closure in CP**3 is
+    #       irreducible
+    #     - using the half-angle substitutions, we can express sin(x), tan(x),
+    #       cos(x) as rational functions in tan(x/2)
+    #     - from this, we get a rational map from CP**1 to our curve
+    #     - this is a morphism, hence the curve is prime
+    #
+    # Step (2) is trivial.
+    #
+    # Step (3) works by adding selected relations of the form
+    # sin(x + y) - sin(x)*cos(y) - sin(y)*cos(x), etc. Geometric primality is
+    # preserved by the same argument as before.
+
+    def parse_hints(hints):
+        """Split hints into (n, funcs, iterables, gens)."""
+        n = 1
+        funcs, iterables, gens = [], [], []
+        for e in hints:
+            if isinstance(e, (SYMPY_INTS, Integer)):
+                n = e
+            elif isinstance(e, FunctionClass):
+                funcs.append(e)
+            elif iterable(e):
+                iterables.append((e[0], e[1:]))
+                # XXX sin(x+2y)?
+                # Note: we go through polys so e.g.
+                # sin(-x) -> -sin(x) -> sin(x)
+                gens.extend(parallel_poly_from_expr(
+                    [e[0](x) for x in e[1:]] + [e[0](Add(*e[1:]))])[1].gens)
+            else:
+                gens.append(e)
+        return n, funcs, iterables, gens
+
+    def build_ideal(x, terms):
+        """
+        Build generators for our ideal. ``Terms`` is an iterable with elements of
+        the form (fn, coeff), indicating that we have a generator fn(coeff*x).
+
+        If any of the terms is trigonometric, sin(x) and cos(x) are guaranteed
+        to appear in terms. Similarly for hyperbolic functions. For tan(n*x),
+        sin(n*x) and cos(n*x) are guaranteed.
+        """
+        I = []
+        y = Dummy('y')
+        for fn, coeff in terms:
+            for c, s, t, rel in (
+                    [cos, sin, tan, cos(x)**2 + sin(x)**2 - 1],
+                    [cosh, sinh, tanh, cosh(x)**2 - sinh(x)**2 - 1]):
+                if coeff == 1 and fn in [c, s]:
+                    I.append(rel)
+                elif fn == t:
+                    I.append(t(coeff*x)*c(coeff*x) - s(coeff*x))
+                elif fn in [c, s]:
+                    cn = fn(coeff*y).expand(trig=True).subs(y, x)
+                    I.append(fn(coeff*x) - cn)
+        return list(set(I))
+
+    def analyse_gens(gens, hints):
+        """
+        Analyse the generators ``gens``, using the hints ``hints``.
+
+        The meaning of ``hints`` is described in the main docstring.
+        Return a new list of generators, and also the ideal we should
+        work with.
+        """
+        # First parse the hints
+        n, funcs, iterables, extragens = parse_hints(hints)
+        debug('n=%s   funcs: %s   iterables: %s    extragens: %s',
+              (funcs, iterables, extragens))
+
+        # We just add the extragens to gens and analyse them as before
+        gens = list(gens)
+        gens.extend(extragens)
+
+        # remove duplicates
+        funcs = list(set(funcs))
+        iterables = list(set(iterables))
+        gens = list(set(gens))
+
+        # all the functions we can do anything with
+        allfuncs = {sin, cos, tan, sinh, cosh, tanh}
+        # sin(3*x) -> ((3, x), sin)
+        trigterms = [(g.args[0].as_coeff_mul(), g.func) for g in gens
+                     if g.func in allfuncs]
+        # Our list of new generators - start with anything that we cannot
+        # work with (i.e. is not a trigonometric term)
+        freegens = [g for g in gens if g.func not in allfuncs]
+        newgens = []
+        trigdict = {}
+        for (coeff, var), fn in trigterms:
+            trigdict.setdefault(var, []).append((coeff, fn))
+        res = [] # the ideal
+
+        for key, val in trigdict.items():
+            # We have now assembeled a dictionary. Its keys are common
+            # arguments in trigonometric expressions, and values are lists of
+            # pairs (fn, coeff). x0, (fn, coeff) in trigdict means that we
+            # need to deal with fn(coeff*x0). We take the rational gcd of the
+            # coeffs, call it ``gcd``. We then use x = x0/gcd as "base symbol",
+            # all other arguments are integral multiples thereof.
+            # We will build an ideal which works with sin(x), cos(x).
+            # If hint tan is provided, also work with tan(x). Moreover, if
+            # n > 1, also work with sin(k*x) for k <= n, and similarly for cos
+            # (and tan if the hint is provided). Finally, any generators which
+            # the ideal does not work with but we need to accommodate (either
+            # because it was in expr or because it was provided as a hint)
+            # we also build into the ideal.
+            # This selection process is expressed in the list ``terms``.
+            # build_ideal then generates the actual relations in our ideal,
+            # from this list.
+            fns = [x[1] for x in val]
+            val = [x[0] for x in val]
+            gcd = reduce(igcd, val)
+            terms = [(fn, v/gcd) for (fn, v) in zip(fns, val)]
+            fs = set(funcs + fns)
+            for c, s, t in ([cos, sin, tan], [cosh, sinh, tanh]):
+                if any(x in fs for x in (c, s, t)):
+                    fs.add(c)
+                    fs.add(s)
+            for fn in fs:
+                for k in range(1, n + 1):
+                    terms.append((fn, k))
+            extra = []
+            for fn, v in terms:
+                if fn == tan:
+                    extra.append((sin, v))
+                    extra.append((cos, v))
+                if fn in [sin, cos] and tan in fs:
+                    extra.append((tan, v))
+                if fn == tanh:
+                    extra.append((sinh, v))
+                    extra.append((cosh, v))
+                if fn in [sinh, cosh] and tanh in fs:
+                    extra.append((tanh, v))
+            terms.extend(extra)
+            x = gcd*Mul(*key)
+            r = build_ideal(x, terms)
+            res.extend(r)
+            newgens.extend({fn(v*x) for fn, v in terms})
+
+        # Add generators for compound expressions from iterables
+        for fn, args in iterables:
+            if fn == tan:
+                # Tan expressions are recovered from sin and cos.
+                iterables.extend([(sin, args), (cos, args)])
+            elif fn == tanh:
+                # Tanh expressions are recovered from sihn and cosh.
+                iterables.extend([(sinh, args), (cosh, args)])
+            else:
+                dummys = symbols('d:%i' % len(args), cls=Dummy)
+                expr = fn( Add(*dummys)).expand(trig=True).subs(list(zip(dummys, args)))
+                res.append(fn(Add(*args)) - expr)
+
+        if myI in gens:
+            res.append(myI**2 + 1)
+            freegens.remove(myI)
+            newgens.append(myI)
+
+        return res, freegens, newgens
+
+    myI = Dummy('I')
+    expr = expr.subs(S.ImaginaryUnit, myI)
+    subs = [(myI, S.ImaginaryUnit)]
+
+    num, denom = cancel(expr).as_numer_denom()
+    try:
+        (pnum, pdenom), opt = parallel_poly_from_expr([num, denom])
+    except PolificationFailed:
+        return expr
+    debug('initial gens:', opt.gens)
+    ideal, freegens, gens = analyse_gens(opt.gens, hints)
+    debug('ideal:', ideal)
+    debug('new gens:', gens, " -- len", len(gens))
+    debug('free gens:', freegens, " -- len", len(gens))
+    # NOTE we force the domain to be ZZ to stop polys from injecting generators
+    #      (which is usually a sign of a bug in the way we build the ideal)
+    if not gens:
+        return expr
+    G = groebner(ideal, order=order, gens=gens, domain=ZZ)
+    debug('groebner basis:', list(G), " -- len", len(G))
+
+    # If our fraction is a polynomial in the free generators, simplify all
+    # coefficients separately:
+
+    from sympy.simplify.ratsimp import ratsimpmodprime
+
+    if freegens and pdenom.has_only_gens(*set(gens).intersection(pdenom.gens)):
+        num = Poly(num, gens=gens+freegens).eject(*gens)
+        res = []
+        for monom, coeff in num.terms():
+            ourgens = set(parallel_poly_from_expr([coeff, denom])[1].gens)
+            # We compute the transitive closure of all generators that can
+            # be reached from our generators through relations in the ideal.
+            changed = True
+            while changed:
+                changed = False
+                for p in ideal:
+                    p = Poly(p)
+                    if not ourgens.issuperset(p.gens) and \
+                       not p.has_only_gens(*set(p.gens).difference(ourgens)):
+                        changed = True
+                        ourgens.update(p.exclude().gens)
+            # NOTE preserve order!
+            realgens = [x for x in gens if x in ourgens]
+            # The generators of the ideal have now been (implicitly) split
+            # into two groups: those involving ourgens and those that don't.
+            # Since we took the transitive closure above, these two groups
+            # live in subgrings generated by a *disjoint* set of variables.
+            # Any sensible groebner basis algorithm will preserve this disjoint
+            # structure (i.e. the elements of the groebner basis can be split
+            # similarly), and and the two subsets of the groebner basis then
+            # form groebner bases by themselves. (For the smaller generating
+            # sets, of course.)
+            ourG = [g.as_expr() for g in G.polys if
+                    g.has_only_gens(*ourgens.intersection(g.gens))]
+            res.append(Mul(*[a**b for a, b in zip(freegens, monom)]) * \
+                       ratsimpmodprime(coeff/denom, ourG, order=order,
+                                       gens=realgens, quick=quick, domain=ZZ,
+                                       polynomial=polynomial).subs(subs))
+        return Add(*res)
+        # NOTE The following is simpler and has less assumptions on the
+        #      groebner basis algorithm. If the above turns out to be broken,
+        #      use this.
+        return Add(*[Mul(*[a**b for a, b in zip(freegens, monom)]) * \
+                     ratsimpmodprime(coeff/denom, list(G), order=order,
+                                     gens=gens, quick=quick, domain=ZZ)
+                     for monom, coeff in num.terms()])
+    else:
+        return ratsimpmodprime(
+            expr, list(G), order=order, gens=freegens+gens,
+            quick=quick, domain=ZZ, polynomial=polynomial).subs(subs)
+
+
+_trigs = (TrigonometricFunction, HyperbolicFunction)
+
+
+def _trigsimp_inverse(rv):
+
+    def check_args(x, y):
+        try:
+            return x.args[0] == y.args[0]
+        except IndexError:
+            return False
+
+    def f(rv):
+        # for simple functions
+        g = getattr(rv, 'inverse', None)
+        if (g is not None and isinstance(rv.args[0], g()) and
+                isinstance(g()(1), TrigonometricFunction)):
+            return rv.args[0].args[0]
+
+        # for atan2 simplifications, harder because atan2 has 2 args
+        if isinstance(rv, atan2):
+            y, x = rv.args
+            if _coeff_isneg(y):
+                return -f(atan2(-y, x))
+            elif _coeff_isneg(x):
+                return S.Pi - f(atan2(y, -x))
+
+            if check_args(x, y):
+                if isinstance(y, sin) and isinstance(x, cos):
+                    return x.args[0]
+                if isinstance(y, cos) and isinstance(x, sin):
+                    return S.Pi / 2 - x.args[0]
+
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def trigsimp(expr, inverse=False, **opts):
+    """Returns a reduced expression by using known trig identities.
+
+    Parameters
+    ==========
+
+    inverse : bool, optional
+        If ``inverse=True``, it will be assumed that a composition of inverse
+        functions, such as sin and asin, can be cancelled in any order.
+        For example, ``asin(sin(x))`` will yield ``x`` without checking whether
+        x belongs to the set where this relation is true. The default is False.
+        Default : True
+
+    method : string, optional
+        Specifies the method to use. Valid choices are:
+
+        - ``'matching'``, default
+        - ``'groebner'``
+        - ``'combined'``
+        - ``'fu'``
+        - ``'old'``
+
+        If ``'matching'``, simplify the expression recursively by targeting
+        common patterns. If ``'groebner'``, apply an experimental groebner
+        basis algorithm. In this case further options are forwarded to
+        ``trigsimp_groebner``, please refer to
+        its docstring. If ``'combined'``, it first runs the groebner basis
+        algorithm with small default parameters, then runs the ``'matching'``
+        algorithm. If ``'fu'``, run the collection of trigonometric
+        transformations described by Fu, et al. (see the
+        :py:func:`~sympy.simplify.fu.fu` docstring). If ``'old'``, the original
+        SymPy trig simplification function is run.
+    opts :
+        Optional keyword arguments passed to the method. See each method's
+        function docstring for details.
+
+    Examples
+    ========
+
+    >>> from sympy import trigsimp, sin, cos, log
+    >>> from sympy.abc import x
+    >>> e = 2*sin(x)**2 + 2*cos(x)**2
+    >>> trigsimp(e)
+    2
+
+    Simplification occurs wherever trigonometric functions are located.
+
+    >>> trigsimp(log(e))
+    log(2)
+
+    Using ``method='groebner'`` (or ``method='combined'``) might lead to
+    greater simplification.
+
+    The old trigsimp routine can be accessed as with method ``method='old'``.
+
+    >>> from sympy import coth, tanh
+    >>> t = 3*tanh(x)**7 - 2/coth(x)**7
+    >>> trigsimp(t, method='old') == t
+    True
+    >>> trigsimp(t)
+    tanh(x)**7
+
+    """
+    from sympy.simplify.fu import fu
+
+    expr = sympify(expr)
+
+    _eval_trigsimp = getattr(expr, '_eval_trigsimp', None)
+    if _eval_trigsimp is not None:
+        return _eval_trigsimp(**opts)
+
+    old = opts.pop('old', False)
+    if not old:
+        opts.pop('deep', None)
+        opts.pop('recursive', None)
+        method = opts.pop('method', 'matching')
+    else:
+        method = 'old'
+
+    def groebnersimp(ex, **opts):
+        def traverse(e):
+            if e.is_Atom:
+                return e
+            args = [traverse(x) for x in e.args]
+            if e.is_Function or e.is_Pow:
+                args = [trigsimp_groebner(x, **opts) for x in args]
+            return e.func(*args)
+        new = traverse(ex)
+        if not isinstance(new, Expr):
+            return new
+        return trigsimp_groebner(new, **opts)
+
+    trigsimpfunc = {
+        'fu': (lambda x: fu(x, **opts)),
+        'matching': (lambda x: futrig(x)),
+        'groebner': (lambda x: groebnersimp(x, **opts)),
+        'combined': (lambda x: futrig(groebnersimp(x,
+                               polynomial=True, hints=[2, tan]))),
+        'old': lambda x: trigsimp_old(x, **opts),
+                   }[method]
+
+    expr_simplified = trigsimpfunc(expr)
+    if inverse:
+        expr_simplified = _trigsimp_inverse(expr_simplified)
+
+    return expr_simplified
+
+
+def exptrigsimp(expr):
+    """
+    Simplifies exponential / trigonometric / hyperbolic functions.
+
+    Examples
+    ========
+
+    >>> from sympy import exptrigsimp, exp, cosh, sinh
+    >>> from sympy.abc import z
+
+    >>> exptrigsimp(exp(z) + exp(-z))
+    2*cosh(z)
+    >>> exptrigsimp(cosh(z) - sinh(z))
+    exp(-z)
+    """
+    from sympy.simplify.fu import hyper_as_trig, TR2i
+
+    def exp_trig(e):
+        # select the better of e, and e rewritten in terms of exp or trig
+        # functions
+        choices = [e]
+        if e.has(*_trigs):
+            choices.append(e.rewrite(exp))
+        choices.append(e.rewrite(cos))
+        return min(*choices, key=count_ops)
+    newexpr = bottom_up(expr, exp_trig)
+
+    def f(rv):
+        if not rv.is_Mul:
+            return rv
+        commutative_part, noncommutative_part = rv.args_cnc()
+        # Since as_powers_dict loses order information,
+        # if there is more than one noncommutative factor,
+        # it should only be used to simplify the commutative part.
+        if (len(noncommutative_part) > 1):
+            return f(Mul(*commutative_part))*Mul(*noncommutative_part)
+        rvd = rv.as_powers_dict()
+        newd = rvd.copy()
+
+        def signlog(expr, sign=S.One):
+            if expr is S.Exp1:
+                return sign, S.One
+            elif isinstance(expr, exp) or (expr.is_Pow and expr.base == S.Exp1):
+                return sign, expr.exp
+            elif sign is S.One:
+                return signlog(-expr, sign=-S.One)
+            else:
+                return None, None
+
+        ee = rvd[S.Exp1]
+        for k in rvd:
+            if k.is_Add and len(k.args) == 2:
+                # k == c*(1 + sign*E**x)
+                c = k.args[0]
+                sign, x = signlog(k.args[1]/c)
+                if not x:
+                    continue
+                m = rvd[k]
+                newd[k] -= m
+                if ee == -x*m/2:
+                    # sinh and cosh
+                    newd[S.Exp1] -= ee
+                    ee = 0
+                    if sign == 1:
+                        newd[2*c*cosh(x/2)] += m
+                    else:
+                        newd[-2*c*sinh(x/2)] += m
+                elif newd[1 - sign*S.Exp1**x] == -m:
+                    # tanh
+                    del newd[1 - sign*S.Exp1**x]
+                    if sign == 1:
+                        newd[-c/tanh(x/2)] += m
+                    else:
+                        newd[-c*tanh(x/2)] += m
+                else:
+                    newd[1 + sign*S.Exp1**x] += m
+                    newd[c] += m
+
+        return Mul(*[k**newd[k] for k in newd])
+    newexpr = bottom_up(newexpr, f)
+
+    # sin/cos and sinh/cosh ratios to tan and tanh, respectively
+    if newexpr.has(HyperbolicFunction):
+        e, f = hyper_as_trig(newexpr)
+        newexpr = f(TR2i(e))
+    if newexpr.has(TrigonometricFunction):
+        newexpr = TR2i(newexpr)
+
+    # can we ever generate an I where there was none previously?
+    if not (newexpr.has(I) and not expr.has(I)):
+        expr = newexpr
+    return expr
+
+#-------------------- the old trigsimp routines ---------------------
+
+def trigsimp_old(expr, *, first=True, **opts):
+    """
+    Reduces expression by using known trig identities.
+
+    Notes
+    =====
+
+    deep:
+    - Apply trigsimp inside all objects with arguments
+
+    recursive:
+    - Use common subexpression elimination (cse()) and apply
+    trigsimp recursively (this is quite expensive if the
+    expression is large)
+
+    method:
+    - Determine the method to use. Valid choices are 'matching' (default),
+    'groebner', 'combined', 'fu' and 'futrig'. If 'matching', simplify the
+    expression recursively by pattern matching. If 'groebner', apply an
+    experimental groebner basis algorithm. In this case further options
+    are forwarded to ``trigsimp_groebner``, please refer to its docstring.
+    If 'combined', first run the groebner basis algorithm with small
+    default parameters, then run the 'matching' algorithm. 'fu' runs the
+    collection of trigonometric transformations described by Fu, et al.
+    (see the `fu` docstring) while `futrig` runs a subset of Fu-transforms
+    that mimic the behavior of `trigsimp`.
+
+    compare:
+    - show input and output from `trigsimp` and `futrig` when different,
+    but returns the `trigsimp` value.
+
+    Examples
+    ========
+
+    >>> from sympy import trigsimp, sin, cos, log, cot
+    >>> from sympy.abc import x
+    >>> e = 2*sin(x)**2 + 2*cos(x)**2
+    >>> trigsimp(e, old=True)
+    2
+    >>> trigsimp(log(e), old=True)
+    log(2*sin(x)**2 + 2*cos(x)**2)
+    >>> trigsimp(log(e), deep=True, old=True)
+    log(2)
+
+    Using `method="groebner"` (or `"combined"`) can sometimes lead to a lot
+    more simplification:
+
+    >>> e = (-sin(x) + 1)/cos(x) + cos(x)/(-sin(x) + 1)
+    >>> trigsimp(e, old=True)
+    (1 - sin(x))/cos(x) + cos(x)/(1 - sin(x))
+    >>> trigsimp(e, method="groebner", old=True)
+    2/cos(x)
+
+    >>> trigsimp(1/cot(x)**2, compare=True, old=True)
+          futrig: tan(x)**2
+    cot(x)**(-2)
+
+    """
+    old = expr
+    if first:
+        if not expr.has(*_trigs):
+            return expr
+
+        trigsyms = set().union(*[t.free_symbols for t in expr.atoms(*_trigs)])
+        if len(trigsyms) > 1:
+            from sympy.simplify.simplify import separatevars
+
+            d = separatevars(expr)
+            if d.is_Mul:
+                d = separatevars(d, dict=True) or d
+            if isinstance(d, dict):
+                expr = 1
+                for v in d.values():
+                    # remove hollow factoring
+                    was = v
+                    v = expand_mul(v)
+                    opts['first'] = False
+                    vnew = trigsimp(v, **opts)
+                    if vnew == v:
+                        vnew = was
+                    expr *= vnew
+                old = expr
+            else:
+                if d.is_Add:
+                    for s in trigsyms:
+                        r, e = expr.as_independent(s)
+                        if r:
+                            opts['first'] = False
+                            expr = r + trigsimp(e, **opts)
+                            if not expr.is_Add:
+                                break
+                    old = expr
+
+    recursive = opts.pop('recursive', False)
+    deep = opts.pop('deep', False)
+    method = opts.pop('method', 'matching')
+
+    def groebnersimp(ex, deep, **opts):
+        def traverse(e):
+            if e.is_Atom:
+                return e
+            args = [traverse(x) for x in e.args]
+            if e.is_Function or e.is_Pow:
+                args = [trigsimp_groebner(x, **opts) for x in args]
+            return e.func(*args)
+        if deep:
+            ex = traverse(ex)
+        return trigsimp_groebner(ex, **opts)
+
+    trigsimpfunc = {
+        'matching': (lambda x, d: _trigsimp(x, d)),
+        'groebner': (lambda x, d: groebnersimp(x, d, **opts)),
+        'combined': (lambda x, d: _trigsimp(groebnersimp(x,
+                                       d, polynomial=True, hints=[2, tan]),
+                                   d))
+                   }[method]
+
+    if recursive:
+        w, g = cse(expr)
+        g = trigsimpfunc(g[0], deep)
+
+        for sub in reversed(w):
+            g = g.subs(sub[0], sub[1])
+            g = trigsimpfunc(g, deep)
+        result = g
+    else:
+        result = trigsimpfunc(expr, deep)
+
+    if opts.get('compare', False):
+        f = futrig(old)
+        if f != result:
+            print('\tfutrig:', f)
+
+    return result
+
+
+def _dotrig(a, b):
+    """Helper to tell whether ``a`` and ``b`` have the same sorts
+    of symbols in them -- no need to test hyperbolic patterns against
+    expressions that have no hyperbolics in them."""
+    return a.func == b.func and (
+        a.has(TrigonometricFunction) and b.has(TrigonometricFunction) or
+        a.has(HyperbolicFunction) and b.has(HyperbolicFunction))
+
+
+_trigpat = None
+def _trigpats():
+    global _trigpat
+    a, b, c = symbols('a b c', cls=Wild)
+    d = Wild('d', commutative=False)
+
+    # for the simplifications like sinh/cosh -> tanh:
+    # DO NOT REORDER THE FIRST 14 since these are assumed to be in this
+    # order in _match_div_rewrite.
+    matchers_division = (
+        (a*sin(b)**c/cos(b)**c, a*tan(b)**c, sin(b), cos(b)),
+        (a*tan(b)**c*cos(b)**c, a*sin(b)**c, sin(b), cos(b)),
+        (a*cot(b)**c*sin(b)**c, a*cos(b)**c, sin(b), cos(b)),
+        (a*tan(b)**c/sin(b)**c, a/cos(b)**c, sin(b), cos(b)),
+        (a*cot(b)**c/cos(b)**c, a/sin(b)**c, sin(b), cos(b)),
+        (a*cot(b)**c*tan(b)**c, a, sin(b), cos(b)),
+        (a*(cos(b) + 1)**c*(cos(b) - 1)**c,
+            a*(-sin(b)**2)**c, cos(b) + 1, cos(b) - 1),
+        (a*(sin(b) + 1)**c*(sin(b) - 1)**c,
+            a*(-cos(b)**2)**c, sin(b) + 1, sin(b) - 1),
+
+        (a*sinh(b)**c/cosh(b)**c, a*tanh(b)**c, S.One, S.One),
+        (a*tanh(b)**c*cosh(b)**c, a*sinh(b)**c, S.One, S.One),
+        (a*coth(b)**c*sinh(b)**c, a*cosh(b)**c, S.One, S.One),
+        (a*tanh(b)**c/sinh(b)**c, a/cosh(b)**c, S.One, S.One),
+        (a*coth(b)**c/cosh(b)**c, a/sinh(b)**c, S.One, S.One),
+        (a*coth(b)**c*tanh(b)**c, a, S.One, S.One),
+
+        (c*(tanh(a) + tanh(b))/(1 + tanh(a)*tanh(b)),
+            tanh(a + b)*c, S.One, S.One),
+    )
+
+    matchers_add = (
+        (c*sin(a)*cos(b) + c*cos(a)*sin(b) + d, sin(a + b)*c + d),
+        (c*cos(a)*cos(b) - c*sin(a)*sin(b) + d, cos(a + b)*c + d),
+        (c*sin(a)*cos(b) - c*cos(a)*sin(b) + d, sin(a - b)*c + d),
+        (c*cos(a)*cos(b) + c*sin(a)*sin(b) + d, cos(a - b)*c + d),
+        (c*sinh(a)*cosh(b) + c*sinh(b)*cosh(a) + d, sinh(a + b)*c + d),
+        (c*cosh(a)*cosh(b) + c*sinh(a)*sinh(b) + d, cosh(a + b)*c + d),
+    )
+
+    # for cos(x)**2 + sin(x)**2 -> 1
+    matchers_identity = (
+        (a*sin(b)**2, a - a*cos(b)**2),
+        (a*tan(b)**2, a*(1/cos(b))**2 - a),
+        (a*cot(b)**2, a*(1/sin(b))**2 - a),
+        (a*sin(b + c), a*(sin(b)*cos(c) + sin(c)*cos(b))),
+        (a*cos(b + c), a*(cos(b)*cos(c) - sin(b)*sin(c))),
+        (a*tan(b + c), a*((tan(b) + tan(c))/(1 - tan(b)*tan(c)))),
+
+        (a*sinh(b)**2, a*cosh(b)**2 - a),
+        (a*tanh(b)**2, a - a*(1/cosh(b))**2),
+        (a*coth(b)**2, a + a*(1/sinh(b))**2),
+        (a*sinh(b + c), a*(sinh(b)*cosh(c) + sinh(c)*cosh(b))),
+        (a*cosh(b + c), a*(cosh(b)*cosh(c) + sinh(b)*sinh(c))),
+        (a*tanh(b + c), a*((tanh(b) + tanh(c))/(1 + tanh(b)*tanh(c)))),
+
+    )
+
+    # Reduce any lingering artifacts, such as sin(x)**2 changing
+    # to 1-cos(x)**2 when sin(x)**2 was "simpler"
+    artifacts = (
+        (a - a*cos(b)**2 + c, a*sin(b)**2 + c, cos),
+        (a - a*(1/cos(b))**2 + c, -a*tan(b)**2 + c, cos),
+        (a - a*(1/sin(b))**2 + c, -a*cot(b)**2 + c, sin),
+
+        (a - a*cosh(b)**2 + c, -a*sinh(b)**2 + c, cosh),
+        (a - a*(1/cosh(b))**2 + c, a*tanh(b)**2 + c, cosh),
+        (a + a*(1/sinh(b))**2 + c, a*coth(b)**2 + c, sinh),
+
+        # same as above but with noncommutative prefactor
+        (a*d - a*d*cos(b)**2 + c, a*d*sin(b)**2 + c, cos),
+        (a*d - a*d*(1/cos(b))**2 + c, -a*d*tan(b)**2 + c, cos),
+        (a*d - a*d*(1/sin(b))**2 + c, -a*d*cot(b)**2 + c, sin),
+
+        (a*d - a*d*cosh(b)**2 + c, -a*d*sinh(b)**2 + c, cosh),
+        (a*d - a*d*(1/cosh(b))**2 + c, a*d*tanh(b)**2 + c, cosh),
+        (a*d + a*d*(1/sinh(b))**2 + c, a*d*coth(b)**2 + c, sinh),
+    )
+
+    _trigpat = (a, b, c, d, matchers_division, matchers_add,
+        matchers_identity, artifacts)
+    return _trigpat
+
+
+def _replace_mul_fpowxgpow(expr, f, g, rexp, h, rexph):
+    """Helper for _match_div_rewrite.
+
+    Replace f(b_)**c_*g(b_)**(rexp(c_)) with h(b)**rexph(c) if f(b_)
+    and g(b_) are both positive or if c_ is an integer.
+    """
+    # assert expr.is_Mul and expr.is_commutative and f != g
+    fargs = defaultdict(int)
+    gargs = defaultdict(int)
+    args = []
+    for x in expr.args:
+        if x.is_Pow or x.func in (f, g):
+            b, e = x.as_base_exp()
+            if b.is_positive or e.is_integer:
+                if b.func == f:
+                    fargs[b.args[0]] += e
+                    continue
+                elif b.func == g:
+                    gargs[b.args[0]] += e
+                    continue
+        args.append(x)
+    common = set(fargs) & set(gargs)
+    hit = False
+    while common:
+        key = common.pop()
+        fe = fargs.pop(key)
+        ge = gargs.pop(key)
+        if fe == rexp(ge):
+            args.append(h(key)**rexph(fe))
+            hit = True
+        else:
+            fargs[key] = fe
+            gargs[key] = ge
+    if not hit:
+        return expr
+    while fargs:
+        key, e = fargs.popitem()
+        args.append(f(key)**e)
+    while gargs:
+        key, e = gargs.popitem()
+        args.append(g(key)**e)
+    return Mul(*args)
+
+
+_idn = lambda x: x
+_midn = lambda x: -x
+_one = lambda x: S.One
+
+def _match_div_rewrite(expr, i):
+    """helper for __trigsimp"""
+    if i == 0:
+        expr = _replace_mul_fpowxgpow(expr, sin, cos,
+            _midn, tan, _idn)
+    elif i == 1:
+        expr = _replace_mul_fpowxgpow(expr, tan, cos,
+            _idn, sin, _idn)
+    elif i == 2:
+        expr = _replace_mul_fpowxgpow(expr, cot, sin,
+            _idn, cos, _idn)
+    elif i == 3:
+        expr = _replace_mul_fpowxgpow(expr, tan, sin,
+            _midn, cos, _midn)
+    elif i == 4:
+        expr = _replace_mul_fpowxgpow(expr, cot, cos,
+            _midn, sin, _midn)
+    elif i == 5:
+        expr = _replace_mul_fpowxgpow(expr, cot, tan,
+            _idn, _one, _idn)
+    # i in (6, 7) is skipped
+    elif i == 8:
+        expr = _replace_mul_fpowxgpow(expr, sinh, cosh,
+            _midn, tanh, _idn)
+    elif i == 9:
+        expr = _replace_mul_fpowxgpow(expr, tanh, cosh,
+            _idn, sinh, _idn)
+    elif i == 10:
+        expr = _replace_mul_fpowxgpow(expr, coth, sinh,
+            _idn, cosh, _idn)
+    elif i == 11:
+        expr = _replace_mul_fpowxgpow(expr, tanh, sinh,
+            _midn, cosh, _midn)
+    elif i == 12:
+        expr = _replace_mul_fpowxgpow(expr, coth, cosh,
+            _midn, sinh, _midn)
+    elif i == 13:
+        expr = _replace_mul_fpowxgpow(expr, coth, tanh,
+            _idn, _one, _idn)
+    else:
+        return None
+    return expr
+
+
+def _trigsimp(expr, deep=False):
+    # protect the cache from non-trig patterns; we only allow
+    # trig patterns to enter the cache
+    if expr.has(*_trigs):
+        return __trigsimp(expr, deep)
+    return expr
+
+
+@cacheit
+def __trigsimp(expr, deep=False):
+    """recursive helper for trigsimp"""
+    from sympy.simplify.fu import TR10i
+
+    if _trigpat is None:
+        _trigpats()
+    a, b, c, d, matchers_division, matchers_add, \
+    matchers_identity, artifacts = _trigpat
+
+    if expr.is_Mul:
+        # do some simplifications like sin/cos -> tan:
+        if not expr.is_commutative:
+            com, nc = expr.args_cnc()
+            expr = _trigsimp(Mul._from_args(com), deep)*Mul._from_args(nc)
+        else:
+            for i, (pattern, simp, ok1, ok2) in enumerate(matchers_division):
+                if not _dotrig(expr, pattern):
+                    continue
+
+                newexpr = _match_div_rewrite(expr, i)
+                if newexpr is not None:
+                    if newexpr != expr:
+                        expr = newexpr
+                        break
+                    else:
+                        continue
+
+                # use SymPy matching instead
+                res = expr.match(pattern)
+                if res and res.get(c, 0):
+                    if not res[c].is_integer:
+                        ok = ok1.subs(res)
+                        if not ok.is_positive:
+                            continue
+                        ok = ok2.subs(res)
+                        if not ok.is_positive:
+                            continue
+                    # if "a" contains any of trig or hyperbolic funcs with
+                    # argument "b" then skip the simplification
+                    if any(w.args[0] == res[b] for w in res[a].atoms(
+                            TrigonometricFunction, HyperbolicFunction)):
+                        continue
+                    # simplify and finish:
+                    expr = simp.subs(res)
+                    break  # process below
+
+    if expr.is_Add:
+        args = []
+        for term in expr.args:
+            if not term.is_commutative:
+                com, nc = term.args_cnc()
+                nc = Mul._from_args(nc)
+                term = Mul._from_args(com)
+            else:
+                nc = S.One
+            term = _trigsimp(term, deep)
+            for pattern, result in matchers_identity:
+                res = term.match(pattern)
+                if res is not None:
+                    term = result.subs(res)
+                    break
+            args.append(term*nc)
+        if args != expr.args:
+            expr = Add(*args)
+            expr = min(expr, expand(expr), key=count_ops)
+        if expr.is_Add:
+            for pattern, result in matchers_add:
+                if not _dotrig(expr, pattern):
+                    continue
+                expr = TR10i(expr)
+                if expr.has(HyperbolicFunction):
+                    res = expr.match(pattern)
+                    # if "d" contains any trig or hyperbolic funcs with
+                    # argument "a" or "b" then skip the simplification;
+                    # this isn't perfect -- see tests
+                    if res is None or not (a in res and b in res) or any(
+                        w.args[0] in (res[a], res[b]) for w in res[d].atoms(
+                            TrigonometricFunction, HyperbolicFunction)):
+                        continue
+                    expr = result.subs(res)
+                    break
+
+        # Reduce any lingering artifacts, such as sin(x)**2 changing
+        # to 1 - cos(x)**2 when sin(x)**2 was "simpler"
+        for pattern, result, ex in artifacts:
+            if not _dotrig(expr, pattern):
+                continue
+            # Substitute a new wild that excludes some function(s)
+            # to help influence a better match. This is because
+            # sometimes, for example, 'a' would match sec(x)**2
+            a_t = Wild('a', exclude=[ex])
+            pattern = pattern.subs(a, a_t)
+            result = result.subs(a, a_t)
+
+            m = expr.match(pattern)
+            was = None
+            while m and was != expr:
+                was = expr
+                if m[a_t] == 0 or \
+                        -m[a_t] in m[c].args or m[a_t] + m[c] == 0:
+                    break
+                if d in m and m[a_t]*m[d] + m[c] == 0:
+                    break
+                expr = result.subs(m)
+                m = expr.match(pattern)
+                m.setdefault(c, S.Zero)
+
+    elif expr.is_Mul or expr.is_Pow or deep and expr.args:
+        expr = expr.func(*[_trigsimp(a, deep) for a in expr.args])
+
+    try:
+        if not expr.has(*_trigs):
+            raise TypeError
+        e = expr.atoms(exp)
+        new = expr.rewrite(exp, deep=deep)
+        if new == e:
+            raise TypeError
+        fnew = factor(new)
+        if fnew != new:
+            new = min([new, factor(new)], key=count_ops)
+        # if all exp that were introduced disappeared then accept it
+        if not (new.atoms(exp) - e):
+            expr = new
+    except TypeError:
+        pass
+
+    return expr
+#------------------- end of old trigsimp routines --------------------
+
+
+def futrig(e, *, hyper=True, **kwargs):
+    """Return simplified ``e`` using Fu-like transformations.
+    This is not the "Fu" algorithm. This is called by default
+    from ``trigsimp``. By default, hyperbolics subexpressions
+    will be simplified, but this can be disabled by setting
+    ``hyper=False``.
+
+    Examples
+    ========
+
+    >>> from sympy import trigsimp, tan, sinh, tanh
+    >>> from sympy.simplify.trigsimp import futrig
+    >>> from sympy.abc import x
+    >>> trigsimp(1/tan(x)**2)
+    tan(x)**(-2)
+
+    >>> futrig(sinh(x)/tanh(x))
+    cosh(x)
+
+    """
+    from sympy.simplify.fu import hyper_as_trig
+
+    e = sympify(e)
+
+    if not isinstance(e, Basic):
+        return e
+
+    if not e.args:
+        return e
+
+    old = e
+    e = bottom_up(e, _futrig)
+
+    if hyper and e.has(HyperbolicFunction):
+        e, f = hyper_as_trig(e)
+        e = f(bottom_up(e, _futrig))
+
+    if e != old and e.is_Mul and e.args[0].is_Rational:
+        # redistribute leading coeff on 2-arg Add
+        e = Mul(*e.as_coeff_Mul())
+    return e
+
+
+def _futrig(e):
+    """Helper for futrig."""
+    from sympy.simplify.fu import (
+        TR1, TR2, TR3, TR2i, TR10, L, TR10i,
+        TR8, TR6, TR15, TR16, TR111, TR5, TRmorrie, TR11, _TR11, TR14, TR22,
+        TR12)
+
+    if not e.has(TrigonometricFunction):
+        return e
+
+    if e.is_Mul:
+        coeff, e = e.as_independent(TrigonometricFunction)
+    else:
+        coeff = None
+
+    Lops = lambda x: (L(x), x.count_ops(), _nodes(x), len(x.args), x.is_Add)
+    trigs = lambda x: x.has(TrigonometricFunction)
+
+    tree = [identity,
+        (
+        TR3,  # canonical angles
+        TR1,  # sec-csc -> cos-sin
+        TR12,  # expand tan of sum
+        lambda x: _eapply(factor, x, trigs),
+        TR2,  # tan-cot -> sin-cos
+        [identity, lambda x: _eapply(_mexpand, x, trigs)],
+        TR2i,  # sin-cos ratio -> tan
+        lambda x: _eapply(lambda i: factor(i.normal()), x, trigs),
+        TR14,  # factored identities
+        TR5,  # sin-pow -> cos_pow
+        TR10,  # sin-cos of sums -> sin-cos prod
+        TR11, _TR11, TR6, # reduce double angles and rewrite cos pows
+        lambda x: _eapply(factor, x, trigs),
+        TR14,  # factored powers of identities
+        [identity, lambda x: _eapply(_mexpand, x, trigs)],
+        TR10i,  # sin-cos products > sin-cos of sums
+        TRmorrie,
+        [identity, TR8],  # sin-cos products -> sin-cos of sums
+        [identity, lambda x: TR2i(TR2(x))],  # tan -> sin-cos -> tan
+        [
+            lambda x: _eapply(expand_mul, TR5(x), trigs),
+            lambda x: _eapply(
+                expand_mul, TR15(x), trigs)], # pos/neg powers of sin
+        [
+            lambda x:  _eapply(expand_mul, TR6(x), trigs),
+            lambda x:  _eapply(
+                expand_mul, TR16(x), trigs)], # pos/neg powers of cos
+        TR111,  # tan, sin, cos to neg power -> cot, csc, sec
+        [identity, TR2i],  # sin-cos ratio to tan
+        [identity, lambda x: _eapply(
+            expand_mul, TR22(x), trigs)],  # tan-cot to sec-csc
+        TR1, TR2, TR2i,
+        [identity, lambda x: _eapply(
+            factor_terms, TR12(x), trigs)],  # expand tan of sum
+        )]
+    e = greedy(tree, objective=Lops)(e)
+
+    if coeff is not None:
+        e = coeff * e
+
+    return e
+
+
+def _is_Expr(e):
+    """_eapply helper to tell whether ``e`` and all its args
+    are Exprs."""
+    if isinstance(e, Derivative):
+        return _is_Expr(e.expr)
+    if not isinstance(e, Expr):
+        return False
+    return all(_is_Expr(i) for i in e.args)
+
+
+def _eapply(func, e, cond=None):
+    """Apply ``func`` to ``e`` if all args are Exprs else only
+    apply it to those args that *are* Exprs."""
+    if not isinstance(e, Expr):
+        return e
+    if _is_Expr(e) or not e.args:
+        return func(e)
+    return e.func(*[
+        _eapply(func, ei) if (cond is None or cond(ei)) else ei
+        for ei in e.args])