Add files using upload-large-folder tool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+from .diffgeom import (
+    BaseCovarDerivativeOp, BaseScalarField, BaseVectorField, Commutator,
+    contravariant_order, CoordSystem, CoordinateSymbol,
+    CovarDerivativeOp, covariant_order, Differential, intcurve_diffequ,
+    intcurve_series, LieDerivative, Manifold, metric_to_Christoffel_1st,
+    metric_to_Christoffel_2nd, metric_to_Ricci_components,
+    metric_to_Riemann_components, Patch, Point, TensorProduct, twoform_to_matrix,
+    vectors_in_basis, WedgeProduct,
+)
+
+__all__ = [
+    'BaseCovarDerivativeOp', 'BaseScalarField', 'BaseVectorField', 'Commutator',
+    'contravariant_order', 'CoordSystem', 'CoordinateSymbol',
+    'CovarDerivativeOp', 'covariant_order', 'Differential', 'intcurve_diffequ',
+    'intcurve_series', 'LieDerivative', 'Manifold', 'metric_to_Christoffel_1st',
+    'metric_to_Christoffel_2nd', 'metric_to_Ricci_components',
+    'metric_to_Riemann_components', 'Patch', 'Point', 'TensorProduct',
+    'twoform_to_matrix', 'vectors_in_basis', 'WedgeProduct',
+]

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

@@ -0,0 +1,2273 @@
+from __future__ import annotations
+from typing import Any
+
+from functools import reduce
+from itertools import permutations
+
+from sympy.combinatorics import Permutation
+from sympy.core import (
+    Basic, Expr, Function, diff,
+    Pow, Mul, Add, Lambda, S, Tuple, Dict
+)
+from sympy.core.cache import cacheit
+
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.symbol import Str
+from sympy.core.sympify import _sympify
+from sympy.functions import factorial
+from sympy.matrices import ImmutableDenseMatrix as Matrix
+from sympy.solvers import solve
+
+from sympy.utilities.exceptions import (sympy_deprecation_warning,
+                                        SymPyDeprecationWarning,
+                                        ignore_warnings)
+
+
+# TODO you are a bit excessive in the use of Dummies
+# TODO dummy point, literal field
+# TODO too often one needs to call doit or simplify on the output, check the
+# tests and find out why
+from sympy.tensor.array import ImmutableDenseNDimArray
+
+
+class Manifold(Basic):
+    """
+    A mathematical manifold.
+
+    Explanation
+    ===========
+
+    A manifold is a topological space that locally resembles
+    Euclidean space near each point [1].
+    This class does not provide any means to study the topological
+    characteristics of the manifold that it represents, though.
+
+    Parameters
+    ==========
+
+    name : str
+        The name of the manifold.
+
+    dim : int
+        The dimension of the manifold.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom import Manifold
+    >>> m = Manifold('M', 2)
+    >>> m
+    M
+    >>> m.dim
+    2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Manifold
+    """
+
+    def __new__(cls, name, dim, **kwargs):
+        if not isinstance(name, Str):
+            name = Str(name)
+        dim = _sympify(dim)
+        obj = super().__new__(cls, name, dim)
+
+        obj.patches = _deprecated_list(
+            """
+            Manifold.patches is deprecated. The Manifold object is now
+            immutable. Instead use a separate list to keep track of the
+            patches.
+            """, [])
+        return obj
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    @property
+    def dim(self):
+        return self.args[1]
+
+
+class Patch(Basic):
+    """
+    A patch on a manifold.
+
+    Explanation
+    ===========
+
+    Coordinate patch, or patch in short, is a simply-connected open set around
+    a point in the manifold [1]. On a manifold one can have many patches that
+    do not always include the whole manifold. On these patches coordinate
+    charts can be defined that permit the parameterization of any point on the
+    patch in terms of a tuple of real numbers (the coordinates).
+
+    This class does not provide any means to study the topological
+    characteristics of the patch that it represents.
+
+    Parameters
+    ==========
+
+    name : str
+        The name of the patch.
+
+    manifold : Manifold
+        The manifold on which the patch is defined.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom import Manifold, Patch
+    >>> m = Manifold('M', 2)
+    >>> p = Patch('P', m)
+    >>> p
+    P
+    >>> p.dim
+    2
+
+    References
+    ==========
+
+    .. [1] G. Sussman, J. Wisdom, W. Farr, Functional Differential Geometry
+           (2013)
+
+    """
+    def __new__(cls, name, manifold, **kwargs):
+        if not isinstance(name, Str):
+            name = Str(name)
+        obj = super().__new__(cls, name, manifold)
+
+        obj.manifold.patches.append(obj) # deprecated
+        obj.coord_systems = _deprecated_list(
+            """
+            Patch.coord_systms is deprecated. The Patch class is now
+            immutable. Instead use a separate list to keep track of coordinate
+            systems.
+            """, [])
+        return obj
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    @property
+    def manifold(self):
+        return self.args[1]
+
+    @property
+    def dim(self):
+        return self.manifold.dim
+
+
+class CoordSystem(Basic):
+    """
+    A coordinate system defined on the patch.
+
+    Explanation
+    ===========
+
+    Coordinate system is a system that uses one or more coordinates to uniquely
+    determine the position of the points or other geometric elements on a
+    manifold [1].
+
+    By passing ``Symbols`` to *symbols* parameter, user can define the name and
+    assumptions of coordinate symbols of the coordinate system. If not passed,
+    these symbols are generated automatically and are assumed to be real valued.
+
+    By passing *relations* parameter, user can define the transform relations of
+    coordinate systems. Inverse transformation and indirect transformation can
+    be found automatically. If this parameter is not passed, coordinate
+    transformation cannot be done.
+
+    Parameters
+    ==========
+
+    name : str
+        The name of the coordinate system.
+
+    patch : Patch
+        The patch where the coordinate system is defined.
+
+    symbols : list of Symbols, optional
+        Defines the names and assumptions of coordinate symbols.
+
+    relations : dict, optional
+        Key is a tuple of two strings, who are the names of the systems where
+        the coordinates transform from and transform to.
+        Value is a tuple of the symbols before transformation and a tuple of
+        the expressions after transformation.
+
+    Examples
+    ========
+
+    We define two-dimensional Cartesian coordinate system and polar coordinate
+    system.
+
+    >>> from sympy import symbols, pi, sqrt, atan2, cos, sin
+    >>> from sympy.diffgeom import Manifold, Patch, CoordSystem
+    >>> m = Manifold('M', 2)
+    >>> p = Patch('P', m)
+    >>> x, y = symbols('x y', real=True)
+    >>> r, theta = symbols('r theta', nonnegative=True)
+    >>> relation_dict = {
+    ... ('Car2D', 'Pol'): [(x, y), (sqrt(x**2 + y**2), atan2(y, x))],
+    ... ('Pol', 'Car2D'): [(r, theta), (r*cos(theta), r*sin(theta))]
+    ... }
+    >>> Car2D = CoordSystem('Car2D', p, (x, y), relation_dict)
+    >>> Pol = CoordSystem('Pol', p, (r, theta), relation_dict)
+
+    ``symbols`` property returns ``CoordinateSymbol`` instances. These symbols
+    are not same with the symbols used to construct the coordinate system.
+
+    >>> Car2D
+    Car2D
+    >>> Car2D.dim
+    2
+    >>> Car2D.symbols
+    (x, y)
+    >>> _[0].func
+    <class 'sympy.diffgeom.diffgeom.CoordinateSymbol'>
+
+    ``transformation()`` method returns the transformation function from
+    one coordinate system to another. ``transform()`` method returns the
+    transformed coordinates.
+
+    >>> Car2D.transformation(Pol)
+    Lambda((x, y), Matrix([
+    [sqrt(x**2 + y**2)],
+    [      atan2(y, x)]]))
+    >>> Car2D.transform(Pol)
+    Matrix([
+    [sqrt(x**2 + y**2)],
+    [      atan2(y, x)]])
+    >>> Car2D.transform(Pol, [1, 2])
+    Matrix([
+    [sqrt(5)],
+    [atan(2)]])
+
+    ``jacobian()`` method returns the Jacobian matrix of coordinate
+    transformation between two systems. ``jacobian_determinant()`` method
+    returns the Jacobian determinant of coordinate transformation between two
+    systems.
+
+    >>> Pol.jacobian(Car2D)
+    Matrix([
+    [cos(theta), -r*sin(theta)],
+    [sin(theta),  r*cos(theta)]])
+    >>> Pol.jacobian(Car2D, [1, pi/2])
+    Matrix([
+    [0, -1],
+    [1,  0]])
+    >>> Car2D.jacobian_determinant(Pol)
+    1/sqrt(x**2 + y**2)
+    >>> Car2D.jacobian_determinant(Pol, [1,0])
+    1
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Coordinate_system
+
+    """
+    def __new__(cls, name, patch, symbols=None, relations={}, **kwargs):
+        if not isinstance(name, Str):
+            name = Str(name)
+
+        # canonicallize the symbols
+        if symbols is None:
+            names = kwargs.get('names', None)
+            if names is None:
+                symbols = Tuple(
+                    *[Symbol('%s_%s' % (name.name, i), real=True)
+                      for i in range(patch.dim)]
+                )
+            else:
+                sympy_deprecation_warning(
+                    f"""
+The 'names' argument to CoordSystem is deprecated. Use 'symbols' instead. That
+is, replace
+
+    CoordSystem(..., names={names})
+
+with
+
+    CoordSystem(..., symbols=[{', '.join(["Symbol(" + repr(n) + ", real=True)" for n in names])}])
+                    """,
+                    deprecated_since_version="1.7",
+                    active_deprecations_target="deprecated-diffgeom-mutable",
+                )
+                symbols = Tuple(
+                    *[Symbol(n, real=True) for n in names]
+                )
+        else:
+            syms = []
+            for s in symbols:
+                if isinstance(s, Symbol):
+                    syms.append(Symbol(s.name, **s._assumptions.generator))
+                elif isinstance(s, str):
+                    sympy_deprecation_warning(
+                        f"""
+
+Passing a string as the coordinate symbol name to CoordSystem is deprecated.
+Pass a Symbol with the appropriate name and assumptions instead.
+
+That is, replace {s} with Symbol({s!r}, real=True).
+                        """,
+
+                        deprecated_since_version="1.7",
+                        active_deprecations_target="deprecated-diffgeom-mutable",
+                    )
+                    syms.append(Symbol(s, real=True))
+            symbols = Tuple(*syms)
+
+        # canonicallize the relations
+        rel_temp = {}
+        for k,v in relations.items():
+            s1, s2 = k
+            if not isinstance(s1, Str):
+                s1 = Str(s1)
+            if not isinstance(s2, Str):
+                s2 = Str(s2)
+            key = Tuple(s1, s2)
+
+            # Old version used Lambda as a value.
+            if isinstance(v, Lambda):
+                v = (tuple(v.signature), tuple(v.expr))
+            else:
+                v = (tuple(v[0]), tuple(v[1]))
+            rel_temp[key] = v
+        relations = Dict(rel_temp)
+
+        # construct the object
+        obj = super().__new__(cls, name, patch, symbols, relations)
+
+        # Add deprecated attributes
+        obj.transforms = _deprecated_dict(
+            """
+            CoordSystem.transforms is deprecated. The CoordSystem class is now
+            immutable. Use the 'relations' keyword argument to the
+            CoordSystems() constructor to specify relations.
+            """, {})
+        obj._names = [str(n) for n in symbols]
+        obj.patch.coord_systems.append(obj) # deprecated
+        obj._dummies = [Dummy(str(n)) for n in symbols] # deprecated
+        obj._dummy = Dummy()
+
+        return obj
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    @property
+    def patch(self):
+        return self.args[1]
+
+    @property
+    def manifold(self):
+        return self.patch.manifold
+
+    @property
+    def symbols(self):
+        return tuple(CoordinateSymbol(self, i, **s._assumptions.generator)
+            for i,s in enumerate(self.args[2]))
+
+    @property
+    def relations(self):
+        return self.args[3]
+
+    @property
+    def dim(self):
+        return self.patch.dim
+
+    ##########################################################################
+    # Finding transformation relation
+    ##########################################################################
+
+    def transformation(self, sys):
+        """
+        Return coordinate transformation function from *self* to *sys*.
+
+        Parameters
+        ==========
+
+        sys : CoordSystem
+
+        Returns
+        =======
+
+        sympy.Lambda
+
+        Examples
+        ========
+
+        >>> from sympy.diffgeom.rn import R2_r, R2_p
+        >>> R2_r.transformation(R2_p)
+        Lambda((x, y), Matrix([
+        [sqrt(x**2 + y**2)],
+        [      atan2(y, x)]]))
+
+        """
+        signature = self.args[2]
+
+        key = Tuple(self.name, sys.name)
+        if self == sys:
+            expr = Matrix(self.symbols)
+        elif key in self.relations:
+            expr = Matrix(self.relations[key][1])
+        elif key[::-1] in self.relations:
+            expr = Matrix(self._inverse_transformation(sys, self))
+        else:
+            expr = Matrix(self._indirect_transformation(self, sys))
+        return Lambda(signature, expr)
+
+    @staticmethod
+    def _solve_inverse(sym1, sym2, exprs, sys1_name, sys2_name):
+        ret = solve(
+            [t[0] - t[1] for t in zip(sym2, exprs)],
+            list(sym1), dict=True)
+
+        if len(ret) == 0:
+            temp = "Cannot solve inverse relation from {} to {}."
+            raise NotImplementedError(temp.format(sys1_name, sys2_name))
+        elif len(ret) > 1:
+            temp = "Obtained multiple inverse relation from {} to {}."
+            raise ValueError(temp.format(sys1_name, sys2_name))
+
+        return ret[0]
+
+    @classmethod
+    def _inverse_transformation(cls, sys1, sys2):
+        # Find the transformation relation from sys2 to sys1
+        forward = sys1.transform(sys2)
+        inv_results = cls._solve_inverse(sys1.symbols, sys2.symbols, forward,
+                                         sys1.name, sys2.name)
+        signature = tuple(sys1.symbols)
+        return [inv_results[s] for s in signature]
+
+    @classmethod
+    @cacheit
+    def _indirect_transformation(cls, sys1, sys2):
+        # Find the transformation relation between two indirectly connected
+        # coordinate systems
+        rel = sys1.relations
+        path = cls._dijkstra(sys1, sys2)
+
+        transforms = []
+        for s1, s2 in zip(path, path[1:]):
+            if (s1, s2) in rel:
+                transforms.append(rel[(s1, s2)])
+            else:
+                sym2, inv_exprs = rel[(s2, s1)]
+                sym1 = tuple(Dummy() for i in sym2)
+                ret = cls._solve_inverse(sym2, sym1, inv_exprs, s2, s1)
+                ret = tuple(ret[s] for s in sym2)
+                transforms.append((sym1, ret))
+        syms = sys1.args[2]
+        exprs = syms
+        for newsyms, newexprs in transforms:
+            exprs = tuple(e.subs(zip(newsyms, exprs)) for e in newexprs)
+        return exprs
+
+    @staticmethod
+    def _dijkstra(sys1, sys2):
+        # Use Dijkstra algorithm to find the shortest path between two indirectly-connected
+        # coordinate systems
+        # return value is the list of the names of the systems.
+        relations = sys1.relations
+        graph = {}
+        for s1, s2 in relations.keys():
+            if s1 not in graph:
+                graph[s1] = {s2}
+            else:
+                graph[s1].add(s2)
+            if s2 not in graph:
+                graph[s2] = {s1}
+            else:
+                graph[s2].add(s1)
+
+        path_dict = {sys:[0, [], 0] for sys in graph} # minimum distance, path, times of visited
+
+        def visit(sys):
+            path_dict[sys][2] = 1
+            for newsys in graph[sys]:
+                distance = path_dict[sys][0] + 1
+                if path_dict[newsys][0] >= distance or not path_dict[newsys][1]:
+                    path_dict[newsys][0] = distance
+                    path_dict[newsys][1] = list(path_dict[sys][1])
+                    path_dict[newsys][1].append(sys)
+
+        visit(sys1.name)
+
+        while True:
+            min_distance = max(path_dict.values(), key=lambda x:x[0])[0]
+            newsys = None
+            for sys, lst in path_dict.items():
+                if 0 < lst[0] <= min_distance and not lst[2]:
+                    min_distance = lst[0]
+                    newsys = sys
+            if newsys is None:
+                break
+            visit(newsys)
+
+        result = path_dict[sys2.name][1]
+        result.append(sys2.name)
+
+        if result == [sys2.name]:
+            raise KeyError("Two coordinate systems are not connected.")
+        return result
+
+    def connect_to(self, to_sys, from_coords, to_exprs, inverse=True, fill_in_gaps=False):
+        sympy_deprecation_warning(
+            """
+            The CoordSystem.connect_to() method is deprecated. Instead,
+            generate a new instance of CoordSystem with the 'relations'
+            keyword argument (CoordSystem classes are now immutable).
+            """,
+            deprecated_since_version="1.7",
+            active_deprecations_target="deprecated-diffgeom-mutable",
+        )
+
+        from_coords, to_exprs = dummyfy(from_coords, to_exprs)
+        self.transforms[to_sys] = Matrix(from_coords), Matrix(to_exprs)
+
+        if inverse:
+            to_sys.transforms[self] = self._inv_transf(from_coords, to_exprs)
+
+        if fill_in_gaps:
+            self._fill_gaps_in_transformations()
+
+    @staticmethod
+    def _inv_transf(from_coords, to_exprs):
+        # Will be removed when connect_to is removed
+        inv_from = [i.as_dummy() for i in from_coords]
+        inv_to = solve(
+            [t[0] - t[1] for t in zip(inv_from, to_exprs)],
+            list(from_coords), dict=True)[0]
+        inv_to = [inv_to[fc] for fc in from_coords]
+        return Matrix(inv_from), Matrix(inv_to)
+
+    @staticmethod
+    def _fill_gaps_in_transformations():
+        # Will be removed when connect_to is removed
+        raise NotImplementedError
+
+    ##########################################################################
+    # Coordinate transformations
+    ##########################################################################
+
+    def transform(self, sys, coordinates=None):
+        """
+        Return the result of coordinate transformation from *self* to *sys*.
+        If coordinates are not given, coordinate symbols of *self* are used.
+
+        Parameters
+        ==========
+
+        sys : CoordSystem
+
+        coordinates : Any iterable, optional.
+
+        Returns
+        =======
+
+        sympy.ImmutableDenseMatrix containing CoordinateSymbol
+
+        Examples
+        ========
+
+        >>> from sympy.diffgeom.rn import R2_r, R2_p
+        >>> R2_r.transform(R2_p)
+        Matrix([
+        [sqrt(x**2 + y**2)],
+        [      atan2(y, x)]])
+        >>> R2_r.transform(R2_p, [0, 1])
+        Matrix([
+        [   1],
+        [pi/2]])
+
+        """
+        if coordinates is None:
+            coordinates = self.symbols
+        if self != sys:
+            transf = self.transformation(sys)
+            coordinates = transf(*coordinates)
+        else:
+            coordinates = Matrix(coordinates)
+        return coordinates
+
+    def coord_tuple_transform_to(self, to_sys, coords):
+        """Transform ``coords`` to coord system ``to_sys``."""
+        sympy_deprecation_warning(
+            """
+            The CoordSystem.coord_tuple_transform_to() method is deprecated.
+            Use the CoordSystem.transform() method instead.
+            """,
+            deprecated_since_version="1.7",
+            active_deprecations_target="deprecated-diffgeom-mutable",
+        )
+
+        coords = Matrix(coords)
+        if self != to_sys:
+            with ignore_warnings(SymPyDeprecationWarning):
+                transf = self.transforms[to_sys]
+            coords = transf[1].subs(list(zip(transf[0], coords)))
+        return coords
+
+    def jacobian(self, sys, coordinates=None):
+        """
+        Return the jacobian matrix of a transformation on given coordinates.
+        If coordinates are not given, coordinate symbols of *self* are used.
+
+        Parameters
+        ==========
+
+        sys : CoordSystem
+
+        coordinates : Any iterable, optional.
+
+        Returns
+        =======
+
+        sympy.ImmutableDenseMatrix
+
+        Examples
+        ========
+
+        >>> from sympy.diffgeom.rn import R2_r, R2_p
+        >>> R2_p.jacobian(R2_r)
+        Matrix([
+        [cos(theta), -rho*sin(theta)],
+        [sin(theta),  rho*cos(theta)]])
+        >>> R2_p.jacobian(R2_r, [1, 0])
+        Matrix([
+        [1, 0],
+        [0, 1]])
+
+        """
+        result = self.transform(sys).jacobian(self.symbols)
+        if coordinates is not None:
+            result = result.subs(list(zip(self.symbols, coordinates)))
+        return result
+    jacobian_matrix = jacobian
+
+    def jacobian_determinant(self, sys, coordinates=None):
+        """
+        Return the jacobian determinant of a transformation on given
+        coordinates. If coordinates are not given, coordinate symbols of *self*
+        are used.
+
+        Parameters
+        ==========
+
+        sys : CoordSystem
+
+        coordinates : Any iterable, optional.
+
+        Returns
+        =======
+
+        sympy.Expr
+
+        Examples
+        ========
+
+        >>> from sympy.diffgeom.rn import R2_r, R2_p
+        >>> R2_r.jacobian_determinant(R2_p)
+        1/sqrt(x**2 + y**2)
+        >>> R2_r.jacobian_determinant(R2_p, [1, 0])
+        1
+
+        """
+        return self.jacobian(sys, coordinates).det()
+
+
+    ##########################################################################
+    # Points
+    ##########################################################################
+
+    def point(self, coords):
+        """Create a ``Point`` with coordinates given in this coord system."""
+        return Point(self, coords)
+
+    def point_to_coords(self, point):
+        """Calculate the coordinates of a point in this coord system."""
+        return point.coords(self)
+
+    ##########################################################################
+    # Base fields.
+    ##########################################################################
+
+    def base_scalar(self, coord_index):
+        """Return ``BaseScalarField`` that takes a point and returns one of the coordinates."""
+        return BaseScalarField(self, coord_index)
+    coord_function = base_scalar
+
+    def base_scalars(self):
+        """Returns a list of all coordinate functions.
+        For more details see the ``base_scalar`` method of this class."""
+        return [self.base_scalar(i) for i in range(self.dim)]
+    coord_functions = base_scalars
+
+    def base_vector(self, coord_index):
+        """Return a basis vector field.
+        The basis vector field for this coordinate system. It is also an
+        operator on scalar fields."""
+        return BaseVectorField(self, coord_index)
+
+    def base_vectors(self):
+        """Returns a list of all base vectors.
+        For more details see the ``base_vector`` method of this class."""
+        return [self.base_vector(i) for i in range(self.dim)]
+
+    def base_oneform(self, coord_index):
+        """Return a basis 1-form field.
+        The basis one-form field for this coordinate system. It is also an
+        operator on vector fields."""
+        return Differential(self.coord_function(coord_index))
+
+    def base_oneforms(self):
+        """Returns a list of all base oneforms.
+        For more details see the ``base_oneform`` method of this class."""
+        return [self.base_oneform(i) for i in range(self.dim)]
+
+
+class CoordinateSymbol(Symbol):
+    """A symbol which denotes an abstract value of i-th coordinate of
+    the coordinate system with given context.
+
+    Explanation
+    ===========
+
+    Each coordinates in coordinate system are represented by unique symbol,
+    such as x, y, z in Cartesian coordinate system.
+
+    You may not construct this class directly. Instead, use `symbols` method
+    of CoordSystem.
+
+    Parameters
+    ==========
+
+    coord_sys : CoordSystem
+
+    index : integer
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Lambda, Matrix, sqrt, atan2, cos, sin
+    >>> from sympy.diffgeom import Manifold, Patch, CoordSystem
+    >>> m = Manifold('M', 2)
+    >>> p = Patch('P', m)
+    >>> x, y = symbols('x y', real=True)
+    >>> r, theta = symbols('r theta', nonnegative=True)
+    >>> relation_dict = {
+    ... ('Car2D', 'Pol'): Lambda((x, y), Matrix([sqrt(x**2 + y**2), atan2(y, x)])),
+    ... ('Pol', 'Car2D'): Lambda((r, theta), Matrix([r*cos(theta), r*sin(theta)]))
+    ... }
+    >>> Car2D = CoordSystem('Car2D', p, [x, y], relation_dict)
+    >>> Pol = CoordSystem('Pol', p, [r, theta], relation_dict)
+    >>> x, y = Car2D.symbols
+
+    ``CoordinateSymbol`` contains its coordinate symbol and index.
+
+    >>> x.name
+    'x'
+    >>> x.coord_sys == Car2D
+    True
+    >>> x.index
+    0
+    >>> x.is_real
+    True
+
+    You can transform ``CoordinateSymbol`` into other coordinate system using
+    ``rewrite()`` method.
+
+    >>> x.rewrite(Pol)
+    r*cos(theta)
+    >>> sqrt(x**2 + y**2).rewrite(Pol).simplify()
+    r
+
+    """
+    def __new__(cls, coord_sys, index, **assumptions):
+        name = coord_sys.args[2][index].name
+        obj = super().__new__(cls, name, **assumptions)
+        obj.coord_sys = coord_sys
+        obj.index = index
+        return obj
+
+    def __getnewargs__(self):
+        return (self.coord_sys, self.index)
+
+    def _hashable_content(self):
+        return (
+            self.coord_sys, self.index
+        ) + tuple(sorted(self.assumptions0.items()))
+
+    def _eval_rewrite(self, rule, args, **hints):
+        if isinstance(rule, CoordSystem):
+            return rule.transform(self.coord_sys)[self.index]
+        return super()._eval_rewrite(rule, args, **hints)
+
+
+class Point(Basic):
+    """Point defined in a coordinate system.
+
+    Explanation
+    ===========
+
+    Mathematically, point is defined in the manifold and does not have any coordinates
+    by itself. Coordinate system is what imbues the coordinates to the point by coordinate
+    chart. However, due to the difficulty of realizing such logic, you must supply
+    a coordinate system and coordinates to define a Point here.
+
+    The usage of this object after its definition is independent of the
+    coordinate system that was used in order to define it, however due to
+    limitations in the simplification routines you can arrive at complicated
+    expressions if you use inappropriate coordinate systems.
+
+    Parameters
+    ==========
+
+    coord_sys : CoordSystem
+
+    coords : list
+        The coordinates of the point.
+
+    Examples
+    ========
+
+    >>> from sympy import pi
+    >>> from sympy.diffgeom import Point
+    >>> from sympy.diffgeom.rn import R2, R2_r, R2_p
+    >>> rho, theta = R2_p.symbols
+
+    >>> p = Point(R2_p, [rho, 3*pi/4])
+
+    >>> p.manifold == R2
+    True
+
+    >>> p.coords()
+    Matrix([
+    [   rho],
+    [3*pi/4]])
+    >>> p.coords(R2_r)
+    Matrix([
+    [-sqrt(2)*rho/2],
+    [ sqrt(2)*rho/2]])
+
+    """
+
+    def __new__(cls, coord_sys, coords, **kwargs):
+        coords = Matrix(coords)
+        obj = super().__new__(cls, coord_sys, coords)
+        obj._coord_sys = coord_sys
+        obj._coords = coords
+        return obj
+
+    @property
+    def patch(self):
+        return self._coord_sys.patch
+
+    @property
+    def manifold(self):
+        return self._coord_sys.manifold
+
+    @property
+    def dim(self):
+        return self.manifold.dim
+
+    def coords(self, sys=None):
+        """
+        Coordinates of the point in given coordinate system. If coordinate system
+        is not passed, it returns the coordinates in the coordinate system in which
+        the poin was defined.
+        """
+        if sys is None:
+            return self._coords
+        else:
+            return self._coord_sys.transform(sys, self._coords)
+
+    @property
+    def free_symbols(self):
+        return self._coords.free_symbols
+
+
+class BaseScalarField(Expr):
+    """Base scalar field over a manifold for a given coordinate system.
+
+    Explanation
+    ===========
+
+    A scalar field takes a point as an argument and returns a scalar.
+    A base scalar field of a coordinate system takes a point and returns one of
+    the coordinates of that point in the coordinate system in question.
+
+    To define a scalar field you need to choose the coordinate system and the
+    index of the coordinate.
+
+    The use of the scalar field after its definition is independent of the
+    coordinate system in which it was defined, however due to limitations in
+    the simplification routines you may arrive at more complicated
+    expression if you use unappropriate coordinate systems.
+    You can build complicated scalar fields by just building up SymPy
+    expressions containing ``BaseScalarField`` instances.
+
+    Parameters
+    ==========
+
+    coord_sys : CoordSystem
+
+    index : integer
+
+    Examples
+    ========
+
+    >>> from sympy import Function, pi
+    >>> from sympy.diffgeom import BaseScalarField
+    >>> from sympy.diffgeom.rn import R2_r, R2_p
+    >>> rho, _ = R2_p.symbols
+    >>> point = R2_p.point([rho, 0])
+    >>> fx, fy = R2_r.base_scalars()
+    >>> ftheta = BaseScalarField(R2_r, 1)
+
+    >>> fx(point)
+    rho
+    >>> fy(point)
+    0
+
+    >>> (fx**2+fy**2).rcall(point)
+    rho**2
+
+    >>> g = Function('g')
+    >>> fg = g(ftheta-pi)
+    >>> fg.rcall(point)
+    g(-pi)
+
+    """
+
+    is_commutative = True
+
+    def __new__(cls, coord_sys, index, **kwargs):
+        index = _sympify(index)
+        obj = super().__new__(cls, coord_sys, index)
+        obj._coord_sys = coord_sys
+        obj._index = index
+        return obj
+
+    @property
+    def coord_sys(self):
+        return self.args[0]
+
+    @property
+    def index(self):
+        return self.args[1]
+
+    @property
+    def patch(self):
+        return self.coord_sys.patch
+
+    @property
+    def manifold(self):
+        return self.coord_sys.manifold
+
+    @property
+    def dim(self):
+        return self.manifold.dim
+
+    def __call__(self, *args):
+        """Evaluating the field at a point or doing nothing.
+        If the argument is a ``Point`` instance, the field is evaluated at that
+        point. The field is returned itself if the argument is any other
+        object. It is so in order to have working recursive calling mechanics
+        for all fields (check the ``__call__`` method of ``Expr``).
+        """
+        point = args[0]
+        if len(args) != 1 or not isinstance(point, Point):
+            return self
+        coords = point.coords(self._coord_sys)
+        # XXX Calling doit  is necessary with all the Subs expressions
+        # XXX Calling simplify is necessary with all the trig expressions
+        return simplify(coords[self._index]).doit()
+
+    # XXX Workaround for limitations on the content of args
+    free_symbols: set[Any] = set()
+
+
+class BaseVectorField(Expr):
+    r"""Base vector field over a manifold for a given coordinate system.
+
+    Explanation
+    ===========
+
+    A vector field is an operator taking a scalar field and returning a
+    directional derivative (which is also a scalar field).
+    A base vector field is the same type of operator, however the derivation is
+    specifically done with respect to a chosen coordinate.
+
+    To define a base vector field you need to choose the coordinate system and
+    the index of the coordinate.
+
+    The use of the vector field after its definition is independent of the
+    coordinate system in which it was defined, however due to limitations in the
+    simplification routines you may arrive at more complicated expression if you
+    use unappropriate coordinate systems.
+
+    Parameters
+    ==========
+    coord_sys : CoordSystem
+
+    index : integer
+
+    Examples
+    ========
+
+    >>> from sympy import Function
+    >>> from sympy.diffgeom.rn import R2_p, R2_r
+    >>> from sympy.diffgeom import BaseVectorField
+    >>> from sympy import pprint
+
+    >>> x, y = R2_r.symbols
+    >>> rho, theta = R2_p.symbols
+    >>> fx, fy = R2_r.base_scalars()
+    >>> point_p = R2_p.point([rho, theta])
+    >>> point_r = R2_r.point([x, y])
+
+    >>> g = Function('g')
+    >>> s_field = g(fx, fy)
+
+    >>> v = BaseVectorField(R2_r, 1)
+    >>> pprint(v(s_field))
+    / d           \|
+    |---(g(x, xi))||
+    \dxi          /|xi=y
+    >>> pprint(v(s_field).rcall(point_r).doit())
+    d
+    --(g(x, y))
+    dy
+    >>> pprint(v(s_field).rcall(point_p))
+    / d                        \|
+    |---(g(rho*cos(theta), xi))||
+    \dxi                       /|xi=rho*sin(theta)
+
+    """
+
+    is_commutative = False
+
+    def __new__(cls, coord_sys, index, **kwargs):
+        index = _sympify(index)
+        obj = super().__new__(cls, coord_sys, index)
+        obj._coord_sys = coord_sys
+        obj._index = index
+        return obj
+
+    @property
+    def coord_sys(self):
+        return self.args[0]
+
+    @property
+    def index(self):
+        return self.args[1]
+
+    @property
+    def patch(self):
+        return self.coord_sys.patch
+
+    @property
+    def manifold(self):
+        return self.coord_sys.manifold
+
+    @property
+    def dim(self):
+        return self.manifold.dim
+
+    def __call__(self, scalar_field):
+        """Apply on a scalar field.
+        The action of a vector field on a scalar field is a directional
+        differentiation.
+        If the argument is not a scalar field an error is raised.
+        """
+        if covariant_order(scalar_field) or contravariant_order(scalar_field):
+            raise ValueError('Only scalar fields can be supplied as arguments to vector fields.')
+
+        if scalar_field is None:
+            return self
+
+        base_scalars = list(scalar_field.atoms(BaseScalarField))
+
+        # First step: e_x(x+r**2) -> e_x(x) + 2*r*e_x(r)
+        d_var = self._coord_sys._dummy
+        # TODO: you need a real dummy function for the next line
+        d_funcs = [Function('_#_%s' % i)(d_var) for i,
+                   b in enumerate(base_scalars)]
+        d_result = scalar_field.subs(list(zip(base_scalars, d_funcs)))
+        d_result = d_result.diff(d_var)
+
+        # Second step: e_x(x) -> 1 and e_x(r) -> cos(atan2(x, y))
+        coords = self._coord_sys.symbols
+        d_funcs_deriv = [f.diff(d_var) for f in d_funcs]
+        d_funcs_deriv_sub = []
+        for b in base_scalars:
+            jac = self._coord_sys.jacobian(b._coord_sys, coords)
+            d_funcs_deriv_sub.append(jac[b._index, self._index])
+        d_result = d_result.subs(list(zip(d_funcs_deriv, d_funcs_deriv_sub)))
+
+        # Remove the dummies
+        result = d_result.subs(list(zip(d_funcs, base_scalars)))
+        result = result.subs(list(zip(coords, self._coord_sys.coord_functions())))
+        return result.doit()
+
+
+def _find_coords(expr):
+    # Finds CoordinateSystems existing in expr
+    fields = expr.atoms(BaseScalarField, BaseVectorField)
+    result = set()
+    for f in fields:
+        result.add(f._coord_sys)
+    return result
+
+
+class Commutator(Expr):
+    r"""Commutator of two vector fields.
+
+    Explanation
+    ===========
+
+    The commutator of two vector fields `v_1` and `v_2` is defined as the
+    vector field `[v_1, v_2]` that evaluated on each scalar field `f` is equal
+    to `v_1(v_2(f)) - v_2(v_1(f))`.
+
+    Examples
+    ========
+
+
+    >>> from sympy.diffgeom.rn import R2_p, R2_r
+    >>> from sympy.diffgeom import Commutator
+    >>> from sympy import simplify
+
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> e_r = R2_p.base_vector(0)
+
+    >>> c_xy = Commutator(e_x, e_y)
+    >>> c_xr = Commutator(e_x, e_r)
+    >>> c_xy
+    0
+
+    Unfortunately, the current code is not able to compute everything:
+
+    >>> c_xr
+    Commutator(e_x, e_rho)
+    >>> simplify(c_xr(fy**2))
+    -2*cos(theta)*y**2/(x**2 + y**2)
+
+    """
+    def __new__(cls, v1, v2):
+        if (covariant_order(v1) or contravariant_order(v1) != 1
+                or covariant_order(v2) or contravariant_order(v2) != 1):
+            raise ValueError(
+                'Only commutators of vector fields are supported.')
+        if v1 == v2:
+            return S.Zero
+        coord_sys = set().union(*[_find_coords(v) for v in (v1, v2)])
+        if len(coord_sys) == 1:
+            # Only one coordinate systems is used, hence it is easy enough to
+            # actually evaluate the commutator.
+            if all(isinstance(v, BaseVectorField) for v in (v1, v2)):
+                return S.Zero
+            bases_1, bases_2 = [list(v.atoms(BaseVectorField))
+                                for v in (v1, v2)]
+            coeffs_1 = [v1.expand().coeff(b) for b in bases_1]
+            coeffs_2 = [v2.expand().coeff(b) for b in bases_2]
+            res = 0
+            for c1, b1 in zip(coeffs_1, bases_1):
+                for c2, b2 in zip(coeffs_2, bases_2):
+                    res += c1*b1(c2)*b2 - c2*b2(c1)*b1
+            return res
+        else:
+            obj = super().__new__(cls, v1, v2)
+            obj._v1 = v1 # deprecated assignment
+            obj._v2 = v2 # deprecated assignment
+            return obj
+
+    @property
+    def v1(self):
+        return self.args[0]
+
+    @property
+    def v2(self):
+        return self.args[1]
+
+    def __call__(self, scalar_field):
+        """Apply on a scalar field.
+        If the argument is not a scalar field an error is raised.
+        """
+        return self.v1(self.v2(scalar_field)) - self.v2(self.v1(scalar_field))
+
+
+class Differential(Expr):
+    r"""Return the differential (exterior derivative) of a form field.
+
+    Explanation
+    ===========
+
+    The differential of a form (i.e. the exterior derivative) has a complicated
+    definition in the general case.
+    The differential `df` of the 0-form `f` is defined for any vector field `v`
+    as `df(v) = v(f)`.
+
+    Examples
+    ========
+
+    >>> from sympy import Function
+    >>> from sympy.diffgeom.rn import R2_r
+    >>> from sympy.diffgeom import Differential
+    >>> from sympy import pprint
+
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> g = Function('g')
+    >>> s_field = g(fx, fy)
+    >>> dg = Differential(s_field)
+
+    >>> dg
+    d(g(x, y))
+    >>> pprint(dg(e_x))
+    / d           \|
+    |---(g(xi, y))||
+    \dxi          /|xi=x
+    >>> pprint(dg(e_y))
+    / d           \|
+    |---(g(x, xi))||
+    \dxi          /|xi=y
+
+    Applying the exterior derivative operator twice always results in:
+
+    >>> Differential(dg)
+    0
+    """
+
+    is_commutative = False
+
+    def __new__(cls, form_field):
+        if contravariant_order(form_field):
+            raise ValueError(
+                'A vector field was supplied as an argument to Differential.')
+        if isinstance(form_field, Differential):
+            return S.Zero
+        else:
+            obj = super().__new__(cls, form_field)
+            obj._form_field = form_field # deprecated assignment
+            return obj
+
+    @property
+    def form_field(self):
+        return self.args[0]
+
+    def __call__(self, *vector_fields):
+        """Apply on a list of vector_fields.
+
+        Explanation
+        ===========
+
+        If the number of vector fields supplied is not equal to 1 + the order of
+        the form field inside the differential the result is undefined.
+
+        For 1-forms (i.e. differentials of scalar fields) the evaluation is
+        done as `df(v)=v(f)`. However if `v` is ``None`` instead of a vector
+        field, the differential is returned unchanged. This is done in order to
+        permit partial contractions for higher forms.
+
+        In the general case the evaluation is done by applying the form field
+        inside the differential on a list with one less elements than the number
+        of elements in the original list. Lowering the number of vector fields
+        is achieved through replacing each pair of fields by their
+        commutator.
+
+        If the arguments are not vectors or ``None``s an error is raised.
+        """
+        if any((contravariant_order(a) != 1 or covariant_order(a)) and a is not None
+                for a in vector_fields):
+            raise ValueError('The arguments supplied to Differential should be vector fields or Nones.')
+        k = len(vector_fields)
+        if k == 1:
+            if vector_fields[0]:
+                return vector_fields[0].rcall(self._form_field)
+            return self
+        else:
+            # For higher form it is more complicated:
+            # Invariant formula:
+            # https://en.wikipedia.org/wiki/Exterior_derivative#Invariant_formula
+            # df(v1, ... vn) = +/- vi(f(v1..no i..vn))
+            #                  +/- f([vi,vj],v1..no i, no j..vn)
+            f = self._form_field
+            v = vector_fields
+            ret = 0
+            for i in range(k):
+                t = v[i].rcall(f.rcall(*v[:i] + v[i + 1:]))
+                ret += (-1)**i*t
+                for j in range(i + 1, k):
+                    c = Commutator(v[i], v[j])
+                    if c:  # TODO this is ugly - the Commutator can be Zero and
+                        # this causes the next line to fail
+                        t = f.rcall(*(c,) + v[:i] + v[i + 1:j] + v[j + 1:])
+                        ret += (-1)**(i + j)*t
+            return ret
+
+
+class TensorProduct(Expr):
+    """Tensor product of forms.
+
+    Explanation
+    ===========
+
+    The tensor product permits the creation of multilinear functionals (i.e.
+    higher order tensors) out of lower order fields (e.g. 1-forms and vector
+    fields). However, the higher tensors thus created lack the interesting
+    features provided by the other type of product, the wedge product, namely
+    they are not antisymmetric and hence are not form fields.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2_r
+    >>> from sympy.diffgeom import TensorProduct
+
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> dx, dy = R2_r.base_oneforms()
+
+    >>> TensorProduct(dx, dy)(e_x, e_y)
+    1
+    >>> TensorProduct(dx, dy)(e_y, e_x)
+    0
+    >>> TensorProduct(dx, fx*dy)(fx*e_x, e_y)
+    x**2
+    >>> TensorProduct(e_x, e_y)(fx**2, fy**2)
+    4*x*y
+    >>> TensorProduct(e_y, dx)(fy)
+    dx
+
+    You can nest tensor products.
+
+    >>> tp1 = TensorProduct(dx, dy)
+    >>> TensorProduct(tp1, dx)(e_x, e_y, e_x)
+    1
+
+    You can make partial contraction for instance when 'raising an index'.
+    Putting ``None`` in the second argument of ``rcall`` means that the
+    respective position in the tensor product is left as it is.
+
+    >>> TP = TensorProduct
+    >>> metric = TP(dx, dx) + 3*TP(dy, dy)
+    >>> metric.rcall(e_y, None)
+    3*dy
+
+    Or automatically pad the args with ``None`` without specifying them.
+
+    >>> metric.rcall(e_y)
+    3*dy
+
+    """
+    def __new__(cls, *args):
+        scalar = Mul(*[m for m in args if covariant_order(m) + contravariant_order(m) == 0])
+        multifields = [m for m in args if covariant_order(m) + contravariant_order(m)]
+        if multifields:
+            if len(multifields) == 1:
+                return scalar*multifields[0]
+            return scalar*super().__new__(cls, *multifields)
+        else:
+            return scalar
+
+    def __call__(self, *fields):
+        """Apply on a list of fields.
+
+        If the number of input fields supplied is not equal to the order of
+        the tensor product field, the list of arguments is padded with ``None``'s.
+
+        The list of arguments is divided in sublists depending on the order of
+        the forms inside the tensor product. The sublists are provided as
+        arguments to these forms and the resulting expressions are given to the
+        constructor of ``TensorProduct``.
+
+        """
+        tot_order = covariant_order(self) + contravariant_order(self)
+        tot_args = len(fields)
+        if tot_args != tot_order:
+            fields = list(fields) + [None]*(tot_order - tot_args)
+        orders = [covariant_order(f) + contravariant_order(f) for f in self._args]
+        indices = [sum(orders[:i + 1]) for i in range(len(orders) - 1)]
+        fields = [fields[i:j] for i, j in zip([0] + indices, indices + [None])]
+        multipliers = [t[0].rcall(*t[1]) for t in zip(self._args, fields)]
+        return TensorProduct(*multipliers)
+
+
+class WedgeProduct(TensorProduct):
+    """Wedge product of forms.
+
+    Explanation
+    ===========
+
+    In the context of integration only completely antisymmetric forms make
+    sense. The wedge product permits the creation of such forms.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2_r
+    >>> from sympy.diffgeom import WedgeProduct
+
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> dx, dy = R2_r.base_oneforms()
+
+    >>> WedgeProduct(dx, dy)(e_x, e_y)
+    1
+    >>> WedgeProduct(dx, dy)(e_y, e_x)
+    -1
+    >>> WedgeProduct(dx, fx*dy)(fx*e_x, e_y)
+    x**2
+    >>> WedgeProduct(e_x, e_y)(fy, None)
+    -e_x
+
+    You can nest wedge products.
+
+    >>> wp1 = WedgeProduct(dx, dy)
+    >>> WedgeProduct(wp1, dx)(e_x, e_y, e_x)
+    0
+
+    """
+    # TODO the calculation of signatures is slow
+    # TODO you do not need all these permutations (neither the prefactor)
+    def __call__(self, *fields):
+        """Apply on a list of vector_fields.
+        The expression is rewritten internally in terms of tensor products and evaluated."""
+        orders = (covariant_order(e) + contravariant_order(e) for e in self.args)
+        mul = 1/Mul(*(factorial(o) for o in orders))
+        perms = permutations(fields)
+        perms_par = (Permutation(
+            p).signature() for p in permutations(range(len(fields))))
+        tensor_prod = TensorProduct(*self.args)
+        return mul*Add(*[tensor_prod(*p[0])*p[1] for p in zip(perms, perms_par)])
+
+
+class LieDerivative(Expr):
+    """Lie derivative with respect to a vector field.
+
+    Explanation
+    ===========
+
+    The transport operator that defines the Lie derivative is the pushforward of
+    the field to be derived along the integral curve of the field with respect
+    to which one derives.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2_r, R2_p
+    >>> from sympy.diffgeom import (LieDerivative, TensorProduct)
+
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> e_rho, e_theta = R2_p.base_vectors()
+    >>> dx, dy = R2_r.base_oneforms()
+
+    >>> LieDerivative(e_x, fy)
+    0
+    >>> LieDerivative(e_x, fx)
+    1
+    >>> LieDerivative(e_x, e_x)
+    0
+
+    The Lie derivative of a tensor field by another tensor field is equal to
+    their commutator:
+
+    >>> LieDerivative(e_x, e_rho)
+    Commutator(e_x, e_rho)
+    >>> LieDerivative(e_x + e_y, fx)
+    1
+
+    >>> tp = TensorProduct(dx, dy)
+    >>> LieDerivative(e_x, tp)
+    LieDerivative(e_x, TensorProduct(dx, dy))
+    >>> LieDerivative(e_x, tp)
+    LieDerivative(e_x, TensorProduct(dx, dy))
+
+    """
+    def __new__(cls, v_field, expr):
+        expr_form_ord = covariant_order(expr)
+        if contravariant_order(v_field) != 1 or covariant_order(v_field):
+            raise ValueError('Lie derivatives are defined only with respect to'
+                             ' vector fields. The supplied argument was not a '
+                             'vector field.')
+        if expr_form_ord > 0:
+            obj = super().__new__(cls, v_field, expr)
+            # deprecated assignments
+            obj._v_field = v_field
+            obj._expr = expr
+            return obj
+        if expr.atoms(BaseVectorField):
+            return Commutator(v_field, expr)
+        else:
+            return v_field.rcall(expr)
+
+    @property
+    def v_field(self):
+        return self.args[0]
+
+    @property
+    def expr(self):
+        return self.args[1]
+
+    def __call__(self, *args):
+        v = self.v_field
+        expr = self.expr
+        lead_term = v(expr(*args))
+        rest = Add(*[Mul(*args[:i] + (Commutator(v, args[i]),) + args[i + 1:])
+                     for i in range(len(args))])
+        return lead_term - rest
+
+
+class BaseCovarDerivativeOp(Expr):
+    """Covariant derivative operator with respect to a base vector.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2_r
+    >>> from sympy.diffgeom import BaseCovarDerivativeOp
+    >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct
+
+    >>> TP = TensorProduct
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> dx, dy = R2_r.base_oneforms()
+
+    >>> ch = metric_to_Christoffel_2nd(TP(dx, dx) + TP(dy, dy))
+    >>> ch
+    [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
+    >>> cvd = BaseCovarDerivativeOp(R2_r, 0, ch)
+    >>> cvd(fx)
+    1
+    >>> cvd(fx*e_x)
+    e_x
+    """
+
+    def __new__(cls, coord_sys, index, christoffel):
+        index = _sympify(index)
+        christoffel = ImmutableDenseNDimArray(christoffel)
+        obj = super().__new__(cls, coord_sys, index, christoffel)
+        # deprecated assignments
+        obj._coord_sys = coord_sys
+        obj._index = index
+        obj._christoffel = christoffel
+        return obj
+
+    @property
+    def coord_sys(self):
+        return self.args[0]
+
+    @property
+    def index(self):
+        return self.args[1]
+
+    @property
+    def christoffel(self):
+        return self.args[2]
+
+    def __call__(self, field):
+        """Apply on a scalar field.
+
+        The action of a vector field on a scalar field is a directional
+        differentiation.
+        If the argument is not a scalar field the behaviour is undefined.
+        """
+        if covariant_order(field) != 0:
+            raise NotImplementedError()
+
+        field = vectors_in_basis(field, self._coord_sys)
+
+        wrt_vector = self._coord_sys.base_vector(self._index)
+        wrt_scalar = self._coord_sys.coord_function(self._index)
+        vectors = list(field.atoms(BaseVectorField))
+
+        # First step: replace all vectors with something susceptible to
+        # derivation and do the derivation
+        # TODO: you need a real dummy function for the next line
+        d_funcs = [Function('_#_%s' % i)(wrt_scalar) for i,
+                   b in enumerate(vectors)]
+        d_result = field.subs(list(zip(vectors, d_funcs)))
+        d_result = wrt_vector(d_result)
+
+        # Second step: backsubstitute the vectors in
+        d_result = d_result.subs(list(zip(d_funcs, vectors)))
+
+        # Third step: evaluate the derivatives of the vectors
+        derivs = []
+        for v in vectors:
+            d = Add(*[(self._christoffel[k, wrt_vector._index, v._index]
+                       *v._coord_sys.base_vector(k))
+                      for k in range(v._coord_sys.dim)])
+            derivs.append(d)
+        to_subs = [wrt_vector(d) for d in d_funcs]
+        # XXX: This substitution can fail when there are Dummy symbols and the
+        # cache is disabled: https://github.com/sympy/sympy/issues/17794
+        result = d_result.subs(list(zip(to_subs, derivs)))
+
+        # Remove the dummies
+        result = result.subs(list(zip(d_funcs, vectors)))
+        return result.doit()
+
+
+class CovarDerivativeOp(Expr):
+    """Covariant derivative operator.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2_r
+    >>> from sympy.diffgeom import CovarDerivativeOp
+    >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct
+    >>> TP = TensorProduct
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> dx, dy = R2_r.base_oneforms()
+    >>> ch = metric_to_Christoffel_2nd(TP(dx, dx) + TP(dy, dy))
+
+    >>> ch
+    [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
+    >>> cvd = CovarDerivativeOp(fx*e_x, ch)
+    >>> cvd(fx)
+    x
+    >>> cvd(fx*e_x)
+    x*e_x
+
+    """
+
+    def __new__(cls, wrt, christoffel):
+        if len({v._coord_sys for v in wrt.atoms(BaseVectorField)}) > 1:
+            raise NotImplementedError()
+        if contravariant_order(wrt) != 1 or covariant_order(wrt):
+            raise ValueError('Covariant derivatives are defined only with '
+                             'respect to vector fields. The supplied argument '
+                             'was not a vector field.')
+        christoffel = ImmutableDenseNDimArray(christoffel)
+        obj = super().__new__(cls, wrt, christoffel)
+        # deprecated assignments
+        obj._wrt = wrt
+        obj._christoffel = christoffel
+        return obj
+
+    @property
+    def wrt(self):
+        return self.args[0]
+
+    @property
+    def christoffel(self):
+        return self.args[1]
+
+    def __call__(self, field):
+        vectors = list(self._wrt.atoms(BaseVectorField))
+        base_ops = [BaseCovarDerivativeOp(v._coord_sys, v._index, self._christoffel)
+                    for v in vectors]
+        return self._wrt.subs(list(zip(vectors, base_ops))).rcall(field)
+
+
+###############################################################################
+# Integral curves on vector fields
+###############################################################################
+def intcurve_series(vector_field, param, start_point, n=6, coord_sys=None, coeffs=False):
+    r"""Return the series expansion for an integral curve of the field.
+
+    Explanation
+    ===========
+
+    Integral curve is a function `\gamma` taking a parameter in `R` to a point
+    in the manifold. It verifies the equation:
+
+    `V(f)\big(\gamma(t)\big) = \frac{d}{dt}f\big(\gamma(t)\big)`
+
+    where the given ``vector_field`` is denoted as `V`. This holds for any
+    value `t` for the parameter and any scalar field `f`.
+
+    This equation can also be decomposed of a basis of coordinate functions
+    `V(f_i)\big(\gamma(t)\big) = \frac{d}{dt}f_i\big(\gamma(t)\big) \quad \forall i`
+
+    This function returns a series expansion of `\gamma(t)` in terms of the
+    coordinate system ``coord_sys``. The equations and expansions are necessarily
+    done in coordinate-system-dependent way as there is no other way to
+    represent movement between points on the manifold (i.e. there is no such
+    thing as a difference of points for a general manifold).
+
+    Parameters
+    ==========
+    vector_field
+        the vector field for which an integral curve will be given
+
+    param
+        the argument of the function `\gamma` from R to the curve
+
+    start_point
+        the point which corresponds to `\gamma(0)`
+
+    n
+        the order to which to expand
+
+    coord_sys
+        the coordinate system in which to expand
+        coeffs (default False) - if True return a list of elements of the expansion
+
+    Examples
+    ========
+
+    Use the predefined R2 manifold:
+
+    >>> from sympy.abc import t, x, y
+    >>> from sympy.diffgeom.rn import R2_p, R2_r
+    >>> from sympy.diffgeom import intcurve_series
+
+    Specify a starting point and a vector field:
+
+    >>> start_point = R2_r.point([x, y])
+    >>> vector_field = R2_r.e_x
+
+    Calculate the series:
+
+    >>> intcurve_series(vector_field, t, start_point, n=3)
+    Matrix([
+    [t + x],
+    [    y]])
+
+    Or get the elements of the expansion in a list:
+
+    >>> series = intcurve_series(vector_field, t, start_point, n=3, coeffs=True)
+    >>> series[0]
+    Matrix([
+    [x],
+    [y]])
+    >>> series[1]
+    Matrix([
+    [t],
+    [0]])
+    >>> series[2]
+    Matrix([
+    [0],
+    [0]])
+
+    The series in the polar coordinate system:
+
+    >>> series = intcurve_series(vector_field, t, start_point,
+    ...             n=3, coord_sys=R2_p, coeffs=True)
+    >>> series[0]
+    Matrix([
+    [sqrt(x**2 + y**2)],
+    [      atan2(y, x)]])
+    >>> series[1]
+    Matrix([
+    [t*x/sqrt(x**2 + y**2)],
+    [   -t*y/(x**2 + y**2)]])
+    >>> series[2]
+    Matrix([
+    [t**2*(-x**2/(x**2 + y**2)**(3/2) + 1/sqrt(x**2 + y**2))/2],
+    [                                t**2*x*y/(x**2 + y**2)**2]])
+
+    See Also
+    ========
+
+    intcurve_diffequ
+
+    """
+    if contravariant_order(vector_field) != 1 or covariant_order(vector_field):
+        raise ValueError('The supplied field was not a vector field.')
+
+    def iter_vfield(scalar_field, i):
+        """Return ``vector_field`` called `i` times on ``scalar_field``."""
+        return reduce(lambda s, v: v.rcall(s), [vector_field, ]*i, scalar_field)
+
+    def taylor_terms_per_coord(coord_function):
+        """Return the series for one of the coordinates."""
+        return [param**i*iter_vfield(coord_function, i).rcall(start_point)/factorial(i)
+                for i in range(n)]
+    coord_sys = coord_sys if coord_sys else start_point._coord_sys
+    coord_functions = coord_sys.coord_functions()
+    taylor_terms = [taylor_terms_per_coord(f) for f in coord_functions]
+    if coeffs:
+        return [Matrix(t) for t in zip(*taylor_terms)]
+    else:
+        return Matrix([sum(c) for c in taylor_terms])
+
+
+def intcurve_diffequ(vector_field, param, start_point, coord_sys=None):
+    r"""Return the differential equation for an integral curve of the field.
+
+    Explanation
+    ===========
+
+    Integral curve is a function `\gamma` taking a parameter in `R` to a point
+    in the manifold. It verifies the equation:
+
+    `V(f)\big(\gamma(t)\big) = \frac{d}{dt}f\big(\gamma(t)\big)`
+
+    where the given ``vector_field`` is denoted as `V`. This holds for any
+    value `t` for the parameter and any scalar field `f`.
+
+    This function returns the differential equation of `\gamma(t)` in terms of the
+    coordinate system ``coord_sys``. The equations and expansions are necessarily
+    done in coordinate-system-dependent way as there is no other way to
+    represent movement between points on the manifold (i.e. there is no such
+    thing as a difference of points for a general manifold).
+
+    Parameters
+    ==========
+
+    vector_field
+        the vector field for which an integral curve will be given
+
+    param
+        the argument of the function `\gamma` from R to the curve
+
+    start_point
+        the point which corresponds to `\gamma(0)`
+
+    coord_sys
+        the coordinate system in which to give the equations
+
+    Returns
+    =======
+
+    a tuple of (equations, initial conditions)
+
+    Examples
+    ========
+
+    Use the predefined R2 manifold:
+
+    >>> from sympy.abc import t
+    >>> from sympy.diffgeom.rn import R2, R2_p, R2_r
+    >>> from sympy.diffgeom import intcurve_diffequ
+
+    Specify a starting point and a vector field:
+
+    >>> start_point = R2_r.point([0, 1])
+    >>> vector_field = -R2.y*R2.e_x + R2.x*R2.e_y
+
+    Get the equation:
+
+    >>> equations, init_cond = intcurve_diffequ(vector_field, t, start_point)
+    >>> equations
+    [f_1(t) + Derivative(f_0(t), t), -f_0(t) + Derivative(f_1(t), t)]
+    >>> init_cond
+    [f_0(0), f_1(0) - 1]
+
+    The series in the polar coordinate system:
+
+    >>> equations, init_cond = intcurve_diffequ(vector_field, t, start_point, R2_p)
+    >>> equations
+    [Derivative(f_0(t), t), Derivative(f_1(t), t) - 1]
+    >>> init_cond
+    [f_0(0) - 1, f_1(0) - pi/2]
+
+    See Also
+    ========
+
+    intcurve_series
+
+    """
+    if contravariant_order(vector_field) != 1 or covariant_order(vector_field):
+        raise ValueError('The supplied field was not a vector field.')
+    coord_sys = coord_sys if coord_sys else start_point._coord_sys
+    gammas = [Function('f_%d' % i)(param) for i in range(
+        start_point._coord_sys.dim)]
+    arbitrary_p = Point(coord_sys, gammas)
+    coord_functions = coord_sys.coord_functions()
+    equations = [simplify(diff(cf.rcall(arbitrary_p), param) - vector_field.rcall(cf).rcall(arbitrary_p))
+                 for cf in coord_functions]
+    init_cond = [simplify(cf.rcall(arbitrary_p).subs(param, 0) - cf.rcall(start_point))
+                 for cf in coord_functions]
+    return equations, init_cond
+
+
+###############################################################################
+# Helpers
+###############################################################################
+def dummyfy(args, exprs):
+    # TODO Is this a good idea?
+    d_args = Matrix([s.as_dummy() for s in args])
+    reps = dict(zip(args, d_args))
+    d_exprs = Matrix([_sympify(expr).subs(reps) for expr in exprs])
+    return d_args, d_exprs
+
+###############################################################################
+# Helpers
+###############################################################################
+def contravariant_order(expr, _strict=False):
+    """Return the contravariant order of an expression.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom import contravariant_order
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.abc import a
+
+    >>> contravariant_order(a)
+    0
+    >>> contravariant_order(a*R2.x + 2)
+    0
+    >>> contravariant_order(a*R2.x*R2.e_y + R2.e_x)
+    1
+
+    """
+    # TODO move some of this to class methods.
+    # TODO rewrite using the .as_blah_blah methods
+    if isinstance(expr, Add):
+        orders = [contravariant_order(e) for e in expr.args]
+        if len(set(orders)) != 1:
+            raise ValueError('Misformed expression containing contravariant fields of varying order.')
+        return orders[0]
+    elif isinstance(expr, Mul):
+        orders = [contravariant_order(e) for e in expr.args]
+        not_zero = [o for o in orders if o != 0]
+        if len(not_zero) > 1:
+            raise ValueError('Misformed expression containing multiplication between vectors.')
+        return 0 if not not_zero else not_zero[0]
+    elif isinstance(expr, Pow):
+        if covariant_order(expr.base) or covariant_order(expr.exp):
+            raise ValueError(
+                'Misformed expression containing a power of a vector.')
+        return 0
+    elif isinstance(expr, BaseVectorField):
+        return 1
+    elif isinstance(expr, TensorProduct):
+        return sum(contravariant_order(a) for a in expr.args)
+    elif not _strict or expr.atoms(BaseScalarField):
+        return 0
+    else:  # If it does not contain anything related to the diffgeom module and it is _strict
+        return -1
+
+
+def covariant_order(expr, _strict=False):
+    """Return the covariant order of an expression.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom import covariant_order
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.abc import a
+
+    >>> covariant_order(a)
+    0
+    >>> covariant_order(a*R2.x + 2)
+    0
+    >>> covariant_order(a*R2.x*R2.dy + R2.dx)
+    1
+
+    """
+    # TODO move some of this to class methods.
+    # TODO rewrite using the .as_blah_blah methods
+    if isinstance(expr, Add):
+        orders = [covariant_order(e) for e in expr.args]
+        if len(set(orders)) != 1:
+            raise ValueError('Misformed expression containing form fields of varying order.')
+        return orders[0]
+    elif isinstance(expr, Mul):
+        orders = [covariant_order(e) for e in expr.args]
+        not_zero = [o for o in orders if o != 0]
+        if len(not_zero) > 1:
+            raise ValueError('Misformed expression containing multiplication between forms.')
+        return 0 if not not_zero else not_zero[0]
+    elif isinstance(expr, Pow):
+        if covariant_order(expr.base) or covariant_order(expr.exp):
+            raise ValueError(
+                'Misformed expression containing a power of a form.')
+        return 0
+    elif isinstance(expr, Differential):
+        return covariant_order(*expr.args) + 1
+    elif isinstance(expr, TensorProduct):
+        return sum(covariant_order(a) for a in expr.args)
+    elif not _strict or expr.atoms(BaseScalarField):
+        return 0
+    else:  # If it does not contain anything related to the diffgeom module and it is _strict
+        return -1
+
+
+###############################################################################
+# Coordinate transformation functions
+###############################################################################
+def vectors_in_basis(expr, to_sys):
+    """Transform all base vectors in base vectors of a specified coord basis.
+    While the new base vectors are in the new coordinate system basis, any
+    coefficients are kept in the old system.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom import vectors_in_basis
+    >>> from sympy.diffgeom.rn import R2_r, R2_p
+
+    >>> vectors_in_basis(R2_r.e_x, R2_p)
+    -y*e_theta/(x**2 + y**2) + x*e_rho/sqrt(x**2 + y**2)
+    >>> vectors_in_basis(R2_p.e_r, R2_r)
+    sin(theta)*e_y + cos(theta)*e_x
+
+    """
+    vectors = list(expr.atoms(BaseVectorField))
+    new_vectors = []
+    for v in vectors:
+        cs = v._coord_sys
+        jac = cs.jacobian(to_sys, cs.coord_functions())
+        new = (jac.T*Matrix(to_sys.base_vectors()))[v._index]
+        new_vectors.append(new)
+    return expr.subs(list(zip(vectors, new_vectors)))
+
+
+###############################################################################
+# Coordinate-dependent functions
+###############################################################################
+def twoform_to_matrix(expr):
+    """Return the matrix representing the twoform.
+
+    For the twoform `w` return the matrix `M` such that `M[i,j]=w(e_i, e_j)`,
+    where `e_i` is the i-th base vector field for the coordinate system in
+    which the expression of `w` is given.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.diffgeom import twoform_to_matrix, TensorProduct
+    >>> TP = TensorProduct
+
+    >>> twoform_to_matrix(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    >>> twoform_to_matrix(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    Matrix([
+    [x, 0],
+    [0, 1]])
+    >>> twoform_to_matrix(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy) - TP(R2.dx, R2.dy)/2)
+    Matrix([
+    [   1, 0],
+    [-1/2, 1]])
+
+    """
+    if covariant_order(expr) != 2 or contravariant_order(expr):
+        raise ValueError('The input expression is not a two-form.')
+    coord_sys = _find_coords(expr)
+    if len(coord_sys) != 1:
+        raise ValueError('The input expression concerns more than one '
+                         'coordinate systems, hence there is no unambiguous '
+                         'way to choose a coordinate system for the matrix.')
+    coord_sys = coord_sys.pop()
+    vectors = coord_sys.base_vectors()
+    expr = expr.expand()
+    matrix_content = [[expr.rcall(v1, v2) for v1 in vectors]
+                      for v2 in vectors]
+    return Matrix(matrix_content)
+
+
+def metric_to_Christoffel_1st(expr):
+    """Return the nested list of Christoffel symbols for the given metric.
+    This returns the Christoffel symbol of first kind that represents the
+    Levi-Civita connection for the given metric.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.diffgeom import metric_to_Christoffel_1st, TensorProduct
+    >>> TP = TensorProduct
+
+    >>> metric_to_Christoffel_1st(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
+    >>> metric_to_Christoffel_1st(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[[1/2, 0], [0, 0]], [[0, 0], [0, 0]]]
+
+    """
+    matrix = twoform_to_matrix(expr)
+    if not matrix.is_symmetric():
+        raise ValueError(
+            'The two-form representing the metric is not symmetric.')
+    coord_sys = _find_coords(expr).pop()
+    deriv_matrices = [matrix.applyfunc(d) for d in coord_sys.base_vectors()]
+    indices = list(range(coord_sys.dim))
+    christoffel = [[[(deriv_matrices[k][i, j] + deriv_matrices[j][i, k] - deriv_matrices[i][j, k])/2
+                     for k in indices]
+                    for j in indices]
+                   for i in indices]
+    return ImmutableDenseNDimArray(christoffel)
+
+
+def metric_to_Christoffel_2nd(expr):
+    """Return the nested list of Christoffel symbols for the given metric.
+    This returns the Christoffel symbol of second kind that represents the
+    Levi-Civita connection for the given metric.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct
+    >>> TP = TensorProduct
+
+    >>> metric_to_Christoffel_2nd(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
+    >>> metric_to_Christoffel_2nd(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[[1/(2*x), 0], [0, 0]], [[0, 0], [0, 0]]]
+
+    """
+    ch_1st = metric_to_Christoffel_1st(expr)
+    coord_sys = _find_coords(expr).pop()
+    indices = list(range(coord_sys.dim))
+    # XXX workaround, inverting a matrix does not work if it contains non
+    # symbols
+    #matrix = twoform_to_matrix(expr).inv()
+    matrix = twoform_to_matrix(expr)
+    s_fields = set()
+    for e in matrix:
+        s_fields.update(e.atoms(BaseScalarField))
+    s_fields = list(s_fields)
+    dums = coord_sys.symbols
+    matrix = matrix.subs(list(zip(s_fields, dums))).inv().subs(list(zip(dums, s_fields)))
+    # XXX end of workaround
+    christoffel = [[[Add(*[matrix[i, l]*ch_1st[l, j, k] for l in indices])
+                     for k in indices]
+                    for j in indices]
+                   for i in indices]
+    return ImmutableDenseNDimArray(christoffel)
+
+
+def metric_to_Riemann_components(expr):
+    """Return the components of the Riemann tensor expressed in a given basis.
+
+    Given a metric it calculates the components of the Riemann tensor in the
+    canonical basis of the coordinate system in which the metric expression is
+    given.
+
+    Examples
+    ========
+
+    >>> from sympy import exp
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.diffgeom import metric_to_Riemann_components, TensorProduct
+    >>> TP = TensorProduct
+
+    >>> metric_to_Riemann_components(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[[[0, 0], [0, 0]], [[0, 0], [0, 0]]], [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]]
+    >>> non_trivial_metric = exp(2*R2.r)*TP(R2.dr, R2.dr) + \
+        R2.r**2*TP(R2.dtheta, R2.dtheta)
+    >>> non_trivial_metric
+    exp(2*rho)*TensorProduct(drho, drho) + rho**2*TensorProduct(dtheta, dtheta)
+    >>> riemann = metric_to_Riemann_components(non_trivial_metric)
+    >>> riemann[0, :, :, :]
+    [[[0, 0], [0, 0]], [[0, exp(-2*rho)*rho], [-exp(-2*rho)*rho, 0]]]
+    >>> riemann[1, :, :, :]
+    [[[0, -1/rho], [1/rho, 0]], [[0, 0], [0, 0]]]
+
+    """
+    ch_2nd = metric_to_Christoffel_2nd(expr)
+    coord_sys = _find_coords(expr).pop()
+    indices = list(range(coord_sys.dim))
+    deriv_ch = [[[[d(ch_2nd[i, j, k])
+                   for d in coord_sys.base_vectors()]
+                  for k in indices]
+                 for j in indices]
+                for i in indices]
+    riemann_a = [[[[deriv_ch[rho][sig][nu][mu] - deriv_ch[rho][sig][mu][nu]
+                    for nu in indices]
+                   for mu in indices]
+                  for sig in indices]
+                     for rho in indices]
+    riemann_b = [[[[Add(*[ch_2nd[rho, l, mu]*ch_2nd[l, sig, nu] - ch_2nd[rho, l, nu]*ch_2nd[l, sig, mu] for l in indices])
+                    for nu in indices]
+                   for mu in indices]
+                  for sig in indices]
+                 for rho in indices]
+    riemann = [[[[riemann_a[rho][sig][mu][nu] + riemann_b[rho][sig][mu][nu]
+                  for nu in indices]
+                     for mu in indices]
+                for sig in indices]
+               for rho in indices]
+    return ImmutableDenseNDimArray(riemann)
+
+
+def metric_to_Ricci_components(expr):
+
+    """Return the components of the Ricci tensor expressed in a given basis.
+
+    Given a metric it calculates the components of the Ricci tensor in the
+    canonical basis of the coordinate system in which the metric expression is
+    given.
+
+    Examples
+    ========
+
+    >>> from sympy import exp
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.diffgeom import metric_to_Ricci_components, TensorProduct
+    >>> TP = TensorProduct
+
+    >>> metric_to_Ricci_components(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[0, 0], [0, 0]]
+    >>> non_trivial_metric = exp(2*R2.r)*TP(R2.dr, R2.dr) + \
+                             R2.r**2*TP(R2.dtheta, R2.dtheta)
+    >>> non_trivial_metric
+    exp(2*rho)*TensorProduct(drho, drho) + rho**2*TensorProduct(dtheta, dtheta)
+    >>> metric_to_Ricci_components(non_trivial_metric)
+    [[1/rho, 0], [0, exp(-2*rho)*rho]]
+
+    """
+    riemann = metric_to_Riemann_components(expr)
+    coord_sys = _find_coords(expr).pop()
+    indices = list(range(coord_sys.dim))
+    ricci = [[Add(*[riemann[k, i, k, j] for k in indices])
+              for j in indices]
+             for i in indices]
+    return ImmutableDenseNDimArray(ricci)
+
+###############################################################################
+# Classes for deprecation
+###############################################################################
+
+class _deprecated_container:
+    # This class gives deprecation warning.
+    # When deprecated features are completely deleted, this should be removed as well.
+    # See https://github.com/sympy/sympy/pull/19368
+    def __init__(self, message, data):
+        super().__init__(data)
+        self.message = message
+
+    def warn(self):
+        sympy_deprecation_warning(
+            self.message,
+            deprecated_since_version="1.7",
+            active_deprecations_target="deprecated-diffgeom-mutable",
+            stacklevel=4
+        )
+
+    def __iter__(self):
+        self.warn()
+        return super().__iter__()
+
+    def __getitem__(self, key):
+        self.warn()
+        return super().__getitem__(key)
+
+    def __contains__(self, key):
+        self.warn()
+        return super().__contains__(key)
+
+
+class _deprecated_list(_deprecated_container, list):
+    pass
+
+
+class _deprecated_dict(_deprecated_container, dict):
+    pass
+
+
+# Import at end to avoid cyclic imports
+from sympy.simplify.simplify import simplify

env-llmeval/lib/python3.10/site-packages/sympy/diffgeom/tests/test_function_diffgeom_book.py

@@ -0,0 +1,145 @@
+from sympy.diffgeom.rn import R2, R2_p, R2_r, R3_r
+from sympy.diffgeom import intcurve_series, Differential, WedgeProduct
+from sympy.core import symbols, Function, Derivative
+from sympy.simplify import trigsimp, simplify
+from sympy.functions import sqrt, atan2, sin, cos
+from sympy.matrices import Matrix
+
+# Most of the functionality is covered in the
+# test_functional_diffgeom_ch* tests which are based on the
+# example from the paper of Sussman and Wisdom.
+# If they do not cover something, additional tests are added in other test
+# functions.
+
+# From "Functional Differential Geometry" as of 2011
+# by Sussman and Wisdom.
+
+
+def test_functional_diffgeom_ch2():
+    x0, y0, r0, theta0 = symbols('x0, y0, r0, theta0', real=True)
+    x, y = symbols('x, y', real=True)
+    f = Function('f')
+
+    assert (R2_p.point_to_coords(R2_r.point([x0, y0])) ==
+           Matrix([sqrt(x0**2 + y0**2), atan2(y0, x0)]))
+    assert (R2_r.point_to_coords(R2_p.point([r0, theta0])) ==
+           Matrix([r0*cos(theta0), r0*sin(theta0)]))
+
+    assert R2_p.jacobian(R2_r, [r0, theta0]) == Matrix(
+        [[cos(theta0), -r0*sin(theta0)], [sin(theta0), r0*cos(theta0)]])
+
+    field = f(R2.x, R2.y)
+    p1_in_rect = R2_r.point([x0, y0])
+    p1_in_polar = R2_p.point([sqrt(x0**2 + y0**2), atan2(y0, x0)])
+    assert field.rcall(p1_in_rect) == f(x0, y0)
+    assert field.rcall(p1_in_polar) == f(x0, y0)
+
+    p_r = R2_r.point([x0, y0])
+    p_p = R2_p.point([r0, theta0])
+    assert R2.x(p_r) == x0
+    assert R2.x(p_p) == r0*cos(theta0)
+    assert R2.r(p_p) == r0
+    assert R2.r(p_r) == sqrt(x0**2 + y0**2)
+    assert R2.theta(p_r) == atan2(y0, x0)
+
+    h = R2.x*R2.r**2 + R2.y**3
+    assert h.rcall(p_r) == x0*(x0**2 + y0**2) + y0**3
+    assert h.rcall(p_p) == r0**3*sin(theta0)**3 + r0**3*cos(theta0)
+
+
+def test_functional_diffgeom_ch3():
+    x0, y0 = symbols('x0, y0', real=True)
+    x, y, t = symbols('x, y, t', real=True)
+    f = Function('f')
+    b1 = Function('b1')
+    b2 = Function('b2')
+    p_r = R2_r.point([x0, y0])
+
+    s_field = f(R2.x, R2.y)
+    v_field = b1(R2.x)*R2.e_x + b2(R2.y)*R2.e_y
+    assert v_field.rcall(s_field).rcall(p_r).doit() == b1(
+        x0)*Derivative(f(x0, y0), x0) + b2(y0)*Derivative(f(x0, y0), y0)
+
+    assert R2.e_x(R2.r**2).rcall(p_r) == 2*x0
+    v = R2.e_x + 2*R2.e_y
+    s = R2.r**2 + 3*R2.x
+    assert v.rcall(s).rcall(p_r).doit() == 2*x0 + 4*y0 + 3
+
+    circ = -R2.y*R2.e_x + R2.x*R2.e_y
+    series = intcurve_series(circ, t, R2_r.point([1, 0]), coeffs=True)
+    series_x, series_y = zip(*series)
+    assert all(
+        [term == cos(t).taylor_term(i, t) for i, term in enumerate(series_x)])
+    assert all(
+        [term == sin(t).taylor_term(i, t) for i, term in enumerate(series_y)])
+
+
+def test_functional_diffgeom_ch4():
+    x0, y0, theta0 = symbols('x0, y0, theta0', real=True)
+    x, y, r, theta = symbols('x, y, r, theta', real=True)
+    r0 = symbols('r0', positive=True)
+    f = Function('f')
+    b1 = Function('b1')
+    b2 = Function('b2')
+    p_r = R2_r.point([x0, y0])
+    p_p = R2_p.point([r0, theta0])
+
+    f_field = b1(R2.x, R2.y)*R2.dx + b2(R2.x, R2.y)*R2.dy
+    assert f_field.rcall(R2.e_x).rcall(p_r) == b1(x0, y0)
+    assert f_field.rcall(R2.e_y).rcall(p_r) == b2(x0, y0)
+
+    s_field_r = f(R2.x, R2.y)
+    df = Differential(s_field_r)
+    assert df(R2.e_x).rcall(p_r).doit() == Derivative(f(x0, y0), x0)
+    assert df(R2.e_y).rcall(p_r).doit() == Derivative(f(x0, y0), y0)
+
+    s_field_p = f(R2.r, R2.theta)
+    df = Differential(s_field_p)
+    assert trigsimp(df(R2.e_x).rcall(p_p).doit()) == (
+        cos(theta0)*Derivative(f(r0, theta0), r0) -
+        sin(theta0)*Derivative(f(r0, theta0), theta0)/r0)
+    assert trigsimp(df(R2.e_y).rcall(p_p).doit()) == (
+        sin(theta0)*Derivative(f(r0, theta0), r0) +
+        cos(theta0)*Derivative(f(r0, theta0), theta0)/r0)
+
+    assert R2.dx(R2.e_x).rcall(p_r) == 1
+    assert R2.dx(R2.e_x) == 1
+    assert R2.dx(R2.e_y).rcall(p_r) == 0
+    assert R2.dx(R2.e_y) == 0
+
+    circ = -R2.y*R2.e_x + R2.x*R2.e_y
+    assert R2.dx(circ).rcall(p_r).doit() == -y0
+    assert R2.dy(circ).rcall(p_r) == x0
+    assert R2.dr(circ).rcall(p_r) == 0
+    assert simplify(R2.dtheta(circ).rcall(p_r)) == 1
+
+    assert (circ - R2.e_theta).rcall(s_field_r).rcall(p_r) == 0
+
+
+def test_functional_diffgeom_ch6():
+    u0, u1, u2, v0, v1, v2, w0, w1, w2 = symbols('u0:3, v0:3, w0:3', real=True)
+
+    u = u0*R2.e_x + u1*R2.e_y
+    v = v0*R2.e_x + v1*R2.e_y
+    wp = WedgeProduct(R2.dx, R2.dy)
+    assert wp(u, v) == u0*v1 - u1*v0
+
+    u = u0*R3_r.e_x + u1*R3_r.e_y + u2*R3_r.e_z
+    v = v0*R3_r.e_x + v1*R3_r.e_y + v2*R3_r.e_z
+    w = w0*R3_r.e_x + w1*R3_r.e_y + w2*R3_r.e_z
+    wp = WedgeProduct(R3_r.dx, R3_r.dy, R3_r.dz)
+    assert wp(
+        u, v, w) == Matrix(3, 3, [u0, u1, u2, v0, v1, v2, w0, w1, w2]).det()
+
+    a, b, c = symbols('a, b, c', cls=Function)
+    a_f = a(R3_r.x, R3_r.y, R3_r.z)
+    b_f = b(R3_r.x, R3_r.y, R3_r.z)
+    c_f = c(R3_r.x, R3_r.y, R3_r.z)
+    theta = a_f*R3_r.dx + b_f*R3_r.dy + c_f*R3_r.dz
+    dtheta = Differential(theta)
+    da = Differential(a_f)
+    db = Differential(b_f)
+    dc = Differential(c_f)
+    expr = dtheta - WedgeProduct(
+        da, R3_r.dx) - WedgeProduct(db, R3_r.dy) - WedgeProduct(dc, R3_r.dz)
+    assert expr.rcall(R3_r.e_x, R3_r.e_y) == 0

env-llmeval/lib/python3.10/site-packages/sympy/diffgeom/tests/test_hyperbolic_space.py

@@ -0,0 +1,91 @@
+r'''
+unit test describing the hyperbolic half-plane with the Poincare metric. This
+is a basic model of hyperbolic geometry on the (positive) half-space
+
+{(x,y) \in R^2 | y > 0}
+
+with the Riemannian metric
+
+ds^2 = (dx^2 + dy^2)/y^2
+
+It has constant negative scalar curvature = -2
+
+https://en.wikipedia.org/wiki/Poincare_half-plane_model
+'''
+from sympy.matrices.dense import diag
+from sympy.diffgeom import (twoform_to_matrix,
+                            metric_to_Christoffel_1st, metric_to_Christoffel_2nd,
+                            metric_to_Riemann_components, metric_to_Ricci_components)
+import sympy.diffgeom.rn
+from sympy.tensor.array import ImmutableDenseNDimArray
+
+
+def test_H2():
+    TP = sympy.diffgeom.TensorProduct
+    R2 = sympy.diffgeom.rn.R2
+    y = R2.y
+    dy = R2.dy
+    dx = R2.dx
+    g = (TP(dx, dx) + TP(dy, dy))*y**(-2)
+    automat = twoform_to_matrix(g)
+    mat = diag(y**(-2), y**(-2))
+    assert mat == automat
+
+    gamma1 = metric_to_Christoffel_1st(g)
+    assert gamma1[0, 0, 0] == 0
+    assert gamma1[0, 0, 1] == -y**(-3)
+    assert gamma1[0, 1, 0] == -y**(-3)
+    assert gamma1[0, 1, 1] == 0
+
+    assert gamma1[1, 1, 1] == -y**(-3)
+    assert gamma1[1, 1, 0] == 0
+    assert gamma1[1, 0, 1] == 0
+    assert gamma1[1, 0, 0] == y**(-3)
+
+    gamma2 = metric_to_Christoffel_2nd(g)
+    assert gamma2[0, 0, 0] == 0
+    assert gamma2[0, 0, 1] == -y**(-1)
+    assert gamma2[0, 1, 0] == -y**(-1)
+    assert gamma2[0, 1, 1] == 0
+
+    assert gamma2[1, 1, 1] == -y**(-1)
+    assert gamma2[1, 1, 0] == 0
+    assert gamma2[1, 0, 1] == 0
+    assert gamma2[1, 0, 0] == y**(-1)
+
+    Rm = metric_to_Riemann_components(g)
+    assert Rm[0, 0, 0, 0] == 0
+    assert Rm[0, 0, 0, 1] == 0
+    assert Rm[0, 0, 1, 0] == 0
+    assert Rm[0, 0, 1, 1] == 0
+
+    assert Rm[0, 1, 0, 0] == 0
+    assert Rm[0, 1, 0, 1] == -y**(-2)
+    assert Rm[0, 1, 1, 0] == y**(-2)
+    assert Rm[0, 1, 1, 1] == 0
+
+    assert Rm[1, 0, 0, 0] == 0
+    assert Rm[1, 0, 0, 1] == y**(-2)
+    assert Rm[1, 0, 1, 0] == -y**(-2)
+    assert Rm[1, 0, 1, 1] == 0
+
+    assert Rm[1, 1, 0, 0] == 0
+    assert Rm[1, 1, 0, 1] == 0
+    assert Rm[1, 1, 1, 0] == 0
+    assert Rm[1, 1, 1, 1] == 0
+
+    Ric = metric_to_Ricci_components(g)
+    assert Ric[0, 0] == -y**(-2)
+    assert Ric[0, 1] == 0
+    assert Ric[1, 0] == 0
+    assert Ric[0, 0] == -y**(-2)
+
+    assert Ric == ImmutableDenseNDimArray([-y**(-2), 0, 0, -y**(-2)], (2, 2))
+
+    ## scalar curvature is -2
+    #TODO - it would be nice to have index contraction built-in
+    R = (Ric[0, 0] + Ric[1, 1])*y**2
+    assert R == -2
+
+    ## Gauss curvature is -1
+    assert R/2 == -1

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/expressions/array_expressions.py

@@ -0,0 +1,1967 @@
+import collections.abc
+import operator
+from collections import defaultdict, Counter
+from functools import reduce
+import itertools
+from itertools import accumulate
+from typing import Optional, List, Tuple as tTuple
+
+import typing
+
+from sympy.core.numbers import Integer
+from sympy.core.relational import Equality
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.function import (Function, Lambda)
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.matrices.common import MatrixCommon
+from sympy.matrices.expressions.diagonal import diagonalize_vector
+from sympy.matrices.expressions.matexpr import MatrixExpr
+from sympy.matrices.expressions.special import ZeroMatrix
+from sympy.tensor.array.arrayop import (permutedims, tensorcontraction, tensordiagonal, tensorproduct)
+from sympy.tensor.array.dense_ndim_array import ImmutableDenseNDimArray
+from sympy.tensor.array.ndim_array import NDimArray
+from sympy.tensor.indexed import (Indexed, IndexedBase)
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.tensor.array.expressions.utils import _apply_recursively_over_nested_lists, _sort_contraction_indices, \
+    _get_mapping_from_subranks, _build_push_indices_up_func_transformation, _get_contraction_links, \
+    _build_push_indices_down_func_transformation
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.permutations import _af_invert
+from sympy.core.sympify import _sympify
+
+
+class _ArrayExpr(Expr):
+    shape: tTuple[Expr, ...]
+
+    def __getitem__(self, item):
+        if not isinstance(item, collections.abc.Iterable):
+            item = (item,)
+        ArrayElement._check_shape(self, item)
+        return self._get(item)
+
+    def _get(self, item):
+        return _get_array_element_or_slice(self, item)
+
+
+class ArraySymbol(_ArrayExpr):
+    """
+    Symbol representing an array expression
+    """
+
+    def __new__(cls, symbol, shape: typing.Iterable) -> "ArraySymbol":
+        if isinstance(symbol, str):
+            symbol = Symbol(symbol)
+        # symbol = _sympify(symbol)
+        shape = Tuple(*map(_sympify, shape))
+        obj = Expr.__new__(cls, symbol, shape)
+        return obj
+
+    @property
+    def name(self):
+        return self._args[0]
+
+    @property
+    def shape(self):
+        return self._args[1]
+
+    def as_explicit(self):
+        if not all(i.is_Integer for i in self.shape):
+            raise ValueError("cannot express explicit array with symbolic shape")
+        data = [self[i] for i in itertools.product(*[range(j) for j in self.shape])]
+        return ImmutableDenseNDimArray(data).reshape(*self.shape)
+
+
+class ArrayElement(Expr):
+    """
+    An element of an array.
+    """
+
+    _diff_wrt = True
+    is_symbol = True
+    is_commutative = True
+
+    def __new__(cls, name, indices):
+        if isinstance(name, str):
+            name = Symbol(name)
+        name = _sympify(name)
+        if not isinstance(indices, collections.abc.Iterable):
+            indices = (indices,)
+        indices = _sympify(tuple(indices))
+        cls._check_shape(name, indices)
+        obj = Expr.__new__(cls, name, indices)
+        return obj
+
+    @classmethod
+    def _check_shape(cls, name, indices):
+        indices = tuple(indices)
+        if hasattr(name, "shape"):
+            index_error = IndexError("number of indices does not match shape of the array")
+            if len(indices) != len(name.shape):
+                raise index_error
+            if any((i >= s) == True for i, s in zip(indices, name.shape)):
+                raise ValueError("shape is out of bounds")
+        if any((i < 0) == True for i in indices):
+            raise ValueError("shape contains negative values")
+
+    @property
+    def name(self):
+        return self._args[0]
+
+    @property
+    def indices(self):
+        return self._args[1]
+
+    def _eval_derivative(self, s):
+        if not isinstance(s, ArrayElement):
+            return S.Zero
+
+        if s == self:
+            return S.One
+
+        if s.name != self.name:
+            return S.Zero
+
+        return Mul.fromiter(KroneckerDelta(i, j) for i, j in zip(self.indices, s.indices))
+
+
+class ZeroArray(_ArrayExpr):
+    """
+    Symbolic array of zeros. Equivalent to ``ZeroMatrix`` for matrices.
+    """
+
+    def __new__(cls, *shape):
+        if len(shape) == 0:
+            return S.Zero
+        shape = map(_sympify, shape)
+        obj = Expr.__new__(cls, *shape)
+        return obj
+
+    @property
+    def shape(self):
+        return self._args
+
+    def as_explicit(self):
+        if not all(i.is_Integer for i in self.shape):
+            raise ValueError("Cannot return explicit form for symbolic shape.")
+        return ImmutableDenseNDimArray.zeros(*self.shape)
+
+    def _get(self, item):
+        return S.Zero
+
+
+class OneArray(_ArrayExpr):
+    """
+    Symbolic array of ones.
+    """
+
+    def __new__(cls, *shape):
+        if len(shape) == 0:
+            return S.One
+        shape = map(_sympify, shape)
+        obj = Expr.__new__(cls, *shape)
+        return obj
+
+    @property
+    def shape(self):
+        return self._args
+
+    def as_explicit(self):
+        if not all(i.is_Integer for i in self.shape):
+            raise ValueError("Cannot return explicit form for symbolic shape.")
+        return ImmutableDenseNDimArray([S.One for i in range(reduce(operator.mul, self.shape))]).reshape(*self.shape)
+
+    def _get(self, item):
+        return S.One
+
+
+class _CodegenArrayAbstract(Basic):
+
+    @property
+    def subranks(self):
+        """
+        Returns the ranks of the objects in the uppermost tensor product inside
+        the current object.  In case no tensor products are contained, return
+        the atomic ranks.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import tensorproduct, tensorcontraction
+        >>> from sympy import MatrixSymbol
+        >>> M = MatrixSymbol("M", 3, 3)
+        >>> N = MatrixSymbol("N", 3, 3)
+        >>> P = MatrixSymbol("P", 3, 3)
+
+        Important: do not confuse the rank of the matrix with the rank of an array.
+
+        >>> tp = tensorproduct(M, N, P)
+        >>> tp.subranks
+        [2, 2, 2]
+
+        >>> co = tensorcontraction(tp, (1, 2), (3, 4))
+        >>> co.subranks
+        [2, 2, 2]
+        """
+        return self._subranks[:]
+
+    def subrank(self):
+        """
+        The sum of ``subranks``.
+        """
+        return sum(self.subranks)
+
+    @property
+    def shape(self):
+        return self._shape
+
+    def doit(self, **hints):
+        deep = hints.get("deep", True)
+        if deep:
+            return self.func(*[arg.doit(**hints) for arg in self.args])._canonicalize()
+        else:
+            return self._canonicalize()
+
+class ArrayTensorProduct(_CodegenArrayAbstract):
+    r"""
+    Class to represent the tensor product of array-like objects.
+    """
+
+    def __new__(cls, *args, **kwargs):
+        args = [_sympify(arg) for arg in args]
+
+        canonicalize = kwargs.pop("canonicalize", False)
+
+        ranks = [get_rank(arg) for arg in args]
+
+        obj = Basic.__new__(cls, *args)
+        obj._subranks = ranks
+        shapes = [get_shape(i) for i in args]
+
+        if any(i is None for i in shapes):
+            obj._shape = None
+        else:
+            obj._shape = tuple(j for i in shapes for j in i)
+        if canonicalize:
+            return obj._canonicalize()
+        return obj
+
+    def _canonicalize(self):
+        args = self.args
+        args = self._flatten(args)
+
+        ranks = [get_rank(arg) for arg in args]
+
+        # Check if there are nested permutation and lift them up:
+        permutation_cycles = []
+        for i, arg in enumerate(args):
+            if not isinstance(arg, PermuteDims):
+                continue
+            permutation_cycles.extend([[k + sum(ranks[:i]) for k in j] for j in arg.permutation.cyclic_form])
+            args[i] = arg.expr
+        if permutation_cycles:
+            return _permute_dims(_array_tensor_product(*args), Permutation(sum(ranks)-1)*Permutation(permutation_cycles))
+
+        if len(args) == 1:
+            return args[0]
+
+        # If any object is a ZeroArray, return a ZeroArray:
+        if any(isinstance(arg, (ZeroArray, ZeroMatrix)) for arg in args):
+            shapes = reduce(operator.add, [get_shape(i) for i in args], ())
+            return ZeroArray(*shapes)
+
+        # If there are contraction objects inside, transform the whole
+        # expression into `ArrayContraction`:
+        contractions = {i: arg for i, arg in enumerate(args) if isinstance(arg, ArrayContraction)}
+        if contractions:
+            ranks = [_get_subrank(arg) if isinstance(arg, ArrayContraction) else get_rank(arg) for arg in args]
+            cumulative_ranks = list(accumulate([0] + ranks))[:-1]
+            tp = _array_tensor_product(*[arg.expr if isinstance(arg, ArrayContraction) else arg for arg in args])
+            contraction_indices = [tuple(cumulative_ranks[i] + k for k in j) for i, arg in contractions.items() for j in arg.contraction_indices]
+            return _array_contraction(tp, *contraction_indices)
+
+        diagonals = {i: arg for i, arg in enumerate(args) if isinstance(arg, ArrayDiagonal)}
+        if diagonals:
+            inverse_permutation = []
+            last_perm = []
+            ranks = [get_rank(arg) for arg in args]
+            cumulative_ranks = list(accumulate([0] + ranks))[:-1]
+            for i, arg in enumerate(args):
+                if isinstance(arg, ArrayDiagonal):
+                    i1 = get_rank(arg) - len(arg.diagonal_indices)
+                    i2 = len(arg.diagonal_indices)
+                    inverse_permutation.extend([cumulative_ranks[i] + j for j in range(i1)])
+                    last_perm.extend([cumulative_ranks[i] + j for j in range(i1, i1 + i2)])
+                else:
+                    inverse_permutation.extend([cumulative_ranks[i] + j for j in range(get_rank(arg))])
+            inverse_permutation.extend(last_perm)
+            tp = _array_tensor_product(*[arg.expr if isinstance(arg, ArrayDiagonal) else arg for arg in args])
+            ranks2 = [_get_subrank(arg) if isinstance(arg, ArrayDiagonal) else get_rank(arg) for arg in args]
+            cumulative_ranks2 = list(accumulate([0] + ranks2))[:-1]
+            diagonal_indices = [tuple(cumulative_ranks2[i] + k for k in j) for i, arg in diagonals.items() for j in arg.diagonal_indices]
+            return _permute_dims(_array_diagonal(tp, *diagonal_indices), _af_invert(inverse_permutation))
+
+        return self.func(*args, canonicalize=False)
+
+    @classmethod
+    def _flatten(cls, args):
+        args = [i for arg in args for i in (arg.args if isinstance(arg, cls) else [arg])]
+        return args
+
+    def as_explicit(self):
+        return tensorproduct(*[arg.as_explicit() if hasattr(arg, "as_explicit") else arg for arg in self.args])
+
+
+class ArrayAdd(_CodegenArrayAbstract):
+    r"""
+    Class for elementwise array additions.
+    """
+
+    def __new__(cls, *args, **kwargs):
+        args = [_sympify(arg) for arg in args]
+        ranks = [get_rank(arg) for arg in args]
+        ranks = list(set(ranks))
+        if len(ranks) != 1:
+            raise ValueError("summing arrays of different ranks")
+        shapes = [arg.shape for arg in args]
+        if len({i for i in shapes if i is not None}) > 1:
+            raise ValueError("mismatching shapes in addition")
+
+        canonicalize = kwargs.pop("canonicalize", False)
+
+        obj = Basic.__new__(cls, *args)
+        obj._subranks = ranks
+        if any(i is None for i in shapes):
+            obj._shape = None
+        else:
+            obj._shape = shapes[0]
+        if canonicalize:
+            return obj._canonicalize()
+        return obj
+
+    def _canonicalize(self):
+        args = self.args
+
+        # Flatten:
+        args = self._flatten_args(args)
+
+        shapes = [get_shape(arg) for arg in args]
+        args = [arg for arg in args if not isinstance(arg, (ZeroArray, ZeroMatrix))]
+        if len(args) == 0:
+            if any(i for i in shapes if i is None):
+                raise NotImplementedError("cannot handle addition of ZeroMatrix/ZeroArray and undefined shape object")
+            return ZeroArray(*shapes[0])
+        elif len(args) == 1:
+            return args[0]
+        return self.func(*args, canonicalize=False)
+
+    @classmethod
+    def _flatten_args(cls, args):
+        new_args = []
+        for arg in args:
+            if isinstance(arg, ArrayAdd):
+                new_args.extend(arg.args)
+            else:
+                new_args.append(arg)
+        return new_args
+
+    def as_explicit(self):
+        return reduce(
+            operator.add,
+            [arg.as_explicit() if hasattr(arg, "as_explicit") else arg for arg in self.args])
+
+
+class PermuteDims(_CodegenArrayAbstract):
+    r"""
+    Class to represent permutation of axes of arrays.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array import permutedims
+    >>> from sympy import MatrixSymbol
+    >>> M = MatrixSymbol("M", 3, 3)
+    >>> cg = permutedims(M, [1, 0])
+
+    The object ``cg`` represents the transposition of ``M``, as the permutation
+    ``[1, 0]`` will act on its indices by switching them:
+
+    `M_{ij} \Rightarrow M_{ji}`
+
+    This is evident when transforming back to matrix form:
+
+    >>> from sympy.tensor.array.expressions.from_array_to_matrix import convert_array_to_matrix
+    >>> convert_array_to_matrix(cg)
+    M.T
+
+    >>> N = MatrixSymbol("N", 3, 2)
+    >>> cg = permutedims(N, [1, 0])
+    >>> cg.shape
+    (2, 3)
+
+    There are optional parameters that can be used as alternative to the permutation:
+
+    >>> from sympy.tensor.array.expressions import ArraySymbol, PermuteDims
+    >>> M = ArraySymbol("M", (1, 2, 3, 4, 5))
+    >>> expr = PermuteDims(M, index_order_old="ijklm", index_order_new="kijml")
+    >>> expr
+    PermuteDims(M, (0 2 1)(3 4))
+    >>> expr.shape
+    (3, 1, 2, 5, 4)
+
+    Permutations of tensor products are simplified in order to achieve a
+    standard form:
+
+    >>> from sympy.tensor.array import tensorproduct
+    >>> M = MatrixSymbol("M", 4, 5)
+    >>> tp = tensorproduct(M, N)
+    >>> tp.shape
+    (4, 5, 3, 2)
+    >>> perm1 = permutedims(tp, [2, 3, 1, 0])
+
+    The args ``(M, N)`` have been sorted and the permutation has been
+    simplified, the expression is equivalent:
+
+    >>> perm1.expr.args
+    (N, M)
+    >>> perm1.shape
+    (3, 2, 5, 4)
+    >>> perm1.permutation
+    (2 3)
+
+    The permutation in its array form has been simplified from
+    ``[2, 3, 1, 0]`` to ``[0, 1, 3, 2]``, as the arguments of the tensor
+    product `M` and `N` have been switched:
+
+    >>> perm1.permutation.array_form
+    [0, 1, 3, 2]
+
+    We can nest a second permutation:
+
+    >>> perm2 = permutedims(perm1, [1, 0, 2, 3])
+    >>> perm2.shape
+    (2, 3, 5, 4)
+    >>> perm2.permutation.array_form
+    [1, 0, 3, 2]
+    """
+
+    def __new__(cls, expr, permutation=None, index_order_old=None, index_order_new=None, **kwargs):
+        from sympy.combinatorics import Permutation
+        expr = _sympify(expr)
+        expr_rank = get_rank(expr)
+        permutation = cls._get_permutation_from_arguments(permutation, index_order_old, index_order_new, expr_rank)
+        permutation = Permutation(permutation)
+        permutation_size = permutation.size
+        if permutation_size != expr_rank:
+            raise ValueError("Permutation size must be the length of the shape of expr")
+
+        canonicalize = kwargs.pop("canonicalize", False)
+
+        obj = Basic.__new__(cls, expr, permutation)
+        obj._subranks = [get_rank(expr)]
+        shape = get_shape(expr)
+        if shape is None:
+            obj._shape = None
+        else:
+            obj._shape = tuple(shape[permutation(i)] for i in range(len(shape)))
+        if canonicalize:
+            return obj._canonicalize()
+        return obj
+
+    def _canonicalize(self):
+        expr = self.expr
+        permutation = self.permutation
+        if isinstance(expr, PermuteDims):
+            subexpr = expr.expr
+            subperm = expr.permutation
+            permutation = permutation * subperm
+            expr = subexpr
+        if isinstance(expr, ArrayContraction):
+            expr, permutation = self._PermuteDims_denestarg_ArrayContraction(expr, permutation)
+        if isinstance(expr, ArrayTensorProduct):
+            expr, permutation = self._PermuteDims_denestarg_ArrayTensorProduct(expr, permutation)
+        if isinstance(expr, (ZeroArray, ZeroMatrix)):
+            return ZeroArray(*[expr.shape[i] for i in permutation.array_form])
+        plist = permutation.array_form
+        if plist == sorted(plist):
+            return expr
+        return self.func(expr, permutation, canonicalize=False)
+
+    @property
+    def expr(self):
+        return self.args[0]
+
+    @property
+    def permutation(self):
+        return self.args[1]
+
+    @classmethod
+    def _PermuteDims_denestarg_ArrayTensorProduct(cls, expr, permutation):
+        # Get the permutation in its image-form:
+        perm_image_form = _af_invert(permutation.array_form)
+        args = list(expr.args)
+        # Starting index global position for every arg:
+        cumul = list(accumulate([0] + expr.subranks))
+        # Split `perm_image_form` into a list of list corresponding to the indices
+        # of every argument:
+        perm_image_form_in_components = [perm_image_form[cumul[i]:cumul[i+1]] for i in range(len(args))]
+        # Create an index, target-position-key array:
+        ps = [(i, sorted(comp)) for i, comp in enumerate(perm_image_form_in_components)]
+        # Sort the array according to the target-position-key:
+        # In this way, we define a canonical way to sort the arguments according
+        # to the permutation.
+        ps.sort(key=lambda x: x[1])
+        # Read the inverse-permutation (i.e. image-form) of the args:
+        perm_args_image_form = [i[0] for i in ps]
+        # Apply the args-permutation to the `args`:
+        args_sorted = [args[i] for i in perm_args_image_form]
+        # Apply the args-permutation to the array-form of the permutation of the axes (of `expr`):
+        perm_image_form_sorted_args = [perm_image_form_in_components[i] for i in perm_args_image_form]
+        new_permutation = Permutation(_af_invert([j for i in perm_image_form_sorted_args for j in i]))
+        return _array_tensor_product(*args_sorted), new_permutation
+
+    @classmethod
+    def _PermuteDims_denestarg_ArrayContraction(cls, expr, permutation):
+        if not isinstance(expr, ArrayContraction):
+            return expr, permutation
+        if not isinstance(expr.expr, ArrayTensorProduct):
+            return expr, permutation
+        args = expr.expr.args
+        subranks = [get_rank(arg) for arg in expr.expr.args]
+
+        contraction_indices = expr.contraction_indices
+        contraction_indices_flat = [j for i in contraction_indices for j in i]
+        cumul = list(accumulate([0] + subranks))
+
+        # Spread the permutation in its array form across the args in the corresponding
+        # tensor-product arguments with free indices:
+        permutation_array_blocks_up = []
+        image_form = _af_invert(permutation.array_form)
+        counter = 0
+        for i, e in enumerate(subranks):
+            current = []
+            for j in range(cumul[i], cumul[i+1]):
+                if j in contraction_indices_flat:
+                    continue
+                current.append(image_form[counter])
+                counter += 1
+            permutation_array_blocks_up.append(current)
+
+        # Get the map of axis repositioning for every argument of tensor-product:
+        index_blocks = [list(range(cumul[i], cumul[i+1])) for i, e in enumerate(expr.subranks)]
+        index_blocks_up = expr._push_indices_up(expr.contraction_indices, index_blocks)
+        inverse_permutation = permutation**(-1)
+        index_blocks_up_permuted = [[inverse_permutation(j) for j in i if j is not None] for i in index_blocks_up]
+
+        # Sorting key is a list of tuple, first element is the index of `args`, second element of
+        # the tuple is the sorting key to sort `args` of the tensor product:
+        sorting_keys = list(enumerate(index_blocks_up_permuted))
+        sorting_keys.sort(key=lambda x: x[1])
+
+        # Now we can get the permutation acting on the args in its image-form:
+        new_perm_image_form = [i[0] for i in sorting_keys]
+        # Apply the args-level permutation to various elements:
+        new_index_blocks = [index_blocks[i] for i in new_perm_image_form]
+        new_index_perm_array_form = _af_invert([j for i in new_index_blocks for j in i])
+        new_args = [args[i] for i in new_perm_image_form]
+        new_contraction_indices = [tuple(new_index_perm_array_form[j] for j in i) for i in contraction_indices]
+        new_expr = _array_contraction(_array_tensor_product(*new_args), *new_contraction_indices)
+        new_permutation = Permutation(_af_invert([j for i in [permutation_array_blocks_up[k] for k in new_perm_image_form] for j in i]))
+        return new_expr, new_permutation
+
+    @classmethod
+    def _check_permutation_mapping(cls, expr, permutation):
+        subranks = expr.subranks
+        index2arg = [i for i, arg in enumerate(expr.args) for j in range(expr.subranks[i])]
+        permuted_indices = [permutation(i) for i in range(expr.subrank())]
+        new_args = list(expr.args)
+        arg_candidate_index = index2arg[permuted_indices[0]]
+        current_indices = []
+        new_permutation = []
+        inserted_arg_cand_indices = set()
+        for i, idx in enumerate(permuted_indices):
+            if index2arg[idx] != arg_candidate_index:
+                new_permutation.extend(current_indices)
+                current_indices = []
+                arg_candidate_index = index2arg[idx]
+            current_indices.append(idx)
+            arg_candidate_rank = subranks[arg_candidate_index]
+            if len(current_indices) == arg_candidate_rank:
+                new_permutation.extend(sorted(current_indices))
+                local_current_indices = [j - min(current_indices) for j in current_indices]
+                i1 = index2arg[i]
+                new_args[i1] = _permute_dims(new_args[i1], Permutation(local_current_indices))
+                inserted_arg_cand_indices.add(arg_candidate_index)
+                current_indices = []
+        new_permutation.extend(current_indices)
+
+        # TODO: swap args positions in order to simplify the expression:
+        # TODO: this should be in a function
+        args_positions = list(range(len(new_args)))
+        # Get possible shifts:
+        maps = {}
+        cumulative_subranks = [0] + list(accumulate(subranks))
+        for i in range(len(subranks)):
+            s = {index2arg[new_permutation[j]] for j in range(cumulative_subranks[i], cumulative_subranks[i+1])}
+            if len(s) != 1:
+                continue
+            elem = next(iter(s))
+            if i != elem:
+                maps[i] = elem
+
+        # Find cycles in the map:
+        lines = []
+        current_line = []
+        while maps:
+            if len(current_line) == 0:
+                k, v = maps.popitem()
+                current_line.append(k)
+            else:
+                k = current_line[-1]
+                if k not in maps:
+                    current_line = []
+                    continue
+                v = maps.pop(k)
+            if v in current_line:
+                lines.append(current_line)
+                current_line = []
+                continue
+            current_line.append(v)
+        for line in lines:
+            for i, e in enumerate(line):
+                args_positions[line[(i + 1) % len(line)]] = e
+
+        # TODO: function in order to permute the args:
+        permutation_blocks = [[new_permutation[cumulative_subranks[i] + j] for j in range(e)] for i, e in enumerate(subranks)]
+        new_args = [new_args[i] for i in args_positions]
+        new_permutation_blocks = [permutation_blocks[i] for i in args_positions]
+        new_permutation2 = [j for i in new_permutation_blocks for j in i]
+        return _array_tensor_product(*new_args), Permutation(new_permutation2)  # **(-1)
+
+    @classmethod
+    def _check_if_there_are_closed_cycles(cls, expr, permutation):
+        args = list(expr.args)
+        subranks = expr.subranks
+        cyclic_form = permutation.cyclic_form
+        cumulative_subranks = [0] + list(accumulate(subranks))
+        cyclic_min = [min(i) for i in cyclic_form]
+        cyclic_max = [max(i) for i in cyclic_form]
+        cyclic_keep = []
+        for i, cycle in enumerate(cyclic_form):
+            flag = True
+            for j in range(len(cumulative_subranks) - 1):
+                if cyclic_min[i] >= cumulative_subranks[j] and cyclic_max[i] < cumulative_subranks[j+1]:
+                    # Found a sinkable cycle.
+                    args[j] = _permute_dims(args[j], Permutation([[k - cumulative_subranks[j] for k in cyclic_form[i]]]))
+                    flag = False
+                    break
+            if flag:
+                cyclic_keep.append(cyclic_form[i])
+        return _array_tensor_product(*args), Permutation(cyclic_keep, size=permutation.size)
+
+    def nest_permutation(self):
+        r"""
+        DEPRECATED.
+        """
+        ret = self._nest_permutation(self.expr, self.permutation)
+        if ret is None:
+            return self
+        return ret
+
+    @classmethod
+    def _nest_permutation(cls, expr, permutation):
+        if isinstance(expr, ArrayTensorProduct):
+            return _permute_dims(*cls._check_if_there_are_closed_cycles(expr, permutation))
+        elif isinstance(expr, ArrayContraction):
+            # Invert tree hierarchy: put the contraction above.
+            cycles = permutation.cyclic_form
+            newcycles = ArrayContraction._convert_outer_indices_to_inner_indices(expr, *cycles)
+            newpermutation = Permutation(newcycles)
+            new_contr_indices = [tuple(newpermutation(j) for j in i) for i in expr.contraction_indices]
+            return _array_contraction(PermuteDims(expr.expr, newpermutation), *new_contr_indices)
+        elif isinstance(expr, ArrayAdd):
+            return _array_add(*[PermuteDims(arg, permutation) for arg in expr.args])
+        return None
+
+    def as_explicit(self):
+        expr = self.expr
+        if hasattr(expr, "as_explicit"):
+            expr = expr.as_explicit()
+        return permutedims(expr, self.permutation)
+
+    @classmethod
+    def _get_permutation_from_arguments(cls, permutation, index_order_old, index_order_new, dim):
+        if permutation is None:
+            if index_order_new is None or index_order_old is None:
+                raise ValueError("Permutation not defined")
+            return PermuteDims._get_permutation_from_index_orders(index_order_old, index_order_new, dim)
+        else:
+            if index_order_new is not None:
+                raise ValueError("index_order_new cannot be defined with permutation")
+            if index_order_old is not None:
+                raise ValueError("index_order_old cannot be defined with permutation")
+            return permutation
+
+    @classmethod
+    def _get_permutation_from_index_orders(cls, index_order_old, index_order_new, dim):
+        if len(set(index_order_new)) != dim:
+            raise ValueError("wrong number of indices in index_order_new")
+        if len(set(index_order_old)) != dim:
+            raise ValueError("wrong number of indices in index_order_old")
+        if len(set.symmetric_difference(set(index_order_new), set(index_order_old))) > 0:
+            raise ValueError("index_order_new and index_order_old must have the same indices")
+        permutation = [index_order_old.index(i) for i in index_order_new]
+        return permutation
+
+
+class ArrayDiagonal(_CodegenArrayAbstract):
+    r"""
+    Class to represent the diagonal operator.
+
+    Explanation
+    ===========
+
+    In a 2-dimensional array it returns the diagonal, this looks like the
+    operation:
+
+    `A_{ij} \rightarrow A_{ii}`
+
+    The diagonal over axes 1 and 2 (the second and third) of the tensor product
+    of two 2-dimensional arrays `A \otimes B` is
+
+    `\Big[ A_{ab} B_{cd} \Big]_{abcd} \rightarrow \Big[ A_{ai} B_{id} \Big]_{adi}`
+
+    In this last example the array expression has been reduced from
+    4-dimensional to 3-dimensional. Notice that no contraction has occurred,
+    rather there is a new index `i` for the diagonal, contraction would have
+    reduced the array to 2 dimensions.
+
+    Notice that the diagonalized out dimensions are added as new dimensions at
+    the end of the indices.
+    """
+
+    def __new__(cls, expr, *diagonal_indices, **kwargs):
+        expr = _sympify(expr)
+        diagonal_indices = [Tuple(*sorted(i)) for i in diagonal_indices]
+        canonicalize = kwargs.get("canonicalize", False)
+
+        shape = get_shape(expr)
+        if shape is not None:
+            cls._validate(expr, *diagonal_indices, **kwargs)
+            # Get new shape:
+            positions, shape = cls._get_positions_shape(shape, diagonal_indices)
+        else:
+            positions = None
+        if len(diagonal_indices) == 0:
+            return expr
+        obj = Basic.__new__(cls, expr, *diagonal_indices)
+        obj._positions = positions
+        obj._subranks = _get_subranks(expr)
+        obj._shape = shape
+        if canonicalize:
+            return obj._canonicalize()
+        return obj
+
+    def _canonicalize(self):
+        expr = self.expr
+        diagonal_indices = self.diagonal_indices
+        trivial_diags = [i for i in diagonal_indices if len(i) == 1]
+        if len(trivial_diags) > 0:
+            trivial_pos = {e[0]: i for i, e in enumerate(diagonal_indices) if len(e) == 1}
+            diag_pos = {e: i for i, e in enumerate(diagonal_indices) if len(e) > 1}
+            diagonal_indices_short = [i for i in diagonal_indices if len(i) > 1]
+            rank1 = get_rank(self)
+            rank2 = len(diagonal_indices)
+            rank3 = rank1 - rank2
+            inv_permutation = []
+            counter1 = 0
+            indices_down = ArrayDiagonal._push_indices_down(diagonal_indices_short, list(range(rank1)), get_rank(expr))
+            for i in indices_down:
+                if i in trivial_pos:
+                    inv_permutation.append(rank3 + trivial_pos[i])
+                elif isinstance(i, (Integer, int)):
+                    inv_permutation.append(counter1)
+                    counter1 += 1
+                else:
+                    inv_permutation.append(rank3 + diag_pos[i])
+            permutation = _af_invert(inv_permutation)
+            if len(diagonal_indices_short) > 0:
+                return _permute_dims(_array_diagonal(expr, *diagonal_indices_short), permutation)
+            else:
+                return _permute_dims(expr, permutation)
+        if isinstance(expr, ArrayAdd):
+            return self._ArrayDiagonal_denest_ArrayAdd(expr, *diagonal_indices)
+        if isinstance(expr, ArrayDiagonal):
+            return self._ArrayDiagonal_denest_ArrayDiagonal(expr, *diagonal_indices)
+        if isinstance(expr, PermuteDims):
+            return self._ArrayDiagonal_denest_PermuteDims(expr, *diagonal_indices)
+        if isinstance(expr, (ZeroArray, ZeroMatrix)):
+            positions, shape = self._get_positions_shape(expr.shape, diagonal_indices)
+            return ZeroArray(*shape)
+        return self.func(expr, *diagonal_indices, canonicalize=False)
+
+    @staticmethod
+    def _validate(expr, *diagonal_indices, **kwargs):
+        # Check that no diagonalization happens on indices with mismatched
+        # dimensions:
+        shape = get_shape(expr)
+        for i in diagonal_indices:
+            if any(j >= len(shape) for j in i):
+                raise ValueError("index is larger than expression shape")
+            if len({shape[j] for j in i}) != 1:
+                raise ValueError("diagonalizing indices of different dimensions")
+            if not kwargs.get("allow_trivial_diags", False) and len(i) <= 1:
+                raise ValueError("need at least two axes to diagonalize")
+            if len(set(i)) != len(i):
+                raise ValueError("axis index cannot be repeated")
+
+    @staticmethod
+    def _remove_trivial_dimensions(shape, *diagonal_indices):
+        return [tuple(j for j in i) for i in diagonal_indices if shape[i[0]] != 1]
+
+    @property
+    def expr(self):
+        return self.args[0]
+
+    @property
+    def diagonal_indices(self):
+        return self.args[1:]
+
+    @staticmethod
+    def _flatten(expr, *outer_diagonal_indices):
+        inner_diagonal_indices = expr.diagonal_indices
+        all_inner = [j for i in inner_diagonal_indices for j in i]
+        all_inner.sort()
+        # TODO: add API for total rank and cumulative rank:
+        total_rank = _get_subrank(expr)
+        inner_rank = len(all_inner)
+        outer_rank = total_rank - inner_rank
+        shifts = [0 for i in range(outer_rank)]
+        counter = 0
+        pointer = 0
+        for i in range(outer_rank):
+            while pointer < inner_rank and counter >= all_inner[pointer]:
+                counter += 1
+                pointer += 1
+            shifts[i] += pointer
+            counter += 1
+        outer_diagonal_indices = tuple(tuple(shifts[j] + j for j in i) for i in outer_diagonal_indices)
+        diagonal_indices = inner_diagonal_indices + outer_diagonal_indices
+        return _array_diagonal(expr.expr, *diagonal_indices)
+
+    @classmethod
+    def _ArrayDiagonal_denest_ArrayAdd(cls, expr, *diagonal_indices):
+        return _array_add(*[_array_diagonal(arg, *diagonal_indices) for arg in expr.args])
+
+    @classmethod
+    def _ArrayDiagonal_denest_ArrayDiagonal(cls, expr, *diagonal_indices):
+        return cls._flatten(expr, *diagonal_indices)
+
+    @classmethod
+    def _ArrayDiagonal_denest_PermuteDims(cls, expr: PermuteDims, *diagonal_indices):
+        back_diagonal_indices = [[expr.permutation(j) for j in i] for i in diagonal_indices]
+        nondiag = [i for i in range(get_rank(expr)) if not any(i in j for j in diagonal_indices)]
+        back_nondiag = [expr.permutation(i) for i in nondiag]
+        remap = {e: i for i, e in enumerate(sorted(back_nondiag))}
+        new_permutation1 = [remap[i] for i in back_nondiag]
+        shift = len(new_permutation1)
+        diag_block_perm = [i + shift for i in range(len(back_diagonal_indices))]
+        new_permutation = new_permutation1 + diag_block_perm
+        return _permute_dims(
+            _array_diagonal(
+                expr.expr,
+                *back_diagonal_indices
+            ),
+            new_permutation
+        )
+
+    def _push_indices_down_nonstatic(self, indices):
+        transform = lambda x: self._positions[x] if x < len(self._positions) else None
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    def _push_indices_up_nonstatic(self, indices):
+
+        def transform(x):
+            for i, e in enumerate(self._positions):
+                if (isinstance(e, int) and x == e) or (isinstance(e, tuple) and x in e):
+                    return i
+
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    @classmethod
+    def _push_indices_down(cls, diagonal_indices, indices, rank):
+        positions, shape = cls._get_positions_shape(range(rank), diagonal_indices)
+        transform = lambda x: positions[x] if x < len(positions) else None
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    @classmethod
+    def _push_indices_up(cls, diagonal_indices, indices, rank):
+        positions, shape = cls._get_positions_shape(range(rank), diagonal_indices)
+
+        def transform(x):
+            for i, e in enumerate(positions):
+                if (isinstance(e, int) and x == e) or (isinstance(e, (tuple, Tuple)) and (x in e)):
+                    return i
+
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    @classmethod
+    def _get_positions_shape(cls, shape, diagonal_indices):
+        data1 = tuple((i, shp) for i, shp in enumerate(shape) if not any(i in j for j in diagonal_indices))
+        pos1, shp1 = zip(*data1) if data1 else ((), ())
+        data2 = tuple((i, shape[i[0]]) for i in diagonal_indices)
+        pos2, shp2 = zip(*data2) if data2 else ((), ())
+        positions = pos1 + pos2
+        shape = shp1 + shp2
+        return positions, shape
+
+    def as_explicit(self):
+        expr = self.expr
+        if hasattr(expr, "as_explicit"):
+            expr = expr.as_explicit()
+        return tensordiagonal(expr, *self.diagonal_indices)
+
+
+class ArrayElementwiseApplyFunc(_CodegenArrayAbstract):
+
+    def __new__(cls, function, element):
+
+        if not isinstance(function, Lambda):
+            d = Dummy('d')
+            function = Lambda(d, function(d))
+
+        obj = _CodegenArrayAbstract.__new__(cls, function, element)
+        obj._subranks = _get_subranks(element)
+        return obj
+
+    @property
+    def function(self):
+        return self.args[0]
+
+    @property
+    def expr(self):
+        return self.args[1]
+
+    @property
+    def shape(self):
+        return self.expr.shape
+
+    def _get_function_fdiff(self):
+        d = Dummy("d")
+        function = self.function(d)
+        fdiff = function.diff(d)
+        if isinstance(fdiff, Function):
+            fdiff = type(fdiff)
+        else:
+            fdiff = Lambda(d, fdiff)
+        return fdiff
+
+    def as_explicit(self):
+        expr = self.expr
+        if hasattr(expr, "as_explicit"):
+            expr = expr.as_explicit()
+        return expr.applyfunc(self.function)
+
+
+class ArrayContraction(_CodegenArrayAbstract):
+    r"""
+    This class is meant to represent contractions of arrays in a form easily
+    processable by the code printers.
+    """
+
+    def __new__(cls, expr, *contraction_indices, **kwargs):
+        contraction_indices = _sort_contraction_indices(contraction_indices)
+        expr = _sympify(expr)
+
+        canonicalize = kwargs.get("canonicalize", False)
+
+        obj = Basic.__new__(cls, expr, *contraction_indices)
+        obj._subranks = _get_subranks(expr)
+        obj._mapping = _get_mapping_from_subranks(obj._subranks)
+
+        free_indices_to_position = {i: i for i in range(sum(obj._subranks)) if all(i not in cind for cind in contraction_indices)}
+        obj._free_indices_to_position = free_indices_to_position
+
+        shape = get_shape(expr)
+        cls._validate(expr, *contraction_indices)
+        if shape:
+            shape = tuple(shp for i, shp in enumerate(shape) if not any(i in j for j in contraction_indices))
+        obj._shape = shape
+        if canonicalize:
+            return obj._canonicalize()
+        return obj
+
+    def _canonicalize(self):
+        expr = self.expr
+        contraction_indices = self.contraction_indices
+
+        if len(contraction_indices) == 0:
+            return expr
+
+        if isinstance(expr, ArrayContraction):
+            return self._ArrayContraction_denest_ArrayContraction(expr, *contraction_indices)
+
+        if isinstance(expr, (ZeroArray, ZeroMatrix)):
+            return self._ArrayContraction_denest_ZeroArray(expr, *contraction_indices)
+
+        if isinstance(expr, PermuteDims):
+            return self._ArrayContraction_denest_PermuteDims(expr, *contraction_indices)
+
+        if isinstance(expr, ArrayTensorProduct):
+            expr, contraction_indices = self._sort_fully_contracted_args(expr, contraction_indices)
+            expr, contraction_indices = self._lower_contraction_to_addends(expr, contraction_indices)
+            if len(contraction_indices) == 0:
+                return expr
+
+        if isinstance(expr, ArrayDiagonal):
+            return self._ArrayContraction_denest_ArrayDiagonal(expr, *contraction_indices)
+
+        if isinstance(expr, ArrayAdd):
+            return self._ArrayContraction_denest_ArrayAdd(expr, *contraction_indices)
+
+        # Check single index contractions on 1-dimensional axes:
+        contraction_indices = [i for i in contraction_indices if len(i) > 1 or get_shape(expr)[i[0]] != 1]
+        if len(contraction_indices) == 0:
+            return expr
+
+        return self.func(expr, *contraction_indices, canonicalize=False)
+
+    def __mul__(self, other):
+        if other == 1:
+            return self
+        else:
+            raise NotImplementedError("Product of N-dim arrays is not uniquely defined. Use another method.")
+
+    def __rmul__(self, other):
+        if other == 1:
+            return self
+        else:
+            raise NotImplementedError("Product of N-dim arrays is not uniquely defined. Use another method.")
+
+    @staticmethod
+    def _validate(expr, *contraction_indices):
+        shape = get_shape(expr)
+        if shape is None:
+            return
+
+        # Check that no contraction happens when the shape is mismatched:
+        for i in contraction_indices:
+            if len({shape[j] for j in i if shape[j] != -1}) != 1:
+                raise ValueError("contracting indices of different dimensions")
+
+    @classmethod
+    def _push_indices_down(cls, contraction_indices, indices):
+        flattened_contraction_indices = [j for i in contraction_indices for j in i]
+        flattened_contraction_indices.sort()
+        transform = _build_push_indices_down_func_transformation(flattened_contraction_indices)
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    @classmethod
+    def _push_indices_up(cls, contraction_indices, indices):
+        flattened_contraction_indices = [j for i in contraction_indices for j in i]
+        flattened_contraction_indices.sort()
+        transform = _build_push_indices_up_func_transformation(flattened_contraction_indices)
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    @classmethod
+    def _lower_contraction_to_addends(cls, expr, contraction_indices):
+        if isinstance(expr, ArrayAdd):
+            raise NotImplementedError()
+        if not isinstance(expr, ArrayTensorProduct):
+            return expr, contraction_indices
+        subranks = expr.subranks
+        cumranks = list(accumulate([0] + subranks))
+        contraction_indices_remaining = []
+        contraction_indices_args = [[] for i in expr.args]
+        backshift = set()
+        for i, contraction_group in enumerate(contraction_indices):
+            for j in range(len(expr.args)):
+                if not isinstance(expr.args[j], ArrayAdd):
+                    continue
+                if all(cumranks[j] <= k < cumranks[j+1] for k in contraction_group):
+                    contraction_indices_args[j].append([k - cumranks[j] for k in contraction_group])
+                    backshift.update(contraction_group)
+                    break
+            else:
+                contraction_indices_remaining.append(contraction_group)
+        if len(contraction_indices_remaining) == len(contraction_indices):
+            return expr, contraction_indices
+        total_rank = get_rank(expr)
+        shifts = list(accumulate([1 if i in backshift else 0 for i in range(total_rank)]))
+        contraction_indices_remaining = [Tuple.fromiter(j - shifts[j] for j in i) for i in contraction_indices_remaining]
+        ret = _array_tensor_product(*[
+            _array_contraction(arg, *contr) for arg, contr in zip(expr.args, contraction_indices_args)
+        ])
+        return ret, contraction_indices_remaining
+
+    def split_multiple_contractions(self):
+        """
+        Recognize multiple contractions and attempt at rewriting them as paired-contractions.
+
+        This allows some contractions involving more than two indices to be
+        rewritten as multiple contractions involving two indices, thus allowing
+        the expression to be rewritten as a matrix multiplication line.
+
+        Examples:
+
+        * `A_ij b_j0 C_jk` ===> `A*DiagMatrix(b)*C`
+
+        Care for:
+        - matrix being diagonalized (i.e. `A_ii`)
+        - vectors being diagonalized (i.e. `a_i0`)
+
+        Multiple contractions can be split into matrix multiplications if
+        not more than two arguments are non-diagonals or non-vectors.
+        Vectors get diagonalized while diagonal matrices remain diagonal.
+        The non-diagonal matrices can be at the beginning or at the end
+        of the final matrix multiplication line.
+        """
+
+        editor = _EditArrayContraction(self)
+
+        contraction_indices = self.contraction_indices
+
+        onearray_insert = []
+
+        for indl, links in enumerate(contraction_indices):
+            if len(links) <= 2:
+                continue
+
+            # Check multiple contractions:
+            #
+            # Examples:
+            #
+            # * `A_ij b_j0 C_jk` ===> `A*DiagMatrix(b)*C \otimes OneArray(1)` with permutation (1 2)
+            #
+            # Care for:
+            # - matrix being diagonalized (i.e. `A_ii`)
+            # - vectors being diagonalized (i.e. `a_i0`)
+
+            # Multiple contractions can be split into matrix multiplications if
+            # not more than three arguments are non-diagonals or non-vectors.
+            #
+            # Vectors get diagonalized while diagonal matrices remain diagonal.
+            # The non-diagonal matrices can be at the beginning or at the end
+            # of the final matrix multiplication line.
+
+            positions = editor.get_mapping_for_index(indl)
+
+            # Also consider the case of diagonal matrices being contracted:
+            current_dimension = self.expr.shape[links[0]]
+
+            not_vectors = []
+            vectors = []
+            for arg_ind, rel_ind in positions:
+                arg = editor.args_with_ind[arg_ind]
+                mat = arg.element
+                abs_arg_start, abs_arg_end = editor.get_absolute_range(arg)
+                other_arg_pos = 1-rel_ind
+                other_arg_abs = abs_arg_start + other_arg_pos
+                if ((1 not in mat.shape) or
+                    ((current_dimension == 1) is True and mat.shape != (1, 1)) or
+                    any(other_arg_abs in l for li, l in enumerate(contraction_indices) if li != indl)
+                ):
+                    not_vectors.append((arg, rel_ind))
+                else:
+                    vectors.append((arg, rel_ind))
+            if len(not_vectors) > 2:
+                # If more than two arguments in the multiple contraction are
+                # non-vectors and non-diagonal matrices, we cannot find a way
+                # to split this contraction into a matrix multiplication line:
+                continue
+            # Three cases to handle:
+            # - zero non-vectors
+            # - one non-vector
+            # - two non-vectors
+            for v, rel_ind in vectors:
+                v.element = diagonalize_vector(v.element)
+            vectors_to_loop = not_vectors[:1] + vectors + not_vectors[1:]
+            first_not_vector, rel_ind = vectors_to_loop[0]
+            new_index = first_not_vector.indices[rel_ind]
+
+            for v, rel_ind in vectors_to_loop[1:-1]:
+                v.indices[rel_ind] = new_index
+                new_index = editor.get_new_contraction_index()
+                assert v.indices.index(None) == 1 - rel_ind
+                v.indices[v.indices.index(None)] = new_index
+                onearray_insert.append(v)
+
+            last_vec, rel_ind = vectors_to_loop[-1]
+            last_vec.indices[rel_ind] = new_index
+
+        for v in onearray_insert:
+            editor.insert_after(v, _ArgE(OneArray(1), [None]))
+
+        return editor.to_array_contraction()
+
+    def flatten_contraction_of_diagonal(self):
+        if not isinstance(self.expr, ArrayDiagonal):
+            return self
+        contraction_down = self.expr._push_indices_down(self.expr.diagonal_indices, self.contraction_indices)
+        new_contraction_indices = []
+        diagonal_indices = self.expr.diagonal_indices[:]
+        for i in contraction_down:
+            contraction_group = list(i)
+            for j in i:
+                diagonal_with = [k for k in diagonal_indices if j in k]
+                contraction_group.extend([l for k in diagonal_with for l in k])
+                diagonal_indices = [k for k in diagonal_indices if k not in diagonal_with]
+            new_contraction_indices.append(sorted(set(contraction_group)))
+
+        new_contraction_indices = ArrayDiagonal._push_indices_up(diagonal_indices, new_contraction_indices)
+        return _array_contraction(
+            _array_diagonal(
+                self.expr.expr,
+                *diagonal_indices
+            ),
+            *new_contraction_indices
+        )
+
+    @staticmethod
+    def _get_free_indices_to_position_map(free_indices, contraction_indices):
+        free_indices_to_position = {}
+        flattened_contraction_indices = [j for i in contraction_indices for j in i]
+        counter = 0
+        for ind in free_indices:
+            while counter in flattened_contraction_indices:
+                counter += 1
+            free_indices_to_position[ind] = counter
+            counter += 1
+        return free_indices_to_position
+
+    @staticmethod
+    def _get_index_shifts(expr):
+        """
+        Get the mapping of indices at the positions before the contraction
+        occurs.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import tensorproduct, tensorcontraction
+        >>> from sympy import MatrixSymbol
+        >>> M = MatrixSymbol("M", 3, 3)
+        >>> N = MatrixSymbol("N", 3, 3)
+        >>> cg = tensorcontraction(tensorproduct(M, N), [1, 2])
+        >>> cg._get_index_shifts(cg)
+        [0, 2]
+
+        Indeed, ``cg`` after the contraction has two dimensions, 0 and 1. They
+        need to be shifted by 0 and 2 to get the corresponding positions before
+        the contraction (that is, 0 and 3).
+        """
+        inner_contraction_indices = expr.contraction_indices
+        all_inner = [j for i in inner_contraction_indices for j in i]
+        all_inner.sort()
+        # TODO: add API for total rank and cumulative rank:
+        total_rank = _get_subrank(expr)
+        inner_rank = len(all_inner)
+        outer_rank = total_rank - inner_rank
+        shifts = [0 for i in range(outer_rank)]
+        counter = 0
+        pointer = 0
+        for i in range(outer_rank):
+            while pointer < inner_rank and counter >= all_inner[pointer]:
+                counter += 1
+                pointer += 1
+            shifts[i] += pointer
+            counter += 1
+        return shifts
+
+    @staticmethod
+    def _convert_outer_indices_to_inner_indices(expr, *outer_contraction_indices):
+        shifts = ArrayContraction._get_index_shifts(expr)
+        outer_contraction_indices = tuple(tuple(shifts[j] + j for j in i) for i in outer_contraction_indices)
+        return outer_contraction_indices
+
+    @staticmethod
+    def _flatten(expr, *outer_contraction_indices):
+        inner_contraction_indices = expr.contraction_indices
+        outer_contraction_indices = ArrayContraction._convert_outer_indices_to_inner_indices(expr, *outer_contraction_indices)
+        contraction_indices = inner_contraction_indices + outer_contraction_indices
+        return _array_contraction(expr.expr, *contraction_indices)
+
+    @classmethod
+    def _ArrayContraction_denest_ArrayContraction(cls, expr, *contraction_indices):
+        return cls._flatten(expr, *contraction_indices)
+
+    @classmethod
+    def _ArrayContraction_denest_ZeroArray(cls, expr, *contraction_indices):
+        contraction_indices_flat = [j for i in contraction_indices for j in i]
+        shape = [e for i, e in enumerate(expr.shape) if i not in contraction_indices_flat]
+        return ZeroArray(*shape)
+
+    @classmethod
+    def _ArrayContraction_denest_ArrayAdd(cls, expr, *contraction_indices):
+        return _array_add(*[_array_contraction(i, *contraction_indices) for i in expr.args])
+
+    @classmethod
+    def _ArrayContraction_denest_PermuteDims(cls, expr, *contraction_indices):
+        permutation = expr.permutation
+        plist = permutation.array_form
+        new_contraction_indices = [tuple(permutation(j) for j in i) for i in contraction_indices]
+        new_plist = [i for i in plist if not any(i in j for j in new_contraction_indices)]
+        new_plist = cls._push_indices_up(new_contraction_indices, new_plist)
+        return _permute_dims(
+            _array_contraction(expr.expr, *new_contraction_indices),
+            Permutation(new_plist)
+        )
+
+    @classmethod
+    def _ArrayContraction_denest_ArrayDiagonal(cls, expr: 'ArrayDiagonal', *contraction_indices):
+        diagonal_indices = list(expr.diagonal_indices)
+        down_contraction_indices = expr._push_indices_down(expr.diagonal_indices, contraction_indices, get_rank(expr.expr))
+        # Flatten diagonally contracted indices:
+        down_contraction_indices = [[k for j in i for k in (j if isinstance(j, (tuple, Tuple)) else [j])] for i in down_contraction_indices]
+        new_contraction_indices = []
+        for contr_indgrp in down_contraction_indices:
+            ind = contr_indgrp[:]
+            for j, diag_indgrp in enumerate(diagonal_indices):
+                if diag_indgrp is None:
+                    continue
+                if any(i in diag_indgrp for i in contr_indgrp):
+                    ind.extend(diag_indgrp)
+                    diagonal_indices[j] = None
+            new_contraction_indices.append(sorted(set(ind)))
+
+        new_diagonal_indices_down = [i for i in diagonal_indices if i is not None]
+        new_diagonal_indices = ArrayContraction._push_indices_up(new_contraction_indices, new_diagonal_indices_down)
+        return _array_diagonal(
+            _array_contraction(expr.expr, *new_contraction_indices),
+            *new_diagonal_indices
+        )
+
+    @classmethod
+    def _sort_fully_contracted_args(cls, expr, contraction_indices):
+        if expr.shape is None:
+            return expr, contraction_indices
+        cumul = list(accumulate([0] + expr.subranks))
+        index_blocks = [list(range(cumul[i], cumul[i+1])) for i in range(len(expr.args))]
+        contraction_indices_flat = {j for i in contraction_indices for j in i}
+        fully_contracted = [all(j in contraction_indices_flat for j in range(cumul[i], cumul[i+1])) for i, arg in enumerate(expr.args)]
+        new_pos = sorted(range(len(expr.args)), key=lambda x: (0, default_sort_key(expr.args[x])) if fully_contracted[x] else (1,))
+        new_args = [expr.args[i] for i in new_pos]
+        new_index_blocks_flat = [j for i in new_pos for j in index_blocks[i]]
+        index_permutation_array_form = _af_invert(new_index_blocks_flat)
+        new_contraction_indices = [tuple(index_permutation_array_form[j] for j in i) for i in contraction_indices]
+        new_contraction_indices = _sort_contraction_indices(new_contraction_indices)
+        return _array_tensor_product(*new_args), new_contraction_indices
+
+    def _get_contraction_tuples(self):
+        r"""
+        Return tuples containing the argument index and position within the
+        argument of the index position.
+
+        Examples
+        ========
+
+        >>> from sympy import MatrixSymbol
+        >>> from sympy.abc import N
+        >>> from sympy.tensor.array import tensorproduct, tensorcontraction
+        >>> A = MatrixSymbol("A", N, N)
+        >>> B = MatrixSymbol("B", N, N)
+
+        >>> cg = tensorcontraction(tensorproduct(A, B), (1, 2))
+        >>> cg._get_contraction_tuples()
+        [[(0, 1), (1, 0)]]
+
+        Notes
+        =====
+
+        Here the contraction pair `(1, 2)` meaning that the 2nd and 3rd indices
+        of the tensor product `A\otimes B` are contracted, has been transformed
+        into `(0, 1)` and `(1, 0)`, identifying the same indices in a different
+        notation. `(0, 1)` is the second index (1) of the first argument (i.e.
+                0 or `A`). `(1, 0)` is the first index (i.e. 0) of the second
+        argument (i.e. 1 or `B`).
+        """
+        mapping = self._mapping
+        return [[mapping[j] for j in i] for i in self.contraction_indices]
+
+    @staticmethod
+    def _contraction_tuples_to_contraction_indices(expr, contraction_tuples):
+        # TODO: check that `expr` has `.subranks`:
+        ranks = expr.subranks
+        cumulative_ranks = [0] + list(accumulate(ranks))
+        return [tuple(cumulative_ranks[j]+k for j, k in i) for i in contraction_tuples]
+
+    @property
+    def free_indices(self):
+        return self._free_indices[:]
+
+    @property
+    def free_indices_to_position(self):
+        return dict(self._free_indices_to_position)
+
+    @property
+    def expr(self):
+        return self.args[0]
+
+    @property
+    def contraction_indices(self):
+        return self.args[1:]
+
+    def _contraction_indices_to_components(self):
+        expr = self.expr
+        if not isinstance(expr, ArrayTensorProduct):
+            raise NotImplementedError("only for contractions of tensor products")
+        ranks = expr.subranks
+        mapping = {}
+        counter = 0
+        for i, rank in enumerate(ranks):
+            for j in range(rank):
+                mapping[counter] = (i, j)
+                counter += 1
+        return mapping
+
+    def sort_args_by_name(self):
+        """
+        Sort arguments in the tensor product so that their order is lexicographical.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+        >>> from sympy import MatrixSymbol
+        >>> from sympy.abc import N
+        >>> A = MatrixSymbol("A", N, N)
+        >>> B = MatrixSymbol("B", N, N)
+        >>> C = MatrixSymbol("C", N, N)
+        >>> D = MatrixSymbol("D", N, N)
+
+        >>> cg = convert_matrix_to_array(C*D*A*B)
+        >>> cg
+        ArrayContraction(ArrayTensorProduct(A, D, C, B), (0, 3), (1, 6), (2, 5))
+        >>> cg.sort_args_by_name()
+        ArrayContraction(ArrayTensorProduct(A, D, B, C), (0, 3), (1, 4), (2, 7))
+        """
+        expr = self.expr
+        if not isinstance(expr, ArrayTensorProduct):
+            return self
+        args = expr.args
+        sorted_data = sorted(enumerate(args), key=lambda x: default_sort_key(x[1]))
+        pos_sorted, args_sorted = zip(*sorted_data)
+        reordering_map = {i: pos_sorted.index(i) for i, arg in enumerate(args)}
+        contraction_tuples = self._get_contraction_tuples()
+        contraction_tuples = [[(reordering_map[j], k) for j, k in i] for i in contraction_tuples]
+        c_tp = _array_tensor_product(*args_sorted)
+        new_contr_indices = self._contraction_tuples_to_contraction_indices(
+                c_tp,
+                contraction_tuples
+        )
+        return _array_contraction(c_tp, *new_contr_indices)
+
+    def _get_contraction_links(self):
+        r"""
+        Returns a dictionary of links between arguments in the tensor product
+        being contracted.
+
+        See the example for an explanation of the values.
+
+        Examples
+        ========
+
+        >>> from sympy import MatrixSymbol
+        >>> from sympy.abc import N
+        >>> from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+        >>> A = MatrixSymbol("A", N, N)
+        >>> B = MatrixSymbol("B", N, N)
+        >>> C = MatrixSymbol("C", N, N)
+        >>> D = MatrixSymbol("D", N, N)
+
+        Matrix multiplications are pairwise contractions between neighboring
+        matrices:
+
+        `A_{ij} B_{jk} C_{kl} D_{lm}`
+
+        >>> cg = convert_matrix_to_array(A*B*C*D)
+        >>> cg
+        ArrayContraction(ArrayTensorProduct(B, C, A, D), (0, 5), (1, 2), (3, 6))
+
+        >>> cg._get_contraction_links()
+        {0: {0: (2, 1), 1: (1, 0)}, 1: {0: (0, 1), 1: (3, 0)}, 2: {1: (0, 0)}, 3: {0: (1, 1)}}
+
+        This dictionary is interpreted as follows: argument in position 0 (i.e.
+        matrix `A`) has its second index (i.e. 1) contracted to `(1, 0)`, that
+        is argument in position 1 (matrix `B`) on the first index slot of `B`,
+        this is the contraction provided by the index `j` from `A`.
+
+        The argument in position 1 (that is, matrix `B`) has two contractions,
+        the ones provided by the indices `j` and `k`, respectively the first
+        and second indices (0 and 1 in the sub-dict).  The link `(0, 1)` and
+        `(2, 0)` respectively. `(0, 1)` is the index slot 1 (the 2nd) of
+        argument in position 0 (that is, `A_{\ldot j}`), and so on.
+        """
+        args, dlinks = _get_contraction_links([self], self.subranks, *self.contraction_indices)
+        return dlinks
+
+    def as_explicit(self):
+        expr = self.expr
+        if hasattr(expr, "as_explicit"):
+            expr = expr.as_explicit()
+        return tensorcontraction(expr, *self.contraction_indices)
+
+
+class Reshape(_CodegenArrayAbstract):
+    """
+    Reshape the dimensions of an array expression.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array.expressions import ArraySymbol, Reshape
+    >>> A = ArraySymbol("A", (6,))
+    >>> A.shape
+    (6,)
+    >>> Reshape(A, (3, 2)).shape
+    (3, 2)
+
+    Check the component-explicit forms:
+
+    >>> A.as_explicit()
+    [A[0], A[1], A[2], A[3], A[4], A[5]]
+    >>> Reshape(A, (3, 2)).as_explicit()
+    [[A[0], A[1]], [A[2], A[3]], [A[4], A[5]]]
+
+    """
+
+    def __new__(cls, expr, shape):
+        expr = _sympify(expr)
+        if not isinstance(shape, Tuple):
+            shape = Tuple(*shape)
+        if Equality(Mul.fromiter(expr.shape), Mul.fromiter(shape)) == False:
+            raise ValueError("shape mismatch")
+        obj = Expr.__new__(cls, expr, shape)
+        obj._shape = tuple(shape)
+        obj._expr = expr
+        return obj
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @property
+    def expr(self):
+        return self._expr
+
+    def doit(self, *args, **kwargs):
+        if kwargs.get("deep", True):
+            expr = self.expr.doit(*args, **kwargs)
+        else:
+            expr = self.expr
+        if isinstance(expr, (MatrixCommon, NDimArray)):
+            return expr.reshape(*self.shape)
+        return Reshape(expr, self.shape)
+
+    def as_explicit(self):
+        ee = self.expr
+        if hasattr(ee, "as_explicit"):
+            ee = ee.as_explicit()
+        if isinstance(ee, MatrixCommon):
+            from sympy import Array
+            ee = Array(ee)
+        elif isinstance(ee, MatrixExpr):
+            return self
+        return ee.reshape(*self.shape)
+
+
+class _ArgE:
+    """
+    The ``_ArgE`` object contains references to the array expression
+    (``.element``) and a list containing the information about index
+    contractions (``.indices``).
+
+    Index contractions are numbered and contracted indices show the number of
+    the contraction. Uncontracted indices have ``None`` value.
+
+    For example:
+    ``_ArgE(M, [None, 3])``
+    This object means that expression ``M`` is part of an array contraction
+    and has two indices, the first is not contracted (value ``None``),
+    the second index is contracted to the 4th (i.e. number ``3``) group of the
+    array contraction object.
+    """
+    indices: List[Optional[int]]
+
+    def __init__(self, element, indices: Optional[List[Optional[int]]] = None):
+        self.element = element
+        if indices is None:
+            self.indices = [None for i in range(get_rank(element))]
+        else:
+            self.indices = indices
+
+    def __str__(self):
+        return "_ArgE(%s, %s)" % (self.element, self.indices)
+
+    __repr__ = __str__
+
+
+class _IndPos:
+    """
+    Index position, requiring two integers in the constructor:
+
+    - arg: the position of the argument in the tensor product,
+    - rel: the relative position of the index inside the argument.
+    """
+    def __init__(self, arg: int, rel: int):
+        self.arg = arg
+        self.rel = rel
+
+    def __str__(self):
+        return "_IndPos(%i, %i)" % (self.arg, self.rel)
+
+    __repr__ = __str__
+
+    def __iter__(self):
+        yield from [self.arg, self.rel]
+
+
+class _EditArrayContraction:
+    """
+    Utility class to help manipulate array contraction objects.
+
+    This class takes as input an ``ArrayContraction`` object and turns it into
+    an editable object.
+
+    The field ``args_with_ind`` of this class is a list of ``_ArgE`` objects
+    which can be used to easily edit the contraction structure of the
+    expression.
+
+    Once editing is finished, the ``ArrayContraction`` object may be recreated
+    by calling the ``.to_array_contraction()`` method.
+    """
+
+    def __init__(self, base_array: typing.Union[ArrayContraction, ArrayDiagonal, ArrayTensorProduct]):
+
+        expr: Basic
+        diagonalized: tTuple[tTuple[int, ...], ...]
+        contraction_indices: List[tTuple[int]]
+        if isinstance(base_array, ArrayContraction):
+            mapping = _get_mapping_from_subranks(base_array.subranks)
+            expr = base_array.expr
+            contraction_indices = base_array.contraction_indices
+            diagonalized = ()
+        elif isinstance(base_array, ArrayDiagonal):
+
+            if isinstance(base_array.expr, ArrayContraction):
+                mapping = _get_mapping_from_subranks(base_array.expr.subranks)
+                expr = base_array.expr.expr
+                diagonalized = ArrayContraction._push_indices_down(base_array.expr.contraction_indices, base_array.diagonal_indices)
+                contraction_indices = base_array.expr.contraction_indices
+            elif isinstance(base_array.expr, ArrayTensorProduct):
+                mapping = {}
+                expr = base_array.expr
+                diagonalized = base_array.diagonal_indices
+                contraction_indices = []
+            else:
+                mapping = {}
+                expr = base_array.expr
+                diagonalized = base_array.diagonal_indices
+                contraction_indices = []
+
+        elif isinstance(base_array, ArrayTensorProduct):
+            expr = base_array
+            contraction_indices = []
+            diagonalized = ()
+        else:
+            raise NotImplementedError()
+
+        if isinstance(expr, ArrayTensorProduct):
+            args = list(expr.args)
+        else:
+            args = [expr]
+
+        args_with_ind: List[_ArgE] = [_ArgE(arg) for arg in args]
+        for i, contraction_tuple in enumerate(contraction_indices):
+            for j in contraction_tuple:
+                arg_pos, rel_pos = mapping[j]
+                args_with_ind[arg_pos].indices[rel_pos] = i
+        self.args_with_ind: List[_ArgE] = args_with_ind
+        self.number_of_contraction_indices: int = len(contraction_indices)
+        self._track_permutation: Optional[List[List[int]]] = None
+
+        mapping = _get_mapping_from_subranks(base_array.subranks)
+
+        # Trick: add diagonalized indices as negative indices into the editor object:
+        for i, e in enumerate(diagonalized):
+            for j in e:
+                arg_pos, rel_pos = mapping[j]
+                self.args_with_ind[arg_pos].indices[rel_pos] = -1 - i
+
+    def insert_after(self, arg: _ArgE, new_arg: _ArgE):
+        pos = self.args_with_ind.index(arg)
+        self.args_with_ind.insert(pos + 1, new_arg)
+
+    def get_new_contraction_index(self):
+        self.number_of_contraction_indices += 1
+        return self.number_of_contraction_indices - 1
+
+    def refresh_indices(self):
+        updates = {}
+        for arg_with_ind in self.args_with_ind:
+            updates.update({i: -1 for i in arg_with_ind.indices if i is not None})
+        for i, e in enumerate(sorted(updates)):
+            updates[e] = i
+        self.number_of_contraction_indices = len(updates)
+        for arg_with_ind in self.args_with_ind:
+            arg_with_ind.indices = [updates.get(i, None) for i in arg_with_ind.indices]
+
+    def merge_scalars(self):
+        scalars = []
+        for arg_with_ind in self.args_with_ind:
+            if len(arg_with_ind.indices) == 0:
+                scalars.append(arg_with_ind)
+        for i in scalars:
+            self.args_with_ind.remove(i)
+        scalar = Mul.fromiter([i.element for i in scalars])
+        if len(self.args_with_ind) == 0:
+            self.args_with_ind.append(_ArgE(scalar))
+        else:
+            from sympy.tensor.array.expressions.from_array_to_matrix import _a2m_tensor_product
+            self.args_with_ind[0].element = _a2m_tensor_product(scalar, self.args_with_ind[0].element)
+
+    def to_array_contraction(self):
+
+        # Count the ranks of the arguments:
+        counter = 0
+        # Create a collector for the new diagonal indices:
+        diag_indices = defaultdict(list)
+
+        count_index_freq = Counter()
+        for arg_with_ind in self.args_with_ind:
+            count_index_freq.update(Counter(arg_with_ind.indices))
+
+        free_index_count = count_index_freq[None]
+
+        # Construct the inverse permutation:
+        inv_perm1 = []
+        inv_perm2 = []
+        # Keep track of which diagonal indices have already been processed:
+        done = set()
+
+        # Counter for the diagonal indices:
+        counter4 = 0
+
+        for arg_with_ind in self.args_with_ind:
+            # If some diagonalization axes have been removed, they should be
+            # permuted in order to keep the permutation.
+            # Add permutation here
+            counter2 = 0  # counter for the indices
+            for i in arg_with_ind.indices:
+                if i is None:
+                    inv_perm1.append(counter4)
+                    counter2 += 1
+                    counter4 += 1
+                    continue
+                if i >= 0:
+                    continue
+                # Reconstruct the diagonal indices:
+                diag_indices[-1 - i].append(counter + counter2)
+                if count_index_freq[i] == 1 and i not in done:
+                    inv_perm1.append(free_index_count - 1 - i)
+                    done.add(i)
+                elif i not in done:
+                    inv_perm2.append(free_index_count - 1 - i)
+                    done.add(i)
+                counter2 += 1
+            # Remove negative indices to restore a proper editor object:
+            arg_with_ind.indices = [i if i is not None and i >= 0 else None for i in arg_with_ind.indices]
+            counter += len([i for i in arg_with_ind.indices if i is None or i < 0])
+
+        inverse_permutation = inv_perm1 + inv_perm2
+        permutation = _af_invert(inverse_permutation)
+
+        # Get the diagonal indices after the detection of HadamardProduct in the expression:
+        diag_indices_filtered = [tuple(v) for v in diag_indices.values() if len(v) > 1]
+
+        self.merge_scalars()
+        self.refresh_indices()
+        args = [arg.element for arg in self.args_with_ind]
+        contraction_indices = self.get_contraction_indices()
+        expr = _array_contraction(_array_tensor_product(*args), *contraction_indices)
+        expr2 = _array_diagonal(expr, *diag_indices_filtered)
+        if self._track_permutation is not None:
+            permutation2 = _af_invert([j for i in self._track_permutation for j in i])
+            expr2 = _permute_dims(expr2, permutation2)
+
+        expr3 = _permute_dims(expr2, permutation)
+        return expr3
+
+    def get_contraction_indices(self) -> List[List[int]]:
+        contraction_indices: List[List[int]] = [[] for i in range(self.number_of_contraction_indices)]
+        current_position: int = 0
+        for i, arg_with_ind in enumerate(self.args_with_ind):
+            for j in arg_with_ind.indices:
+                if j is not None:
+                    contraction_indices[j].append(current_position)
+                current_position += 1
+        return contraction_indices
+
+    def get_mapping_for_index(self, ind) -> List[_IndPos]:
+        if ind >= self.number_of_contraction_indices:
+            raise ValueError("index value exceeding the index range")
+        positions: List[_IndPos] = []
+        for i, arg_with_ind in enumerate(self.args_with_ind):
+            for j, arg_ind in enumerate(arg_with_ind.indices):
+                if ind == arg_ind:
+                    positions.append(_IndPos(i, j))
+        return positions
+
+    def get_contraction_indices_to_ind_rel_pos(self) -> List[List[_IndPos]]:
+        contraction_indices: List[List[_IndPos]] = [[] for i in range(self.number_of_contraction_indices)]
+        for i, arg_with_ind in enumerate(self.args_with_ind):
+            for j, ind in enumerate(arg_with_ind.indices):
+                if ind is not None:
+                    contraction_indices[ind].append(_IndPos(i, j))
+        return contraction_indices
+
+    def count_args_with_index(self, index: int) -> int:
+        """
+        Count the number of arguments that have the given index.
+        """
+        counter: int = 0
+        for arg_with_ind in self.args_with_ind:
+            if index in arg_with_ind.indices:
+                counter += 1
+        return counter
+
+    def get_args_with_index(self, index: int) -> List[_ArgE]:
+        """
+        Get a list of arguments having the given index.
+        """
+        ret: List[_ArgE] = [i for i in self.args_with_ind if index in i.indices]
+        return ret
+
+    @property
+    def number_of_diagonal_indices(self):
+        data = set()
+        for arg in self.args_with_ind:
+            data.update({i for i in arg.indices if i is not None and i < 0})
+        return len(data)
+
+    def track_permutation_start(self):
+        permutation = []
+        perm_diag = []
+        counter = 0
+        counter2 = -1
+        for arg_with_ind in self.args_with_ind:
+            perm = []
+            for i in arg_with_ind.indices:
+                if i is not None:
+                    if i < 0:
+                        perm_diag.append(counter2)
+                        counter2 -= 1
+                    continue
+                perm.append(counter)
+                counter += 1
+            permutation.append(perm)
+        max_ind = max([max(i) if i else -1 for i in permutation]) if permutation else -1
+        perm_diag = [max_ind - i for i in perm_diag]
+        self._track_permutation = permutation + [perm_diag]
+
+    def track_permutation_merge(self, destination: _ArgE, from_element: _ArgE):
+        index_destination = self.args_with_ind.index(destination)
+        index_element = self.args_with_ind.index(from_element)
+        self._track_permutation[index_destination].extend(self._track_permutation[index_element]) # type: ignore
+        self._track_permutation.pop(index_element) # type: ignore
+
+    def get_absolute_free_range(self, arg: _ArgE) -> typing.Tuple[int, int]:
+        """
+        Return the range of the free indices of the arg as absolute positions
+        among all free indices.
+        """
+        counter = 0
+        for arg_with_ind in self.args_with_ind:
+            number_free_indices = len([i for i in arg_with_ind.indices if i is None])
+            if arg_with_ind == arg:
+                return counter, counter + number_free_indices
+            counter += number_free_indices
+        raise IndexError("argument not found")
+
+    def get_absolute_range(self, arg: _ArgE) -> typing.Tuple[int, int]:
+        """
+        Return the absolute range of indices for arg, disregarding dummy
+        indices.
+        """
+        counter = 0
+        for arg_with_ind in self.args_with_ind:
+            number_indices = len(arg_with_ind.indices)
+            if arg_with_ind == arg:
+                return counter, counter + number_indices
+            counter += number_indices
+        raise IndexError("argument not found")
+
+
+def get_rank(expr):
+    if isinstance(expr, (MatrixExpr, MatrixElement)):
+        return 2
+    if isinstance(expr, _CodegenArrayAbstract):
+        return len(expr.shape)
+    if isinstance(expr, NDimArray):
+        return expr.rank()
+    if isinstance(expr, Indexed):
+        return expr.rank
+    if isinstance(expr, IndexedBase):
+        shape = expr.shape
+        if shape is None:
+            return -1
+        else:
+            return len(shape)
+    if hasattr(expr, "shape"):
+        return len(expr.shape)
+    return 0
+
+
+def _get_subrank(expr):
+    if isinstance(expr, _CodegenArrayAbstract):
+        return expr.subrank()
+    return get_rank(expr)
+
+
+def _get_subranks(expr):
+    if isinstance(expr, _CodegenArrayAbstract):
+        return expr.subranks
+    else:
+        return [get_rank(expr)]
+
+
+def get_shape(expr):
+    if hasattr(expr, "shape"):
+        return expr.shape
+    return ()
+
+
+def nest_permutation(expr):
+    if isinstance(expr, PermuteDims):
+        return expr.nest_permutation()
+    else:
+        return expr
+
+
+def _array_tensor_product(*args, **kwargs):
+    return ArrayTensorProduct(*args, canonicalize=True, **kwargs)
+
+
+def _array_contraction(expr, *contraction_indices, **kwargs):
+    return ArrayContraction(expr, *contraction_indices, canonicalize=True, **kwargs)
+
+
+def _array_diagonal(expr, *diagonal_indices, **kwargs):
+    return ArrayDiagonal(expr, *diagonal_indices, canonicalize=True, **kwargs)
+
+
+def _permute_dims(expr, permutation, **kwargs):
+    return PermuteDims(expr, permutation, canonicalize=True, **kwargs)
+
+
+def _array_add(*args, **kwargs):
+    return ArrayAdd(*args, canonicalize=True, **kwargs)
+
+
+def _get_array_element_or_slice(expr, indices):
+    return ArrayElement(expr, indices)

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/expressions/conv_array_to_indexed.py

@@ -0,0 +1,12 @@
+from sympy.tensor.array.expressions import from_array_to_indexed
+from sympy.utilities.decorator import deprecated
+
+
+_conv_to_from_decorator = deprecated(
+    "module has been renamed by replacing 'conv_' with 'from_' in its name",
+    deprecated_since_version="1.11",
+    active_deprecations_target="deprecated-conv-array-expr-module-names",
+)
+
+
+convert_array_to_indexed = _conv_to_from_decorator(from_array_to_indexed.convert_array_to_indexed)

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/expressions/conv_array_to_matrix.py

@@ -0,0 +1,6 @@
+from sympy.tensor.array.expressions import from_array_to_matrix
+from sympy.tensor.array.expressions.conv_array_to_indexed import _conv_to_from_decorator
+
+convert_array_to_matrix = _conv_to_from_decorator(from_array_to_matrix.convert_array_to_matrix)
+_array2matrix = _conv_to_from_decorator(from_array_to_matrix._array2matrix)
+_remove_trivial_dims = _conv_to_from_decorator(from_array_to_matrix._remove_trivial_dims)

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/expressions/conv_indexed_to_array.py

@@ -0,0 +1,4 @@
+from sympy.tensor.array.expressions import from_indexed_to_array
+from sympy.tensor.array.expressions.conv_array_to_indexed import _conv_to_from_decorator
+
+convert_indexed_to_array = _conv_to_from_decorator(from_indexed_to_array.convert_indexed_to_array)

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/expressions/conv_matrix_to_array.py

@@ -0,0 +1,4 @@
+from sympy.tensor.array.expressions import from_matrix_to_array
+from sympy.tensor.array.expressions.conv_array_to_indexed import _conv_to_from_decorator
+
+convert_matrix_to_array = _conv_to_from_decorator(from_matrix_to_array.convert_matrix_to_array)

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/expressions/from_array_to_indexed.py

@@ -0,0 +1,84 @@
+import collections.abc
+import operator
+from itertools import accumulate
+
+from sympy import Mul, Sum, Dummy, Add
+from sympy.tensor.array.expressions import PermuteDims, ArrayAdd, ArrayElementwiseApplyFunc, Reshape
+from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct, get_rank, ArrayContraction, \
+    ArrayDiagonal, get_shape, _get_array_element_or_slice, _ArrayExpr
+from sympy.tensor.array.expressions.utils import _apply_permutation_to_list
+
+
+def convert_array_to_indexed(expr, indices):
+    return _ConvertArrayToIndexed().do_convert(expr, indices)
+
+
+class _ConvertArrayToIndexed:
+
+    def __init__(self):
+        self.count_dummies = 0
+
+    def do_convert(self, expr, indices):
+        if isinstance(expr, ArrayTensorProduct):
+            cumul = list(accumulate([0] + [get_rank(arg) for arg in expr.args]))
+            indices_grp = [indices[cumul[i]:cumul[i+1]] for i in range(len(expr.args))]
+            return Mul.fromiter(self.do_convert(arg, ind) for arg, ind in zip(expr.args, indices_grp))
+        if isinstance(expr, ArrayContraction):
+            new_indices = [None for i in range(get_rank(expr.expr))]
+            limits = []
+            bottom_shape = get_shape(expr.expr)
+            for contraction_index_grp in expr.contraction_indices:
+                d = Dummy(f"d{self.count_dummies}")
+                self.count_dummies += 1
+                dim = bottom_shape[contraction_index_grp[0]]
+                limits.append((d, 0, dim-1))
+                for i in contraction_index_grp:
+                    new_indices[i] = d
+            j = 0
+            for i in range(len(new_indices)):
+                if new_indices[i] is None:
+                    new_indices[i] = indices[j]
+                    j += 1
+            newexpr = self.do_convert(expr.expr, new_indices)
+            return Sum(newexpr, *limits)
+        if isinstance(expr, ArrayDiagonal):
+            new_indices = [None for i in range(get_rank(expr.expr))]
+            ind_pos = expr._push_indices_down(expr.diagonal_indices, list(range(len(indices))), get_rank(expr))
+            for i, index in zip(ind_pos, indices):
+                if isinstance(i, collections.abc.Iterable):
+                    for j in i:
+                        new_indices[j] = index
+                else:
+                    new_indices[i] = index
+            newexpr = self.do_convert(expr.expr, new_indices)
+            return newexpr
+        if isinstance(expr, PermuteDims):
+            permuted_indices = _apply_permutation_to_list(expr.permutation, indices)
+            return self.do_convert(expr.expr, permuted_indices)
+        if isinstance(expr, ArrayAdd):
+            return Add.fromiter(self.do_convert(arg, indices) for arg in expr.args)
+        if isinstance(expr, _ArrayExpr):
+            return expr.__getitem__(tuple(indices))
+        if isinstance(expr, ArrayElementwiseApplyFunc):
+            return expr.function(self.do_convert(expr.expr, indices))
+        if isinstance(expr, Reshape):
+            shape_up = expr.shape
+            shape_down = get_shape(expr.expr)
+            cumul = list(accumulate([1] + list(reversed(shape_up)), operator.mul))
+            one_index = Add.fromiter(i*s for i, s in zip(reversed(indices), cumul))
+            dest_indices = [None for _ in shape_down]
+            c = 1
+            for i, e in enumerate(reversed(shape_down)):
+                if c == 1:
+                    if i == len(shape_down) - 1:
+                        dest_indices[i] = one_index
+                    else:
+                        dest_indices[i] = one_index % e
+                elif i == len(shape_down) - 1:
+                    dest_indices[i] = one_index // c
+                else:
+                    dest_indices[i] = one_index // c % e
+                c *= e
+            dest_indices.reverse()
+            return self.do_convert(expr.expr, dest_indices)
+        return _get_array_element_or_slice(expr, indices)

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/expressions/from_array_to_matrix.py

@@ -0,0 +1,1003 @@
+import itertools
+from collections import defaultdict
+from typing import Tuple as tTuple, Union as tUnion, FrozenSet, Dict as tDict, List, Optional
+from functools import singledispatch
+from itertools import accumulate
+
+from sympy import MatMul, Basic, Wild, KroneckerProduct
+from sympy.assumptions.ask import (Q, ask)
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.matrices.expressions.diagonal import DiagMatrix
+from sympy.matrices.expressions.hadamard import hadamard_product, HadamardPower
+from sympy.matrices.expressions.matexpr import MatrixExpr
+from sympy.matrices.expressions.special import (Identity, ZeroMatrix, OneMatrix)
+from sympy.matrices.expressions.trace import Trace
+from sympy.matrices.expressions.transpose import Transpose
+from sympy.combinatorics.permutations import _af_invert, Permutation
+from sympy.matrices.common import MatrixCommon
+from sympy.matrices.expressions.applyfunc import ElementwiseApplyFunction
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.tensor.array.expressions.array_expressions import PermuteDims, ArrayDiagonal, \
+    ArrayTensorProduct, OneArray, get_rank, _get_subrank, ZeroArray, ArrayContraction, \
+    ArrayAdd, _CodegenArrayAbstract, get_shape, ArrayElementwiseApplyFunc, _ArrayExpr, _EditArrayContraction, _ArgE, \
+    ArrayElement, _array_tensor_product, _array_contraction, _array_diagonal, _array_add, _permute_dims
+from sympy.tensor.array.expressions.utils import _get_mapping_from_subranks
+
+
+def _get_candidate_for_matmul_from_contraction(scan_indices: List[Optional[int]], remaining_args: List[_ArgE]) -> tTuple[Optional[_ArgE], bool, int]:
+
+    scan_indices_int: List[int] = [i for i in scan_indices if i is not None]
+    if len(scan_indices_int) == 0:
+        return None, False, -1
+
+    transpose: bool = False
+    candidate: Optional[_ArgE] = None
+    candidate_index: int = -1
+    for arg_with_ind2 in remaining_args:
+        if not isinstance(arg_with_ind2.element, MatrixExpr):
+            continue
+        for index in scan_indices_int:
+            if candidate_index != -1 and candidate_index != index:
+                # A candidate index has already been selected, check
+                # repetitions only for that index:
+                continue
+            if index in arg_with_ind2.indices:
+                if set(arg_with_ind2.indices) == {index}:
+                    # Index repeated twice in arg_with_ind2
+                    candidate = None
+                    break
+                if candidate is None:
+                    candidate = arg_with_ind2
+                    candidate_index = index
+                    transpose = (index == arg_with_ind2.indices[1])
+                else:
+                    # Index repeated more than twice, break
+                    candidate = None
+                    break
+    return candidate, transpose, candidate_index
+
+
+def _insert_candidate_into_editor(editor: _EditArrayContraction, arg_with_ind: _ArgE, candidate: _ArgE, transpose1: bool, transpose2: bool):
+    other = candidate.element
+    other_index: Optional[int]
+    if transpose2:
+        other = Transpose(other)
+        other_index = candidate.indices[0]
+    else:
+        other_index = candidate.indices[1]
+    new_element = (Transpose(arg_with_ind.element) if transpose1 else arg_with_ind.element) * other
+    editor.args_with_ind.remove(candidate)
+    new_arge = _ArgE(new_element)
+    return new_arge, other_index
+
+
+def _support_function_tp1_recognize(contraction_indices, args):
+    if len(contraction_indices) == 0:
+        return _a2m_tensor_product(*args)
+
+    ac = _array_contraction(_array_tensor_product(*args), *contraction_indices)
+    editor = _EditArrayContraction(ac)
+    editor.track_permutation_start()
+
+    while True:
+        flag_stop = True
+        for i, arg_with_ind in enumerate(editor.args_with_ind):
+            if not isinstance(arg_with_ind.element, MatrixExpr):
+                continue
+
+            first_index = arg_with_ind.indices[0]
+            second_index = arg_with_ind.indices[1]
+
+            first_frequency = editor.count_args_with_index(first_index)
+            second_frequency = editor.count_args_with_index(second_index)
+
+            if first_index is not None and first_frequency == 1 and first_index == second_index:
+                flag_stop = False
+                arg_with_ind.element = Trace(arg_with_ind.element)._normalize()
+                arg_with_ind.indices = []
+                break
+
+            scan_indices = []
+            if first_frequency == 2:
+                scan_indices.append(first_index)
+            if second_frequency == 2:
+                scan_indices.append(second_index)
+
+            candidate, transpose, found_index = _get_candidate_for_matmul_from_contraction(scan_indices, editor.args_with_ind[i+1:])
+            if candidate is not None:
+                flag_stop = False
+                editor.track_permutation_merge(arg_with_ind, candidate)
+                transpose1 = found_index == first_index
+                new_arge, other_index = _insert_candidate_into_editor(editor, arg_with_ind, candidate, transpose1, transpose)
+                if found_index == first_index:
+                    new_arge.indices = [second_index, other_index]
+                else:
+                    new_arge.indices = [first_index, other_index]
+                set_indices = set(new_arge.indices)
+                if len(set_indices) == 1 and set_indices != {None}:
+                    # This is a trace:
+                    new_arge.element = Trace(new_arge.element)._normalize()
+                    new_arge.indices = []
+                editor.args_with_ind[i] = new_arge
+                # TODO: is this break necessary?
+                break
+
+        if flag_stop:
+            break
+
+    editor.refresh_indices()
+    return editor.to_array_contraction()
+
+
+def _find_trivial_matrices_rewrite(expr: ArrayTensorProduct):
+    # If there are matrices of trivial shape in the tensor product (i.e. shape
+    # (1, 1)), try to check if there is a suitable non-trivial MatMul where the
+    # expression can be inserted.
+
+    # For example, if "a" has shape (1, 1) and "b" has shape (k, 1), the
+    # expressions "_array_tensor_product(a, b*b.T)" can be rewritten as
+    # "b*a*b.T"
+
+    trivial_matrices = []
+    pos: Optional[int] = None
+    first: Optional[MatrixExpr] = None
+    second: Optional[MatrixExpr] = None
+    removed: List[int] = []
+    counter: int = 0
+    args: List[Optional[Basic]] = list(expr.args)
+    for i, arg in enumerate(expr.args):
+        if isinstance(arg, MatrixExpr):
+            if arg.shape == (1, 1):
+                trivial_matrices.append(arg)
+                args[i] = None
+                removed.extend([counter, counter+1])
+            elif pos is None and isinstance(arg, MatMul):
+                margs = arg.args
+                for j, e in enumerate(margs):
+                    if isinstance(e, MatrixExpr) and e.shape[1] == 1:
+                        pos = i
+                        first = MatMul.fromiter(margs[:j+1])
+                        second = MatMul.fromiter(margs[j+1:])
+                        break
+        counter += get_rank(arg)
+    if pos is None:
+        return expr, []
+    args[pos] = (first*MatMul.fromiter(i for i in trivial_matrices)*second).doit()
+    return _array_tensor_product(*[i for i in args if i is not None]), removed
+
+
+def _find_trivial_kronecker_products_broadcast(expr: ArrayTensorProduct):
+    newargs: List[Basic] = []
+    removed = []
+    count_dims = 0
+    for i, arg in enumerate(expr.args):
+        count_dims += get_rank(arg)
+        shape = get_shape(arg)
+        current_range = [count_dims-i for i in range(len(shape), 0, -1)]
+        if (shape == (1, 1) and len(newargs) > 0 and 1 not in get_shape(newargs[-1]) and
+            isinstance(newargs[-1], MatrixExpr) and isinstance(arg, MatrixExpr)):
+            # KroneckerProduct object allows the trick of broadcasting:
+            newargs[-1] = KroneckerProduct(newargs[-1], arg)
+            removed.extend(current_range)
+        elif 1 not in shape and len(newargs) > 0 and get_shape(newargs[-1]) == (1, 1):
+            # Broadcast:
+            newargs[-1] = KroneckerProduct(newargs[-1], arg)
+            prev_range = [i for i in range(min(current_range)) if i not in removed]
+            removed.extend(prev_range[-2:])
+        else:
+            newargs.append(arg)
+    return _array_tensor_product(*newargs), removed
+
+
+@singledispatch
+def _array2matrix(expr):
+    return expr
+
+
+@_array2matrix.register(ZeroArray)
+def _(expr: ZeroArray):
+    if get_rank(expr) == 2:
+        return ZeroMatrix(*expr.shape)
+    else:
+        return expr
+
+
+@_array2matrix.register(ArrayTensorProduct)
+def _(expr: ArrayTensorProduct):
+    return _a2m_tensor_product(*[_array2matrix(arg) for arg in expr.args])
+
+
+@_array2matrix.register(ArrayContraction)
+def _(expr: ArrayContraction):
+    expr = expr.flatten_contraction_of_diagonal()
+    expr = identify_removable_identity_matrices(expr)
+    expr = expr.split_multiple_contractions()
+    expr = identify_hadamard_products(expr)
+    if not isinstance(expr, ArrayContraction):
+        return _array2matrix(expr)
+    subexpr = expr.expr
+    contraction_indices: tTuple[tTuple[int]] = expr.contraction_indices
+    if contraction_indices == ((0,), (1,)) or (
+        contraction_indices == ((0,),) and subexpr.shape[1] == 1
+    ) or (
+        contraction_indices == ((1,),) and subexpr.shape[0] == 1
+    ):
+        shape = subexpr.shape
+        subexpr = _array2matrix(subexpr)
+        if isinstance(subexpr, MatrixExpr):
+            return OneMatrix(1, shape[0])*subexpr*OneMatrix(shape[1], 1)
+    if isinstance(subexpr, ArrayTensorProduct):
+        newexpr = _array_contraction(_array2matrix(subexpr), *contraction_indices)
+        contraction_indices = newexpr.contraction_indices
+        if any(i > 2 for i in newexpr.subranks):
+            addends = _array_add(*[_a2m_tensor_product(*j) for j in itertools.product(*[i.args if isinstance(i,
+                                                                                                                             ArrayAdd) else [i] for i in expr.expr.args])])
+            newexpr = _array_contraction(addends, *contraction_indices)
+        if isinstance(newexpr, ArrayAdd):
+            ret = _array2matrix(newexpr)
+            return ret
+        assert isinstance(newexpr, ArrayContraction)
+        ret = _support_function_tp1_recognize(contraction_indices, list(newexpr.expr.args))
+        return ret
+    elif not isinstance(subexpr, _CodegenArrayAbstract):
+        ret = _array2matrix(subexpr)
+        if isinstance(ret, MatrixExpr):
+            assert expr.contraction_indices == ((0, 1),)
+            return _a2m_trace(ret)
+        else:
+            return _array_contraction(ret, *expr.contraction_indices)
+
+
+@_array2matrix.register(ArrayDiagonal)
+def _(expr: ArrayDiagonal):
+    pexpr = _array_diagonal(_array2matrix(expr.expr), *expr.diagonal_indices)
+    pexpr = identify_hadamard_products(pexpr)
+    if isinstance(pexpr, ArrayDiagonal):
+        pexpr = _array_diag2contr_diagmatrix(pexpr)
+    if expr == pexpr:
+        return expr
+    return _array2matrix(pexpr)
+
+
+@_array2matrix.register(PermuteDims)
+def _(expr: PermuteDims):
+    if expr.permutation.array_form == [1, 0]:
+        return _a2m_transpose(_array2matrix(expr.expr))
+    elif isinstance(expr.expr, ArrayTensorProduct):
+        ranks = expr.expr.subranks
+        inv_permutation = expr.permutation**(-1)
+        newrange = [inv_permutation(i) for i in range(sum(ranks))]
+        newpos = []
+        counter = 0
+        for rank in ranks:
+            newpos.append(newrange[counter:counter+rank])
+            counter += rank
+        newargs = []
+        newperm = []
+        scalars = []
+        for pos, arg in zip(newpos, expr.expr.args):
+            if len(pos) == 0:
+                scalars.append(_array2matrix(arg))
+            elif pos == sorted(pos):
+                newargs.append((_array2matrix(arg), pos[0]))
+                newperm.extend(pos)
+            elif len(pos) == 2:
+                newargs.append((_a2m_transpose(_array2matrix(arg)), pos[0]))
+                newperm.extend(reversed(pos))
+            else:
+                raise NotImplementedError()
+        newargs = [i[0] for i in newargs]
+        return _permute_dims(_a2m_tensor_product(*scalars, *newargs), _af_invert(newperm))
+    elif isinstance(expr.expr, ArrayContraction):
+        mat_mul_lines = _array2matrix(expr.expr)
+        if not isinstance(mat_mul_lines, ArrayTensorProduct):
+            return _permute_dims(mat_mul_lines, expr.permutation)
+        # TODO: this assumes that all arguments are matrices, it may not be the case:
+        permutation = Permutation(2*len(mat_mul_lines.args)-1)*expr.permutation
+        permuted = [permutation(i) for i in range(2*len(mat_mul_lines.args))]
+        args_array = [None for i in mat_mul_lines.args]
+        for i in range(len(mat_mul_lines.args)):
+            p1 = permuted[2*i]
+            p2 = permuted[2*i+1]
+            if p1 // 2 != p2 // 2:
+                return _permute_dims(mat_mul_lines, permutation)
+            if p1 > p2:
+                args_array[i] = _a2m_transpose(mat_mul_lines.args[p1 // 2])
+            else:
+                args_array[i] = mat_mul_lines.args[p1 // 2]
+        return _a2m_tensor_product(*args_array)
+    else:
+        return expr
+
+
+@_array2matrix.register(ArrayAdd)
+def _(expr: ArrayAdd):
+    addends = [_array2matrix(arg) for arg in expr.args]
+    return _a2m_add(*addends)
+
+
+@_array2matrix.register(ArrayElementwiseApplyFunc)
+def _(expr: ArrayElementwiseApplyFunc):
+    subexpr = _array2matrix(expr.expr)
+    if isinstance(subexpr, MatrixExpr):
+        if subexpr.shape != (1, 1):
+            d = expr.function.bound_symbols[0]
+            w = Wild("w", exclude=[d])
+            p = Wild("p", exclude=[d])
+            m = expr.function.expr.match(w*d**p)
+            if m is not None:
+                return m[w]*HadamardPower(subexpr, m[p])
+        return ElementwiseApplyFunction(expr.function, subexpr)
+    else:
+        return ArrayElementwiseApplyFunc(expr.function, subexpr)
+
+
+@_array2matrix.register(ArrayElement)
+def _(expr: ArrayElement):
+    ret = _array2matrix(expr.name)
+    if isinstance(ret, MatrixExpr):
+        return MatrixElement(ret, *expr.indices)
+    return ArrayElement(ret, expr.indices)
+
+
+@singledispatch
+def _remove_trivial_dims(expr):
+    return expr, []
+
+
+@_remove_trivial_dims.register(ArrayTensorProduct)
+def _(expr: ArrayTensorProduct):
+    # Recognize expressions like [x, y] with shape (k, 1, k, 1) as `x*y.T`.
+    # The matrix expression has to be equivalent to the tensor product of the
+    # matrices, with trivial dimensions (i.e. dim=1) dropped.
+    # That is, add contractions over trivial dimensions:
+
+    removed = []
+    newargs = []
+    cumul = list(accumulate([0] + [get_rank(arg) for arg in expr.args]))
+    pending = None
+    prev_i = None
+    for i, arg in enumerate(expr.args):
+        current_range = list(range(cumul[i], cumul[i+1]))
+        if isinstance(arg, OneArray):
+            removed.extend(current_range)
+            continue
+        if not isinstance(arg, (MatrixExpr, MatrixCommon)):
+            rarg, rem = _remove_trivial_dims(arg)
+            removed.extend(rem)
+            newargs.append(rarg)
+            continue
+        elif getattr(arg, "is_Identity", False) and arg.shape == (1, 1):
+            if arg.shape == (1, 1):
+                # Ignore identity matrices of shape (1, 1) - they are equivalent to scalar 1.
+                removed.extend(current_range)
+            continue
+        elif arg.shape == (1, 1):
+            arg, _ = _remove_trivial_dims(arg)
+            # Matrix is equivalent to scalar:
+            if len(newargs) == 0:
+                newargs.append(arg)
+            elif 1 in get_shape(newargs[-1]):
+                if newargs[-1].shape[1] == 1:
+                    newargs[-1] = newargs[-1]*arg
+                else:
+                    newargs[-1] = arg*newargs[-1]
+                removed.extend(current_range)
+            else:
+                newargs.append(arg)
+        elif 1 in arg.shape:
+            k = [i for i in arg.shape if i != 1][0]
+            if pending is None:
+                pending = k
+                prev_i = i
+                newargs.append(arg)
+            elif pending == k:
+                prev = newargs[-1]
+                if prev.shape[0] == 1:
+                    d1 = cumul[prev_i]
+                    prev = _a2m_transpose(prev)
+                else:
+                    d1 = cumul[prev_i] + 1
+                if arg.shape[1] == 1:
+                    d2 = cumul[i] + 1
+                    arg = _a2m_transpose(arg)
+                else:
+                    d2 = cumul[i]
+                newargs[-1] = prev*arg
+                pending = None
+                removed.extend([d1, d2])
+            else:
+                newargs.append(arg)
+                pending = k
+                prev_i = i
+        else:
+            newargs.append(arg)
+            pending = None
+    newexpr, newremoved = _a2m_tensor_product(*newargs), sorted(removed)
+    if isinstance(newexpr, ArrayTensorProduct):
+        newexpr, newremoved2 = _find_trivial_matrices_rewrite(newexpr)
+        newremoved = _combine_removed(-1, newremoved, newremoved2)
+    if isinstance(newexpr, ArrayTensorProduct):
+        newexpr, newremoved2 = _find_trivial_kronecker_products_broadcast(newexpr)
+        newremoved = _combine_removed(-1, newremoved, newremoved2)
+    return newexpr, newremoved
+
+
+@_remove_trivial_dims.register(ArrayAdd)
+def _(expr: ArrayAdd):
+    rec = [_remove_trivial_dims(arg) for arg in expr.args]
+    newargs, removed = zip(*rec)
+    if len({get_shape(i) for i in newargs}) > 1:
+        return expr, []
+    if len(removed) == 0:
+        return expr, removed
+    removed1 = removed[0]
+    return _a2m_add(*newargs), removed1
+
+
+@_remove_trivial_dims.register(PermuteDims)
+def _(expr: PermuteDims):
+    subexpr, subremoved = _remove_trivial_dims(expr.expr)
+    p = expr.permutation.array_form
+    pinv = _af_invert(expr.permutation.array_form)
+    shift = list(accumulate([1 if i in subremoved else 0 for i in range(len(p))]))
+    premoved = [pinv[i] for i in subremoved]
+    p2 = [e - shift[e] for i, e in enumerate(p) if e not in subremoved]
+    # TODO: check if subremoved should be permuted as well...
+    newexpr = _permute_dims(subexpr, p2)
+    premoved = sorted(premoved)
+    if newexpr != expr:
+        newexpr, removed2 = _remove_trivial_dims(_array2matrix(newexpr))
+        premoved = _combine_removed(-1, premoved, removed2)
+    return newexpr, premoved
+
+
+@_remove_trivial_dims.register(ArrayContraction)
+def _(expr: ArrayContraction):
+    new_expr, removed0 = _array_contraction_to_diagonal_multiple_identity(expr)
+    if new_expr != expr:
+        new_expr2, removed1 = _remove_trivial_dims(_array2matrix(new_expr))
+        removed = _combine_removed(-1, removed0, removed1)
+        return new_expr2, removed
+    rank1 = get_rank(expr)
+    expr, removed1 = remove_identity_matrices(expr)
+    if not isinstance(expr, ArrayContraction):
+        expr2, removed2 = _remove_trivial_dims(expr)
+        return expr2, _combine_removed(rank1, removed1, removed2)
+    newexpr, removed2 = _remove_trivial_dims(expr.expr)
+    shifts = list(accumulate([1 if i in removed2 else 0 for i in range(get_rank(expr.expr))]))
+    new_contraction_indices = [tuple(j for j in i if j not in removed2) for i in expr.contraction_indices]
+    # Remove possible empty tuples "()":
+    new_contraction_indices = [i for i in new_contraction_indices if len(i) > 0]
+    contraction_indices_flat = [j for i in expr.contraction_indices for j in i]
+    removed2 = [i for i in removed2 if i not in contraction_indices_flat]
+    new_contraction_indices = [tuple(j - shifts[j] for j in i) for i in new_contraction_indices]
+    # Shift removed2:
+    removed2 = ArrayContraction._push_indices_up(expr.contraction_indices, removed2)
+    removed = _combine_removed(rank1, removed1, removed2)
+    return _array_contraction(newexpr, *new_contraction_indices), list(removed)
+
+
+def _remove_diagonalized_identity_matrices(expr: ArrayDiagonal):
+    assert isinstance(expr, ArrayDiagonal)
+    editor = _EditArrayContraction(expr)
+    mapping = {i: {j for j in editor.args_with_ind if i in j.indices} for i in range(-1, -1-editor.number_of_diagonal_indices, -1)}
+    removed = []
+    counter: int = 0
+    for i, arg_with_ind in enumerate(editor.args_with_ind):
+        counter += len(arg_with_ind.indices)
+        if isinstance(arg_with_ind.element, Identity):
+            if None in arg_with_ind.indices and any(i is not None and (i < 0) == True for i in arg_with_ind.indices):
+                diag_ind = [j for j in arg_with_ind.indices if j is not None][0]
+                other = [j for j in mapping[diag_ind] if j != arg_with_ind][0]
+                if not isinstance(other.element, MatrixExpr):
+                    continue
+                if 1 not in other.element.shape:
+                    continue
+                if None not in other.indices:
+                    continue
+                editor.args_with_ind[i].element = None
+                none_index = other.indices.index(None)
+                other.element = DiagMatrix(other.element)
+                other_range = editor.get_absolute_range(other)
+                removed.extend([other_range[0] + none_index])
+    editor.args_with_ind = [i for i in editor.args_with_ind if i.element is not None]
+    removed = ArrayDiagonal._push_indices_up(expr.diagonal_indices, removed, get_rank(expr.expr))
+    return editor.to_array_contraction(), removed
+
+
+@_remove_trivial_dims.register(ArrayDiagonal)
+def _(expr: ArrayDiagonal):
+    newexpr, removed = _remove_trivial_dims(expr.expr)
+    shifts = list(accumulate([0] + [1 if i in removed else 0 for i in range(get_rank(expr.expr))]))
+    new_diag_indices_map = {i: tuple(j for j in i if j not in removed) for i in expr.diagonal_indices}
+    for old_diag_tuple, new_diag_tuple in new_diag_indices_map.items():
+        if len(new_diag_tuple) == 1:
+            removed = [i for i in removed if i not in old_diag_tuple]
+    new_diag_indices = [tuple(j - shifts[j] for j in i) for i in new_diag_indices_map.values()]
+    rank = get_rank(expr.expr)
+    removed = ArrayDiagonal._push_indices_up(expr.diagonal_indices, removed, rank)
+    removed = sorted(set(removed))
+    # If there are single axes to diagonalize remaining, it means that their
+    # corresponding dimension has been removed, they no longer need diagonalization:
+    new_diag_indices = [i for i in new_diag_indices if len(i) > 0]
+    if len(new_diag_indices) > 0:
+        newexpr2 = _array_diagonal(newexpr, *new_diag_indices, allow_trivial_diags=True)
+    else:
+        newexpr2 = newexpr
+    if isinstance(newexpr2, ArrayDiagonal):
+        newexpr3, removed2 = _remove_diagonalized_identity_matrices(newexpr2)
+        removed = _combine_removed(-1, removed, removed2)
+        return newexpr3, removed
+    else:
+        return newexpr2, removed
+
+
+@_remove_trivial_dims.register(ElementwiseApplyFunction)
+def _(expr: ElementwiseApplyFunction):
+    subexpr, removed = _remove_trivial_dims(expr.expr)
+    if subexpr.shape == (1, 1):
+        # TODO: move this to ElementwiseApplyFunction
+        return expr.function(subexpr), removed + [0, 1]
+    return ElementwiseApplyFunction(expr.function, subexpr), []
+
+
+@_remove_trivial_dims.register(ArrayElementwiseApplyFunc)
+def _(expr: ArrayElementwiseApplyFunc):
+    subexpr, removed = _remove_trivial_dims(expr.expr)
+    return ArrayElementwiseApplyFunc(expr.function, subexpr), removed
+
+
+def convert_array_to_matrix(expr):
+    r"""
+    Recognize matrix expressions in codegen objects.
+
+    If more than one matrix multiplication line have been detected, return a
+    list with the matrix expressions.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array.expressions.from_indexed_to_array import convert_indexed_to_array
+    >>> from sympy.tensor.array import tensorcontraction, tensorproduct
+    >>> from sympy import MatrixSymbol, Sum
+    >>> from sympy.abc import i, j, k, l, N
+    >>> from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+    >>> from sympy.tensor.array.expressions.from_array_to_matrix import convert_array_to_matrix
+    >>> A = MatrixSymbol("A", N, N)
+    >>> B = MatrixSymbol("B", N, N)
+    >>> C = MatrixSymbol("C", N, N)
+    >>> D = MatrixSymbol("D", N, N)
+
+    >>> expr = Sum(A[i, j]*B[j, k], (j, 0, N-1))
+    >>> cg = convert_indexed_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    A*B
+    >>> cg = convert_indexed_to_array(expr, first_indices=[k])
+    >>> convert_array_to_matrix(cg)
+    B.T*A.T
+
+    Transposition is detected:
+
+    >>> expr = Sum(A[j, i]*B[j, k], (j, 0, N-1))
+    >>> cg = convert_indexed_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    A.T*B
+    >>> cg = convert_indexed_to_array(expr, first_indices=[k])
+    >>> convert_array_to_matrix(cg)
+    B.T*A
+
+    Detect the trace:
+
+    >>> expr = Sum(A[i, i], (i, 0, N-1))
+    >>> cg = convert_indexed_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    Trace(A)
+
+    Recognize some more complex traces:
+
+    >>> expr = Sum(A[i, j]*B[j, i], (i, 0, N-1), (j, 0, N-1))
+    >>> cg = convert_indexed_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    Trace(A*B)
+
+    More complicated expressions:
+
+    >>> expr = Sum(A[i, j]*B[k, j]*A[l, k], (j, 0, N-1), (k, 0, N-1))
+    >>> cg = convert_indexed_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    A*B.T*A.T
+
+    Expressions constructed from matrix expressions do not contain literal
+    indices, the positions of free indices are returned instead:
+
+    >>> expr = A*B
+    >>> cg = convert_matrix_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    A*B
+
+    If more than one line of matrix multiplications is detected, return
+    separate matrix multiplication factors embedded in a tensor product object:
+
+    >>> cg = tensorcontraction(tensorproduct(A, B, C, D), (1, 2), (5, 6))
+    >>> convert_array_to_matrix(cg)
+    ArrayTensorProduct(A*B, C*D)
+
+    The two lines have free indices at axes 0, 3 and 4, 7, respectively.
+    """
+    rec = _array2matrix(expr)
+    rec, removed = _remove_trivial_dims(rec)
+    return rec
+
+
+def _array_diag2contr_diagmatrix(expr: ArrayDiagonal):
+    if isinstance(expr.expr, ArrayTensorProduct):
+        args = list(expr.expr.args)
+        diag_indices = list(expr.diagonal_indices)
+        mapping = _get_mapping_from_subranks([_get_subrank(arg) for arg in args])
+        tuple_links = [[mapping[j] for j in i] for i in diag_indices]
+        contr_indices = []
+        total_rank = get_rank(expr)
+        replaced = [False for arg in args]
+        for i, (abs_pos, rel_pos) in enumerate(zip(diag_indices, tuple_links)):
+            if len(abs_pos) != 2:
+                continue
+            (pos1_outer, pos1_inner), (pos2_outer, pos2_inner) = rel_pos
+            arg1 = args[pos1_outer]
+            arg2 = args[pos2_outer]
+            if get_rank(arg1) != 2 or get_rank(arg2) != 2:
+                if replaced[pos1_outer]:
+                    diag_indices[i] = None
+                if replaced[pos2_outer]:
+                    diag_indices[i] = None
+                continue
+            pos1_in2 = 1 - pos1_inner
+            pos2_in2 = 1 - pos2_inner
+            if arg1.shape[pos1_in2] == 1:
+                if arg1.shape[pos1_inner] != 1:
+                    darg1 = DiagMatrix(arg1)
+                else:
+                    darg1 = arg1
+                args.append(darg1)
+                contr_indices.append(((pos2_outer, pos2_inner), (len(args)-1, pos1_inner)))
+                total_rank += 1
+                diag_indices[i] = None
+                args[pos1_outer] = OneArray(arg1.shape[pos1_in2])
+                replaced[pos1_outer] = True
+            elif arg2.shape[pos2_in2] == 1:
+                if arg2.shape[pos2_inner] != 1:
+                    darg2 = DiagMatrix(arg2)
+                else:
+                    darg2 = arg2
+                args.append(darg2)
+                contr_indices.append(((pos1_outer, pos1_inner), (len(args)-1, pos2_inner)))
+                total_rank += 1
+                diag_indices[i] = None
+                args[pos2_outer] = OneArray(arg2.shape[pos2_in2])
+                replaced[pos2_outer] = True
+        diag_indices_new = [i for i in diag_indices if i is not None]
+        cumul = list(accumulate([0] + [get_rank(arg) for arg in args]))
+        contr_indices2 = [tuple(cumul[a] + b for a, b in i) for i in contr_indices]
+        tc = _array_contraction(
+            _array_tensor_product(*args), *contr_indices2
+        )
+        td = _array_diagonal(tc, *diag_indices_new)
+        return td
+    return expr
+
+
+def _a2m_mul(*args):
+    if not any(isinstance(i, _CodegenArrayAbstract) for i in args):
+        from sympy.matrices.expressions.matmul import MatMul
+        return MatMul(*args).doit()
+    else:
+        return _array_contraction(
+            _array_tensor_product(*args),
+            *[(2*i-1, 2*i) for i in range(1, len(args))]
+        )
+
+
+def _a2m_tensor_product(*args):
+    scalars = []
+    arrays = []
+    for arg in args:
+        if isinstance(arg, (MatrixExpr, _ArrayExpr, _CodegenArrayAbstract)):
+            arrays.append(arg)
+        else:
+            scalars.append(arg)
+    scalar = Mul.fromiter(scalars)
+    if len(arrays) == 0:
+        return scalar
+    if scalar != 1:
+        if isinstance(arrays[0], _CodegenArrayAbstract):
+            arrays = [scalar] + arrays
+        else:
+            arrays[0] *= scalar
+    return _array_tensor_product(*arrays)
+
+
+def _a2m_add(*args):
+    if not any(isinstance(i, _CodegenArrayAbstract) for i in args):
+        from sympy.matrices.expressions.matadd import MatAdd
+        return MatAdd(*args).doit()
+    else:
+        return _array_add(*args)
+
+
+def _a2m_trace(arg):
+    if isinstance(arg, _CodegenArrayAbstract):
+        return _array_contraction(arg, (0, 1))
+    else:
+        from sympy.matrices.expressions.trace import Trace
+        return Trace(arg)
+
+
+def _a2m_transpose(arg):
+    if isinstance(arg, _CodegenArrayAbstract):
+        return _permute_dims(arg, [1, 0])
+    else:
+        from sympy.matrices.expressions.transpose import Transpose
+        return Transpose(arg).doit()
+
+
+def identify_hadamard_products(expr: tUnion[ArrayContraction, ArrayDiagonal]):
+
+    editor: _EditArrayContraction = _EditArrayContraction(expr)
+
+    map_contr_to_args: tDict[FrozenSet, List[_ArgE]] = defaultdict(list)
+    map_ind_to_inds: tDict[Optional[int], int] = defaultdict(int)
+    for arg_with_ind in editor.args_with_ind:
+        for ind in arg_with_ind.indices:
+            map_ind_to_inds[ind] += 1
+        if None in arg_with_ind.indices:
+            continue
+        map_contr_to_args[frozenset(arg_with_ind.indices)].append(arg_with_ind)
+
+    k: FrozenSet[int]
+    v: List[_ArgE]
+    for k, v in map_contr_to_args.items():
+        make_trace: bool = False
+        if len(k) == 1 and next(iter(k)) >= 0 and sum([next(iter(k)) in i for i in map_contr_to_args]) == 1:
+            # This is a trace: the arguments are fully contracted with only one
+            # index, and the index isn't used anywhere else:
+            make_trace = True
+            first_element = S.One
+        elif len(k) != 2:
+            # Hadamard product only defined for matrices:
+            continue
+        if len(v) == 1:
+            # Hadamard product with a single argument makes no sense:
+            continue
+        for ind in k:
+            if map_ind_to_inds[ind] <= 2:
+                # There is no other contraction, skip:
+                continue
+
+        def check_transpose(x):
+            x = [i if i >= 0 else -1-i for i in x]
+            return x == sorted(x)
+
+        # Check if expression is a trace:
+        if all([map_ind_to_inds[j] == len(v) and j >= 0 for j in k]) and all([j >= 0 for j in k]):
+            # This is a trace
+            make_trace = True
+            first_element = v[0].element
+            if not check_transpose(v[0].indices):
+                first_element = first_element.T
+            hadamard_factors = v[1:]
+        else:
+            hadamard_factors = v
+
+        # This is a Hadamard product:
+
+        hp = hadamard_product(*[i.element if check_transpose(i.indices) else Transpose(i.element) for i in hadamard_factors])
+        hp_indices = v[0].indices
+        if not check_transpose(hadamard_factors[0].indices):
+            hp_indices = list(reversed(hp_indices))
+        if make_trace:
+            hp = Trace(first_element*hp.T)._normalize()
+            hp_indices = []
+        editor.insert_after(v[0], _ArgE(hp, hp_indices))
+        for i in v:
+            editor.args_with_ind.remove(i)
+
+    return editor.to_array_contraction()
+
+
+def identify_removable_identity_matrices(expr):
+    editor = _EditArrayContraction(expr)
+
+    flag = True
+    while flag:
+        flag = False
+        for arg_with_ind in editor.args_with_ind:
+            if isinstance(arg_with_ind.element, Identity):
+                k = arg_with_ind.element.shape[0]
+                # Candidate for removal:
+                if arg_with_ind.indices == [None, None]:
+                    # Free identity matrix, will be cleared by _remove_trivial_dims:
+                    continue
+                elif None in arg_with_ind.indices:
+                    ind = [j for j in arg_with_ind.indices if j is not None][0]
+                    counted = editor.count_args_with_index(ind)
+                    if counted == 1:
+                        # Identity matrix contracted only on one index with itself,
+                        # transform to a OneArray(k) element:
+                        editor.insert_after(arg_with_ind, OneArray(k))
+                        editor.args_with_ind.remove(arg_with_ind)
+                        flag = True
+                        break
+                    elif counted > 2:
+                        # Case counted = 2 is a matrix multiplication by identity matrix, skip it.
+                        # Case counted > 2 is a multiple contraction,
+                        # this is a case where the contraction becomes a diagonalization if the
+                        # identity matrix is dropped.
+                        continue
+                elif arg_with_ind.indices[0] == arg_with_ind.indices[1]:
+                    ind = arg_with_ind.indices[0]
+                    counted = editor.count_args_with_index(ind)
+                    if counted > 1:
+                        editor.args_with_ind.remove(arg_with_ind)
+                        flag = True
+                        break
+                    else:
+                        # This is a trace, skip it as it will be recognized somewhere else:
+                        pass
+            elif ask(Q.diagonal(arg_with_ind.element)):
+                if arg_with_ind.indices == [None, None]:
+                    continue
+                elif None in arg_with_ind.indices:
+                    pass
+                elif arg_with_ind.indices[0] == arg_with_ind.indices[1]:
+                    ind = arg_with_ind.indices[0]
+                    counted = editor.count_args_with_index(ind)
+                    if counted == 3:
+                        # A_ai B_bi D_ii ==> A_ai D_ij B_bj
+                        ind_new = editor.get_new_contraction_index()
+                        other_args = [j for j in editor.args_with_ind if j != arg_with_ind]
+                        other_args[1].indices = [ind_new if j == ind else j for j in other_args[1].indices]
+                        arg_with_ind.indices = [ind, ind_new]
+                        flag = True
+                        break
+
+    return editor.to_array_contraction()
+
+
+def remove_identity_matrices(expr: ArrayContraction):
+    editor = _EditArrayContraction(expr)
+    removed: List[int] = []
+
+    permutation_map = {}
+
+    free_indices = list(accumulate([0] + [sum([i is None for i in arg.indices]) for arg in editor.args_with_ind]))
+    free_map = {k: v for k, v in zip(editor.args_with_ind, free_indices[:-1])}
+
+    update_pairs = {}
+
+    for ind in range(editor.number_of_contraction_indices):
+        args = editor.get_args_with_index(ind)
+        identity_matrices = [i for i in args if isinstance(i.element, Identity)]
+        number_identity_matrices = len(identity_matrices)
+        # If the contraction involves a non-identity matrix and multiple identity matrices:
+        if number_identity_matrices != len(args) - 1 or number_identity_matrices == 0:
+            continue
+        # Get the non-identity element:
+        non_identity = [i for i in args if not isinstance(i.element, Identity)][0]
+        # Check that all identity matrices have at least one free index
+        # (otherwise they would be contractions to some other elements)
+        if any([None not in i.indices for i in identity_matrices]):
+            continue
+        # Mark the identity matrices for removal:
+        for i in identity_matrices:
+            i.element = None
+            removed.extend(range(free_map[i], free_map[i] + len([j for j in i.indices if j is None])))
+        last_removed = removed.pop(-1)
+        update_pairs[last_removed, ind] = non_identity.indices[:]
+        # Remove the indices from the non-identity matrix, as the contraction
+        # no longer exists:
+        non_identity.indices = [None if i == ind else i for i in non_identity.indices]
+
+    removed.sort()
+
+    shifts = list(accumulate([1 if i in removed else 0 for i in range(get_rank(expr))]))
+    for (last_removed, ind), non_identity_indices in update_pairs.items():
+        pos = [free_map[non_identity] + i for i, e in enumerate(non_identity_indices) if e == ind]
+        assert len(pos) == 1
+        for j in pos:
+            permutation_map[j] = last_removed
+
+    editor.args_with_ind = [i for i in editor.args_with_ind if i.element is not None]
+    ret_expr = editor.to_array_contraction()
+    permutation = []
+    counter = 0
+    counter2 = 0
+    for j in range(get_rank(expr)):
+        if j in removed:
+            continue
+        if counter2 in permutation_map:
+            target = permutation_map[counter2]
+            permutation.append(target - shifts[target])
+            counter2 += 1
+        else:
+            while counter in permutation_map.values():
+                counter += 1
+            permutation.append(counter)
+            counter += 1
+            counter2 += 1
+    ret_expr2 = _permute_dims(ret_expr, _af_invert(permutation))
+    return ret_expr2, removed
+
+
+def _combine_removed(dim: int, removed1: List[int], removed2: List[int]) -> List[int]:
+    # Concatenate two axis removal operations as performed by
+    # _remove_trivial_dims,
+    removed1 = sorted(removed1)
+    removed2 = sorted(removed2)
+    i = 0
+    j = 0
+    removed = []
+    while True:
+        if j >= len(removed2):
+            while i < len(removed1):
+                removed.append(removed1[i])
+                i += 1
+            break
+        elif i < len(removed1) and removed1[i] <= i + removed2[j]:
+            removed.append(removed1[i])
+            i += 1
+        else:
+            removed.append(i + removed2[j])
+            j += 1
+    return removed
+
+
+def _array_contraction_to_diagonal_multiple_identity(expr: ArrayContraction):
+    editor = _EditArrayContraction(expr)
+    editor.track_permutation_start()
+    removed: List[int] = []
+    diag_index_counter: int = 0
+    for i in range(editor.number_of_contraction_indices):
+        identities = []
+        args = []
+        for j, arg in enumerate(editor.args_with_ind):
+            if i not in arg.indices:
+                continue
+            if isinstance(arg.element, Identity):
+                identities.append(arg)
+            else:
+                args.append(arg)
+        if len(identities) == 0:
+            continue
+        if len(args) + len(identities) < 3:
+            continue
+        new_diag_ind = -1 - diag_index_counter
+        diag_index_counter += 1
+        # Variable "flag" to control whether to skip this contraction set:
+        flag: bool = True
+        for i1, id1 in enumerate(identities):
+            if None not in id1.indices:
+                flag = True
+                break
+            free_pos = list(range(*editor.get_absolute_free_range(id1)))[0]
+            editor._track_permutation[-1].append(free_pos) # type: ignore
+            id1.element = None
+            flag = False
+            break
+        if flag:
+            continue
+        for arg in identities[:i1] + identities[i1+1:]:
+            arg.element = None
+            removed.extend(range(*editor.get_absolute_free_range(arg)))
+        for arg in args:
+            arg.indices = [new_diag_ind if j == i else j for j in arg.indices]
+    for j, e in enumerate(editor.args_with_ind):
+        if e.element is None:
+            editor._track_permutation[j] = None # type: ignore
+    editor._track_permutation = [i for i in editor._track_permutation if i is not None] # type: ignore
+    # Renumber permutation array form in order to deal with deleted positions:
+    remap = {e: i for i, e in enumerate(sorted({k for j in editor._track_permutation for k in j}))}
+    editor._track_permutation = [[remap[j] for j in i] for i in editor._track_permutation]
+    editor.args_with_ind = [i for i in editor.args_with_ind if i.element is not None]
+    new_expr = editor.to_array_contraction()
+    return new_expr, removed

env-llmeval/lib/python3.10/site-packages/sympy/tensor/array/expressions/from_matrix_to_array.py

@@ -0,0 +1,87 @@
+from sympy import KroneckerProduct
+from sympy.core.basic import Basic
+from sympy.core.function import Lambda
+from sympy.core.mul import Mul
+from sympy.core.numbers import Integer
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.matrices.expressions.hadamard import (HadamardPower, HadamardProduct)
+from sympy.matrices.expressions.matadd import MatAdd
+from sympy.matrices.expressions.matmul import MatMul
+from sympy.matrices.expressions.matpow import MatPow
+from sympy.matrices.expressions.trace import Trace
+from sympy.matrices.expressions.transpose import Transpose
+from sympy.matrices.expressions.matexpr import MatrixExpr
+from sympy.tensor.array.expressions.array_expressions import \
+    ArrayElementwiseApplyFunc, _array_tensor_product, _array_contraction, \
+    _array_diagonal, _array_add, _permute_dims, Reshape
+
+
+def convert_matrix_to_array(expr: Basic) -> Basic:
+    if isinstance(expr, MatMul):
+        args_nonmat = []
+        args = []
+        for arg in expr.args:
+            if isinstance(arg, MatrixExpr):
+                args.append(arg)
+            else:
+                args_nonmat.append(convert_matrix_to_array(arg))
+        contractions = [(2*i+1, 2*i+2) for i in range(len(args)-1)]
+        scalar = _array_tensor_product(*args_nonmat) if args_nonmat else S.One
+        if scalar == 1:
+            tprod = _array_tensor_product(
+                *[convert_matrix_to_array(arg) for arg in args])
+        else:
+            tprod = _array_tensor_product(
+                scalar,
+                *[convert_matrix_to_array(arg) for arg in args])
+        return _array_contraction(
+                tprod,
+                *contractions
+        )
+    elif isinstance(expr, MatAdd):
+        return _array_add(
+                *[convert_matrix_to_array(arg) for arg in expr.args]
+        )
+    elif isinstance(expr, Transpose):
+        return _permute_dims(
+                convert_matrix_to_array(expr.args[0]), [1, 0]
+        )
+    elif isinstance(expr, Trace):
+        inner_expr: MatrixExpr = convert_matrix_to_array(expr.arg) # type: ignore
+        return _array_contraction(inner_expr, (0, len(inner_expr.shape) - 1))
+    elif isinstance(expr, Mul):
+        return _array_tensor_product(*[convert_matrix_to_array(i) for i in expr.args])
+    elif isinstance(expr, Pow):
+        base = convert_matrix_to_array(expr.base)
+        if (expr.exp > 0) == True:
+            return _array_tensor_product(*[base for i in range(expr.exp)])
+        else:
+            return expr
+    elif isinstance(expr, MatPow):
+        base = convert_matrix_to_array(expr.base)
+        if expr.exp.is_Integer != True:
+            b = symbols("b", cls=Dummy)
+            return ArrayElementwiseApplyFunc(Lambda(b, b**expr.exp), convert_matrix_to_array(base))
+        elif (expr.exp > 0) == True:
+            return convert_matrix_to_array(MatMul.fromiter(base for i in range(expr.exp)))
+        else:
+            return expr
+    elif isinstance(expr, HadamardProduct):
+        tp = _array_tensor_product(*[convert_matrix_to_array(arg) for arg in expr.args])
+        diag = [[2*i for i in range(len(expr.args))], [2*i+1 for i in range(len(expr.args))]]
+        return _array_diagonal(tp, *diag)
+    elif isinstance(expr, HadamardPower):
+        base, exp = expr.args
+        if isinstance(exp, Integer) and exp > 0:
+            return convert_matrix_to_array(HadamardProduct.fromiter(base for i in range(exp)))
+        else:
+            d = Dummy("d")
+            return ArrayElementwiseApplyFunc(Lambda(d, d**exp), base)
+    elif isinstance(expr, KroneckerProduct):
+        kp_args = [convert_matrix_to_array(arg) for arg in expr.args]
+        permutation = [2*i for i in range(len(kp_args))] + [2*i + 1 for i in range(len(kp_args))]
+        return Reshape(_permute_dims(_array_tensor_product(*kp_args), permutation), expr.shape)
+    else:
+        return expr