Add files using upload-large-folder tool

.gitattributes

@@ -297,3 +297,5 @@ pllava/lib/python3.10/site-packages/transformers/models/seamless_m4t_v2/__pycach
 pllava/lib/python3.10/site-packages/transformers/__pycache__/trainer.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 pllava/lib/python3.10/site-packages/sympy/matrices/tests/__pycache__/test_matrixbase.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 pllava/lib/python3.10/site-packages/sympy/physics/quantum/tests/__pycache__/test_spin.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+pllava/lib/python3.10/site-packages/sympy/polys/__pycache__/polytools.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+pllava/lib/python3.10/site-packages/sympy/polys/tests/__pycache__/test_polytools.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

pllava/lib/python3.10/site-packages/sympy/algebras/quaternion.py

@@ -0,0 +1,1667 @@
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.relational import is_eq
+from sympy.functions.elementary.complexes import (conjugate, im, re, sign)
+from sympy.functions.elementary.exponential import (exp, log as ln)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, asin, atan2)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.simplify.trigsimp import trigsimp
+from sympy.integrals.integrals import integrate
+from sympy.matrices.dense import MutableDenseMatrix as Matrix
+from sympy.core.sympify import sympify, _sympify
+from sympy.core.expr import Expr
+from sympy.core.logic import fuzzy_not, fuzzy_or
+from sympy.utilities.misc import as_int
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+def _check_norm(elements, norm):
+    """validate if input norm is consistent"""
+    if norm is not None and norm.is_number:
+        if norm.is_positive is False:
+            raise ValueError("Input norm must be positive.")
+
+        numerical = all(i.is_number and i.is_real is True for i in elements)
+        if numerical and is_eq(norm**2, sum(i**2 for i in elements)) is False:
+            raise ValueError("Incompatible value for norm.")
+
+
+def _is_extrinsic(seq):
+    """validate seq and return True if seq is lowercase and False if uppercase"""
+    if type(seq) != str:
+        raise ValueError('Expected seq to be a string.')
+    if len(seq) != 3:
+        raise ValueError("Expected 3 axes, got `{}`.".format(seq))
+
+    intrinsic = seq.isupper()
+    extrinsic = seq.islower()
+    if not (intrinsic or extrinsic):
+        raise ValueError("seq must either be fully uppercase (for extrinsic "
+                         "rotations), or fully lowercase, for intrinsic "
+                         "rotations).")
+
+    i, j, k = seq.lower()
+    if (i == j) or (j == k):
+        raise ValueError("Consecutive axes must be different")
+
+    bad = set(seq) - set('xyzXYZ')
+    if bad:
+        raise ValueError("Expected axes from `seq` to be from "
+                         "['x', 'y', 'z'] or ['X', 'Y', 'Z'], "
+                         "got {}".format(''.join(bad)))
+
+    return extrinsic
+
+
+class Quaternion(Expr):
+    """Provides basic quaternion operations.
+    Quaternion objects can be instantiated as ``Quaternion(a, b, c, d)``
+    as in $q = a + bi + cj + dk$.
+
+    Parameters
+    ==========
+
+    norm : None or number
+        Pre-defined quaternion norm. If a value is given, Quaternion.norm
+        returns this pre-defined value instead of calculating the norm
+
+    Examples
+    ========
+
+    >>> from sympy import Quaternion
+    >>> q = Quaternion(1, 2, 3, 4)
+    >>> q
+    1 + 2*i + 3*j + 4*k
+
+    Quaternions over complex fields can be defined as:
+
+    >>> from sympy import Quaternion
+    >>> from sympy import symbols, I
+    >>> x = symbols('x')
+    >>> q1 = Quaternion(x, x**3, x, x**2, real_field = False)
+    >>> q2 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+    >>> q1
+    x + x**3*i + x*j + x**2*k
+    >>> q2
+    (3 + 4*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k
+
+    Defining symbolic unit quaternions:
+
+    >>> from sympy import Quaternion
+    >>> from sympy.abc import w, x, y, z
+    >>> q = Quaternion(w, x, y, z, norm=1)
+    >>> q
+    w + x*i + y*j + z*k
+    >>> q.norm()
+    1
+
+    References
+    ==========
+
+    .. [1] https://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/
+    .. [2] https://en.wikipedia.org/wiki/Quaternion
+
+    """
+    _op_priority = 11.0
+
+    is_commutative = False
+
+    def __new__(cls, a=0, b=0, c=0, d=0, real_field=True, norm=None):
+        a, b, c, d = map(sympify, (a, b, c, d))
+
+        if any(i.is_commutative is False for i in [a, b, c, d]):
+            raise ValueError("arguments have to be commutative")
+        obj = super().__new__(cls, a, b, c, d)
+        obj._real_field = real_field
+        obj.set_norm(norm)
+        return obj
+
+    def set_norm(self, norm):
+        """Sets norm of an already instantiated quaternion.
+
+        Parameters
+        ==========
+
+        norm : None or number
+            Pre-defined quaternion norm. If a value is given, Quaternion.norm
+            returns this pre-defined value instead of calculating the norm
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion(a, b, c, d)
+        >>> q.norm()
+        sqrt(a**2 + b**2 + c**2 + d**2)
+
+        Setting the norm:
+
+        >>> q.set_norm(1)
+        >>> q.norm()
+        1
+
+        Removing set norm:
+
+        >>> q.set_norm(None)
+        >>> q.norm()
+        sqrt(a**2 + b**2 + c**2 + d**2)
+
+        """
+        norm = sympify(norm)
+        _check_norm(self.args, norm)
+        self._norm = norm
+
+    @property
+    def a(self):
+        return self.args[0]
+
+    @property
+    def b(self):
+        return self.args[1]
+
+    @property
+    def c(self):
+        return self.args[2]
+
+    @property
+    def d(self):
+        return self.args[3]
+
+    @property
+    def real_field(self):
+        return self._real_field
+
+    @property
+    def product_matrix_left(self):
+        r"""Returns 4 x 4 Matrix equivalent to a Hamilton product from the
+        left. This can be useful when treating quaternion elements as column
+        vectors. Given a quaternion $q = a + bi + cj + dk$ where a, b, c and d
+        are real numbers, the product matrix from the left is:
+
+        .. math::
+
+            M  =  \begin{bmatrix} a  &-b  &-c  &-d \\
+                                  b  & a  &-d  & c \\
+                                  c  & d  & a  &-b \\
+                                  d  &-c  & b  & a \end{bmatrix}
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q1 = Quaternion(1, 0, 0, 1)
+        >>> q2 = Quaternion(a, b, c, d)
+        >>> q1.product_matrix_left
+        Matrix([
+        [1, 0,  0, -1],
+        [0, 1, -1,  0],
+        [0, 1,  1,  0],
+        [1, 0,  0,  1]])
+
+        >>> q1.product_matrix_left * q2.to_Matrix()
+        Matrix([
+        [a - d],
+        [b - c],
+        [b + c],
+        [a + d]])
+
+        This is equivalent to:
+
+        >>> (q1 * q2).to_Matrix()
+        Matrix([
+        [a - d],
+        [b - c],
+        [b + c],
+        [a + d]])
+        """
+        return Matrix([
+                [self.a, -self.b, -self.c, -self.d],
+                [self.b, self.a, -self.d, self.c],
+                [self.c, self.d, self.a, -self.b],
+                [self.d, -self.c, self.b, self.a]])
+
+    @property
+    def product_matrix_right(self):
+        r"""Returns 4 x 4 Matrix equivalent to a Hamilton product from the
+        right. This can be useful when treating quaternion elements as column
+        vectors. Given a quaternion $q = a + bi + cj + dk$ where a, b, c and d
+        are real numbers, the product matrix from the left is:
+
+        .. math::
+
+            M  =  \begin{bmatrix} a  &-b  &-c  &-d \\
+                                  b  & a  & d  &-c \\
+                                  c  &-d  & a  & b \\
+                                  d  & c  &-b  & a \end{bmatrix}
+
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q1 = Quaternion(a, b, c, d)
+        >>> q2 = Quaternion(1, 0, 0, 1)
+        >>> q2.product_matrix_right
+        Matrix([
+        [1, 0, 0, -1],
+        [0, 1, 1, 0],
+        [0, -1, 1, 0],
+        [1, 0, 0, 1]])
+
+        Note the switched arguments: the matrix represents the quaternion on
+        the right, but is still considered as a matrix multiplication from the
+        left.
+
+        >>> q2.product_matrix_right * q1.to_Matrix()
+        Matrix([
+        [ a - d],
+        [ b + c],
+        [-b + c],
+        [ a + d]])
+
+        This is equivalent to:
+
+        >>> (q1 * q2).to_Matrix()
+        Matrix([
+        [ a - d],
+        [ b + c],
+        [-b + c],
+        [ a + d]])
+        """
+        return Matrix([
+                [self.a, -self.b, -self.c, -self.d],
+                [self.b, self.a, self.d, -self.c],
+                [self.c, -self.d, self.a, self.b],
+                [self.d, self.c, -self.b, self.a]])
+
+    def to_Matrix(self, vector_only=False):
+        """Returns elements of quaternion as a column vector.
+        By default, a ``Matrix`` of length 4 is returned, with the real part as the
+        first element.
+        If ``vector_only`` is ``True``, returns only imaginary part as a Matrix of
+        length 3.
+
+        Parameters
+        ==========
+
+        vector_only : bool
+            If True, only imaginary part is returned.
+            Default value: False
+
+        Returns
+        =======
+
+        Matrix
+            A column vector constructed by the elements of the quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion(a, b, c, d)
+        >>> q
+        a + b*i + c*j + d*k
+
+        >>> q.to_Matrix()
+        Matrix([
+        [a],
+        [b],
+        [c],
+        [d]])
+
+
+        >>> q.to_Matrix(vector_only=True)
+        Matrix([
+        [b],
+        [c],
+        [d]])
+
+        """
+        if vector_only:
+            return Matrix(self.args[1:])
+        else:
+            return Matrix(self.args)
+
+    @classmethod
+    def from_Matrix(cls, elements):
+        """Returns quaternion from elements of a column vector`.
+        If vector_only is True, returns only imaginary part as a Matrix of
+        length 3.
+
+        Parameters
+        ==========
+
+        elements : Matrix, list or tuple of length 3 or 4. If length is 3,
+            assume real part is zero.
+            Default value: False
+
+        Returns
+        =======
+
+        Quaternion
+            A quaternion created from the input elements.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion.from_Matrix([a, b, c, d])
+        >>> q
+        a + b*i + c*j + d*k
+
+        >>> q = Quaternion.from_Matrix([b, c, d])
+        >>> q
+        0 + b*i + c*j + d*k
+
+        """
+        length = len(elements)
+        if length != 3 and length != 4:
+            raise ValueError("Input elements must have length 3 or 4, got {} "
+                             "elements".format(length))
+
+        if length == 3:
+            return Quaternion(0, *elements)
+        else:
+            return Quaternion(*elements)
+
+    @classmethod
+    def from_euler(cls, angles, seq):
+        """Returns quaternion equivalent to rotation represented by the Euler
+        angles, in the sequence defined by ``seq``.
+
+        Parameters
+        ==========
+
+        angles : list, tuple or Matrix of 3 numbers
+            The Euler angles (in radians).
+        seq : string of length 3
+            Represents the sequence of rotations.
+            For extrinsic rotations, seq must be all lowercase and its elements
+            must be from the set ``{'x', 'y', 'z'}``
+            For intrinsic rotations, seq must be all uppercase and its elements
+            must be from the set ``{'X', 'Y', 'Z'}``
+
+        Returns
+        =======
+
+        Quaternion
+            The normalized rotation quaternion calculated from the Euler angles
+            in the given sequence.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import pi
+        >>> q = Quaternion.from_euler([pi/2, 0, 0], 'xyz')
+        >>> q
+        sqrt(2)/2 + sqrt(2)/2*i + 0*j + 0*k
+
+        >>> q = Quaternion.from_euler([0, pi/2, pi] , 'zyz')
+        >>> q
+        0 + (-sqrt(2)/2)*i + 0*j + sqrt(2)/2*k
+
+        >>> q = Quaternion.from_euler([0, pi/2, pi] , 'ZYZ')
+        >>> q
+        0 + sqrt(2)/2*i + 0*j + sqrt(2)/2*k
+
+        """
+
+        if len(angles) != 3:
+            raise ValueError("3 angles must be given.")
+
+        extrinsic = _is_extrinsic(seq)
+        i, j, k = seq.lower()
+
+        # get elementary basis vectors
+        ei = [1 if n == i else 0 for n in 'xyz']
+        ej = [1 if n == j else 0 for n in 'xyz']
+        ek = [1 if n == k else 0 for n in 'xyz']
+
+        # calculate distinct quaternions
+        qi = cls.from_axis_angle(ei, angles[0])
+        qj = cls.from_axis_angle(ej, angles[1])
+        qk = cls.from_axis_angle(ek, angles[2])
+
+        if extrinsic:
+            return trigsimp(qk * qj * qi)
+        else:
+            return trigsimp(qi * qj * qk)
+
+    def to_euler(self, seq, angle_addition=True, avoid_square_root=False):
+        r"""Returns Euler angles representing same rotation as the quaternion,
+        in the sequence given by ``seq``. This implements the method described
+        in [1]_.
+
+        For degenerate cases (gymbal lock cases), the third angle is
+        set to zero.
+
+        Parameters
+        ==========
+
+        seq : string of length 3
+            Represents the sequence of rotations.
+            For extrinsic rotations, seq must be all lowercase and its elements
+            must be from the set ``{'x', 'y', 'z'}``
+            For intrinsic rotations, seq must be all uppercase and its elements
+            must be from the set ``{'X', 'Y', 'Z'}``
+
+        angle_addition : bool
+            When True, first and third angles are given as an addition and
+            subtraction of two simpler ``atan2`` expressions. When False, the
+            first and third angles are each given by a single more complicated
+            ``atan2`` expression. This equivalent expression is given by:
+
+            .. math::
+
+                \operatorname{atan_2} (b,a) \pm \operatorname{atan_2} (d,c) =
+                \operatorname{atan_2} (bc\pm ad, ac\mp bd)
+
+            Default value: True
+
+        avoid_square_root : bool
+            When True, the second angle is calculated with an expression based
+            on ``acos``, which is slightly more complicated but avoids a square
+            root. When False, second angle is calculated with ``atan2``, which
+            is simpler and can be better for numerical reasons (some
+            numerical implementations of ``acos`` have problems near zero).
+            Default value: False
+
+
+        Returns
+        =======
+
+        Tuple
+            The Euler angles calculated from the quaternion
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> euler = Quaternion(a, b, c, d).to_euler('zyz')
+        >>> euler
+        (-atan2(-b, c) + atan2(d, a),
+         2*atan2(sqrt(b**2 + c**2), sqrt(a**2 + d**2)),
+         atan2(-b, c) + atan2(d, a))
+
+
+        References
+        ==========
+
+        .. [1] https://doi.org/10.1371/journal.pone.0276302
+
+        """
+        if self.is_zero_quaternion():
+            raise ValueError('Cannot convert a quaternion with norm 0.')
+
+        angles = [0, 0, 0]
+
+        extrinsic = _is_extrinsic(seq)
+        i, j, k = seq.lower()
+
+        # get index corresponding to elementary basis vectors
+        i = 'xyz'.index(i) + 1
+        j = 'xyz'.index(j) + 1
+        k = 'xyz'.index(k) + 1
+
+        if not extrinsic:
+            i, k = k, i
+
+        # check if sequence is symmetric
+        symmetric = i == k
+        if symmetric:
+            k = 6 - i - j
+
+        # parity of the permutation
+        sign = (i - j) * (j - k) * (k - i) // 2
+
+        # permutate elements
+        elements = [self.a, self.b, self.c, self.d]
+        a = elements[0]
+        b = elements[i]
+        c = elements[j]
+        d = elements[k] * sign
+
+        if not symmetric:
+            a, b, c, d = a - c, b + d, c + a, d - b
+
+        if avoid_square_root:
+            if symmetric:
+                n2 = self.norm()**2
+                angles[1] = acos((a * a + b * b - c * c - d * d) / n2)
+            else:
+                n2 = 2 * self.norm()**2
+                angles[1] = asin((c * c + d * d - a * a - b * b) / n2)
+        else:
+            angles[1] = 2 * atan2(sqrt(c * c + d * d), sqrt(a * a + b * b))
+            if not symmetric:
+                angles[1] -= S.Pi / 2
+
+        # Check for singularities in numerical cases
+        case = 0
+        if is_eq(c, S.Zero) and is_eq(d, S.Zero):
+            case = 1
+        if is_eq(a, S.Zero) and is_eq(b, S.Zero):
+            case = 2
+
+        if case == 0:
+            if angle_addition:
+                angles[0] = atan2(b, a) + atan2(d, c)
+                angles[2] = atan2(b, a) - atan2(d, c)
+            else:
+                angles[0] = atan2(b*c + a*d, a*c - b*d)
+                angles[2] = atan2(b*c - a*d, a*c + b*d)
+
+        else:  # any degenerate case
+            angles[2 * (not extrinsic)] = S.Zero
+            if case == 1:
+                angles[2 * extrinsic] = 2 * atan2(b, a)
+            else:
+                angles[2 * extrinsic] = 2 * atan2(d, c)
+                angles[2 * extrinsic] *= (-1 if extrinsic else 1)
+
+        # for Tait-Bryan angles
+        if not symmetric:
+            angles[0] *= sign
+
+        if extrinsic:
+            return tuple(angles[::-1])
+        else:
+            return tuple(angles)
+
+    @classmethod
+    def from_axis_angle(cls, vector, angle):
+        """Returns a rotation quaternion given the axis and the angle of rotation.
+
+        Parameters
+        ==========
+
+        vector : tuple of three numbers
+            The vector representation of the given axis.
+        angle : number
+            The angle by which axis is rotated (in radians).
+
+        Returns
+        =======
+
+        Quaternion
+            The normalized rotation quaternion calculated from the given axis and the angle of rotation.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import pi, sqrt
+        >>> q = Quaternion.from_axis_angle((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3), 2*pi/3)
+        >>> q
+        1/2 + 1/2*i + 1/2*j + 1/2*k
+
+        """
+        (x, y, z) = vector
+        norm = sqrt(x**2 + y**2 + z**2)
+        (x, y, z) = (x / norm, y / norm, z / norm)
+        s = sin(angle * S.Half)
+        a = cos(angle * S.Half)
+        b = x * s
+        c = y * s
+        d = z * s
+
+        # note that this quaternion is already normalized by construction:
+        # c^2 + (s*x)^2 + (s*y)^2 + (s*z)^2 = c^2 + s^2*(x^2 + y^2 + z^2) = c^2 + s^2 * 1 = c^2 + s^2 = 1
+        # so, what we return is a normalized quaternion
+
+        return cls(a, b, c, d)
+
+    @classmethod
+    def from_rotation_matrix(cls, M):
+        """Returns the equivalent quaternion of a matrix. The quaternion will be normalized
+        only if the matrix is special orthogonal (orthogonal and det(M) = 1).
+
+        Parameters
+        ==========
+
+        M : Matrix
+            Input matrix to be converted to equivalent quaternion. M must be special
+            orthogonal (orthogonal and det(M) = 1) for the quaternion to be normalized.
+
+        Returns
+        =======
+
+        Quaternion
+            The quaternion equivalent to given matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import Matrix, symbols, cos, sin, trigsimp
+        >>> x = symbols('x')
+        >>> M = Matrix([[cos(x), -sin(x), 0], [sin(x), cos(x), 0], [0, 0, 1]])
+        >>> q = trigsimp(Quaternion.from_rotation_matrix(M))
+        >>> q
+        sqrt(2)*sqrt(cos(x) + 1)/2 + 0*i + 0*j + sqrt(2 - 2*cos(x))*sign(sin(x))/2*k
+
+        """
+
+        absQ = M.det()**Rational(1, 3)
+
+        a = sqrt(absQ + M[0, 0] + M[1, 1] + M[2, 2]) / 2
+        b = sqrt(absQ + M[0, 0] - M[1, 1] - M[2, 2]) / 2
+        c = sqrt(absQ - M[0, 0] + M[1, 1] - M[2, 2]) / 2
+        d = sqrt(absQ - M[0, 0] - M[1, 1] + M[2, 2]) / 2
+
+        b = b * sign(M[2, 1] - M[1, 2])
+        c = c * sign(M[0, 2] - M[2, 0])
+        d = d * sign(M[1, 0] - M[0, 1])
+
+        return Quaternion(a, b, c, d)
+
+    def __add__(self, other):
+        return self.add(other)
+
+    def __radd__(self, other):
+        return self.add(other)
+
+    def __sub__(self, other):
+        return self.add(other*-1)
+
+    def __mul__(self, other):
+        return self._generic_mul(self, _sympify(other))
+
+    def __rmul__(self, other):
+        return self._generic_mul(_sympify(other), self)
+
+    def __pow__(self, p):
+        return self.pow(p)
+
+    def __neg__(self):
+        return Quaternion(-self.a, -self.b, -self.c, -self.d)
+
+    def __truediv__(self, other):
+        return self * sympify(other)**-1
+
+    def __rtruediv__(self, other):
+        return sympify(other) * self**-1
+
+    def _eval_Integral(self, *args):
+        return self.integrate(*args)
+
+    def diff(self, *symbols, **kwargs):
+        kwargs.setdefault('evaluate', True)
+        return self.func(*[a.diff(*symbols, **kwargs) for a  in self.args])
+
+    def add(self, other):
+        """Adds quaternions.
+
+        Parameters
+        ==========
+
+        other : Quaternion
+            The quaternion to add to current (self) quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after adding self to other
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> q1.add(q2)
+        6 + 8*i + 10*j + 12*k
+        >>> q1 + 5
+        6 + 2*i + 3*j + 4*k
+        >>> x = symbols('x', real = True)
+        >>> q1.add(x)
+        (x + 1) + 2*i + 3*j + 4*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import Quaternion
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> q3.add(2 + 3*I)
+        (5 + 7*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k
+
+        """
+        q1 = self
+        q2 = sympify(other)
+
+        # If q2 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q2, Quaternion):
+            if q1.real_field and q2.is_complex:
+                return Quaternion(re(q2) + q1.a, im(q2) + q1.b, q1.c, q1.d)
+            elif q2.is_commutative:
+                return Quaternion(q1.a + q2, q1.b, q1.c, q1.d)
+            else:
+                raise ValueError("Only commutative expressions can be added with a Quaternion.")
+
+        return Quaternion(q1.a + q2.a, q1.b + q2.b, q1.c + q2.c, q1.d
+                          + q2.d)
+
+    def mul(self, other):
+        """Multiplies quaternions.
+
+        Parameters
+        ==========
+
+        other : Quaternion or symbol
+            The quaternion to multiply to current (self) quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after multiplying self with other
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> q1.mul(q2)
+        (-60) + 12*i + 30*j + 24*k
+        >>> q1.mul(2)
+        2 + 4*i + 6*j + 8*k
+        >>> x = symbols('x', real = True)
+        >>> q1.mul(x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import Quaternion
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> q3.mul(2 + 3*I)
+        (2 + 3*I)*(3 + 4*I) + (2 + 3*I)*(2 + 5*I)*i + 0*j + (2 + 3*I)*(7 + 8*I)*k
+
+        """
+        return self._generic_mul(self, _sympify(other))
+
+    @staticmethod
+    def _generic_mul(q1, q2):
+        """Generic multiplication.
+
+        Parameters
+        ==========
+
+        q1 : Quaternion or symbol
+        q2 : Quaternion or symbol
+
+        It is important to note that if neither q1 nor q2 is a Quaternion,
+        this function simply returns q1 * q2.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after multiplying q1 and q2
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import Symbol, S
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> Quaternion._generic_mul(q1, q2)
+        (-60) + 12*i + 30*j + 24*k
+        >>> Quaternion._generic_mul(q1, S(2))
+        2 + 4*i + 6*j + 8*k
+        >>> x = Symbol('x', real = True)
+        >>> Quaternion._generic_mul(q1, x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> Quaternion._generic_mul(q3, 2 + 3*I)
+        (2 + 3*I)*(3 + 4*I) + (2 + 3*I)*(2 + 5*I)*i + 0*j + (2 + 3*I)*(7 + 8*I)*k
+
+        """
+        # None is a Quaternion:
+        if not isinstance(q1, Quaternion) and not isinstance(q2, Quaternion):
+            return q1 * q2
+
+        # If q1 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q1, Quaternion):
+            if q2.real_field and q1.is_complex:
+                return Quaternion(re(q1), im(q1), 0, 0) * q2
+            elif q1.is_commutative:
+                return Quaternion(q1 * q2.a, q1 * q2.b, q1 * q2.c, q1 * q2.d)
+            else:
+                raise ValueError("Only commutative expressions can be multiplied with a Quaternion.")
+
+        # If q2 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q2, Quaternion):
+            if q1.real_field and q2.is_complex:
+                return q1 * Quaternion(re(q2), im(q2), 0, 0)
+            elif q2.is_commutative:
+                return Quaternion(q2 * q1.a, q2 * q1.b, q2 * q1.c, q2 * q1.d)
+            else:
+                raise ValueError("Only commutative expressions can be multiplied with a Quaternion.")
+
+        # If any of the quaternions has a fixed norm, pre-compute norm
+        if q1._norm is None and q2._norm is None:
+            norm = None
+        else:
+            norm = q1.norm() * q2.norm()
+
+        return Quaternion(-q1.b*q2.b - q1.c*q2.c - q1.d*q2.d + q1.a*q2.a,
+                          q1.b*q2.a + q1.c*q2.d - q1.d*q2.c + q1.a*q2.b,
+                          -q1.b*q2.d + q1.c*q2.a + q1.d*q2.b + q1.a*q2.c,
+                          q1.b*q2.c - q1.c*q2.b + q1.d*q2.a + q1.a * q2.d,
+                          norm=norm)
+
+    def _eval_conjugate(self):
+        """Returns the conjugate of the quaternion."""
+        q = self
+        return Quaternion(q.a, -q.b, -q.c, -q.d, norm=q._norm)
+
+    def norm(self):
+        """Returns the norm of the quaternion."""
+        if self._norm is None:  # check if norm is pre-defined
+            q = self
+            # trigsimp is used to simplify sin(x)^2 + cos(x)^2 (these terms
+            # arise when from_axis_angle is used).
+            return sqrt(trigsimp(q.a**2 + q.b**2 + q.c**2 + q.d**2))
+
+        return self._norm
+
+    def normalize(self):
+        """Returns the normalized form of the quaternion."""
+        q = self
+        return q * (1/q.norm())
+
+    def inverse(self):
+        """Returns the inverse of the quaternion."""
+        q = self
+        if not q.norm():
+            raise ValueError("Cannot compute inverse for a quaternion with zero norm")
+        return conjugate(q) * (1/q.norm()**2)
+
+    def pow(self, p):
+        """Finds the pth power of the quaternion.
+
+        Parameters
+        ==========
+
+        p : int
+            Power to be applied on quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Returns the p-th power of the current quaternion.
+            Returns the inverse if p = -1.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.pow(4)
+        668 + (-224)*i + (-336)*j + (-448)*k
+
+        """
+        try:
+            q, p = self, as_int(p)
+        except ValueError:
+            return NotImplemented
+
+        if p < 0:
+            q, p = q.inverse(), -p
+
+        if p == 1:
+            return q
+
+        res = Quaternion(1, 0, 0, 0)
+        while p > 0:
+            if p & 1:
+                res *= q
+            q *= q
+            p >>= 1
+
+        return res
+
+    def exp(self):
+        """Returns the exponential of $q$, given by $e^q$.
+
+        Returns
+        =======
+
+        Quaternion
+            The exponential of the quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.exp()
+        E*cos(sqrt(29))
+        + 2*sqrt(29)*E*sin(sqrt(29))/29*i
+        + 3*sqrt(29)*E*sin(sqrt(29))/29*j
+        + 4*sqrt(29)*E*sin(sqrt(29))/29*k
+
+        """
+        # exp(q) = e^a(cos||v|| + v/||v||*sin||v||)
+        q = self
+        vector_norm = sqrt(q.b**2 + q.c**2 + q.d**2)
+        a = exp(q.a) * cos(vector_norm)
+        b = exp(q.a) * sin(vector_norm) * q.b / vector_norm
+        c = exp(q.a) * sin(vector_norm) * q.c / vector_norm
+        d = exp(q.a) * sin(vector_norm) * q.d / vector_norm
+
+        return Quaternion(a, b, c, d)
+
+    def log(self):
+        r"""Returns the logarithm of the quaternion, given by $\log q$.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.log()
+        log(sqrt(30))
+        + 2*sqrt(29)*acos(sqrt(30)/30)/29*i
+        + 3*sqrt(29)*acos(sqrt(30)/30)/29*j
+        + 4*sqrt(29)*acos(sqrt(30)/30)/29*k
+
+        """
+        # log(q) = log||q|| + v/||v||*arccos(a/||q||)
+        q = self
+        vector_norm = sqrt(q.b**2 + q.c**2 + q.d**2)
+        q_norm = q.norm()
+        a = ln(q_norm)
+        b = q.b * acos(q.a / q_norm) / vector_norm
+        c = q.c * acos(q.a / q_norm) / vector_norm
+        d = q.d * acos(q.a / q_norm) / vector_norm
+
+        return Quaternion(a, b, c, d)
+
+    def _eval_subs(self, *args):
+        elements = [i.subs(*args) for i in self.args]
+        norm = self._norm
+        if norm is not None:
+            norm = norm.subs(*args)
+        _check_norm(elements, norm)
+        return Quaternion(*elements, norm=norm)
+
+    def _eval_evalf(self, prec):
+        """Returns the floating point approximations (decimal numbers) of the quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Floating point approximations of quaternion(self)
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import sqrt
+        >>> q = Quaternion(1/sqrt(1), 1/sqrt(2), 1/sqrt(3), 1/sqrt(4))
+        >>> q.evalf()
+        1.00000000000000
+        + 0.707106781186547*i
+        + 0.577350269189626*j
+        + 0.500000000000000*k
+
+        """
+        nprec = prec_to_dps(prec)
+        return Quaternion(*[arg.evalf(n=nprec) for arg in self.args])
+
+    def pow_cos_sin(self, p):
+        """Computes the pth power in the cos-sin form.
+
+        Parameters
+        ==========
+
+        p : int
+            Power to be applied on quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The p-th power in the cos-sin form.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.pow_cos_sin(4)
+        900*cos(4*acos(sqrt(30)/30))
+        + 1800*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*i
+        + 2700*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*j
+        + 3600*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*k
+
+        """
+        # q = ||q||*(cos(a) + u*sin(a))
+        # q^p = ||q||^p * (cos(p*a) + u*sin(p*a))
+
+        q = self
+        (v, angle) = q.to_axis_angle()
+        q2 = Quaternion.from_axis_angle(v, p * angle)
+        return q2 * (q.norm()**p)
+
+    def integrate(self, *args):
+        """Computes integration of quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Integration of the quaternion(self) with the given variable.
+
+        Examples
+        ========
+
+        Indefinite Integral of quaternion :
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import x
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.integrate(x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Definite integral of quaternion :
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import x
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.integrate((x, 1, 5))
+        4 + 8*i + 12*j + 16*k
+
+        """
+        # TODO: is this expression correct?
+        return Quaternion(integrate(self.a, *args), integrate(self.b, *args),
+                          integrate(self.c, *args), integrate(self.d, *args))
+
+    @staticmethod
+    def rotate_point(pin, r):
+        """Returns the coordinates of the point pin (a 3 tuple) after rotation.
+
+        Parameters
+        ==========
+
+        pin : tuple
+            A 3-element tuple of coordinates of a point which needs to be
+            rotated.
+        r : Quaternion or tuple
+            Axis and angle of rotation.
+
+            It's important to note that when r is a tuple, it must be of the form
+            (axis, angle)
+
+        Returns
+        =======
+
+        tuple
+            The coordinates of the point after rotation.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols, trigsimp, cos, sin
+        >>> x = symbols('x')
+        >>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
+        >>> trigsimp(Quaternion.rotate_point((1, 1, 1), q))
+        (sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1)
+        >>> (axis, angle) = q.to_axis_angle()
+        >>> trigsimp(Quaternion.rotate_point((1, 1, 1), (axis, angle)))
+        (sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1)
+
+        """
+        if isinstance(r, tuple):
+            # if r is of the form (vector, angle)
+            q = Quaternion.from_axis_angle(r[0], r[1])
+        else:
+            # if r is a quaternion
+            q = r.normalize()
+        pout = q * Quaternion(0, pin[0], pin[1], pin[2]) * conjugate(q)
+        return (pout.b, pout.c, pout.d)
+
+    def to_axis_angle(self):
+        """Returns the axis and angle of rotation of a quaternion.
+
+        Returns
+        =======
+
+        tuple
+            Tuple of (axis, angle)
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> (axis, angle) = q.to_axis_angle()
+        >>> axis
+        (sqrt(3)/3, sqrt(3)/3, sqrt(3)/3)
+        >>> angle
+        2*pi/3
+
+        """
+        q = self
+        if q.a.is_negative:
+            q = q * -1
+
+        q = q.normalize()
+        angle = trigsimp(2 * acos(q.a))
+
+        # Since quaternion is normalised, q.a is less than 1.
+        s = sqrt(1 - q.a*q.a)
+
+        x = trigsimp(q.b / s)
+        y = trigsimp(q.c / s)
+        z = trigsimp(q.d / s)
+
+        v = (x, y, z)
+        t = (v, angle)
+
+        return t
+
+    def to_rotation_matrix(self, v=None, homogeneous=True):
+        """Returns the equivalent rotation transformation matrix of the quaternion
+        which represents rotation about the origin if ``v`` is not passed.
+
+        Parameters
+        ==========
+
+        v : tuple or None
+            Default value: None
+        homogeneous : bool
+            When True, gives an expression that may be more efficient for
+            symbolic calculations but less so for direct evaluation. Both
+            formulas are mathematically equivalent.
+            Default value: True
+
+        Returns
+        =======
+
+        tuple
+            Returns the equivalent rotation transformation matrix of the quaternion
+            which represents rotation about the origin if v is not passed.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols, trigsimp, cos, sin
+        >>> x = symbols('x')
+        >>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
+        >>> trigsimp(q.to_rotation_matrix())
+        Matrix([
+        [cos(x), -sin(x), 0],
+        [sin(x),  cos(x), 0],
+        [     0,       0, 1]])
+
+        Generates a 4x4 transformation matrix (used for rotation about a point
+        other than the origin) if the point(v) is passed as an argument.
+        """
+
+        q = self
+        s = q.norm()**-2
+
+        # diagonal elements are different according to parameter normal
+        if homogeneous:
+            m00 = s*(q.a**2 + q.b**2 - q.c**2 - q.d**2)
+            m11 = s*(q.a**2 - q.b**2 + q.c**2 - q.d**2)
+            m22 = s*(q.a**2 - q.b**2 - q.c**2 + q.d**2)
+        else:
+            m00 = 1 - 2*s*(q.c**2 + q.d**2)
+            m11 = 1 - 2*s*(q.b**2 + q.d**2)
+            m22 = 1 - 2*s*(q.b**2 + q.c**2)
+
+        m01 = 2*s*(q.b*q.c - q.d*q.a)
+        m02 = 2*s*(q.b*q.d + q.c*q.a)
+
+        m10 = 2*s*(q.b*q.c + q.d*q.a)
+        m12 = 2*s*(q.c*q.d - q.b*q.a)
+
+        m20 = 2*s*(q.b*q.d - q.c*q.a)
+        m21 = 2*s*(q.c*q.d + q.b*q.a)
+
+        if not v:
+            return Matrix([[m00, m01, m02], [m10, m11, m12], [m20, m21, m22]])
+
+        else:
+            (x, y, z) = v
+
+            m03 = x - x*m00 - y*m01 - z*m02
+            m13 = y - x*m10 - y*m11 - z*m12
+            m23 = z - x*m20 - y*m21 - z*m22
+            m30 = m31 = m32 = 0
+            m33 = 1
+
+            return Matrix([[m00, m01, m02, m03], [m10, m11, m12, m13],
+                          [m20, m21, m22, m23], [m30, m31, m32, m33]])
+
+    def scalar_part(self):
+        r"""Returns scalar part($\mathbf{S}(q)$) of the quaternion q.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{S}(q) = a$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(4, 8, 13, 12)
+        >>> q.scalar_part()
+        4
+
+        """
+
+        return self.a
+
+    def vector_part(self):
+        r"""
+        Returns $\mathbf{V}(q)$, the vector part of the quaternion $q$.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{V}(q) = bi + cj + dk$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> q.vector_part()
+        0 + 1*i + 1*j + 1*k
+
+        >>> q = Quaternion(4, 8, 13, 12)
+        >>> q.vector_part()
+        0 + 8*i + 13*j + 12*k
+
+        """
+
+        return Quaternion(0, self.b, self.c, self.d)
+
+    def axis(self):
+        r"""
+        Returns $\mathbf{Ax}(q)$, the axis of the quaternion $q$.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{Ax}(q)$  i.e., the versor of the vector part of that quaternion
+        equal to $\mathbf{U}[\mathbf{V}(q)]$.
+        The axis is always an imaginary unit with square equal to $-1 + 0i + 0j + 0k$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> q.axis()
+        0 + sqrt(3)/3*i + sqrt(3)/3*j + sqrt(3)/3*k
+
+        See Also
+        ========
+
+        vector_part
+
+        """
+        axis = self.vector_part().normalize()
+
+        return Quaternion(0, axis.b, axis.c, axis.d)
+
+    def is_pure(self):
+        """
+        Returns true if the quaternion is pure, false if the quaternion is not pure
+        or returns none if it is unknown.
+
+        Explanation
+        ===========
+
+        A pure quaternion (also a vector quaternion) is a quaternion with scalar
+        part equal to 0.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 8, 13, 12)
+        >>> q.is_pure()
+        True
+
+        See Also
+        ========
+        scalar_part
+
+        """
+
+        return self.a.is_zero
+
+    def is_zero_quaternion(self):
+        """
+        Returns true if the quaternion is a zero quaternion or false if it is not a zero quaternion
+        and None if the value is unknown.
+
+        Explanation
+        ===========
+
+        A zero quaternion is a quaternion with both scalar part and
+        vector part equal to 0.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 0, 0, 0)
+        >>> q.is_zero_quaternion()
+        False
+
+        >>> q = Quaternion(0, 0, 0, 0)
+        >>> q.is_zero_quaternion()
+        True
+
+        See Also
+        ========
+        scalar_part
+        vector_part
+
+        """
+
+        return self.norm().is_zero
+
+    def angle(self):
+        r"""
+        Returns the angle of the quaternion measured in the real-axis plane.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$ where $a$, $b$, $c$ and $d$
+        are real numbers, returns the angle of the quaternion given by
+
+        .. math::
+            \theta := 2 \operatorname{atan_2}\left(\sqrt{b^2 + c^2 + d^2}, {a}\right)
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 4, 4, 4)
+        >>> q.angle()
+        2*atan(4*sqrt(3))
+
+        """
+
+        return 2 * atan2(self.vector_part().norm(), self.scalar_part())
+
+
+    def arc_coplanar(self, other):
+        """
+        Returns True if the transformation arcs represented by the input quaternions happen in the same plane.
+
+        Explanation
+        ===========
+
+        Two quaternions are said to be coplanar (in this arc sense) when their axes are parallel.
+        The plane of a quaternion is the one normal to its axis.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the planes of the two quaternions are the same, apart from its orientation/sign.
+        False : if the planes of the two quaternions are not the same, apart from its orientation/sign.
+        None : if plane of either of the quaternion is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q1 = Quaternion(1, 4, 4, 4)
+        >>> q2 = Quaternion(3, 8, 8, 8)
+        >>> Quaternion.arc_coplanar(q1, q2)
+        True
+
+        >>> q1 = Quaternion(2, 8, 13, 12)
+        >>> Quaternion.arc_coplanar(q1, q2)
+        False
+
+        See Also
+        ========
+
+        vector_coplanar
+        is_pure
+
+        """
+        if (self.is_zero_quaternion()) or (other.is_zero_quaternion()):
+            raise ValueError('Neither of the given quaternions can be 0')
+
+        return fuzzy_or([(self.axis() - other.axis()).is_zero_quaternion(), (self.axis() + other.axis()).is_zero_quaternion()])
+
+    @classmethod
+    def vector_coplanar(cls, q1, q2, q3):
+        r"""
+        Returns True if the axis of the pure quaternions seen as 3D vectors
+        ``q1``, ``q2``, and ``q3`` are coplanar.
+
+        Explanation
+        ===========
+
+        Three pure quaternions are vector coplanar if the quaternions seen as 3D vectors are coplanar.
+
+        Parameters
+        ==========
+
+        q1
+            A pure Quaternion.
+        q2
+            A pure Quaternion.
+        q3
+            A pure Quaternion.
+
+        Returns
+        =======
+
+        True : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are coplanar.
+        False : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are not coplanar.
+        None : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are coplanar is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q1 = Quaternion(0, 4, 4, 4)
+        >>> q2 = Quaternion(0, 8, 8, 8)
+        >>> q3 = Quaternion(0, 24, 24, 24)
+        >>> Quaternion.vector_coplanar(q1, q2, q3)
+        True
+
+        >>> q1 = Quaternion(0, 8, 16, 8)
+        >>> q2 = Quaternion(0, 8, 3, 12)
+        >>> Quaternion.vector_coplanar(q1, q2, q3)
+        False
+
+        See Also
+        ========
+
+        axis
+        is_pure
+
+        """
+
+        if fuzzy_not(q1.is_pure()) or fuzzy_not(q2.is_pure()) or fuzzy_not(q3.is_pure()):
+            raise ValueError('The given quaternions must be pure')
+
+        M = Matrix([[q1.b, q1.c, q1.d], [q2.b, q2.c, q2.d], [q3.b, q3.c, q3.d]]).det()
+        return M.is_zero
+
+    def parallel(self, other):
+        """
+        Returns True if the two pure quaternions seen as 3D vectors are parallel.
+
+        Explanation
+        ===========
+
+        Two pure quaternions are called parallel when their vector product is commutative which
+        implies that the quaternions seen as 3D vectors have same direction.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the two pure quaternions seen as 3D vectors are parallel.
+        False : if the two pure quaternions seen as 3D vectors are not parallel.
+        None : if the two pure quaternions seen as 3D vectors are parallel is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 4, 4, 4)
+        >>> q1 = Quaternion(0, 8, 8, 8)
+        >>> q.parallel(q1)
+        True
+
+        >>> q1 = Quaternion(0, 8, 13, 12)
+        >>> q.parallel(q1)
+        False
+
+        """
+
+        if fuzzy_not(self.is_pure()) or fuzzy_not(other.is_pure()):
+            raise ValueError('The provided quaternions must be pure')
+
+        return (self*other - other*self).is_zero_quaternion()
+
+    def orthogonal(self, other):
+        """
+        Returns the orthogonality of two quaternions.
+
+        Explanation
+        ===========
+
+        Two pure quaternions are called orthogonal when their product is anti-commutative.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the two pure quaternions seen as 3D vectors are orthogonal.
+        False : if the two pure quaternions seen as 3D vectors are not orthogonal.
+        None : if the two pure quaternions seen as 3D vectors are orthogonal is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 4, 4, 4)
+        >>> q1 = Quaternion(0, 8, 8, 8)
+        >>> q.orthogonal(q1)
+        False
+
+        >>> q1 = Quaternion(0, 2, 2, 0)
+        >>> q = Quaternion(0, 2, -2, 0)
+        >>> q.orthogonal(q1)
+        True
+
+        """
+
+        if fuzzy_not(self.is_pure()) or fuzzy_not(other.is_pure()):
+            raise ValueError('The given quaternions must be pure')
+
+        return (self*other + other*self).is_zero_quaternion()
+
+    def index_vector(self):
+        r"""
+        Returns the index vector of the quaternion.
+
+        Explanation
+        ===========
+
+        The index vector is given by $\mathbf{T}(q)$, the norm (or magnitude) of
+        the quaternion $q$, multiplied by $\mathbf{Ax}(q)$, the axis of $q$.
+
+        Returns
+        =======
+
+        Quaternion: representing index vector of the provided quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(2, 4, 2, 4)
+        >>> q.index_vector()
+        0 + 4*sqrt(10)/3*i + 2*sqrt(10)/3*j + 4*sqrt(10)/3*k
+
+        See Also
+        ========
+
+        axis
+        norm
+
+        """
+
+        return self.norm() * self.axis()
+
+    def mensor(self):
+        """
+        Returns the natural logarithm of the norm(magnitude) of the quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(2, 4, 2, 4)
+        >>> q.mensor()
+        log(2*sqrt(10))
+        >>> q.norm()
+        2*sqrt(10)
+
+        See Also
+        ========
+
+        norm
+
+        """
+
+        return ln(self.norm())

pllava/lib/python3.10/site-packages/sympy/categories/__init__.py

@@ -0,0 +1,33 @@
+"""
+Category Theory module.
+
+Provides some of the fundamental category-theory-related classes,
+including categories, morphisms, diagrams.  Functors are not
+implemented yet.
+
+The general reference work this module tries to follow is
+
+  [JoyOfCats] J. Adamek, H. Herrlich. G. E. Strecker: Abstract and
+              Concrete Categories. The Joy of Cats.
+
+The latest version of this book should be available for free download
+from
+
+   katmat.math.uni-bremen.de/acc/acc.pdf
+
+"""
+
+from .baseclasses import (Object, Morphism, IdentityMorphism,
+                         NamedMorphism, CompositeMorphism, Category,
+                         Diagram)
+
+from .diagram_drawing import (DiagramGrid, XypicDiagramDrawer,
+                             xypic_draw_diagram, preview_diagram)
+
+__all__ = [
+    'Object', 'Morphism', 'IdentityMorphism', 'NamedMorphism',
+    'CompositeMorphism', 'Category', 'Diagram',
+
+    'DiagramGrid', 'XypicDiagramDrawer', 'xypic_draw_diagram',
+    'preview_diagram',
+]

pllava/lib/python3.10/site-packages/sympy/categories/baseclasses.py

@@ -0,0 +1,978 @@
+from sympy.core import S, Basic, Dict, Symbol, Tuple, sympify
+from sympy.core.symbol import Str
+from sympy.sets import Set, FiniteSet, EmptySet
+from sympy.utilities.iterables import iterable
+
+
+class Class(Set):
+    r"""
+    The base class for any kind of class in the set-theoretic sense.
+
+    Explanation
+    ===========
+
+    In axiomatic set theories, everything is a class.  A class which
+    can be a member of another class is a set.  A class which is not a
+    member of another class is a proper class.  The class `\{1, 2\}`
+    is a set; the class of all sets is a proper class.
+
+    This class is essentially a synonym for :class:`sympy.core.Set`.
+    The goal of this class is to assure easier migration to the
+    eventual proper implementation of set theory.
+    """
+    is_proper = False
+
+
+class Object(Symbol):
+    """
+    The base class for any kind of object in an abstract category.
+
+    Explanation
+    ===========
+
+    While technically any instance of :class:`~.Basic` will do, this
+    class is the recommended way to create abstract objects in
+    abstract categories.
+    """
+
+
+class Morphism(Basic):
+    """
+    The base class for any morphism in an abstract category.
+
+    Explanation
+    ===========
+
+    In abstract categories, a morphism is an arrow between two
+    category objects.  The object where the arrow starts is called the
+    domain, while the object where the arrow ends is called the
+    codomain.
+
+    Two morphisms between the same pair of objects are considered to
+    be the same morphisms.  To distinguish between morphisms between
+    the same objects use :class:`NamedMorphism`.
+
+    It is prohibited to instantiate this class.  Use one of the
+    derived classes instead.
+
+    See Also
+    ========
+
+    IdentityMorphism, NamedMorphism, CompositeMorphism
+    """
+    def __new__(cls, domain, codomain):
+        raise(NotImplementedError(
+            "Cannot instantiate Morphism.  Use derived classes instead."))
+
+    @property
+    def domain(self):
+        """
+        Returns the domain of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.domain
+        Object("A")
+
+        """
+        return self.args[0]
+
+    @property
+    def codomain(self):
+        """
+        Returns the codomain of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.codomain
+        Object("B")
+
+        """
+        return self.args[1]
+
+    def compose(self, other):
+        r"""
+        Composes self with the supplied morphism.
+
+        The order of elements in the composition is the usual order,
+        i.e., to construct `g\circ f` use ``g.compose(f)``.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> g * f
+        CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"),
+        NamedMorphism(Object("B"), Object("C"), "g")))
+        >>> (g * f).domain
+        Object("A")
+        >>> (g * f).codomain
+        Object("C")
+
+        """
+        return CompositeMorphism(other, self)
+
+    def __mul__(self, other):
+        r"""
+        Composes self with the supplied morphism.
+
+        The semantics of this operation is given by the following
+        equation: ``g * f == g.compose(f)`` for composable morphisms
+        ``g`` and ``f``.
+
+        See Also
+        ========
+
+        compose
+        """
+        return self.compose(other)
+
+
+class IdentityMorphism(Morphism):
+    """
+    Represents an identity morphism.
+
+    Explanation
+    ===========
+
+    An identity morphism is a morphism with equal domain and codomain,
+    which acts as an identity with respect to composition.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, IdentityMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> id_A = IdentityMorphism(A)
+    >>> id_B = IdentityMorphism(B)
+    >>> f * id_A == f
+    True
+    >>> id_B * f == f
+    True
+
+    See Also
+    ========
+
+    Morphism
+    """
+    def __new__(cls, domain):
+        return Basic.__new__(cls, domain)
+
+    @property
+    def codomain(self):
+        return self.domain
+
+
+class NamedMorphism(Morphism):
+    """
+    Represents a morphism which has a name.
+
+    Explanation
+    ===========
+
+    Names are used to distinguish between morphisms which have the
+    same domain and codomain: two named morphisms are equal if they
+    have the same domains, codomains, and names.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> f
+    NamedMorphism(Object("A"), Object("B"), "f")
+    >>> f.name
+    'f'
+
+    See Also
+    ========
+
+    Morphism
+    """
+    def __new__(cls, domain, codomain, name):
+        if not name:
+            raise ValueError("Empty morphism names not allowed.")
+
+        if not isinstance(name, Str):
+            name = Str(name)
+
+        return Basic.__new__(cls, domain, codomain, name)
+
+    @property
+    def name(self):
+        """
+        Returns the name of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.name
+        'f'
+
+        """
+        return self.args[2].name
+
+
+class CompositeMorphism(Morphism):
+    r"""
+    Represents a morphism which is a composition of other morphisms.
+
+    Explanation
+    ===========
+
+    Two composite morphisms are equal if the morphisms they were
+    obtained from (components) are the same and were listed in the
+    same order.
+
+    The arguments to the constructor for this class should be listed
+    in diagram order: to obtain the composition `g\circ f` from the
+    instances of :class:`Morphism` ``g`` and ``f`` use
+    ``CompositeMorphism(f, g)``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, CompositeMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> g * f
+    CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"),
+    NamedMorphism(Object("B"), Object("C"), "g")))
+    >>> CompositeMorphism(f, g) == g * f
+    True
+
+    """
+    @staticmethod
+    def _add_morphism(t, morphism):
+        """
+        Intelligently adds ``morphism`` to tuple ``t``.
+
+        Explanation
+        ===========
+
+        If ``morphism`` is a composite morphism, its components are
+        added to the tuple.  If ``morphism`` is an identity, nothing
+        is added to the tuple.
+
+        No composability checks are performed.
+        """
+        if isinstance(morphism, CompositeMorphism):
+            # ``morphism`` is a composite morphism; we have to
+            # denest its components.
+            return t + morphism.components
+        elif isinstance(morphism, IdentityMorphism):
+            # ``morphism`` is an identity.  Nothing happens.
+            return t
+        else:
+            return t + Tuple(morphism)
+
+    def __new__(cls, *components):
+        if components and not isinstance(components[0], Morphism):
+            # Maybe the user has explicitly supplied a list of
+            # morphisms.
+            return CompositeMorphism.__new__(cls, *components[0])
+
+        normalised_components = Tuple()
+
+        for current, following in zip(components, components[1:]):
+            if not isinstance(current, Morphism) or \
+                    not isinstance(following, Morphism):
+                raise TypeError("All components must be morphisms.")
+
+            if current.codomain != following.domain:
+                raise ValueError("Uncomposable morphisms.")
+
+            normalised_components = CompositeMorphism._add_morphism(
+                normalised_components, current)
+
+        # We haven't added the last morphism to the list of normalised
+        # components.  Add it now.
+        normalised_components = CompositeMorphism._add_morphism(
+            normalised_components, components[-1])
+
+        if not normalised_components:
+            # If ``normalised_components`` is empty, only identities
+            # were supplied.  Since they all were composable, they are
+            # all the same identities.
+            return components[0]
+        elif len(normalised_components) == 1:
+            # No sense to construct a whole CompositeMorphism.
+            return normalised_components[0]
+
+        return Basic.__new__(cls, normalised_components)
+
+    @property
+    def components(self):
+        """
+        Returns the components of this composite morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).components
+        (NamedMorphism(Object("A"), Object("B"), "f"),
+        NamedMorphism(Object("B"), Object("C"), "g"))
+
+        """
+        return self.args[0]
+
+    @property
+    def domain(self):
+        """
+        Returns the domain of this composite morphism.
+
+        The domain of the composite morphism is the domain of its
+        first component.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).domain
+        Object("A")
+
+        """
+        return self.components[0].domain
+
+    @property
+    def codomain(self):
+        """
+        Returns the codomain of this composite morphism.
+
+        The codomain of the composite morphism is the codomain of its
+        last component.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).codomain
+        Object("C")
+
+        """
+        return self.components[-1].codomain
+
+    def flatten(self, new_name):
+        """
+        Forgets the composite structure of this morphism.
+
+        Explanation
+        ===========
+
+        If ``new_name`` is not empty, returns a :class:`NamedMorphism`
+        with the supplied name, otherwise returns a :class:`Morphism`.
+        In both cases the domain of the new morphism is the domain of
+        this composite morphism and the codomain of the new morphism
+        is the codomain of this composite morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).flatten("h")
+        NamedMorphism(Object("A"), Object("C"), "h")
+
+        """
+        return NamedMorphism(self.domain, self.codomain, new_name)
+
+
+class Category(Basic):
+    r"""
+    An (abstract) category.
+
+    Explanation
+    ===========
+
+    A category [JoyOfCats] is a quadruple `\mbox{K} = (O, \hom, id,
+    \circ)` consisting of
+
+    * a (set-theoretical) class `O`, whose members are called
+      `K`-objects,
+
+    * for each pair `(A, B)` of `K`-objects, a set `\hom(A, B)` whose
+      members are called `K`-morphisms from `A` to `B`,
+
+    * for a each `K`-object `A`, a morphism `id:A\rightarrow A`,
+      called the `K`-identity of `A`,
+
+    * a composition law `\circ` associating with every `K`-morphisms
+      `f:A\rightarrow B` and `g:B\rightarrow C` a `K`-morphism `g\circ
+      f:A\rightarrow C`, called the composite of `f` and `g`.
+
+    Composition is associative, `K`-identities are identities with
+    respect to composition, and the sets `\hom(A, B)` are pairwise
+    disjoint.
+
+    This class knows nothing about its objects and morphisms.
+    Concrete cases of (abstract) categories should be implemented as
+    classes derived from this one.
+
+    Certain instances of :class:`Diagram` can be asserted to be
+    commutative in a :class:`Category` by supplying the argument
+    ``commutative_diagrams`` in the constructor.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram, Category
+    >>> from sympy import FiniteSet
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g])
+    >>> K = Category("K", commutative_diagrams=[d])
+    >>> K.commutative_diagrams == FiniteSet(d)
+    True
+
+    See Also
+    ========
+
+    Diagram
+    """
+    def __new__(cls, name, objects=EmptySet, commutative_diagrams=EmptySet):
+        if not name:
+            raise ValueError("A Category cannot have an empty name.")
+
+        if not isinstance(name, Str):
+            name = Str(name)
+
+        if not isinstance(objects, Class):
+            objects = Class(objects)
+
+        new_category = Basic.__new__(cls, name, objects,
+                                     FiniteSet(*commutative_diagrams))
+        return new_category
+
+    @property
+    def name(self):
+        """
+        Returns the name of this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Category
+        >>> K = Category("K")
+        >>> K.name
+        'K'
+
+        """
+        return self.args[0].name
+
+    @property
+    def objects(self):
+        """
+        Returns the class of objects of this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, Category
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> K = Category("K", FiniteSet(A, B))
+        >>> K.objects
+        Class({Object("A"), Object("B")})
+
+        """
+        return self.args[1]
+
+    @property
+    def commutative_diagrams(self):
+        """
+        Returns the :class:`~.FiniteSet` of diagrams which are known to
+        be commutative in this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram, Category
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> K = Category("K", commutative_diagrams=[d])
+        >>> K.commutative_diagrams == FiniteSet(d)
+        True
+
+        """
+        return self.args[2]
+
+    def hom(self, A, B):
+        raise NotImplementedError(
+            "hom-sets are not implemented in Category.")
+
+    def all_morphisms(self):
+        raise NotImplementedError(
+            "Obtaining the class of morphisms is not implemented in Category.")
+
+
+class Diagram(Basic):
+    r"""
+    Represents a diagram in a certain category.
+
+    Explanation
+    ===========
+
+    Informally, a diagram is a collection of objects of a category and
+    certain morphisms between them.  A diagram is still a monoid with
+    respect to morphism composition; i.e., identity morphisms, as well
+    as all composites of morphisms included in the diagram belong to
+    the diagram.  For a more formal approach to this notion see
+    [Pare1970].
+
+    The components of composite morphisms are also added to the
+    diagram.  No properties are assigned to such morphisms by default.
+
+    A commutative diagram is often accompanied by a statement of the
+    following kind: "if such morphisms with such properties exist,
+    then such morphisms which such properties exist and the diagram is
+    commutative".  To represent this, an instance of :class:`Diagram`
+    includes a collection of morphisms which are the premises and
+    another collection of conclusions.  ``premises`` and
+    ``conclusions`` associate morphisms belonging to the corresponding
+    categories with the :class:`~.FiniteSet`'s of their properties.
+
+    The set of properties of a composite morphism is the intersection
+    of the sets of properties of its components.  The domain and
+    codomain of a conclusion morphism should be among the domains and
+    codomains of the morphisms listed as the premises of a diagram.
+
+    No checks are carried out of whether the supplied object and
+    morphisms do belong to one and the same category.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy import pprint, default_sort_key
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g])
+    >>> premises_keys = sorted(d.premises.keys(), key=default_sort_key)
+    >>> pprint(premises_keys, use_unicode=False)
+    [g*f:A-->C, id:A-->A, id:B-->B, id:C-->C, f:A-->B, g:B-->C]
+    >>> pprint(d.premises, use_unicode=False)
+    {g*f:A-->C: EmptySet, id:A-->A: EmptySet, id:B-->B: EmptySet,
+     id:C-->C: EmptySet, f:A-->B: EmptySet, g:B-->C: EmptySet}
+    >>> d = Diagram([f, g], {g * f: "unique"})
+    >>> pprint(d.conclusions,use_unicode=False)
+    {g*f:A-->C: {unique}}
+
+    References
+    ==========
+
+    [Pare1970] B. Pareigis: Categories and functors.  Academic Press, 1970.
+
+    """
+    @staticmethod
+    def _set_dict_union(dictionary, key, value):
+        """
+        If ``key`` is in ``dictionary``, set the new value of ``key``
+        to be the union between the old value and ``value``.
+        Otherwise, set the value of ``key`` to ``value.
+
+        Returns ``True`` if the key already was in the dictionary and
+        ``False`` otherwise.
+        """
+        if key in dictionary:
+            dictionary[key] = dictionary[key] | value
+            return True
+        else:
+            dictionary[key] = value
+            return False
+
+    @staticmethod
+    def _add_morphism_closure(morphisms, morphism, props, add_identities=True,
+                              recurse_composites=True):
+        """
+        Adds a morphism and its attributes to the supplied dictionary
+        ``morphisms``.  If ``add_identities`` is True, also adds the
+        identity morphisms for the domain and the codomain of
+        ``morphism``.
+        """
+        if not Diagram._set_dict_union(morphisms, morphism, props):
+            # We have just added a new morphism.
+
+            if isinstance(morphism, IdentityMorphism):
+                if props:
+                    # Properties for identity morphisms don't really
+                    # make sense, because very much is known about
+                    # identity morphisms already, so much that they
+                    # are trivial.  Having properties for identity
+                    # morphisms would only be confusing.
+                    raise ValueError(
+                        "Instances of IdentityMorphism cannot have properties.")
+                return
+
+            if add_identities:
+                empty = EmptySet
+
+                id_dom = IdentityMorphism(morphism.domain)
+                id_cod = IdentityMorphism(morphism.codomain)
+
+                Diagram._set_dict_union(morphisms, id_dom, empty)
+                Diagram._set_dict_union(morphisms, id_cod, empty)
+
+            for existing_morphism, existing_props in list(morphisms.items()):
+                new_props = existing_props & props
+                if morphism.domain == existing_morphism.codomain:
+                    left = morphism * existing_morphism
+                    Diagram._set_dict_union(morphisms, left, new_props)
+                if morphism.codomain == existing_morphism.domain:
+                    right = existing_morphism * morphism
+                    Diagram._set_dict_union(morphisms, right, new_props)
+
+            if isinstance(morphism, CompositeMorphism) and recurse_composites:
+                # This is a composite morphism, add its components as
+                # well.
+                empty = EmptySet
+                for component in morphism.components:
+                    Diagram._add_morphism_closure(morphisms, component, empty,
+                                                  add_identities)
+
+    def __new__(cls, *args):
+        """
+        Construct a new instance of Diagram.
+
+        Explanation
+        ===========
+
+        If no arguments are supplied, an empty diagram is created.
+
+        If at least an argument is supplied, ``args[0]`` is
+        interpreted as the premises of the diagram.  If ``args[0]`` is
+        a list, it is interpreted as a list of :class:`Morphism`'s, in
+        which each :class:`Morphism` has an empty set of properties.
+        If ``args[0]`` is a Python dictionary or a :class:`Dict`, it
+        is interpreted as a dictionary associating to some
+        :class:`Morphism`'s some properties.
+
+        If at least two arguments are supplied ``args[1]`` is
+        interpreted as the conclusions of the diagram.  The type of
+        ``args[1]`` is interpreted in exactly the same way as the type
+        of ``args[0]``.  If only one argument is supplied, the diagram
+        has no conclusions.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> IdentityMorphism(A) in d.premises.keys()
+        True
+        >>> g * f in d.premises.keys()
+        True
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d.conclusions[g * f]
+        {unique}
+
+        """
+        premises = {}
+        conclusions = {}
+
+        # Here we will keep track of the objects which appear in the
+        # premises.
+        objects = EmptySet
+
+        if len(args) >= 1:
+            # We've got some premises in the arguments.
+            premises_arg = args[0]
+
+            if isinstance(premises_arg, list):
+                # The user has supplied a list of morphisms, none of
+                # which have any attributes.
+                empty = EmptySet
+
+                for morphism in premises_arg:
+                    objects |= FiniteSet(morphism.domain, morphism.codomain)
+                    Diagram._add_morphism_closure(premises, morphism, empty)
+            elif isinstance(premises_arg, (dict, Dict)):
+                # The user has supplied a dictionary of morphisms and
+                # their properties.
+                for morphism, props in premises_arg.items():
+                    objects |= FiniteSet(morphism.domain, morphism.codomain)
+                    Diagram._add_morphism_closure(
+                        premises, morphism, FiniteSet(*props) if iterable(props) else FiniteSet(props))
+
+        if len(args) >= 2:
+            # We also have some conclusions.
+            conclusions_arg = args[1]
+
+            if isinstance(conclusions_arg, list):
+                # The user has supplied a list of morphisms, none of
+                # which have any attributes.
+                empty = EmptySet
+
+                for morphism in conclusions_arg:
+                    # Check that no new objects appear in conclusions.
+                    if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                        (sympify(objects.contains(morphism.codomain)) is S.true)):
+                        # No need to add identities and recurse
+                        # composites this time.
+                        Diagram._add_morphism_closure(
+                            conclusions, morphism, empty, add_identities=False,
+                            recurse_composites=False)
+            elif isinstance(conclusions_arg, (dict, Dict)):
+                # The user has supplied a dictionary of morphisms and
+                # their properties.
+                for morphism, props in conclusions_arg.items():
+                    # Check that no new objects appear in conclusions.
+                    if (morphism.domain in objects) and \
+                       (morphism.codomain in objects):
+                        # No need to add identities and recurse
+                        # composites this time.
+                        Diagram._add_morphism_closure(
+                            conclusions, morphism, FiniteSet(*props) if iterable(props) else FiniteSet(props),
+                            add_identities=False, recurse_composites=False)
+
+        return Basic.__new__(cls, Dict(premises), Dict(conclusions), objects)
+
+    @property
+    def premises(self):
+        """
+        Returns the premises of this diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> from sympy import pretty
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> id_A = IdentityMorphism(A)
+        >>> id_B = IdentityMorphism(B)
+        >>> d = Diagram([f])
+        >>> print(pretty(d.premises, use_unicode=False))
+        {id:A-->A: EmptySet, id:B-->B: EmptySet, f:A-->B: EmptySet}
+
+        """
+        return self.args[0]
+
+    @property
+    def conclusions(self):
+        """
+        Returns the conclusions of this diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> IdentityMorphism(A) in d.premises.keys()
+        True
+        >>> g * f in d.premises.keys()
+        True
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d.conclusions[g * f] == FiniteSet("unique")
+        True
+
+        """
+        return self.args[1]
+
+    @property
+    def objects(self):
+        """
+        Returns the :class:`~.FiniteSet` of objects that appear in this
+        diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> d.objects
+        {Object("A"), Object("B"), Object("C")}
+
+        """
+        return self.args[2]
+
+    def hom(self, A, B):
+        """
+        Returns a 2-tuple of sets of morphisms between objects ``A`` and
+        ``B``: one set of morphisms listed as premises, and the other set
+        of morphisms listed as conclusions.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy import pretty
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> print(pretty(d.hom(A, C), use_unicode=False))
+        ({g*f:A-->C}, {g*f:A-->C})
+
+        See Also
+        ========
+        Object, Morphism
+        """
+        premises = EmptySet
+        conclusions = EmptySet
+
+        for morphism in self.premises.keys():
+            if (morphism.domain == A) and (morphism.codomain == B):
+                premises |= FiniteSet(morphism)
+        for morphism in self.conclusions.keys():
+            if (morphism.domain == A) and (morphism.codomain == B):
+                conclusions |= FiniteSet(morphism)
+
+        return (premises, conclusions)
+
+    def is_subdiagram(self, diagram):
+        """
+        Checks whether ``diagram`` is a subdiagram of ``self``.
+        Diagram `D'` is a subdiagram of `D` if all premises
+        (conclusions) of `D'` are contained in the premises
+        (conclusions) of `D`.  The morphisms contained
+        both in `D'` and `D` should have the same properties for `D'`
+        to be a subdiagram of `D`.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d1 = Diagram([f])
+        >>> d.is_subdiagram(d1)
+        True
+        >>> d1.is_subdiagram(d)
+        False
+        """
+        premises = all((m in self.premises) and
+                       (diagram.premises[m] == self.premises[m])
+                       for m in diagram.premises)
+        if not premises:
+            return False
+
+        conclusions = all((m in self.conclusions) and
+                          (diagram.conclusions[m] == self.conclusions[m])
+                          for m in diagram.conclusions)
+
+        # Premises is surely ``True`` here.
+        return conclusions
+
+    def subdiagram_from_objects(self, objects):
+        """
+        If ``objects`` is a subset of the objects of ``self``, returns
+        a diagram which has as premises all those premises of ``self``
+        which have a domains and codomains in ``objects``, likewise
+        for conclusions.  Properties are preserved.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {f: "unique", g*f: "veryunique"})
+        >>> d1 = d.subdiagram_from_objects(FiniteSet(A, B))
+        >>> d1 == Diagram([f], {f: "unique"})
+        True
+        """
+        if not objects.is_subset(self.objects):
+            raise ValueError(
+                "Supplied objects should all belong to the diagram.")
+
+        new_premises = {}
+        for morphism, props in self.premises.items():
+            if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                (sympify(objects.contains(morphism.codomain)) is S.true)):
+                new_premises[morphism] = props
+
+        new_conclusions = {}
+        for morphism, props in self.conclusions.items():
+            if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                (sympify(objects.contains(morphism.codomain)) is S.true)):
+                new_conclusions[morphism] = props
+
+        return Diagram(new_premises, new_conclusions)

pllava/lib/python3.10/site-packages/sympy/categories/diagram_drawing.py

@@ -0,0 +1,2582 @@
+r"""
+This module contains the functionality to arrange the nodes of a
+diagram on an abstract grid, and then to produce a graphical
+representation of the grid.
+
+The currently supported back-ends are Xy-pic [Xypic].
+
+Layout Algorithm
+================
+
+This section provides an overview of the algorithms implemented in
+:class:`DiagramGrid` to lay out diagrams.
+
+The first step of the algorithm is the removal composite and identity
+morphisms which do not have properties in the supplied diagram.  The
+premises and conclusions of the diagram are then merged.
+
+The generic layout algorithm begins with the construction of the
+"skeleton" of the diagram.  The skeleton is an undirected graph which
+has the objects of the diagram as vertices and has an (undirected)
+edge between each pair of objects between which there exist morphisms.
+The direction of the morphisms does not matter at this stage.  The
+skeleton also includes an edge between each pair of vertices `A` and
+`C` such that there exists an object `B` which is connected via
+a morphism to `A`, and via a morphism to `C`.
+
+The skeleton constructed in this way has the property that every
+object is a vertex of a triangle formed by three edges of the
+skeleton.  This property lies at the base of the generic layout
+algorithm.
+
+After the skeleton has been constructed, the algorithm lists all
+triangles which can be formed.  Note that some triangles will not have
+all edges corresponding to morphisms which will actually be drawn.
+Triangles which have only one edge or less which will actually be
+drawn are immediately discarded.
+
+The list of triangles is sorted according to the number of edges which
+correspond to morphisms, then the triangle with the least number of such
+edges is selected.  One of such edges is picked and the corresponding
+objects are placed horizontally, on a grid.  This edge is recorded to
+be in the fringe.  The algorithm then finds a "welding" of a triangle
+to the fringe.  A welding is an edge in the fringe where a triangle
+could be attached.  If the algorithm succeeds in finding such a
+welding, it adds to the grid that vertex of the triangle which was not
+yet included in any edge in the fringe and records the two new edges in
+the fringe.  This process continues iteratively until all objects of
+the diagram has been placed or until no more weldings can be found.
+
+An edge is only removed from the fringe when a welding to this edge
+has been found, and there is no room around this edge to place
+another vertex.
+
+When no more weldings can be found, but there are still triangles
+left, the algorithm searches for a possibility of attaching one of the
+remaining triangles to the existing structure by a vertex.  If such a
+possibility is found, the corresponding edge of the found triangle is
+placed in the found space and the iterative process of welding
+triangles restarts.
+
+When logical groups are supplied, each of these groups is laid out
+independently.  Then a diagram is constructed in which groups are
+objects and any two logical groups between which there exist morphisms
+are connected via a morphism.  This diagram is laid out.  Finally,
+the grid which includes all objects of the initial diagram is
+constructed by replacing the cells which contain logical groups with
+the corresponding laid out grids, and by correspondingly expanding the
+rows and columns.
+
+The sequential layout algorithm begins by constructing the
+underlying undirected graph defined by the morphisms obtained after
+simplifying premises and conclusions and merging them (see above).
+The vertex with the minimal degree is then picked up and depth-first
+search is started from it.  All objects which are located at distance
+`n` from the root in the depth-first search tree, are positioned in
+the `n`-th column of the resulting grid.  The sequential layout will
+therefore attempt to lay the objects out along a line.
+
+References
+==========
+
+.. [Xypic] https://xy-pic.sourceforge.net/
+
+"""
+from sympy.categories import (CompositeMorphism, IdentityMorphism,
+                              NamedMorphism, Diagram)
+from sympy.core import Dict, Symbol, default_sort_key
+from sympy.printing.latex import latex
+from sympy.sets import FiniteSet
+from sympy.utilities.iterables import iterable
+from sympy.utilities.decorator import doctest_depends_on
+
+from itertools import chain
+
+
+__doctest_requires__ = {('preview_diagram',): 'pyglet'}
+
+
+class _GrowableGrid:
+    """
+    Holds a growable grid of objects.
+
+    Explanation
+    ===========
+
+    It is possible to append or prepend a row or a column to the grid
+    using the corresponding methods.  Prepending rows or columns has
+    the effect of changing the coordinates of the already existing
+    elements.
+
+    This class currently represents a naive implementation of the
+    functionality with little attempt at optimisation.
+    """
+    def __init__(self, width, height):
+        self._width = width
+        self._height = height
+
+        self._array = [[None for j in range(width)] for i in range(height)]
+
+    @property
+    def width(self):
+        return self._width
+
+    @property
+    def height(self):
+        return self._height
+
+    def __getitem__(self, i_j):
+        """
+        Returns the element located at in the i-th line and j-th
+        column.
+        """
+        i, j = i_j
+        return self._array[i][j]
+
+    def __setitem__(self, i_j, newvalue):
+        """
+        Sets the element located at in the i-th line and j-th
+        column.
+        """
+        i, j = i_j
+        self._array[i][j] = newvalue
+
+    def append_row(self):
+        """
+        Appends an empty row to the grid.
+        """
+        self._height += 1
+        self._array.append([None for j in range(self._width)])
+
+    def append_column(self):
+        """
+        Appends an empty column to the grid.
+        """
+        self._width += 1
+        for i in range(self._height):
+            self._array[i].append(None)
+
+    def prepend_row(self):
+        """
+        Prepends the grid with an empty row.
+        """
+        self._height += 1
+        self._array.insert(0, [None for j in range(self._width)])
+
+    def prepend_column(self):
+        """
+        Prepends the grid with an empty column.
+        """
+        self._width += 1
+        for i in range(self._height):
+            self._array[i].insert(0, None)
+
+
+class DiagramGrid:
+    r"""
+    Constructs and holds the fitting of the diagram into a grid.
+
+    Explanation
+    ===========
+
+    The mission of this class is to analyse the structure of the
+    supplied diagram and to place its objects on a grid such that,
+    when the objects and the morphisms are actually drawn, the diagram
+    would be "readable", in the sense that there will not be many
+    intersections of moprhisms.  This class does not perform any
+    actual drawing.  It does strive nevertheless to offer sufficient
+    metadata to draw a diagram.
+
+    Consider the following simple diagram.
+
+    >>> from sympy.categories import Object, NamedMorphism
+    >>> from sympy.categories import Diagram, DiagramGrid
+    >>> from sympy import pprint
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g])
+
+    The simplest way to have a diagram laid out is the following:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> (grid.width, grid.height)
+    (2, 2)
+    >>> pprint(grid)
+    A  B
+    <BLANKLINE>
+       C
+
+    Sometimes one sees the diagram as consisting of logical groups.
+    One can advise ``DiagramGrid`` as to such groups by employing the
+    ``groups`` keyword argument.
+
+    Consider the following diagram:
+
+    >>> D = Object("D")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> h = NamedMorphism(D, A, "h")
+    >>> k = NamedMorphism(D, B, "k")
+    >>> diagram = Diagram([f, g, h, k])
+
+    Lay it out with generic layout:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> pprint(grid)
+    A  B  D
+    <BLANKLINE>
+       C
+
+    Now, we can group the objects `A` and `D` to have them near one
+    another:
+
+    >>> grid = DiagramGrid(diagram, groups=[[A, D], B, C])
+    >>> pprint(grid)
+    B     C
+    <BLANKLINE>
+    A  D
+
+    Note how the positioning of the other objects changes.
+
+    Further indications can be supplied to the constructor of
+    :class:`DiagramGrid` using keyword arguments.  The currently
+    supported hints are explained in the following paragraphs.
+
+    :class:`DiagramGrid` does not automatically guess which layout
+    would suit the supplied diagram better.  Consider, for example,
+    the following linear diagram:
+
+    >>> E = Object("E")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> h = NamedMorphism(C, D, "h")
+    >>> i = NamedMorphism(D, E, "i")
+    >>> diagram = Diagram([f, g, h, i])
+
+    When laid out with the generic layout, it does not get to look
+    linear:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> pprint(grid)
+    A  B
+    <BLANKLINE>
+       C  D
+    <BLANKLINE>
+          E
+
+    To get it laid out in a line, use ``layout="sequential"``:
+
+    >>> grid = DiagramGrid(diagram, layout="sequential")
+    >>> pprint(grid)
+    A  B  C  D  E
+
+    One may sometimes need to transpose the resulting layout.  While
+    this can always be done by hand, :class:`DiagramGrid` provides a
+    hint for that purpose:
+
+    >>> grid = DiagramGrid(diagram, layout="sequential", transpose=True)
+    >>> pprint(grid)
+    A
+    <BLANKLINE>
+    B
+    <BLANKLINE>
+    C
+    <BLANKLINE>
+    D
+    <BLANKLINE>
+    E
+
+    Separate hints can also be provided for each group.  For an
+    example, refer to ``tests/test_drawing.py``, and see the different
+    ways in which the five lemma [FiveLemma] can be laid out.
+
+    See Also
+    ========
+
+    Diagram
+
+    References
+    ==========
+
+    .. [FiveLemma] https://en.wikipedia.org/wiki/Five_lemma
+    """
+    @staticmethod
+    def _simplify_morphisms(morphisms):
+        """
+        Given a dictionary mapping morphisms to their properties,
+        returns a new dictionary in which there are no morphisms which
+        do not have properties, and which are compositions of other
+        morphisms included in the dictionary.  Identities are dropped
+        as well.
+        """
+        newmorphisms = {}
+        for morphism, props in morphisms.items():
+            if isinstance(morphism, CompositeMorphism) and not props:
+                continue
+            elif isinstance(morphism, IdentityMorphism):
+                continue
+            else:
+                newmorphisms[morphism] = props
+        return newmorphisms
+
+    @staticmethod
+    def _merge_premises_conclusions(premises, conclusions):
+        """
+        Given two dictionaries of morphisms and their properties,
+        produces a single dictionary which includes elements from both
+        dictionaries.  If a morphism has some properties in premises
+        and also in conclusions, the properties in conclusions take
+        priority.
+        """
+        return dict(chain(premises.items(), conclusions.items()))
+
+    @staticmethod
+    def _juxtapose_edges(edge1, edge2):
+        """
+        If ``edge1`` and ``edge2`` have precisely one common endpoint,
+        returns an edge which would form a triangle with ``edge1`` and
+        ``edge2``.
+
+        If ``edge1`` and ``edge2`` do not have a common endpoint,
+        returns ``None``.
+
+        If ``edge1`` and ``edge`` are the same edge, returns ``None``.
+        """
+        intersection = edge1 & edge2
+        if len(intersection) != 1:
+            # The edges either have no common points or are equal.
+            return None
+
+        # The edges have a common endpoint.  Extract the different
+        # endpoints and set up the new edge.
+        return (edge1 - intersection) | (edge2 - intersection)
+
+    @staticmethod
+    def _add_edge_append(dictionary, edge, elem):
+        """
+        If ``edge`` is not in ``dictionary``, adds ``edge`` to the
+        dictionary and sets its value to ``[elem]``.  Otherwise
+        appends ``elem`` to the value of existing entry.
+
+        Note that edges are undirected, thus `(A, B) = (B, A)`.
+        """
+        if edge in dictionary:
+            dictionary[edge].append(elem)
+        else:
+            dictionary[edge] = [elem]
+
+    @staticmethod
+    def _build_skeleton(morphisms):
+        """
+        Creates a dictionary which maps edges to corresponding
+        morphisms.  Thus for a morphism `f:A\rightarrow B`, the edge
+        `(A, B)` will be associated with `f`.  This function also adds
+        to the list those edges which are formed by juxtaposition of
+        two edges already in the list.  These new edges are not
+        associated with any morphism and are only added to assure that
+        the diagram can be decomposed into triangles.
+        """
+        edges = {}
+        # Create edges for morphisms.
+        for morphism in morphisms:
+            DiagramGrid._add_edge_append(
+                edges, frozenset([morphism.domain, morphism.codomain]), morphism)
+
+        # Create new edges by juxtaposing existing edges.
+        edges1 = dict(edges)
+        for w in edges1:
+            for v in edges1:
+                wv = DiagramGrid._juxtapose_edges(w, v)
+                if wv and wv not in edges:
+                    edges[wv] = []
+
+        return edges
+
+    @staticmethod
+    def _list_triangles(edges):
+        """
+        Builds the set of triangles formed by the supplied edges.  The
+        triangles are arbitrary and need not be commutative.  A
+        triangle is a set that contains all three of its sides.
+        """
+        triangles = set()
+
+        for w in edges:
+            for v in edges:
+                wv = DiagramGrid._juxtapose_edges(w, v)
+                if wv and wv in edges:
+                    triangles.add(frozenset([w, v, wv]))
+
+        return triangles
+
+    @staticmethod
+    def _drop_redundant_triangles(triangles, skeleton):
+        """
+        Returns a list which contains only those triangles who have
+        morphisms associated with at least two edges.
+        """
+        return [tri for tri in triangles
+                if len([e for e in tri if skeleton[e]]) >= 2]
+
+    @staticmethod
+    def _morphism_length(morphism):
+        """
+        Returns the length of a morphism.  The length of a morphism is
+        the number of components it consists of.  A non-composite
+        morphism is of length 1.
+        """
+        if isinstance(morphism, CompositeMorphism):
+            return len(morphism.components)
+        else:
+            return 1
+
+    @staticmethod
+    def _compute_triangle_min_sizes(triangles, edges):
+        r"""
+        Returns a dictionary mapping triangles to their minimal sizes.
+        The minimal size of a triangle is the sum of maximal lengths
+        of morphisms associated to the sides of the triangle.  The
+        length of a morphism is the number of components it consists
+        of.  A non-composite morphism is of length 1.
+
+        Sorting triangles by this metric attempts to address two
+        aspects of layout.  For triangles with only simple morphisms
+        in the edge, this assures that triangles with all three edges
+        visible will get typeset after triangles with less visible
+        edges, which sometimes minimizes the necessity in diagonal
+        arrows.  For triangles with composite morphisms in the edges,
+        this assures that objects connected with shorter morphisms
+        will be laid out first, resulting the visual proximity of
+        those objects which are connected by shorter morphisms.
+        """
+        triangle_sizes = {}
+        for triangle in triangles:
+            size = 0
+            for e in triangle:
+                morphisms = edges[e]
+                if morphisms:
+                    size += max(DiagramGrid._morphism_length(m)
+                                for m in morphisms)
+            triangle_sizes[triangle] = size
+        return triangle_sizes
+
+    @staticmethod
+    def _triangle_objects(triangle):
+        """
+        Given a triangle, returns the objects included in it.
+        """
+        # A triangle is a frozenset of three two-element frozensets
+        # (the edges).  This chains the three edges together and
+        # creates a frozenset from the iterator, thus producing a
+        # frozenset of objects of the triangle.
+        return frozenset(chain(*tuple(triangle)))
+
+    @staticmethod
+    def _other_vertex(triangle, edge):
+        """
+        Given a triangle and an edge of it, returns the vertex which
+        opposes the edge.
+        """
+        # This gets the set of objects of the triangle and then
+        # subtracts the set of objects employed in ``edge`` to get the
+        # vertex opposite to ``edge``.
+        return list(DiagramGrid._triangle_objects(triangle) - set(edge))[0]
+
+    @staticmethod
+    def _empty_point(pt, grid):
+        """
+        Checks if the cell at coordinates ``pt`` is either empty or
+        out of the bounds of the grid.
+        """
+        if (pt[0] < 0) or (pt[1] < 0) or \
+           (pt[0] >= grid.height) or (pt[1] >= grid.width):
+            return True
+        return grid[pt] is None
+
+    @staticmethod
+    def _put_object(coords, obj, grid, fringe):
+        """
+        Places an object at the coordinate ``cords`` in ``grid``,
+        growing the grid and updating ``fringe``, if necessary.
+        Returns (0, 0) if no row or column has been prepended, (1, 0)
+        if a row was prepended, (0, 1) if a column was prepended and
+        (1, 1) if both a column and a row were prepended.
+        """
+        (i, j) = coords
+        offset = (0, 0)
+        if i == -1:
+            grid.prepend_row()
+            i = 0
+            offset = (1, 0)
+            for k in range(len(fringe)):
+                ((i1, j1), (i2, j2)) = fringe[k]
+                fringe[k] = ((i1 + 1, j1), (i2 + 1, j2))
+        elif i == grid.height:
+            grid.append_row()
+
+        if j == -1:
+            j = 0
+            offset = (offset[0], 1)
+            grid.prepend_column()
+            for k in range(len(fringe)):
+                ((i1, j1), (i2, j2)) = fringe[k]
+                fringe[k] = ((i1, j1 + 1), (i2, j2 + 1))
+        elif j == grid.width:
+            grid.append_column()
+
+        grid[i, j] = obj
+        return offset
+
+    @staticmethod
+    def _choose_target_cell(pt1, pt2, edge, obj, skeleton, grid):
+        """
+        Given two points, ``pt1`` and ``pt2``, and the welding edge
+        ``edge``, chooses one of the two points to place the opposing
+        vertex ``obj`` of the triangle.  If neither of this points
+        fits, returns ``None``.
+        """
+        pt1_empty = DiagramGrid._empty_point(pt1, grid)
+        pt2_empty = DiagramGrid._empty_point(pt2, grid)
+
+        if pt1_empty and pt2_empty:
+            # Both cells are empty.  Of these two, choose that cell
+            # which will assure that a visible edge of the triangle
+            # will be drawn perpendicularly to the current welding
+            # edge.
+
+            A = grid[edge[0]]
+
+            if skeleton.get(frozenset([A, obj])):
+                return pt1
+            else:
+                return pt2
+        if pt1_empty:
+            return pt1
+        elif pt2_empty:
+            return pt2
+        else:
+            return None
+
+    @staticmethod
+    def _find_triangle_to_weld(triangles, fringe, grid):
+        """
+        Finds, if possible, a triangle and an edge in the ``fringe`` to
+        which the triangle could be attached.  Returns the tuple
+        containing the triangle and the index of the corresponding
+        edge in the ``fringe``.
+
+        This function relies on the fact that objects are unique in
+        the diagram.
+        """
+        for triangle in triangles:
+            for (a, b) in fringe:
+                if frozenset([grid[a], grid[b]]) in triangle:
+                    return (triangle, (a, b))
+        return None
+
+    @staticmethod
+    def _weld_triangle(tri, welding_edge, fringe, grid, skeleton):
+        """
+        If possible, welds the triangle ``tri`` to ``fringe`` and
+        returns ``False``.  If this method encounters a degenerate
+        situation in the fringe and corrects it such that a restart of
+        the search is required, it returns ``True`` (which means that
+        a restart in finding triangle weldings is required).
+
+        A degenerate situation is a situation when an edge listed in
+        the fringe does not belong to the visual boundary of the
+        diagram.
+        """
+        a, b = welding_edge
+        target_cell = None
+
+        obj = DiagramGrid._other_vertex(tri, (grid[a], grid[b]))
+
+        # We now have a triangle and an edge where it can be welded to
+        # the fringe.  Decide where to place the other vertex of the
+        # triangle and check for degenerate situations en route.
+
+        if (abs(a[0] - b[0]) == 1) and (abs(a[1] - b[1]) == 1):
+            # A diagonal edge.
+            target_cell = (a[0], b[1])
+            if grid[target_cell]:
+                # That cell is already occupied.
+                target_cell = (b[0], a[1])
+
+                if grid[target_cell]:
+                    # Degenerate situation, this edge is not
+                    # on the actual fringe.  Correct the
+                    # fringe and go on.
+                    fringe.remove((a, b))
+                    return True
+        elif a[0] == b[0]:
+            # A horizontal edge.  We first attempt to build the
+            # triangle in the downward direction.
+
+            down_left = a[0] + 1, a[1]
+            down_right = a[0] + 1, b[1]
+
+            target_cell = DiagramGrid._choose_target_cell(
+                down_left, down_right, (a, b), obj, skeleton, grid)
+
+            if not target_cell:
+                # No room below this edge.  Check above.
+                up_left = a[0] - 1, a[1]
+                up_right = a[0] - 1, b[1]
+
+                target_cell = DiagramGrid._choose_target_cell(
+                    up_left, up_right, (a, b), obj, skeleton, grid)
+
+                if not target_cell:
+                    # This edge is not in the fringe, remove it
+                    # and restart.
+                    fringe.remove((a, b))
+                    return True
+        elif a[1] == b[1]:
+            # A vertical edge.  We will attempt to place the other
+            # vertex of the triangle to the right of this edge.
+            right_up = a[0], a[1] + 1
+            right_down = b[0], a[1] + 1
+
+            target_cell = DiagramGrid._choose_target_cell(
+                right_up, right_down, (a, b), obj, skeleton, grid)
+
+            if not target_cell:
+                # No room to the left.  See what's to the right.
+                left_up = a[0], a[1] - 1
+                left_down = b[0], a[1] - 1
+
+                target_cell = DiagramGrid._choose_target_cell(
+                    left_up, left_down, (a, b), obj, skeleton, grid)
+
+                if not target_cell:
+                    # This edge is not in the fringe, remove it
+                    # and restart.
+                    fringe.remove((a, b))
+                    return True
+
+        # We now know where to place the other vertex of the
+        # triangle.
+        offset = DiagramGrid._put_object(target_cell, obj, grid, fringe)
+
+        # Take care of the displacement of coordinates if a row or
+        # a column was prepended.
+        target_cell = (target_cell[0] + offset[0],
+                       target_cell[1] + offset[1])
+        a = (a[0] + offset[0], a[1] + offset[1])
+        b = (b[0] + offset[0], b[1] + offset[1])
+
+        fringe.extend([(a, target_cell), (b, target_cell)])
+
+        # No restart is required.
+        return False
+
+    @staticmethod
+    def _triangle_key(tri, triangle_sizes):
+        """
+        Returns a key for the supplied triangle.  It should be the
+        same independently of the hash randomisation.
+        """
+        objects = sorted(
+            DiagramGrid._triangle_objects(tri), key=default_sort_key)
+        return (triangle_sizes[tri], default_sort_key(objects))
+
+    @staticmethod
+    def _pick_root_edge(tri, skeleton):
+        """
+        For a given triangle always picks the same root edge.  The
+        root edge is the edge that will be placed first on the grid.
+        """
+        candidates = [sorted(e, key=default_sort_key)
+                      for e in tri if skeleton[e]]
+        sorted_candidates = sorted(candidates, key=default_sort_key)
+        # Don't forget to assure the proper ordering of the vertices
+        # in this edge.
+        return tuple(sorted(sorted_candidates[0], key=default_sort_key))
+
+    @staticmethod
+    def _drop_irrelevant_triangles(triangles, placed_objects):
+        """
+        Returns only those triangles whose set of objects is not
+        completely included in ``placed_objects``.
+        """
+        return [tri for tri in triangles if not placed_objects.issuperset(
+            DiagramGrid._triangle_objects(tri))]
+
+    @staticmethod
+    def _grow_pseudopod(triangles, fringe, grid, skeleton, placed_objects):
+        """
+        Starting from an object in the existing structure on the ``grid``,
+        adds an edge to which a triangle from ``triangles`` could be
+        welded.  If this method has found a way to do so, it returns
+        the object it has just added.
+
+        This method should be applied when ``_weld_triangle`` cannot
+        find weldings any more.
+        """
+        for i in range(grid.height):
+            for j in range(grid.width):
+                obj = grid[i, j]
+                if not obj:
+                    continue
+
+                # Here we need to choose a triangle which has only
+                # ``obj`` in common with the existing structure.  The
+                # situations when this is not possible should be
+                # handled elsewhere.
+
+                def good_triangle(tri):
+                    objs = DiagramGrid._triangle_objects(tri)
+                    return obj in objs and \
+                        placed_objects & (objs - {obj}) == set()
+
+                tris = [tri for tri in triangles if good_triangle(tri)]
+                if not tris:
+                    # This object is not interesting.
+                    continue
+
+                # Pick the "simplest" of the triangles which could be
+                # attached.  Remember that the list of triangles is
+                # sorted according to their "simplicity" (see
+                # _compute_triangle_min_sizes for the metric).
+                #
+                # Note that ``tris`` are sequentially built from
+                # ``triangles``, so we don't have to worry about hash
+                # randomisation.
+                tri = tris[0]
+
+                # We have found a triangle which could be attached to
+                # the existing structure by a vertex.
+
+                candidates = sorted([e for e in tri if skeleton[e]],
+                                    key=lambda e: FiniteSet(*e).sort_key())
+                edges = [e for e in candidates if obj in e]
+
+                # Note that a meaningful edge (i.e., and edge that is
+                # associated with a morphism) containing ``obj``
+                # always exists.  That's because all triangles are
+                # guaranteed to have at least two meaningful edges.
+                # See _drop_redundant_triangles.
+
+                # Get the object at the other end of the edge.
+                edge = edges[0]
+                other_obj = tuple(edge - frozenset([obj]))[0]
+
+                # Now check for free directions.  When checking for
+                # free directions, prefer the horizontal and vertical
+                # directions.
+                neighbours = [(i - 1, j), (i, j + 1), (i + 1, j), (i, j - 1),
+                              (i - 1, j - 1), (i - 1, j + 1), (i + 1, j - 1), (i + 1, j + 1)]
+
+                for pt in neighbours:
+                    if DiagramGrid._empty_point(pt, grid):
+                        # We have a found a place to grow the
+                        # pseudopod into.
+                        offset = DiagramGrid._put_object(
+                            pt, other_obj, grid, fringe)
+
+                        i += offset[0]
+                        j += offset[1]
+                        pt = (pt[0] + offset[0], pt[1] + offset[1])
+                        fringe.append(((i, j), pt))
+
+                        return other_obj
+
+        # This diagram is actually cooler that I can handle.  Fail cowardly.
+        return None
+
+    @staticmethod
+    def _handle_groups(diagram, groups, merged_morphisms, hints):
+        """
+        Given the slightly preprocessed morphisms of the diagram,
+        produces a grid laid out according to ``groups``.
+
+        If a group has hints, it is laid out with those hints only,
+        without any influence from ``hints``.  Otherwise, it is laid
+        out with ``hints``.
+        """
+        def lay_out_group(group, local_hints):
+            """
+            If ``group`` is a set of objects, uses a ``DiagramGrid``
+            to lay it out and returns the grid.  Otherwise returns the
+            object (i.e., ``group``).  If ``local_hints`` is not
+            empty, it is supplied to ``DiagramGrid`` as the dictionary
+            of hints.  Otherwise, the ``hints`` argument of
+            ``_handle_groups`` is used.
+            """
+            if isinstance(group, FiniteSet):
+                # Set up the corresponding object-to-group
+                # mappings.
+                for obj in group:
+                    obj_groups[obj] = group
+
+                # Lay out the current group.
+                if local_hints:
+                    groups_grids[group] = DiagramGrid(
+                        diagram.subdiagram_from_objects(group), **local_hints)
+                else:
+                    groups_grids[group] = DiagramGrid(
+                        diagram.subdiagram_from_objects(group), **hints)
+            else:
+                obj_groups[group] = group
+
+        def group_to_finiteset(group):
+            """
+            Converts ``group`` to a :class:``FiniteSet`` if it is an
+            iterable.
+            """
+            if iterable(group):
+                return FiniteSet(*group)
+            else:
+                return group
+
+        obj_groups = {}
+        groups_grids = {}
+
+        # We would like to support various containers to represent
+        # groups.  To achieve that, before laying each group out, it
+        # should be converted to a FiniteSet, because that is what the
+        # following code expects.
+
+        if isinstance(groups, (dict, Dict)):
+            finiteset_groups = {}
+            for group, local_hints in groups.items():
+                finiteset_group = group_to_finiteset(group)
+                finiteset_groups[finiteset_group] = local_hints
+                lay_out_group(group, local_hints)
+            groups = finiteset_groups
+        else:
+            finiteset_groups = []
+            for group in groups:
+                finiteset_group = group_to_finiteset(group)
+                finiteset_groups.append(finiteset_group)
+                lay_out_group(finiteset_group, None)
+            groups = finiteset_groups
+
+        new_morphisms = []
+        for morphism in merged_morphisms:
+            dom = obj_groups[morphism.domain]
+            cod = obj_groups[morphism.codomain]
+            # Note that we are not really interested in morphisms
+            # which do not employ two different groups, because
+            # these do not influence the layout.
+            if dom != cod:
+                # These are essentially unnamed morphisms; they are
+                # not going to mess in the final layout.  By giving
+                # them the same names, we avoid unnecessary
+                # duplicates.
+                new_morphisms.append(NamedMorphism(dom, cod, "dummy"))
+
+        # Lay out the new diagram.  Since these are dummy morphisms,
+        # properties and conclusions are irrelevant.
+        top_grid = DiagramGrid(Diagram(new_morphisms))
+
+        # We now have to substitute the groups with the corresponding
+        # grids, laid out at the beginning of this function.  Compute
+        # the size of each row and column in the grid, so that all
+        # nested grids fit.
+
+        def group_size(group):
+            """
+            For the supplied group (or object, eventually), returns
+            the size of the cell that will hold this group (object).
+            """
+            if group in groups_grids:
+                grid = groups_grids[group]
+                return (grid.height, grid.width)
+            else:
+                return (1, 1)
+
+        row_heights = [max(group_size(top_grid[i, j])[0]
+                           for j in range(top_grid.width))
+                       for i in range(top_grid.height)]
+
+        column_widths = [max(group_size(top_grid[i, j])[1]
+                             for i in range(top_grid.height))
+                         for j in range(top_grid.width)]
+
+        grid = _GrowableGrid(sum(column_widths), sum(row_heights))
+
+        real_row = 0
+        real_column = 0
+        for logical_row in range(top_grid.height):
+            for logical_column in range(top_grid.width):
+                obj = top_grid[logical_row, logical_column]
+
+                if obj in groups_grids:
+                    # This is a group.  Copy the corresponding grid in
+                    # place.
+                    local_grid = groups_grids[obj]
+                    for i in range(local_grid.height):
+                        for j in range(local_grid.width):
+                            grid[real_row + i,
+                                real_column + j] = local_grid[i, j]
+                else:
+                    # This is an object.  Just put it there.
+                    grid[real_row, real_column] = obj
+
+                real_column += column_widths[logical_column]
+            real_column = 0
+            real_row += row_heights[logical_row]
+
+        return grid
+
+    @staticmethod
+    def _generic_layout(diagram, merged_morphisms):
+        """
+        Produces the generic layout for the supplied diagram.
+        """
+        all_objects = set(diagram.objects)
+        if len(all_objects) == 1:
+            # There only one object in the diagram, just put in on 1x1
+            # grid.
+            grid = _GrowableGrid(1, 1)
+            grid[0, 0] = tuple(all_objects)[0]
+            return grid
+
+        skeleton = DiagramGrid._build_skeleton(merged_morphisms)
+
+        grid = _GrowableGrid(2, 1)
+
+        if len(skeleton) == 1:
+            # This diagram contains only one morphism.  Draw it
+            # horizontally.
+            objects = sorted(all_objects, key=default_sort_key)
+            grid[0, 0] = objects[0]
+            grid[0, 1] = objects[1]
+
+            return grid
+
+        triangles = DiagramGrid._list_triangles(skeleton)
+        triangles = DiagramGrid._drop_redundant_triangles(triangles, skeleton)
+        triangle_sizes = DiagramGrid._compute_triangle_min_sizes(
+            triangles, skeleton)
+
+        triangles = sorted(triangles, key=lambda tri:
+                           DiagramGrid._triangle_key(tri, triangle_sizes))
+
+        # Place the first edge on the grid.
+        root_edge = DiagramGrid._pick_root_edge(triangles[0], skeleton)
+        grid[0, 0], grid[0, 1] = root_edge
+        fringe = [((0, 0), (0, 1))]
+
+        # Record which objects we now have on the grid.
+        placed_objects = set(root_edge)
+
+        while placed_objects != all_objects:
+            welding = DiagramGrid._find_triangle_to_weld(
+                triangles, fringe, grid)
+
+            if welding:
+                (triangle, welding_edge) = welding
+
+                restart_required = DiagramGrid._weld_triangle(
+                    triangle, welding_edge, fringe, grid, skeleton)
+                if restart_required:
+                    continue
+
+                placed_objects.update(
+                    DiagramGrid._triangle_objects(triangle))
+            else:
+                # No more weldings found.  Try to attach triangles by
+                # vertices.
+                new_obj = DiagramGrid._grow_pseudopod(
+                    triangles, fringe, grid, skeleton, placed_objects)
+
+                if not new_obj:
+                    # No more triangles can be attached, not even by
+                    # the edge.  We will set up a new diagram out of
+                    # what has been left, laid it out independently,
+                    # and then attach it to this one.
+
+                    remaining_objects = all_objects - placed_objects
+
+                    remaining_diagram = diagram.subdiagram_from_objects(
+                        FiniteSet(*remaining_objects))
+                    remaining_grid = DiagramGrid(remaining_diagram)
+
+                    # Now, let's glue ``remaining_grid`` to ``grid``.
+                    final_width = grid.width + remaining_grid.width
+                    final_height = max(grid.height, remaining_grid.height)
+                    final_grid = _GrowableGrid(final_width, final_height)
+
+                    for i in range(grid.width):
+                        for j in range(grid.height):
+                            final_grid[i, j] = grid[i, j]
+
+                    start_j = grid.width
+                    for i in range(remaining_grid.height):
+                        for j in range(remaining_grid.width):
+                            final_grid[i, start_j + j] = remaining_grid[i, j]
+
+                    return final_grid
+
+                placed_objects.add(new_obj)
+
+            triangles = DiagramGrid._drop_irrelevant_triangles(
+                triangles, placed_objects)
+
+        return grid
+
+    @staticmethod
+    def _get_undirected_graph(objects, merged_morphisms):
+        """
+        Given the objects and the relevant morphisms of a diagram,
+        returns the adjacency lists of the underlying undirected
+        graph.
+        """
+        adjlists = {}
+        for obj in objects:
+            adjlists[obj] = []
+
+        for morphism in merged_morphisms:
+            adjlists[morphism.domain].append(morphism.codomain)
+            adjlists[morphism.codomain].append(morphism.domain)
+
+        # Assure that the objects in the adjacency list are always in
+        # the same order.
+        for obj in adjlists.keys():
+            adjlists[obj].sort(key=default_sort_key)
+
+        return adjlists
+
+    @staticmethod
+    def _sequential_layout(diagram, merged_morphisms):
+        r"""
+        Lays out the diagram in "sequential" layout.  This method
+        will attempt to produce a result as close to a line as
+        possible.  For linear diagrams, the result will actually be a
+        line.
+        """
+        objects = diagram.objects
+        sorted_objects = sorted(objects, key=default_sort_key)
+
+        # Set up the adjacency lists of the underlying undirected
+        # graph of ``merged_morphisms``.
+        adjlists = DiagramGrid._get_undirected_graph(objects, merged_morphisms)
+
+        root = min(sorted_objects, key=lambda x: len(adjlists[x]))
+        grid = _GrowableGrid(1, 1)
+        grid[0, 0] = root
+
+        placed_objects = {root}
+
+        def place_objects(pt, placed_objects):
+            """
+            Does depth-first search in the underlying graph of the
+            diagram and places the objects en route.
+            """
+            # We will start placing new objects from here.
+            new_pt = (pt[0], pt[1] + 1)
+
+            for adjacent_obj in adjlists[grid[pt]]:
+                if adjacent_obj in placed_objects:
+                    # This object has already been placed.
+                    continue
+
+                DiagramGrid._put_object(new_pt, adjacent_obj, grid, [])
+                placed_objects.add(adjacent_obj)
+                placed_objects.update(place_objects(new_pt, placed_objects))
+
+                new_pt = (new_pt[0] + 1, new_pt[1])
+
+            return placed_objects
+
+        place_objects((0, 0), placed_objects)
+
+        return grid
+
+    @staticmethod
+    def _drop_inessential_morphisms(merged_morphisms):
+        r"""
+        Removes those morphisms which should appear in the diagram,
+        but which have no relevance to object layout.
+
+        Currently this removes "loop" morphisms: the non-identity
+        morphisms with the same domains and codomains.
+        """
+        morphisms = [m for m in merged_morphisms if m.domain != m.codomain]
+        return morphisms
+
+    @staticmethod
+    def _get_connected_components(objects, merged_morphisms):
+        """
+        Given a container of morphisms, returns a list of connected
+        components formed by these morphisms.  A connected component
+        is represented by a diagram consisting of the corresponding
+        morphisms.
+        """
+        component_index = {}
+        for o in objects:
+            component_index[o] = None
+
+        # Get the underlying undirected graph of the diagram.
+        adjlist = DiagramGrid._get_undirected_graph(objects, merged_morphisms)
+
+        def traverse_component(object, current_index):
+            """
+            Does a depth-first search traversal of the component
+            containing ``object``.
+            """
+            component_index[object] = current_index
+            for o in adjlist[object]:
+                if component_index[o] is None:
+                    traverse_component(o, current_index)
+
+        # Traverse all components.
+        current_index = 0
+        for o in adjlist:
+            if component_index[o] is None:
+                traverse_component(o, current_index)
+                current_index += 1
+
+        # List the objects of the components.
+        component_objects = [[] for i in range(current_index)]
+        for o, idx in component_index.items():
+            component_objects[idx].append(o)
+
+        # Finally, list the morphisms belonging to each component.
+        #
+        # Note: If some objects are isolated, they will not get any
+        # morphisms at this stage, and since the layout algorithm
+        # relies, we are essentially going to lose this object.
+        # Therefore, check if there are isolated objects and, for each
+        # of them, provide the trivial identity morphism.  It will get
+        # discarded later, but the object will be there.
+
+        component_morphisms = []
+        for component in component_objects:
+            current_morphisms = {}
+            for m in merged_morphisms:
+                if (m.domain in component) and (m.codomain in component):
+                    current_morphisms[m] = merged_morphisms[m]
+
+            if len(component) == 1:
+                # Let's add an identity morphism, for the sake of
+                # surely having morphisms in this component.
+                current_morphisms[IdentityMorphism(component[0])] = FiniteSet()
+
+            component_morphisms.append(Diagram(current_morphisms))
+
+        return component_morphisms
+
+    def __init__(self, diagram, groups=None, **hints):
+        premises = DiagramGrid._simplify_morphisms(diagram.premises)
+        conclusions = DiagramGrid._simplify_morphisms(diagram.conclusions)
+        all_merged_morphisms = DiagramGrid._merge_premises_conclusions(
+            premises, conclusions)
+        merged_morphisms = DiagramGrid._drop_inessential_morphisms(
+            all_merged_morphisms)
+
+        # Store the merged morphisms for later use.
+        self._morphisms = all_merged_morphisms
+
+        components = DiagramGrid._get_connected_components(
+            diagram.objects, all_merged_morphisms)
+
+        if groups and (groups != diagram.objects):
+            # Lay out the diagram according to the groups.
+            self._grid = DiagramGrid._handle_groups(
+                diagram, groups, merged_morphisms, hints)
+        elif len(components) > 1:
+            # Note that we check for connectedness _before_ checking
+            # the layout hints because the layout strategies don't
+            # know how to deal with disconnected diagrams.
+
+            # The diagram is disconnected.  Lay out the components
+            # independently.
+            grids = []
+
+            # Sort the components to eventually get the grids arranged
+            # in a fixed, hash-independent order.
+            components = sorted(components, key=default_sort_key)
+
+            for component in components:
+                grid = DiagramGrid(component, **hints)
+                grids.append(grid)
+
+            # Throw the grids together, in a line.
+            total_width = sum(g.width for g in grids)
+            total_height = max(g.height for g in grids)
+
+            grid = _GrowableGrid(total_width, total_height)
+            start_j = 0
+            for g in grids:
+                for i in range(g.height):
+                    for j in range(g.width):
+                        grid[i, start_j + j] = g[i, j]
+
+                start_j += g.width
+
+            self._grid = grid
+        elif "layout" in hints:
+            if hints["layout"] == "sequential":
+                self._grid = DiagramGrid._sequential_layout(
+                    diagram, merged_morphisms)
+        else:
+            self._grid = DiagramGrid._generic_layout(diagram, merged_morphisms)
+
+        if hints.get("transpose"):
+            # Transpose the resulting grid.
+            grid = _GrowableGrid(self._grid.height, self._grid.width)
+            for i in range(self._grid.height):
+                for j in range(self._grid.width):
+                    grid[j, i] = self._grid[i, j]
+            self._grid = grid
+
+    @property
+    def width(self):
+        """
+        Returns the number of columns in this diagram layout.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.width
+        2
+
+        """
+        return self._grid.width
+
+    @property
+    def height(self):
+        """
+        Returns the number of rows in this diagram layout.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.height
+        2
+
+        """
+        return self._grid.height
+
+    def __getitem__(self, i_j):
+        """
+        Returns the object placed in the row ``i`` and column ``j``.
+        The indices are 0-based.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> (grid[0, 0], grid[0, 1])
+        (Object("A"), Object("B"))
+        >>> (grid[1, 0], grid[1, 1])
+        (None, Object("C"))
+
+        """
+        i, j = i_j
+        return self._grid[i, j]
+
+    @property
+    def morphisms(self):
+        """
+        Returns those morphisms (and their properties) which are
+        sufficiently meaningful to be drawn.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.morphisms
+        {NamedMorphism(Object("A"), Object("B"), "f"): EmptySet,
+        NamedMorphism(Object("B"), Object("C"), "g"): EmptySet}
+
+        """
+        return self._morphisms
+
+    def __str__(self):
+        """
+        Produces a string representation of this class.
+
+        This method returns a string representation of the underlying
+        list of lists of objects.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> print(grid)
+        [[Object("A"), Object("B")],
+        [None, Object("C")]]
+
+        """
+        return repr(self._grid._array)
+
+
+class ArrowStringDescription:
+    r"""
+    Stores the information necessary for producing an Xy-pic
+    description of an arrow.
+
+    The principal goal of this class is to abstract away the string
+    representation of an arrow and to also provide the functionality
+    to produce the actual Xy-pic string.
+
+    ``unit`` sets the unit which will be used to specify the amount of
+    curving and other distances.  ``horizontal_direction`` should be a
+    string of ``"r"`` or ``"l"`` specifying the horizontal offset of the
+    target cell of the arrow relatively to the current one.
+    ``vertical_direction`` should  specify the vertical offset using a
+    series of either ``"d"`` or ``"u"``.  ``label_position`` should be
+    either ``"^"``, ``"_"``,  or ``"|"`` to specify that the label should
+    be positioned above the arrow, below the arrow or just over the arrow,
+    in a break.  Note that the notions "above" and "below" are relative
+    to arrow direction.  ``label`` stores the morphism label.
+
+    This works as follows (disregard the yet unexplained arguments):
+
+    >>> from sympy.categories.diagram_drawing import ArrowStringDescription
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving=None, curving_amount=None,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar[dr]_{f}
+
+    ``curving`` should be one of ``"^"``, ``"_"`` to specify in which
+    direction the arrow is going to curve. ``curving_amount`` is a number
+    describing how many ``unit``'s the morphism is going to curve:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar@/^12mm/[dr]_{f}
+
+    ``looping_start`` and ``looping_end`` are currently only used for
+    loop morphisms, those which have the same domain and codomain.
+    These two attributes should store a valid Xy-pic direction and
+    specify, correspondingly, the direction the arrow gets out into
+    and the direction the arrow gets back from:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving=None, curving_amount=None,
+    ... looping_start="u", looping_end="l", horizontal_direction="",
+    ... vertical_direction="", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar@(u,l)[]_{f}
+
+    ``label_displacement`` controls how far the arrow label is from
+    the ends of the arrow.  For example, to position the arrow label
+    near the arrow head, use ">":
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> astr.label_displacement = ">"
+    >>> print(str(astr))
+    \ar@/^12mm/[dr]_>{f}
+
+    Finally, ``arrow_style`` is used to specify the arrow style.  To
+    get a dashed arrow, for example, use "{-->}" as arrow style:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> astr.arrow_style = "{-->}"
+    >>> print(str(astr))
+    \ar@/^12mm/@{-->}[dr]_{f}
+
+    Notes
+    =====
+
+    Instances of :class:`ArrowStringDescription` will be constructed
+    by :class:`XypicDiagramDrawer` and provided for further use in
+    formatters.  The user is not expected to construct instances of
+    :class:`ArrowStringDescription` themselves.
+
+    To be able to properly utilise this class, the reader is encouraged
+    to checkout the Xy-pic user guide, available at [Xypic].
+
+    See Also
+    ========
+
+    XypicDiagramDrawer
+
+    References
+    ==========
+
+    .. [Xypic] https://xy-pic.sourceforge.net/
+    """
+    def __init__(self, unit, curving, curving_amount, looping_start,
+                 looping_end, horizontal_direction, vertical_direction,
+                 label_position, label):
+        self.unit = unit
+        self.curving = curving
+        self.curving_amount = curving_amount
+        self.looping_start = looping_start
+        self.looping_end = looping_end
+        self.horizontal_direction = horizontal_direction
+        self.vertical_direction = vertical_direction
+        self.label_position = label_position
+        self.label = label
+
+        self.label_displacement = ""
+        self.arrow_style = ""
+
+        # This flag shows that the position of the label of this
+        # morphism was set while typesetting a curved morphism and
+        # should not be modified later.
+        self.forced_label_position = False
+
+    def __str__(self):
+        if self.curving:
+            curving_str = "@/%s%d%s/" % (self.curving, self.curving_amount,
+                                         self.unit)
+        else:
+            curving_str = ""
+
+        if self.looping_start and self.looping_end:
+            looping_str = "@(%s,%s)" % (self.looping_start, self.looping_end)
+        else:
+            looping_str = ""
+
+        if self.arrow_style:
+
+            style_str = "@" + self.arrow_style
+        else:
+            style_str = ""
+
+        return "\\ar%s%s%s[%s%s]%s%s{%s}" % \
+               (curving_str, looping_str, style_str, self.horizontal_direction,
+                self.vertical_direction, self.label_position,
+                self.label_displacement, self.label)
+
+
+class XypicDiagramDrawer:
+    r"""
+    Given a :class:`~.Diagram` and the corresponding
+    :class:`DiagramGrid`, produces the Xy-pic representation of the
+    diagram.
+
+    The most important method in this class is ``draw``.  Consider the
+    following triangle diagram:
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import DiagramGrid, XypicDiagramDrawer
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g], {g * f: "unique"})
+
+    To draw this diagram, its objects need to be laid out with a
+    :class:`DiagramGrid`::
+
+    >>> grid = DiagramGrid(diagram)
+
+    Finally, the drawing:
+
+    >>> drawer = XypicDiagramDrawer()
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    For further details see the docstring of this method.
+
+    To control the appearance of the arrows, formatters are used.  The
+    dictionary ``arrow_formatters`` maps morphisms to formatter
+    functions.  A formatter is accepts an
+    :class:`ArrowStringDescription` and is allowed to modify any of
+    the arrow properties exposed thereby.  For example, to have all
+    morphisms with the property ``unique`` appear as dashed arrows,
+    and to have their names prepended with `\exists !`, the following
+    should be done:
+
+    >>> def formatter(astr):
+    ...   astr.label = r"\exists !" + astr.label
+    ...   astr.arrow_style = "{-->}"
+    >>> drawer.arrow_formatters["unique"] = formatter
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar@{-->}[d]_{\exists !g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    To modify the appearance of all arrows in the diagram, set
+    ``default_arrow_formatter``.  For example, to place all morphism
+    labels a little bit farther from the arrow head so that they look
+    more centred, do as follows:
+
+    >>> def default_formatter(astr):
+    ...   astr.label_displacement = "(0.45)"
+    >>> drawer.default_arrow_formatter = default_formatter
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar@{-->}[d]_(0.45){\exists !g\circ f} \ar[r]^(0.45){f} & B \ar[ld]^(0.45){g} \\
+    C &
+    }
+
+    In some diagrams some morphisms are drawn as curved arrows.
+    Consider the following diagram:
+
+    >>> D = Object("D")
+    >>> E = Object("E")
+    >>> h = NamedMorphism(D, A, "h")
+    >>> k = NamedMorphism(D, B, "k")
+    >>> diagram = Diagram([f, g, h, k])
+    >>> grid = DiagramGrid(diagram)
+    >>> drawer = XypicDiagramDrawer()
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_3mm/[ll]_{h} \\
+    & C &
+    }
+
+    To control how far the morphisms are curved by default, one can
+    use the ``unit`` and ``default_curving_amount`` attributes:
+
+    >>> drawer.unit = "cm"
+    >>> drawer.default_curving_amount = 1
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_1cm/[ll]_{h} \\
+    & C &
+    }
+
+    In some diagrams, there are multiple curved morphisms between the
+    same two objects.  To control by how much the curving changes
+    between two such successive morphisms, use
+    ``default_curving_step``:
+
+    >>> drawer.default_curving_step = 1
+    >>> h1 = NamedMorphism(A, D, "h1")
+    >>> diagram = Diagram([f, g, h, k, h1])
+    >>> grid = DiagramGrid(diagram)
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} \ar@/^1cm/[rr]^{h_{1}} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_2cm/[ll]_{h} \\
+    & C &
+    }
+
+    The default value of ``default_curving_step`` is 4 units.
+
+    See Also
+    ========
+
+    draw, ArrowStringDescription
+    """
+    def __init__(self):
+        self.unit = "mm"
+        self.default_curving_amount = 3
+        self.default_curving_step = 4
+
+        # This dictionary maps properties to the corresponding arrow
+        # formatters.
+        self.arrow_formatters = {}
+
+        # This is the default arrow formatter which will be applied to
+        # each arrow independently of its properties.
+        self.default_arrow_formatter = None
+
+    @staticmethod
+    def _process_loop_morphism(i, j, grid, morphisms_str_info, object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a loop morphism.  This function is invoked
+        from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        curving = ""
+        label_pos = "^"
+        looping_start = ""
+        looping_end = ""
+
+        # This is a loop morphism.  Count how many morphisms stick
+        # in each of the four quadrants.  Note that straight
+        # vertical and horizontal morphisms count in two quadrants
+        # at the same time (i.e., a morphism going up counts both
+        # in the first and the second quadrants).
+
+        # The usual numbering (counterclockwise) of quadrants
+        # applies.
+        quadrant = [0, 0, 0, 0]
+
+        obj = grid[i, j]
+
+        for m, m_str_info in morphisms_str_info.items():
+            if (m.domain == obj) and (m.codomain == obj):
+                # That's another loop morphism.  Check how it
+                # loops and mark the corresponding quadrants as
+                # busy.
+                (l_s, l_e) = (m_str_info.looping_start, m_str_info.looping_end)
+
+                if (l_s, l_e) == ("r", "u"):
+                    quadrant[0] += 1
+                elif (l_s, l_e) == ("u", "l"):
+                    quadrant[1] += 1
+                elif (l_s, l_e) == ("l", "d"):
+                    quadrant[2] += 1
+                elif (l_s, l_e) == ("d", "r"):
+                    quadrant[3] += 1
+
+                continue
+            if m.domain == obj:
+                (end_i, end_j) = object_coords[m.codomain]
+                goes_out = True
+            elif m.codomain == obj:
+                (end_i, end_j) = object_coords[m.domain]
+                goes_out = False
+            else:
+                continue
+
+            d_i = end_i - i
+            d_j = end_j - j
+            m_curving = m_str_info.curving
+
+            if (d_i != 0) and (d_j != 0):
+                # This is really a diagonal morphism.  Detect the
+                # quadrant.
+                if (d_i > 0) and (d_j > 0):
+                    quadrant[0] += 1
+                elif (d_i > 0) and (d_j < 0):
+                    quadrant[1] += 1
+                elif (d_i < 0) and (d_j < 0):
+                    quadrant[2] += 1
+                elif (d_i < 0) and (d_j > 0):
+                    quadrant[3] += 1
+            elif d_i == 0:
+                # Knowing where the other end of the morphism is
+                # and which way it goes, we now have to decide
+                # which quadrant is now the upper one and which is
+                # the lower one.
+                if d_j > 0:
+                    if goes_out:
+                        upper_quadrant = 0
+                        lower_quadrant = 3
+                    else:
+                        upper_quadrant = 3
+                        lower_quadrant = 0
+                else:
+                    if goes_out:
+                        upper_quadrant = 2
+                        lower_quadrant = 1
+                    else:
+                        upper_quadrant = 1
+                        lower_quadrant = 2
+
+                if m_curving:
+                    if m_curving == "^":
+                        quadrant[upper_quadrant] += 1
+                    elif m_curving == "_":
+                        quadrant[lower_quadrant] += 1
+                else:
+                    # This morphism counts in both upper and lower
+                    # quadrants.
+                    quadrant[upper_quadrant] += 1
+                    quadrant[lower_quadrant] += 1
+            elif d_j == 0:
+                # Knowing where the other end of the morphism is
+                # and which way it goes, we now have to decide
+                # which quadrant is now the left one and which is
+                # the right one.
+                if d_i < 0:
+                    if goes_out:
+                        left_quadrant = 1
+                        right_quadrant = 0
+                    else:
+                        left_quadrant = 0
+                        right_quadrant = 1
+                else:
+                    if goes_out:
+                        left_quadrant = 3
+                        right_quadrant = 2
+                    else:
+                        left_quadrant = 2
+                        right_quadrant = 3
+
+                if m_curving:
+                    if m_curving == "^":
+                        quadrant[left_quadrant] += 1
+                    elif m_curving == "_":
+                        quadrant[right_quadrant] += 1
+                else:
+                    # This morphism counts in both upper and lower
+                    # quadrants.
+                    quadrant[left_quadrant] += 1
+                    quadrant[right_quadrant] += 1
+
+        # Pick the freest quadrant to curve our morphism into.
+        freest_quadrant = 0
+        for i in range(4):
+            if quadrant[i] < quadrant[freest_quadrant]:
+                freest_quadrant = i
+
+        # Now set up proper looping.
+        (looping_start, looping_end) = [("r", "u"), ("u", "l"), ("l", "d"),
+                                        ("d", "r")][freest_quadrant]
+
+        return (curving, label_pos, looping_start, looping_end)
+
+    @staticmethod
+    def _process_horizontal_morphism(i, j, target_j, grid, morphisms_str_info,
+                                     object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a horizontal morphism.  This function is
+        invoked from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        # The arrow is horizontal.  Check if it goes from left to
+        # right (``backwards == False``) or from right to left
+        # (``backwards == True``).
+        backwards = False
+        start = j
+        end = target_j
+        if end < start:
+            (start, end) = (end, start)
+            backwards = True
+
+        # Let's see which objects are there between ``start`` and
+        # ``end``, and then count how many morphisms stick out
+        # upwards, and how many stick out downwards.
+        #
+        # For example, consider the situation:
+        #
+        #    B1 C1
+        #    |  |
+        # A--B--C--D
+        #    |
+        #    B2
+        #
+        # Between the objects `A` and `D` there are two objects:
+        # `B` and `C`.  Further, there are two morphisms which
+        # stick out upward (the ones between `B1` and `B` and
+        # between `C` and `C1`) and one morphism which sticks out
+        # downward (the one between `B and `B2`).
+        #
+        # We need this information to decide how to curve the
+        # arrow between `A` and `D`.  First of all, since there
+        # are two objects between `A` and `D``, we must curve the
+        # arrow.  Then, we will have it curve downward, because
+        # there is more space (less morphisms stick out downward
+        # than upward).
+        up = []
+        down = []
+        straight_horizontal = []
+        for k in range(start + 1, end):
+            obj = grid[i, k]
+            if not obj:
+                continue
+
+            for m in morphisms_str_info:
+                if m.domain == obj:
+                    (end_i, end_j) = object_coords[m.codomain]
+                elif m.codomain == obj:
+                    (end_i, end_j) = object_coords[m.domain]
+                else:
+                    continue
+
+                if end_i > i:
+                    down.append(m)
+                elif end_i < i:
+                    up.append(m)
+                elif not morphisms_str_info[m].curving:
+                    # This is a straight horizontal morphism,
+                    # because it has no curving.
+                    straight_horizontal.append(m)
+
+        if len(up) < len(down):
+            # More morphisms stick out downward than upward, let's
+            # curve the morphism up.
+            if backwards:
+                curving = "_"
+                label_pos = "_"
+            else:
+                curving = "^"
+                label_pos = "^"
+
+            # Assure that the straight horizontal morphisms have
+            # their labels on the lower side of the arrow.
+            for m in straight_horizontal:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if j1 < j2:
+                    m_str_info.label_position = "_"
+                else:
+                    m_str_info.label_position = "^"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+        else:
+            # More morphisms stick out downward than upward, let's
+            # curve the morphism up.
+            if backwards:
+                curving = "^"
+                label_pos = "^"
+            else:
+                curving = "_"
+                label_pos = "_"
+
+            # Assure that the straight horizontal morphisms have
+            # their labels on the upper side of the arrow.
+            for m in straight_horizontal:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if j1 < j2:
+                    m_str_info.label_position = "^"
+                else:
+                    m_str_info.label_position = "_"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+
+        return (curving, label_pos)
+
+    @staticmethod
+    def _process_vertical_morphism(i, j, target_i, grid, morphisms_str_info,
+                                   object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a vertical morphism.  This function is
+        invoked from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        # This arrow is vertical.  Check if it goes from top to
+        # bottom (``backwards == False``) or from bottom to top
+        # (``backwards == True``).
+        backwards = False
+        start = i
+        end = target_i
+        if end < start:
+            (start, end) = (end, start)
+            backwards = True
+
+        # Let's see which objects are there between ``start`` and
+        # ``end``, and then count how many morphisms stick out to
+        # the left, and how many stick out to the right.
+        #
+        # See the corresponding comment in the previous branch of
+        # this if-statement for more details.
+        left = []
+        right = []
+        straight_vertical = []
+        for k in range(start + 1, end):
+            obj = grid[k, j]
+            if not obj:
+                continue
+
+            for m in morphisms_str_info:
+                if m.domain == obj:
+                    (end_i, end_j) = object_coords[m.codomain]
+                elif m.codomain == obj:
+                    (end_i, end_j) = object_coords[m.domain]
+                else:
+                    continue
+
+                if end_j > j:
+                    right.append(m)
+                elif end_j < j:
+                    left.append(m)
+                elif not morphisms_str_info[m].curving:
+                    # This is a straight vertical morphism,
+                    # because it has no curving.
+                    straight_vertical.append(m)
+
+        if len(left) < len(right):
+            # More morphisms stick out to the left than to the
+            # right, let's curve the morphism to the right.
+            if backwards:
+                curving = "^"
+                label_pos = "^"
+            else:
+                curving = "_"
+                label_pos = "_"
+
+            # Assure that the straight vertical morphisms have
+            # their labels on the left side of the arrow.
+            for m in straight_vertical:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if i1 < i2:
+                    m_str_info.label_position = "^"
+                else:
+                    m_str_info.label_position = "_"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+        else:
+            # More morphisms stick out to the right than to the
+            # left, let's curve the morphism to the left.
+            if backwards:
+                curving = "_"
+                label_pos = "_"
+            else:
+                curving = "^"
+                label_pos = "^"
+
+            # Assure that the straight vertical morphisms have
+            # their labels on the right side of the arrow.
+            for m in straight_vertical:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if i1 < i2:
+                    m_str_info.label_position = "_"
+                else:
+                    m_str_info.label_position = "^"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+
+        return (curving, label_pos)
+
+    def _process_morphism(self, diagram, grid, morphism, object_coords,
+                          morphisms, morphisms_str_info):
+        """
+        Given the required information, produces the string
+        representation of ``morphism``.
+        """
+        def repeat_string_cond(times, str_gt, str_lt):
+            """
+            If ``times > 0``, repeats ``str_gt`` ``times`` times.
+            Otherwise, repeats ``str_lt`` ``-times`` times.
+            """
+            if times > 0:
+                return str_gt * times
+            else:
+                return str_lt * (-times)
+
+        def count_morphisms_undirected(A, B):
+            """
+            Counts how many processed morphisms there are between the
+            two supplied objects.
+            """
+            return len([m for m in morphisms_str_info
+                        if {m.domain, m.codomain} == {A, B}])
+
+        def count_morphisms_filtered(dom, cod, curving):
+            """
+            Counts the processed morphisms which go out of ``dom``
+            into ``cod`` with curving ``curving``.
+            """
+            return len([m for m, m_str_info in morphisms_str_info.items()
+                        if (m.domain, m.codomain) == (dom, cod) and
+                        (m_str_info.curving == curving)])
+
+        (i, j) = object_coords[morphism.domain]
+        (target_i, target_j) = object_coords[morphism.codomain]
+
+        # We now need to determine the direction of
+        # the arrow.
+        delta_i = target_i - i
+        delta_j = target_j - j
+        vertical_direction = repeat_string_cond(delta_i,
+                                                "d", "u")
+        horizontal_direction = repeat_string_cond(delta_j,
+                                                  "r", "l")
+
+        curving = ""
+        label_pos = "^"
+        looping_start = ""
+        looping_end = ""
+
+        if (delta_i == 0) and (delta_j == 0):
+            # This is a loop morphism.
+            (curving, label_pos, looping_start,
+             looping_end) = XypicDiagramDrawer._process_loop_morphism(
+                 i, j, grid, morphisms_str_info, object_coords)
+        elif (delta_i == 0) and (abs(j - target_j) > 1):
+            # This is a horizontal morphism.
+            (curving, label_pos) = XypicDiagramDrawer._process_horizontal_morphism(
+                i, j, target_j, grid, morphisms_str_info, object_coords)
+        elif (delta_j == 0) and (abs(i - target_i) > 1):
+            # This is a vertical morphism.
+            (curving, label_pos) = XypicDiagramDrawer._process_vertical_morphism(
+                i, j, target_i, grid, morphisms_str_info, object_coords)
+
+        count = count_morphisms_undirected(morphism.domain, morphism.codomain)
+        curving_amount = ""
+        if curving:
+            # This morphisms should be curved anyway.
+            curving_amount = self.default_curving_amount + count * \
+                self.default_curving_step
+        elif count:
+            # There are no objects between the domain and codomain of
+            # the current morphism, but this is not there already are
+            # some morphisms with the same domain and codomain, so we
+            # have to curve this one.
+            curving = "^"
+            filtered_morphisms = count_morphisms_filtered(
+                morphism.domain, morphism.codomain, curving)
+            curving_amount = self.default_curving_amount + \
+                filtered_morphisms * \
+                self.default_curving_step
+
+        # Let's now get the name of the morphism.
+        morphism_name = ""
+        if isinstance(morphism, IdentityMorphism):
+            morphism_name = "id_{%s}" + latex(grid[i, j])
+        elif isinstance(morphism, CompositeMorphism):
+            component_names = [latex(Symbol(component.name)) for
+                               component in morphism.components]
+            component_names.reverse()
+            morphism_name = "\\circ ".join(component_names)
+        elif isinstance(morphism, NamedMorphism):
+            morphism_name = latex(Symbol(morphism.name))
+
+        return ArrowStringDescription(
+            self.unit, curving, curving_amount, looping_start,
+            looping_end, horizontal_direction, vertical_direction,
+            label_pos, morphism_name)
+
+    @staticmethod
+    def _check_free_space_horizontal(dom_i, dom_j, cod_j, grid):
+        """
+        For a horizontal morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) above the morphism
+        or below it.
+        """
+        if dom_j < cod_j:
+            (start, end) = (dom_j, cod_j)
+            backwards = False
+        else:
+            (start, end) = (cod_j, dom_j)
+            backwards = True
+
+        # Check for free space above.
+        if dom_i == 0:
+            free_up = True
+        else:
+            free_up = all(grid[dom_i - 1, j] for j in
+                          range(start, end + 1))
+
+        # Check for free space below.
+        if dom_i == grid.height - 1:
+            free_down = True
+        else:
+            free_down = not any(grid[dom_i + 1, j] for j in
+                                range(start, end + 1))
+
+        return (free_up, free_down, backwards)
+
+    @staticmethod
+    def _check_free_space_vertical(dom_i, cod_i, dom_j, grid):
+        """
+        For a vertical morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) to the left of the
+        morphism or to the right of it.
+        """
+        if dom_i < cod_i:
+            (start, end) = (dom_i, cod_i)
+            backwards = False
+        else:
+            (start, end) = (cod_i, dom_i)
+            backwards = True
+
+        # Check if there's space to the left.
+        if dom_j == 0:
+            free_left = True
+        else:
+            free_left = not any(grid[i, dom_j - 1] for i in
+                                range(start, end + 1))
+
+        if dom_j == grid.width - 1:
+            free_right = True
+        else:
+            free_right = not any(grid[i, dom_j + 1] for i in
+                                 range(start, end + 1))
+
+        return (free_left, free_right, backwards)
+
+    @staticmethod
+    def _check_free_space_diagonal(dom_i, cod_i, dom_j, cod_j, grid):
+        """
+        For a diagonal morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) above the morphism
+        or below it.
+        """
+        def abs_xrange(start, end):
+            if start < end:
+                return range(start, end + 1)
+            else:
+                return range(end, start + 1)
+
+        if dom_i < cod_i and dom_j < cod_j:
+            # This morphism goes from top-left to
+            # bottom-right.
+            (start_i, start_j) = (dom_i, dom_j)
+            (end_i, end_j) = (cod_i, cod_j)
+            backwards = False
+        elif dom_i > cod_i and dom_j > cod_j:
+            # This morphism goes from bottom-right to
+            # top-left.
+            (start_i, start_j) = (cod_i, cod_j)
+            (end_i, end_j) = (dom_i, dom_j)
+            backwards = True
+        if dom_i < cod_i and dom_j > cod_j:
+            # This morphism goes from top-right to
+            # bottom-left.
+            (start_i, start_j) = (dom_i, dom_j)
+            (end_i, end_j) = (cod_i, cod_j)
+            backwards = True
+        elif dom_i > cod_i and dom_j < cod_j:
+            # This morphism goes from bottom-left to
+            # top-right.
+            (start_i, start_j) = (cod_i, cod_j)
+            (end_i, end_j) = (dom_i, dom_j)
+            backwards = False
+
+        # This is an attempt at a fast and furious strategy to
+        # decide where there is free space on the two sides of
+        # a diagonal morphism.  For a diagonal morphism
+        # starting at ``(start_i, start_j)`` and ending at
+        # ``(end_i, end_j)`` the rectangle defined by these
+        # two points is considered.  The slope of the diagonal
+        # ``alpha`` is then computed.  Then, for every cell
+        # ``(i, j)`` within the rectangle, the slope
+        # ``alpha1`` of the line through ``(start_i,
+        # start_j)`` and ``(i, j)`` is considered.  If
+        # ``alpha1`` is between 0 and ``alpha``, the point
+        # ``(i, j)`` is above the diagonal, if ``alpha1`` is
+        # between ``alpha`` and infinity, the point is below
+        # the diagonal.  Also note that, with some beforehand
+        # precautions, this trick works for both the main and
+        # the secondary diagonals of the rectangle.
+
+        # I have considered the possibility to only follow the
+        # shorter diagonals immediately above and below the
+        # main (or secondary) diagonal.  This, however,
+        # wouldn't have resulted in much performance gain or
+        # better detection of outer edges, because of
+        # relatively small sizes of diagram grids, while the
+        # code would have become harder to understand.
+
+        alpha = float(end_i - start_i)/(end_j - start_j)
+        free_up = True
+        free_down = True
+        for i in abs_xrange(start_i, end_i):
+            if not free_up and not free_down:
+                break
+
+            for j in abs_xrange(start_j, end_j):
+                if not free_up and not free_down:
+                    break
+
+                if (i, j) == (start_i, start_j):
+                    continue
+
+                if j == start_j:
+                    alpha1 = "inf"
+                else:
+                    alpha1 = float(i - start_i)/(j - start_j)
+
+                if grid[i, j]:
+                    if (alpha1 == "inf") or (abs(alpha1) > abs(alpha)):
+                        free_down = False
+                    elif abs(alpha1) < abs(alpha):
+                        free_up = False
+
+        return (free_up, free_down, backwards)
+
+    def _push_labels_out(self, morphisms_str_info, grid, object_coords):
+        """
+        For all straight morphisms which form the visual boundary of
+        the laid out diagram, puts their labels on their outer sides.
+        """
+        def set_label_position(free1, free2, pos1, pos2, backwards, m_str_info):
+            """
+            Given the information about room available to one side and
+            to the other side of a morphism (``free1`` and ``free2``),
+            sets the position of the morphism label in such a way that
+            it is on the freer side.  This latter operations involves
+            choice between ``pos1`` and ``pos2``, taking ``backwards``
+            in consideration.
+
+            Thus this function will do nothing if either both ``free1
+            == True`` and ``free2 == True`` or both ``free1 == False``
+            and ``free2 == False``.  In either case, choosing one side
+            over the other presents no advantage.
+            """
+            if backwards:
+                (pos1, pos2) = (pos2, pos1)
+
+            if free1 and not free2:
+                m_str_info.label_position = pos1
+            elif free2 and not free1:
+                m_str_info.label_position = pos2
+
+        for m, m_str_info in morphisms_str_info.items():
+            if m_str_info.curving or m_str_info.forced_label_position:
+                # This is either a curved morphism, and curved
+                # morphisms have other magic, or the position of this
+                # label has already been fixed.
+                continue
+
+            if m.domain == m.codomain:
+                # This is a loop morphism, their labels, again have a
+                # different magic.
+                continue
+
+            (dom_i, dom_j) = object_coords[m.domain]
+            (cod_i, cod_j) = object_coords[m.codomain]
+
+            if dom_i == cod_i:
+                # Horizontal morphism.
+                (free_up, free_down,
+                 backwards) = XypicDiagramDrawer._check_free_space_horizontal(
+                     dom_i, dom_j, cod_j, grid)
+
+                set_label_position(free_up, free_down, "^", "_",
+                                   backwards, m_str_info)
+            elif dom_j == cod_j:
+                # Vertical morphism.
+                (free_left, free_right,
+                 backwards) = XypicDiagramDrawer._check_free_space_vertical(
+                     dom_i, cod_i, dom_j, grid)
+
+                set_label_position(free_left, free_right, "_", "^",
+                                   backwards, m_str_info)
+            else:
+                # A diagonal morphism.
+                (free_up, free_down,
+                 backwards) = XypicDiagramDrawer._check_free_space_diagonal(
+                     dom_i, cod_i, dom_j, cod_j, grid)
+
+                set_label_position(free_up, free_down, "^", "_",
+                                   backwards, m_str_info)
+
+    @staticmethod
+    def _morphism_sort_key(morphism, object_coords):
+        """
+        Provides a morphism sorting key such that horizontal or
+        vertical morphisms between neighbouring objects come
+        first, then horizontal or vertical morphisms between more
+        far away objects, and finally, all other morphisms.
+        """
+        (i, j) = object_coords[morphism.domain]
+        (target_i, target_j) = object_coords[morphism.codomain]
+
+        if morphism.domain == morphism.codomain:
+            # Loop morphisms should get after diagonal morphisms
+            # so that the proper direction in which to curve the
+            # loop can be determined.
+            return (3, 0, default_sort_key(morphism))
+
+        if target_i == i:
+            return (1, abs(target_j - j), default_sort_key(morphism))
+
+        if target_j == j:
+            return (1, abs(target_i - i), default_sort_key(morphism))
+
+        # Diagonal morphism.
+        return (2, 0, default_sort_key(morphism))
+
+    @staticmethod
+    def _build_xypic_string(diagram, grid, morphisms,
+                            morphisms_str_info, diagram_format):
+        """
+        Given a collection of :class:`ArrowStringDescription`
+        describing the morphisms of a diagram and the object layout
+        information of a diagram, produces the final Xy-pic picture.
+        """
+        # Build the mapping between objects and morphisms which have
+        # them as domains.
+        object_morphisms = {}
+        for obj in diagram.objects:
+            object_morphisms[obj] = []
+        for morphism in morphisms:
+            object_morphisms[morphism.domain].append(morphism)
+
+        result = "\\xymatrix%s{\n" % diagram_format
+
+        for i in range(grid.height):
+            for j in range(grid.width):
+                obj = grid[i, j]
+                if obj:
+                    result += latex(obj) + " "
+
+                    morphisms_to_draw = object_morphisms[obj]
+                    for morphism in morphisms_to_draw:
+                        result += str(morphisms_str_info[morphism]) + " "
+
+                # Don't put the & after the last column.
+                if j < grid.width - 1:
+                    result += "& "
+
+            # Don't put the line break after the last row.
+            if i < grid.height - 1:
+                result += "\\\\"
+            result += "\n"
+
+        result += "}\n"
+
+        return result
+
+    def draw(self, diagram, grid, masked=None, diagram_format=""):
+        r"""
+        Returns the Xy-pic representation of ``diagram`` laid out in
+        ``grid``.
+
+        Consider the following simple triangle diagram.
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy.categories import DiagramGrid, XypicDiagramDrawer
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g], {g * f: "unique"})
+
+        To draw this diagram, its objects need to be laid out with a
+        :class:`DiagramGrid`::
+
+        >>> grid = DiagramGrid(diagram)
+
+        Finally, the drawing:
+
+        >>> drawer = XypicDiagramDrawer()
+        >>> print(drawer.draw(diagram, grid))
+        \xymatrix{
+        A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        The argument ``masked`` can be used to skip morphisms in the
+        presentation of the diagram:
+
+        >>> print(drawer.draw(diagram, grid, masked=[g * f]))
+        \xymatrix{
+        A \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        Finally, the ``diagram_format`` argument can be used to
+        specify the format string of the diagram.  For example, to
+        increase the spacing by 1 cm, proceeding as follows:
+
+        >>> print(drawer.draw(diagram, grid, diagram_format="@+1cm"))
+        \xymatrix@+1cm{
+        A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        """
+        # This method works in several steps.  It starts by removing
+        # the masked morphisms, if necessary, and then maps objects to
+        # their positions in the grid (coordinate tuples).  Remember
+        # that objects are unique in ``Diagram`` and in the layout
+        # produced by ``DiagramGrid``, so every object is mapped to a
+        # single coordinate pair.
+        #
+        # The next step is the central step and is concerned with
+        # analysing the morphisms of the diagram and deciding how to
+        # draw them.  For example, how to curve the arrows is decided
+        # at this step.  The bulk of the analysis is implemented in
+        # ``_process_morphism``, to the result of which the
+        # appropriate formatters are applied.
+        #
+        # The result of the previous step is a list of
+        # ``ArrowStringDescription``.  After the analysis and
+        # application of formatters, some extra logic tries to assure
+        # better positioning of morphism labels (for example, an
+        # attempt is made to avoid the situations when arrows cross
+        # labels).  This functionality constitutes the next step and
+        # is implemented in ``_push_labels_out``.  Note that label
+        # positions which have been set via a formatter are not
+        # affected in this step.
+        #
+        # Finally, at the closing step, the array of
+        # ``ArrowStringDescription`` and the layout information
+        # incorporated in ``DiagramGrid`` are combined to produce the
+        # resulting Xy-pic picture.  This part of code lies in
+        # ``_build_xypic_string``.
+
+        if not masked:
+            morphisms_props = grid.morphisms
+        else:
+            morphisms_props = {}
+            for m, props in grid.morphisms.items():
+                if m in masked:
+                    continue
+                morphisms_props[m] = props
+
+        # Build the mapping between objects and their position in the
+        # grid.
+        object_coords = {}
+        for i in range(grid.height):
+            for j in range(grid.width):
+                if grid[i, j]:
+                    object_coords[grid[i, j]] = (i, j)
+
+        morphisms = sorted(morphisms_props,
+                           key=lambda m: XypicDiagramDrawer._morphism_sort_key(
+                               m, object_coords))
+
+        # Build the tuples defining the string representations of
+        # morphisms.
+        morphisms_str_info = {}
+        for morphism in morphisms:
+            string_description = self._process_morphism(
+                diagram, grid, morphism, object_coords, morphisms,
+                morphisms_str_info)
+
+            if self.default_arrow_formatter:
+                self.default_arrow_formatter(string_description)
+
+            for prop in morphisms_props[morphism]:
+                # prop is a Symbol.  TODO: Find out why.
+                if prop.name in self.arrow_formatters:
+                    formatter = self.arrow_formatters[prop.name]
+                    formatter(string_description)
+
+            morphisms_str_info[morphism] = string_description
+
+        # Reposition the labels a bit.
+        self._push_labels_out(morphisms_str_info, grid, object_coords)
+
+        return XypicDiagramDrawer._build_xypic_string(
+            diagram, grid, morphisms, morphisms_str_info, diagram_format)
+
+
+def xypic_draw_diagram(diagram, masked=None, diagram_format="",
+                       groups=None, **hints):
+    r"""
+    Provides a shortcut combining :class:`DiagramGrid` and
+    :class:`XypicDiagramDrawer`.  Returns an Xy-pic presentation of
+    ``diagram``.  The argument ``masked`` is a list of morphisms which
+    will be not be drawn.  The argument ``diagram_format`` is the
+    format string inserted after "\xymatrix".  ``groups`` should be a
+    set of logical groups.  The ``hints`` will be passed directly to
+    the constructor of :class:`DiagramGrid`.
+
+    For more information about the arguments, see the docstrings of
+    :class:`DiagramGrid` and ``XypicDiagramDrawer.draw``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import xypic_draw_diagram
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g], {g * f: "unique"})
+    >>> print(xypic_draw_diagram(diagram))
+    \xymatrix{
+    A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    See Also
+    ========
+
+    XypicDiagramDrawer, DiagramGrid
+    """
+    grid = DiagramGrid(diagram, groups, **hints)
+    drawer = XypicDiagramDrawer()
+    return drawer.draw(diagram, grid, masked, diagram_format)
+
+
+@doctest_depends_on(exe=('latex', 'dvipng'), modules=('pyglet',))
+def preview_diagram(diagram, masked=None, diagram_format="", groups=None,
+                    output='png', viewer=None, euler=True, **hints):
+    """
+    Combines the functionality of ``xypic_draw_diagram`` and
+    ``sympy.printing.preview``.  The arguments ``masked``,
+    ``diagram_format``, ``groups``, and ``hints`` are passed to
+    ``xypic_draw_diagram``, while ``output``, ``viewer, and ``euler``
+    are passed to ``preview``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import preview_diagram
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g], {g * f: "unique"})
+    >>> preview_diagram(d)
+
+    See Also
+    ========
+
+    XypicDiagramDrawer
+    """
+    from sympy.printing import preview
+    latex_output = xypic_draw_diagram(diagram, masked, diagram_format,
+                                      groups, **hints)
+    preview(latex_output, output, viewer, euler, ("xypic",))

pllava/lib/python3.10/site-packages/sympy/categories/tests/test_baseclasses.py

@@ -0,0 +1,209 @@
+from sympy.categories import (Object, Morphism, IdentityMorphism,
+                              NamedMorphism, CompositeMorphism,
+                              Diagram, Category)
+from sympy.categories.baseclasses import Class
+from sympy.testing.pytest import raises
+from sympy.core.containers import (Dict, Tuple)
+from sympy.sets import EmptySet
+from sympy.sets.sets import FiniteSet
+
+
+def test_morphisms():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+
+    # Test the base morphism.
+    f = NamedMorphism(A, B, "f")
+    assert f.domain == A
+    assert f.codomain == B
+    assert f == NamedMorphism(A, B, "f")
+
+    # Test identities.
+    id_A = IdentityMorphism(A)
+    id_B = IdentityMorphism(B)
+    assert id_A.domain == A
+    assert id_A.codomain == A
+    assert id_A == IdentityMorphism(A)
+    assert id_A != id_B
+
+    # Test named morphisms.
+    g = NamedMorphism(B, C, "g")
+    assert g.name == "g"
+    assert g != f
+    assert g == NamedMorphism(B, C, "g")
+    assert g != NamedMorphism(B, C, "f")
+
+    # Test composite morphisms.
+    assert f == CompositeMorphism(f)
+
+    k = g.compose(f)
+    assert k.domain == A
+    assert k.codomain == C
+    assert k.components == Tuple(f, g)
+    assert g * f == k
+    assert CompositeMorphism(f, g) == k
+
+    assert CompositeMorphism(g * f) == g * f
+
+    # Test the associativity of composition.
+    h = NamedMorphism(C, D, "h")
+
+    p = h * g
+    u = h * g * f
+
+    assert h * k == u
+    assert p * f == u
+    assert CompositeMorphism(f, g, h) == u
+
+    # Test flattening.
+    u2 = u.flatten("u")
+    assert isinstance(u2, NamedMorphism)
+    assert u2.name == "u"
+    assert u2.domain == A
+    assert u2.codomain == D
+
+    # Test identities.
+    assert f * id_A == f
+    assert id_B * f == f
+    assert id_A * id_A == id_A
+    assert CompositeMorphism(id_A) == id_A
+
+    # Test bad compositions.
+    raises(ValueError, lambda: f * g)
+
+    raises(TypeError, lambda: f.compose(None))
+    raises(TypeError, lambda: id_A.compose(None))
+    raises(TypeError, lambda: f * None)
+    raises(TypeError, lambda: id_A * None)
+
+    raises(TypeError, lambda: CompositeMorphism(f, None, 1))
+
+    raises(ValueError, lambda: NamedMorphism(A, B, ""))
+    raises(NotImplementedError, lambda: Morphism(A, B))
+
+
+def test_diagram():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    id_A = IdentityMorphism(A)
+    id_B = IdentityMorphism(B)
+
+    empty = EmptySet
+
+    # Test the addition of identities.
+    d1 = Diagram([f])
+
+    assert d1.objects == FiniteSet(A, B)
+    assert d1.hom(A, B) == (FiniteSet(f), empty)
+    assert d1.hom(A, A) == (FiniteSet(id_A), empty)
+    assert d1.hom(B, B) == (FiniteSet(id_B), empty)
+
+    assert d1 == Diagram([id_A, f])
+    assert d1 == Diagram([f, f])
+
+    # Test the addition of composites.
+    d2 = Diagram([f, g])
+    homAC = d2.hom(A, C)[0]
+
+    assert d2.objects == FiniteSet(A, B, C)
+    assert g * f in d2.premises.keys()
+    assert homAC == FiniteSet(g * f)
+
+    # Test equality, inequality and hash.
+    d11 = Diagram([f])
+
+    assert d1 == d11
+    assert d1 != d2
+    assert hash(d1) == hash(d11)
+
+    d11 = Diagram({f: "unique"})
+    assert d1 != d11
+
+    # Make sure that (re-)adding composites (with new properties)
+    # works as expected.
+    d = Diagram([f, g], {g * f: "unique"})
+    assert d.conclusions == Dict({g * f: FiniteSet("unique")})
+
+    # Check the hom-sets when there are premises and conclusions.
+    assert d.hom(A, C) == (FiniteSet(g * f), FiniteSet(g * f))
+    d = Diagram([f, g], [g * f])
+    assert d.hom(A, C) == (FiniteSet(g * f), FiniteSet(g * f))
+
+    # Check how the properties of composite morphisms are computed.
+    d = Diagram({f: ["unique", "isomorphism"], g: "unique"})
+    assert d.premises[g * f] == FiniteSet("unique")
+
+    # Check that conclusion morphisms with new objects are not allowed.
+    d = Diagram([f], [g])
+    assert d.conclusions == Dict({})
+
+    # Test an empty diagram.
+    d = Diagram()
+    assert d.premises == Dict({})
+    assert d.conclusions == Dict({})
+    assert d.objects == empty
+
+    # Check a SymPy Dict object.
+    d = Diagram(Dict({f: FiniteSet("unique", "isomorphism"), g: "unique"}))
+    assert d.premises[g * f] == FiniteSet("unique")
+
+    # Check the addition of components of composite morphisms.
+    d = Diagram([g * f])
+    assert f in d.premises
+    assert g in d.premises
+
+    # Check subdiagrams.
+    d = Diagram([f, g], {g * f: "unique"})
+
+    d1 = Diagram([f])
+    assert d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram([NamedMorphism(B, A, "f'")])
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d1 = Diagram([f, g], {g * f: ["unique", "something"]})
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram({f: "blooh"})
+    d1 = Diagram({f: "bleeh"})
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram([f, g], {f: "unique", g * f: "veryunique"})
+    d1 = d.subdiagram_from_objects(FiniteSet(A, B))
+    assert d1 == Diagram([f], {f: "unique"})
+    raises(ValueError, lambda: d.subdiagram_from_objects(FiniteSet(A,
+           Object("D"))))
+
+    raises(ValueError, lambda: Diagram({IdentityMorphism(A): "unique"}))
+
+
+def test_category():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+
+    d1 = Diagram([f, g])
+    d2 = Diagram([f])
+
+    objects = d1.objects | d2.objects
+
+    K = Category("K", objects, commutative_diagrams=[d1, d2])
+
+    assert K.name == "K"
+    assert K.objects == Class(objects)
+    assert K.commutative_diagrams == FiniteSet(d1, d2)
+
+    raises(ValueError, lambda: Category(""))

pllava/lib/python3.10/site-packages/sympy/categories/tests/test_drawing.py

@@ -0,0 +1,919 @@
+from sympy.categories.diagram_drawing import _GrowableGrid, ArrowStringDescription
+from sympy.categories import (DiagramGrid, Object, NamedMorphism,
+                              Diagram, XypicDiagramDrawer, xypic_draw_diagram)
+from sympy.sets.sets import FiniteSet
+
+
+def test_GrowableGrid():
+    grid = _GrowableGrid(1, 2)
+
+    # Check dimensions.
+    assert grid.width == 1
+    assert grid.height == 2
+
+    # Check initialization of elements.
+    assert grid[0, 0] is None
+    assert grid[1, 0] is None
+
+    # Check assignment to elements.
+    grid[0, 0] = 1
+    grid[1, 0] = "two"
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+
+    # Check appending a row.
+    grid.append_row()
+
+    assert grid.width == 1
+    assert grid.height == 3
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+    assert grid[2, 0] is None
+
+    # Check appending a column.
+    grid.append_column()
+    assert grid.width == 2
+    assert grid.height == 3
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+    assert grid[2, 0] is None
+
+    assert grid[0, 1] is None
+    assert grid[1, 1] is None
+    assert grid[2, 1] is None
+
+    grid = _GrowableGrid(1, 2)
+    grid[0, 0] = 1
+    grid[1, 0] = "two"
+
+    # Check prepending a row.
+    grid.prepend_row()
+    assert grid.width == 1
+    assert grid.height == 3
+
+    assert grid[0, 0] is None
+    assert grid[1, 0] == 1
+    assert grid[2, 0] == "two"
+
+    # Check prepending a column.
+    grid.prepend_column()
+    assert grid.width == 2
+    assert grid.height == 3
+
+    assert grid[0, 0] is None
+    assert grid[1, 0] is None
+    assert grid[2, 0] is None
+
+    assert grid[0, 1] is None
+    assert grid[1, 1] == 1
+    assert grid[2, 1] == "two"
+
+
+def test_DiagramGrid():
+    # Set up some objects and morphisms.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(D, A, "h")
+    k = NamedMorphism(D, B, "k")
+
+    # A one-morphism diagram.
+    d = Diagram([f])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid.morphisms == {f: FiniteSet()}
+
+    # A triangle.
+    d = Diagram([f, g], {g * f: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] == C
+    assert grid[1, 1] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(),
+                              g * f: FiniteSet("unique")}
+
+    # A triangle with a "loop" morphism.
+    l_A = NamedMorphism(A, A, "l_A")
+    d = Diagram([f, g, l_A])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), l_A: FiniteSet()}
+
+    # A simple diagram.
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == D
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    assert str(grid) == '[[Object("A"), Object("B"), Object("D")], ' \
+        '[None, Object("C"), None]]'
+
+    # A chain of morphisms.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    k = NamedMorphism(D, E, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    # A square.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, D, "g")
+    h = NamedMorphism(A, C, "h")
+    k = NamedMorphism(C, D, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] == C
+    assert grid[1, 1] == D
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    # A strange diagram which resulted from a typo when creating a
+    # test for five lemma, but which allowed to stop one extra problem
+    # in the algorithm.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+
+    # These 4 morphisms should be between primed objects.
+    j = NamedMorphism(A, B, "j")
+    k = NamedMorphism(B, C, "k")
+    l = NamedMorphism(C, D, "l")
+    m = NamedMorphism(D, E, "m")
+
+    o = NamedMorphism(A, A_, "o")
+    p = NamedMorphism(B, B_, "p")
+    q = NamedMorphism(C, C_, "q")
+    r = NamedMorphism(D, D_, "r")
+    s = NamedMorphism(E, E_, "s")
+
+    d = Diagram([f, g, h, i, j, k, l, m, o, p, q, r, s])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 4
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A
+    assert grid[0, 2] == A_
+    assert grid[1, 0] == C
+    assert grid[1, 1] == B
+    assert grid[1, 2] == B_
+    assert grid[2, 0] == C_
+    assert grid[2, 1] == D
+    assert grid[2, 2] == D_
+    assert grid[3, 0] is None
+    assert grid[3, 1] == E
+    assert grid[3, 2] == E_
+
+    morphisms = {}
+    for m in [f, g, h, i, j, k, l, m, o, p, q, r, s]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # A cube.
+    A1 = Object("A1")
+    A2 = Object("A2")
+    A3 = Object("A3")
+    A4 = Object("A4")
+    A5 = Object("A5")
+    A6 = Object("A6")
+    A7 = Object("A7")
+    A8 = Object("A8")
+
+    # The top face of the cube.
+    f1 = NamedMorphism(A1, A2, "f1")
+    f2 = NamedMorphism(A1, A3, "f2")
+    f3 = NamedMorphism(A2, A4, "f3")
+    f4 = NamedMorphism(A3, A4, "f3")
+
+    # The bottom face of the cube.
+    f5 = NamedMorphism(A5, A6, "f5")
+    f6 = NamedMorphism(A5, A7, "f6")
+    f7 = NamedMorphism(A6, A8, "f7")
+    f8 = NamedMorphism(A7, A8, "f8")
+
+    # The remaining morphisms.
+    f9 = NamedMorphism(A1, A5, "f9")
+    f10 = NamedMorphism(A2, A6, "f10")
+    f11 = NamedMorphism(A3, A7, "f11")
+    f12 = NamedMorphism(A4, A8, "f11")
+
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 3
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A5
+    assert grid[0, 2] == A6
+    assert grid[0, 3] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == A1
+    assert grid[1, 2] == A2
+    assert grid[1, 3] is None
+    assert grid[2, 0] == A7
+    assert grid[2, 1] == A3
+    assert grid[2, 2] == A4
+    assert grid[2, 3] == A8
+
+    morphisms = {}
+    for m in [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # A line diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+    grid = DiagramGrid(d, layout="sequential")
+
+    assert grid.width == 5
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid[0, 4] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              i: FiniteSet()}
+
+    # Test the transposed version.
+    grid = DiagramGrid(d, layout="sequential", transpose=True)
+
+    assert grid.width == 1
+    assert grid.height == 5
+    assert grid[0, 0] == A
+    assert grid[1, 0] == B
+    assert grid[2, 0] == C
+    assert grid[3, 0] == D
+    assert grid[4, 0] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              i: FiniteSet()}
+
+    # A pullback.
+    m1 = NamedMorphism(A, B, "m1")
+    m2 = NamedMorphism(A, C, "m2")
+    s1 = NamedMorphism(B, D, "s1")
+    s2 = NamedMorphism(C, D, "s2")
+    f1 = NamedMorphism(E, B, "f1")
+    f2 = NamedMorphism(E, C, "f2")
+    g = NamedMorphism(E, A, "g")
+
+    d = Diagram([m1, m2, s1, s2, f1, f2], {g: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == E
+    assert grid[1, 0] == C
+    assert grid[1, 1] == D
+    assert grid[1, 2] is None
+
+    morphisms = {g: FiniteSet("unique")}
+    for m in [m1, m2, s1, s2, f1, f2]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # Test the pullback with sequential layout, just for stress
+    # testing.
+    grid = DiagramGrid(d, layout="sequential")
+
+    assert grid.width == 5
+    assert grid.height == 1
+    assert grid[0, 0] == D
+    assert grid[0, 1] == B
+    assert grid[0, 2] == A
+    assert grid[0, 3] == C
+    assert grid[0, 4] == E
+    assert grid.morphisms == morphisms
+
+    # Test a pullback with object grouping.
+    grid = DiagramGrid(d, groups=FiniteSet(E, FiniteSet(A, B, C, D)))
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == E
+    assert grid[0, 1] == A
+    assert grid[0, 2] == B
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid.morphisms == morphisms
+
+    # Five lemma, actually.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+
+    j = NamedMorphism(A_, B_, "j")
+    k = NamedMorphism(B_, C_, "k")
+    l = NamedMorphism(C_, D_, "l")
+    m = NamedMorphism(D_, E_, "m")
+
+    o = NamedMorphism(A, A_, "o")
+    p = NamedMorphism(B, B_, "p")
+    q = NamedMorphism(C, C_, "q")
+    r = NamedMorphism(D, D_, "r")
+    s = NamedMorphism(E, E_, "s")
+
+    d = Diagram([f, g, h, i, j, k, l, m, o, p, q, r, s])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 5
+    assert grid.height == 3
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A
+    assert grid[0, 2] == A_
+    assert grid[0, 3] is None
+    assert grid[0, 4] is None
+    assert grid[1, 0] == C
+    assert grid[1, 1] == B
+    assert grid[1, 2] == B_
+    assert grid[1, 3] == C_
+    assert grid[1, 4] is None
+    assert grid[2, 0] == D
+    assert grid[2, 1] == E
+    assert grid[2, 2] is None
+    assert grid[2, 3] == D_
+    assert grid[2, 4] == E_
+
+    morphisms = {}
+    for m in [f, g, h, i, j, k, l, m, o, p, q, r, s]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping.
+    grid = DiagramGrid(d, FiniteSet(
+        FiniteSet(A, B, C, D, E), FiniteSet(A_, B_, C_, D_, E_)))
+
+    assert grid.width == 6
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[0, 3] == A_
+    assert grid[0, 4] == B_
+    assert grid[0, 5] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[1, 3] is None
+    assert grid[1, 4] == C_
+    assert grid[1, 5] == D_
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+    assert grid[2, 5] == E_
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping, but mixing containers
+    # to represent groups.
+    grid = DiagramGrid(d, [(A, B, C, D, E), {A_, B_, C_, D_, E_}])
+
+    assert grid.width == 6
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[0, 3] == A_
+    assert grid[0, 4] == B_
+    assert grid[0, 5] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[1, 3] is None
+    assert grid[1, 4] == C_
+    assert grid[1, 5] == D_
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+    assert grid[2, 5] == E_
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping and hints.
+    grid = DiagramGrid(d, {
+        FiniteSet(A, B, C, D, E): {"layout": "sequential",
+                                   "transpose": True},
+        FiniteSet(A_, B_, C_, D_, E_): {"layout": "sequential",
+                                        "transpose": True}},
+        transpose=True)
+
+    assert grid.width == 5
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid[0, 4] == E
+    assert grid[1, 0] == A_
+    assert grid[1, 1] == B_
+    assert grid[1, 2] == C_
+    assert grid[1, 3] == D_
+    assert grid[1, 4] == E_
+    assert grid.morphisms == morphisms
+
+    # A two-triangle disconnected diagram.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    f_ = NamedMorphism(A_, B_, "f")
+    g_ = NamedMorphism(B_, C_, "g")
+    d = Diagram([f, g, f_, g_], {g * f: "unique", g_ * f_: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == A_
+    assert grid[0, 3] == B_
+    assert grid[1, 0] == C
+    assert grid[1, 1] is None
+    assert grid[1, 2] == C_
+    assert grid[1, 3] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), f_: FiniteSet(),
+                              g_: FiniteSet(), g * f: FiniteSet("unique"),
+                              g_ * f_: FiniteSet("unique")}
+
+    # A two-morphism disconnected diagram.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(C, D, "g")
+    d = Diagram([f, g])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet()}
+
+    # Test a one-object diagram.
+    f = NamedMorphism(A, A, "f")
+    d = Diagram([f])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 1
+    assert grid.height == 1
+    assert grid[0, 0] == A
+
+    # Test a two-object disconnected diagram.
+    g = NamedMorphism(B, B, "g")
+    d = Diagram([f, g])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+
+
+def test_DiagramGrid_pseudopod():
+    # Test a diagram in which even growing a pseudopod does not
+    # eventually help.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    F = Object("F")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f1 = NamedMorphism(A, B, "f1")
+    f2 = NamedMorphism(A, C, "f2")
+    f3 = NamedMorphism(A, D, "f3")
+    f4 = NamedMorphism(A, E, "f4")
+    f5 = NamedMorphism(A, A_, "f5")
+    f6 = NamedMorphism(A, B_, "f6")
+    f7 = NamedMorphism(A, C_, "f7")
+    f8 = NamedMorphism(A, D_, "f8")
+    f9 = NamedMorphism(A, E_, "f9")
+    f10 = NamedMorphism(A, F, "f10")
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 5
+    assert grid.height == 3
+    assert grid[0, 0] == E
+    assert grid[0, 1] == C
+    assert grid[0, 2] == C_
+    assert grid[0, 3] == E_
+    assert grid[0, 4] == F
+    assert grid[1, 0] == D
+    assert grid[1, 1] == A
+    assert grid[1, 2] == A_
+    assert grid[1, 3] is None
+    assert grid[1, 4] is None
+    assert grid[2, 0] == D_
+    assert grid[2, 1] == B
+    assert grid[2, 2] == B_
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+
+    morphisms = {}
+    for f in [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10]:
+        morphisms[f] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+
+def test_ArrowStringDescription():
+    astr = ArrowStringDescription("cm", "", None, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "^", 12, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@/^12cm/[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@(r,u)[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@(r,u)[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    astr.arrow_style = "{-->}"
+    assert str(astr) == "\\ar@(r,u)@{-->}[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "_", 12, "", "", "d", "r", "_", "f")
+    astr.arrow_style = "{-->}"
+    assert str(astr) == "\\ar@/_12cm/@{-->}[dr]_{f}"
+
+
+def test_XypicDiagramDrawer_line():
+    # A linear diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+    grid = DiagramGrid(d, layout="sequential")
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]^{f} & B \\ar[r]^{g} & C \\ar[r]^{h} & D \\ar[r]^{i} & E \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, layout="sequential", transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\\\\n" \
+        "B \\ar[d]^{g} \\\\\n" \
+        "C \\ar[d]^{h} \\\\\n" \
+        "D \\ar[d]^{i} \\\\\n" \
+        "E \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_triangle():
+    # A triangle diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+
+    d = Diagram([f, g], {g * f: "unique"})
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]_{g\\circ f} \\ar[r]^{f} & B \\ar[ld]^{g} \\\\\n" \
+        "C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]^{g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B \\ar[ru]_{g} & \n" \
+        "}\n"
+
+    # The same diagram, with a masked morphism.
+    assert drawer.draw(d, grid, masked=[g]) == "\\xymatrix{\n" \
+        "A \\ar[r]^{g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B & \n" \
+        "}\n"
+
+    # The same diagram with a formatter for "unique".
+    def formatter(astr):
+        astr.label = "\\exists !" + astr.label
+        astr.arrow_style = "{-->}"
+
+    drawer.arrow_formatters["unique"] = formatter
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar@{-->}[r]^{\\exists !g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B \\ar[ru]_{g} & \n" \
+        "}\n"
+
+    # The same diagram with a default formatter.
+    def default_formatter(astr):
+        astr.label_displacement = "(0.45)"
+
+    drawer.default_arrow_formatter = default_formatter
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar@{-->}[r]^(0.45){\\exists !g\\circ f} \\ar[d]_(0.45){f} & C \\\\\n" \
+        "B \\ar[ru]_(0.45){g} & \n" \
+        "}\n"
+
+    # A triangle diagram with a lot of morphisms between the same
+    # objects.
+    f1 = NamedMorphism(B, A, "f1")
+    f2 = NamedMorphism(A, B, "f2")
+    g1 = NamedMorphism(C, B, "g1")
+    g2 = NamedMorphism(B, C, "g2")
+    d = Diagram([f, f1, f2, g, g1, g2], {f1 * g1: "unique", g2 * f2: "unique"})
+
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid, masked=[f1*g1*g2*f2, g2*f2*f1*g1]) == \
+        "\\xymatrix{\n" \
+        "A \\ar[r]^{g_{2}\\circ f_{2}} \\ar[d]_{f} \\ar@/^3mm/[d]^{f_{2}} " \
+        "& C \\ar@/^3mm/[l]^{f_{1}\\circ g_{1}} \\ar@/^3mm/[ld]^{g_{1}} \\\\\n" \
+        "B \\ar@/^3mm/[u]^{f_{1}} \\ar[ru]_{g} \\ar@/^3mm/[ru]^{g_{2}} & \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_cube():
+    # A cube diagram.
+    A1 = Object("A1")
+    A2 = Object("A2")
+    A3 = Object("A3")
+    A4 = Object("A4")
+    A5 = Object("A5")
+    A6 = Object("A6")
+    A7 = Object("A7")
+    A8 = Object("A8")
+
+    # The top face of the cube.
+    f1 = NamedMorphism(A1, A2, "f1")
+    f2 = NamedMorphism(A1, A3, "f2")
+    f3 = NamedMorphism(A2, A4, "f3")
+    f4 = NamedMorphism(A3, A4, "f3")
+
+    # The bottom face of the cube.
+    f5 = NamedMorphism(A5, A6, "f5")
+    f6 = NamedMorphism(A5, A7, "f6")
+    f7 = NamedMorphism(A6, A8, "f7")
+    f8 = NamedMorphism(A7, A8, "f8")
+
+    # The remaining morphisms.
+    f9 = NamedMorphism(A1, A5, "f9")
+    f10 = NamedMorphism(A2, A6, "f10")
+    f11 = NamedMorphism(A3, A7, "f11")
+    f12 = NamedMorphism(A4, A8, "f11")
+
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "& A_{5} \\ar[r]^{f_{5}} \\ar[ldd]_{f_{6}} & A_{6} \\ar[rdd]^{f_{7}} " \
+        "& \\\\\n" \
+        "& A_{1} \\ar[r]^{f_{1}} \\ar[d]^{f_{2}} \\ar[u]^{f_{9}} & A_{2} " \
+        "\\ar[d]^{f_{3}} \\ar[u]_{f_{10}} & \\\\\n" \
+        "A_{7} \\ar@/_3mm/[rrr]_{f_{8}} & A_{3} \\ar[r]^{f_{3}} \\ar[l]_{f_{11}} " \
+        "& A_{4} \\ar[r]^{f_{11}} & A_{8} \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "& & A_{7} \\ar@/^3mm/[ddd]^{f_{8}} \\\\\n" \
+        "A_{5} \\ar[d]_{f_{5}} \\ar[rru]^{f_{6}} & A_{1} \\ar[d]^{f_{1}} " \
+        "\\ar[r]^{f_{2}} \\ar[l]^{f_{9}} & A_{3} \\ar[d]_{f_{3}} " \
+        "\\ar[u]^{f_{11}} \\\\\n" \
+        "A_{6} \\ar[rrd]_{f_{7}} & A_{2} \\ar[r]^{f_{3}} \\ar[l]^{f_{10}} " \
+        "& A_{4} \\ar[d]_{f_{11}} \\\\\n" \
+        "& & A_{8} \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_curved_and_loops():
+    # A simple diagram, with a curved arrow.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(D, A, "h")
+    k = NamedMorphism(D, B, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} & B \\ar[d]^{g} & D \\ar[l]^{k} \\ar@/_3mm/[ll]_{h} \\\\\n" \
+        "& C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^3mm/[uu]^{h} & \n" \
+        "}\n"
+
+    # The same diagram, larger and rotated.
+    assert drawer.draw(d, grid, diagram_format="@+1cm@dr") == \
+        "\\xymatrix@+1cm@dr{\n" \
+        "A \\ar[d]^{f} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^3mm/[uu]^{h} & \n" \
+        "}\n"
+
+    # A simple diagram with three curved arrows.
+    h1 = NamedMorphism(D, A, "h1")
+    h2 = NamedMorphism(A, D, "h2")
+    k = NamedMorphism(D, B, "k")
+    d = Diagram([f, g, h, k, h1, h2])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} & B \\ar[d]^{g} & D \\ar[l]^{k} " \
+        "\\ar@/_7mm/[ll]_{h} \\ar@/_11mm/[ll]_{h_{1}} \\\\\n" \
+        "& C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} & \n" \
+        "}\n"
+
+    # The same diagram, with "loop" morphisms.
+    l_A = NamedMorphism(A, A, "l_A")
+    l_D = NamedMorphism(D, D, "l_D")
+    l_C = NamedMorphism(C, C, "l_C")
+    d = Diagram([f, g, h, k, h1, h2, l_A, l_D, l_C])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} \\ar@(u,l)[]^{l_{A}} " \
+        "& B \\ar[d]^{g} & D \\ar[l]^{k} \\ar@/_7mm/[ll]_{h} " \
+        "\\ar@/_11mm/[ll]_{h_{1}} \\ar@(r,u)[]^{l_{D}} \\\\\n" \
+        "& C \\ar@(l,d)[]^{l_{C}} & \n" \
+        "}\n"
+
+    # The same diagram with "loop" morphisms, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} \\ar@(r,u)[]^{l_{A}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\ar@(r,u)[]^{l_{C}} \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} " \
+        "\\ar@(l,d)[]^{l_{D}} & \n" \
+        "}\n"
+
+    # The same diagram with two "loop" morphisms per object.
+    l_A_ = NamedMorphism(A, A, "n_A")
+    l_D_ = NamedMorphism(D, D, "n_D")
+    l_C_ = NamedMorphism(C, C, "n_C")
+    d = Diagram([f, g, h, k, h1, h2, l_A, l_D, l_C, l_A_, l_D_, l_C_])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} \\ar@(u,l)[]^{l_{A}} " \
+        "\\ar@/^3mm/@(l,d)[]^{n_{A}} & B \\ar[d]^{g} & D \\ar[l]^{k} " \
+        "\\ar@/_7mm/[ll]_{h} \\ar@/_11mm/[ll]_{h_{1}} \\ar@(r,u)[]^{l_{D}} " \
+        "\\ar@/^3mm/@(d,r)[]^{n_{D}} \\\\\n" \
+        "& C \\ar@(l,d)[]^{l_{C}} \\ar@/^3mm/@(d,r)[]^{n_{C}} & \n" \
+        "}\n"
+
+    # The same diagram with two "loop" morphisms per object, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} \\ar@(r,u)[]^{l_{A}} " \
+        "\\ar@/^3mm/@(u,l)[]^{n_{A}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\ar@(r,u)[]^{l_{C}} \\ar@/^3mm/@(d,r)[]^{n_{C}} \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} " \
+        "\\ar@(l,d)[]^{l_{D}} \\ar@/^3mm/@(d,r)[]^{n_{D}} & \n" \
+        "}\n"
+
+
+def test_xypic_draw_diagram():
+    # A linear diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+
+    grid = DiagramGrid(d, layout="sequential")
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == xypic_draw_diagram(d, layout="sequential")

pllava/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',
+]

pllava/lib/python3.10/site-packages/sympy/diffgeom/diffgeom.py

@@ -0,0 +1,2270 @@
+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)
+    return {f._coord_sys for f in fields}
+
+
+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

pllava/lib/python3.10/site-packages/sympy/diffgeom/rn.py

@@ -0,0 +1,143 @@
+"""Predefined R^n manifolds together with common coord. systems.
+
+Coordinate systems are predefined as well as the transformation laws between
+them.
+
+Coordinate functions can be accessed as attributes of the manifold (eg `R2.x`),
+as attributes of the coordinate systems (eg `R2_r.x` and `R2_p.theta`), or by
+using the usual `coord_sys.coord_function(index, name)` interface.
+"""
+
+from typing import Any
+import warnings
+
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, atan2, cos, sin)
+from .diffgeom import Manifold, Patch, CoordSystem
+
+__all__ = [
+    'R2', 'R2_origin', 'relations_2d', 'R2_r', 'R2_p',
+    'R3', 'R3_origin', 'relations_3d', 'R3_r', 'R3_c', 'R3_s'
+]
+
+###############################################################################
+# R2
+###############################################################################
+R2: Any = Manifold('R^2', 2)
+
+R2_origin: Any = Patch('origin', R2)
+
+x, y = symbols('x y', real=True)
+r, theta = symbols('rho theta', nonnegative=True)
+
+relations_2d = {
+    ('rectangular', 'polar'): [(x, y), (sqrt(x**2 + y**2), atan2(y, x))],
+    ('polar', 'rectangular'): [(r, theta), (r*cos(theta), r*sin(theta))],
+}
+
+R2_r: Any = CoordSystem('rectangular', R2_origin, (x, y), relations_2d)
+R2_p: Any = CoordSystem('polar', R2_origin, (r, theta), relations_2d)
+
+# support deprecated feature
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    x, y, r, theta = symbols('x y r theta', cls=Dummy)
+    R2_r.connect_to(R2_p, [x, y],
+                        [sqrt(x**2 + y**2), atan2(y, x)],
+                    inverse=False, fill_in_gaps=False)
+    R2_p.connect_to(R2_r, [r, theta],
+                        [r*cos(theta), r*sin(theta)],
+                    inverse=False, fill_in_gaps=False)
+
+# Defining the basis coordinate functions and adding shortcuts for them to the
+# manifold and the patch.
+R2.x, R2.y = R2_origin.x, R2_origin.y = R2_r.x, R2_r.y = R2_r.coord_functions()
+R2.r, R2.theta = R2_origin.r, R2_origin.theta = R2_p.r, R2_p.theta = R2_p.coord_functions()
+
+# Defining the basis vector fields and adding shortcuts for them to the
+# manifold and the patch.
+R2.e_x, R2.e_y = R2_origin.e_x, R2_origin.e_y = R2_r.e_x, R2_r.e_y = R2_r.base_vectors()
+R2.e_r, R2.e_theta = R2_origin.e_r, R2_origin.e_theta = R2_p.e_r, R2_p.e_theta = R2_p.base_vectors()
+
+# Defining the basis oneform fields and adding shortcuts for them to the
+# manifold and the patch.
+R2.dx, R2.dy = R2_origin.dx, R2_origin.dy = R2_r.dx, R2_r.dy = R2_r.base_oneforms()
+R2.dr, R2.dtheta = R2_origin.dr, R2_origin.dtheta = R2_p.dr, R2_p.dtheta = R2_p.base_oneforms()
+
+###############################################################################
+# R3
+###############################################################################
+R3: Any = Manifold('R^3', 3)
+
+R3_origin: Any = Patch('origin', R3)
+
+x, y, z = symbols('x y z', real=True)
+rho, psi, r, theta, phi = symbols('rho psi r theta phi', nonnegative=True)
+
+relations_3d = {
+    ('rectangular', 'cylindrical'): [(x, y, z),
+                                     (sqrt(x**2 + y**2), atan2(y, x), z)],
+    ('cylindrical', 'rectangular'): [(rho, psi, z),
+                                     (rho*cos(psi), rho*sin(psi), z)],
+    ('rectangular', 'spherical'): [(x, y, z),
+                                   (sqrt(x**2 + y**2 + z**2),
+                                    acos(z/sqrt(x**2 + y**2 + z**2)),
+                                    atan2(y, x))],
+    ('spherical', 'rectangular'): [(r, theta, phi),
+                                   (r*sin(theta)*cos(phi),
+                                    r*sin(theta)*sin(phi),
+                                    r*cos(theta))],
+    ('cylindrical', 'spherical'): [(rho, psi, z),
+                                   (sqrt(rho**2 + z**2),
+                                    acos(z/sqrt(rho**2 + z**2)),
+                                    psi)],
+    ('spherical', 'cylindrical'): [(r, theta, phi),
+                                   (r*sin(theta), phi, r*cos(theta))],
+}
+
+R3_r: Any = CoordSystem('rectangular', R3_origin, (x, y, z), relations_3d)
+R3_c: Any = CoordSystem('cylindrical', R3_origin, (rho, psi, z), relations_3d)
+R3_s: Any = CoordSystem('spherical', R3_origin, (r, theta, phi), relations_3d)
+
+# support deprecated feature
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    x, y, z, rho, psi, r, theta, phi = symbols('x y z rho psi r theta phi', cls=Dummy)
+    R3_r.connect_to(R3_c, [x, y, z],
+                        [sqrt(x**2 + y**2), atan2(y, x), z],
+                    inverse=False, fill_in_gaps=False)
+    R3_c.connect_to(R3_r, [rho, psi, z],
+                        [rho*cos(psi), rho*sin(psi), z],
+                    inverse=False, fill_in_gaps=False)
+    ## rectangular <-> spherical
+    R3_r.connect_to(R3_s, [x, y, z],
+                        [sqrt(x**2 + y**2 + z**2), acos(z/
+                                sqrt(x**2 + y**2 + z**2)), atan2(y, x)],
+                    inverse=False, fill_in_gaps=False)
+    R3_s.connect_to(R3_r, [r, theta, phi],
+                        [r*sin(theta)*cos(phi), r*sin(
+                            theta)*sin(phi), r*cos(theta)],
+                    inverse=False, fill_in_gaps=False)
+    ## cylindrical <-> spherical
+    R3_c.connect_to(R3_s, [rho, psi, z],
+                        [sqrt(rho**2 + z**2), acos(z/sqrt(rho**2 + z**2)), psi],
+                    inverse=False, fill_in_gaps=False)
+    R3_s.connect_to(R3_c, [r, theta, phi],
+                        [r*sin(theta), phi, r*cos(theta)],
+                    inverse=False, fill_in_gaps=False)
+
+# Defining the basis coordinate functions.
+R3_r.x, R3_r.y, R3_r.z = R3_r.coord_functions()
+R3_c.rho, R3_c.psi, R3_c.z = R3_c.coord_functions()
+R3_s.r, R3_s.theta, R3_s.phi = R3_s.coord_functions()
+
+# Defining the basis vector fields.
+R3_r.e_x, R3_r.e_y, R3_r.e_z = R3_r.base_vectors()
+R3_c.e_rho, R3_c.e_psi, R3_c.e_z = R3_c.base_vectors()
+R3_s.e_r, R3_s.e_theta, R3_s.e_phi = R3_s.base_vectors()
+
+# Defining the basis oneform fields.
+R3_r.dx, R3_r.dy, R3_r.dz = R3_r.base_oneforms()
+R3_c.drho, R3_c.dpsi, R3_c.dz = R3_c.base_oneforms()
+R3_s.dr, R3_s.dtheta, R3_s.dphi = R3_s.base_oneforms()

pllava/lib/python3.10/site-packages/sympy/diffgeom/tests/test_class_structure.py

@@ -0,0 +1,33 @@
+from sympy.diffgeom import Manifold, Patch, CoordSystem, Point
+from sympy.core.function import Function
+from sympy.core.symbol import symbols
+from sympy.testing.pytest import warns_deprecated_sympy
+
+m = Manifold('m', 2)
+p = Patch('p', m)
+a, b = symbols('a b')
+cs = CoordSystem('cs', p, [a, b])
+x, y = symbols('x y')
+f = Function('f')
+s1, s2 = cs.coord_functions()
+v1, v2 = cs.base_vectors()
+f1, f2 = cs.base_oneforms()
+
+def test_point():
+    point = Point(cs, [x, y])
+    assert point != Point(cs, [2, y])
+    #TODO assert point.subs(x, 2) == Point(cs, [2, y])
+    #TODO assert point.free_symbols == set([x, y])
+
+def test_subs():
+    assert s1.subs(s1, s2) == s2
+    assert v1.subs(v1, v2) == v2
+    assert f1.subs(f1, f2) == f2
+    assert (x*f(s1) + y).subs(s1, s2) == x*f(s2) + y
+    assert (f(s1)*v1).subs(v1, v2) == f(s1)*v2
+    assert (y*f(s1)*f1).subs(f1, f2) == y*f(s1)*f2
+
+def test_deprecated():
+    with warns_deprecated_sympy():
+        cs_wname = CoordSystem('cs', p, ['a', 'b'])
+        assert cs_wname == cs_wname.func(*cs_wname.args)

pllava/lib/python3.10/site-packages/sympy/diffgeom/tests/test_diffgeom.py

@@ -0,0 +1,342 @@
+from sympy.core import Lambda, Symbol, symbols
+from sympy.diffgeom.rn import R2, R2_p, R2_r, R3_r, R3_c, R3_s, R2_origin
+from sympy.diffgeom import (Manifold, Patch, CoordSystem, Commutator, Differential, TensorProduct,
+        WedgeProduct, BaseCovarDerivativeOp, CovarDerivativeOp, LieDerivative,
+        covariant_order, contravariant_order, twoform_to_matrix, metric_to_Christoffel_1st,
+        metric_to_Christoffel_2nd, metric_to_Riemann_components,
+        metric_to_Ricci_components, intcurve_diffequ, intcurve_series)
+from sympy.simplify import trigsimp, simplify
+from sympy.functions import sqrt, atan2, sin
+from sympy.matrices import Matrix
+from sympy.testing.pytest import raises, nocache_fail
+from sympy.testing.pytest import warns_deprecated_sympy
+
+TP = TensorProduct
+
+
+def test_coordsys_transform():
+    # test inverse transforms
+    p, q, r, s = symbols('p q r s')
+    rel = {('first', 'second'): [(p, q), (q, -p)]}
+    R2_pq = CoordSystem('first', R2_origin, [p, q], rel)
+    R2_rs = CoordSystem('second', R2_origin, [r, s], rel)
+    r, s = R2_rs.symbols
+    assert R2_rs.transform(R2_pq) == Matrix([[-s], [r]])
+
+    # inverse transform impossible case
+    a, b = symbols('a b', positive=True)
+    rel = {('first', 'second'): [(a,), (-a,)]}
+    R2_a = CoordSystem('first', R2_origin, [a], rel)
+    R2_b = CoordSystem('second', R2_origin, [b], rel)
+    # This transformation is uninvertible because there is no positive a, b satisfying a = -b
+    with raises(NotImplementedError):
+        R2_b.transform(R2_a)
+
+    # inverse transform ambiguous case
+    c, d = symbols('c d')
+    rel = {('first', 'second'): [(c,), (c**2,)]}
+    R2_c = CoordSystem('first', R2_origin, [c], rel)
+    R2_d = CoordSystem('second', R2_origin, [d], rel)
+    # The transform method should throw if it finds multiple inverses for a coordinate transformation.
+    with raises(ValueError):
+        R2_d.transform(R2_c)
+
+    # test indirect transformation
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    rel = {('C1', 'C2'): [(a, b), (2*a, 3*b)],
+        ('C2', 'C3'): [(c, d), (3*c, 2*d)]}
+    C1 = CoordSystem('C1', R2_origin, (a, b), rel)
+    C2 = CoordSystem('C2', R2_origin, (c, d), rel)
+    C3 = CoordSystem('C3', R2_origin, (e, f), rel)
+    a, b = C1.symbols
+    c, d = C2.symbols
+    e, f = C3.symbols
+    assert C2.transform(C1) == Matrix([c/2, d/3])
+    assert C1.transform(C3) == Matrix([6*a, 6*b])
+    assert C3.transform(C1) == Matrix([e/6, f/6])
+    assert C3.transform(C2) == Matrix([e/3, f/2])
+
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    rel = {('C1', 'C2'): [(a, b), (2*a, 3*b + 1)],
+        ('C3', 'C2'): [(e, f), (-e - 2, 2*f)]}
+    C1 = CoordSystem('C1', R2_origin, (a, b), rel)
+    C2 = CoordSystem('C2', R2_origin, (c, d), rel)
+    C3 = CoordSystem('C3', R2_origin, (e, f), rel)
+    a, b = C1.symbols
+    c, d = C2.symbols
+    e, f = C3.symbols
+    assert C2.transform(C1) == Matrix([c/2, (d - 1)/3])
+    assert C1.transform(C3) == Matrix([-2*a - 2, (3*b + 1)/2])
+    assert C3.transform(C1) == Matrix([-e/2 - 1, (2*f - 1)/3])
+    assert C3.transform(C2) == Matrix([-e - 2, 2*f])
+
+    # old signature uses Lambda
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    rel = {('C1', 'C2'): Lambda((a, b), (2*a, 3*b + 1)),
+        ('C3', 'C2'): Lambda((e, f), (-e - 2, 2*f))}
+    C1 = CoordSystem('C1', R2_origin, (a, b), rel)
+    C2 = CoordSystem('C2', R2_origin, (c, d), rel)
+    C3 = CoordSystem('C3', R2_origin, (e, f), rel)
+    a, b = C1.symbols
+    c, d = C2.symbols
+    e, f = C3.symbols
+    assert C2.transform(C1) == Matrix([c/2, (d - 1)/3])
+    assert C1.transform(C3) == Matrix([-2*a - 2, (3*b + 1)/2])
+    assert C3.transform(C1) == Matrix([-e/2 - 1, (2*f - 1)/3])
+    assert C3.transform(C2) == Matrix([-e - 2, 2*f])
+
+
+def test_R2():
+    x0, y0, r0, theta0 = symbols('x0, y0, r0, theta0', real=True)
+    point_r = R2_r.point([x0, y0])
+    point_p = R2_p.point([r0, theta0])
+
+    # r**2 = x**2 + y**2
+    assert (R2.r**2 - R2.x**2 - R2.y**2).rcall(point_r) == 0
+    assert trigsimp( (R2.r**2 - R2.x**2 - R2.y**2).rcall(point_p) ) == 0
+    assert trigsimp(R2.e_r(R2.x**2 + R2.y**2).rcall(point_p).doit()) == 2*r0
+
+    # polar->rect->polar == Id
+    a, b = symbols('a b', positive=True)
+    m = Matrix([[a], [b]])
+
+    #TODO assert m == R2_r.transform(R2_p, R2_p.transform(R2_r, [a, b])).applyfunc(simplify)
+    assert m == R2_p.transform(R2_r, R2_r.transform(R2_p, m)).applyfunc(simplify)
+
+    # deprecated method
+    with warns_deprecated_sympy():
+        assert m == R2_p.coord_tuple_transform_to(
+            R2_r, R2_r.coord_tuple_transform_to(R2_p, m)).applyfunc(simplify)
+
+
+def test_R3():
+    a, b, c = symbols('a b c', positive=True)
+    m = Matrix([[a], [b], [c]])
+
+    assert m == R3_c.transform(R3_r, R3_r.transform(R3_c, m)).applyfunc(simplify)
+    #TODO assert m == R3_r.transform(R3_c, R3_c.transform(R3_r, m)).applyfunc(simplify)
+    assert m == R3_s.transform(
+        R3_r, R3_r.transform(R3_s, m)).applyfunc(simplify)
+    #TODO assert m == R3_r.transform(R3_s, R3_s.transform(R3_r, m)).applyfunc(simplify)
+    assert m == R3_s.transform(
+        R3_c, R3_c.transform(R3_s, m)).applyfunc(simplify)
+    #TODO assert m == R3_c.transform(R3_s, R3_s.transform(R3_c, m)).applyfunc(simplify)
+
+    with warns_deprecated_sympy():
+        assert m == R3_c.coord_tuple_transform_to(
+            R3_r, R3_r.coord_tuple_transform_to(R3_c, m)).applyfunc(simplify)
+        #TODO assert m == R3_r.coord_tuple_transform_to(R3_c, R3_c.coord_tuple_transform_to(R3_r, m)).applyfunc(simplify)
+        assert m == R3_s.coord_tuple_transform_to(
+            R3_r, R3_r.coord_tuple_transform_to(R3_s, m)).applyfunc(simplify)
+        #TODO assert m == R3_r.coord_tuple_transform_to(R3_s, R3_s.coord_tuple_transform_to(R3_r, m)).applyfunc(simplify)
+        assert m == R3_s.coord_tuple_transform_to(
+            R3_c, R3_c.coord_tuple_transform_to(R3_s, m)).applyfunc(simplify)
+        #TODO assert m == R3_c.coord_tuple_transform_to(R3_s, R3_s.coord_tuple_transform_to(R3_c, m)).applyfunc(simplify)
+
+
+def test_CoordinateSymbol():
+    x, y = R2_r.symbols
+    r, theta = R2_p.symbols
+    assert y.rewrite(R2_p) == r*sin(theta)
+
+
+def test_point():
+    x, y = symbols('x, y')
+    p = R2_r.point([x, y])
+    assert p.free_symbols == {x, y}
+    assert p.coords(R2_r) == p.coords() == Matrix([x, y])
+    assert p.coords(R2_p) == Matrix([sqrt(x**2 + y**2), atan2(y, x)])
+
+
+def test_commutator():
+    assert Commutator(R2.e_x, R2.e_y) == 0
+    assert Commutator(R2.x*R2.e_x, R2.x*R2.e_x) == 0
+    assert Commutator(R2.x*R2.e_x, R2.x*R2.e_y) == R2.x*R2.e_y
+    c = Commutator(R2.e_x, R2.e_r)
+    assert c(R2.x) == R2.y*(R2.x**2 + R2.y**2)**(-1)*sin(R2.theta)
+
+
+def test_differential():
+    xdy = R2.x*R2.dy
+    dxdy = Differential(xdy)
+    assert xdy.rcall(None) == xdy
+    assert dxdy(R2.e_x, R2.e_y) == 1
+    assert dxdy(R2.e_x, R2.x*R2.e_y) == R2.x
+    assert Differential(dxdy) == 0
+
+
+def test_products():
+    assert TensorProduct(
+        R2.dx, R2.dy)(R2.e_x, R2.e_y) == R2.dx(R2.e_x)*R2.dy(R2.e_y) == 1
+    assert TensorProduct(R2.dx, R2.dy)(None, R2.e_y) == R2.dx
+    assert TensorProduct(R2.dx, R2.dy)(R2.e_x, None) == R2.dy
+    assert TensorProduct(R2.dx, R2.dy)(R2.e_x) == R2.dy
+    assert TensorProduct(R2.x, R2.dx) == R2.x*R2.dx
+    assert TensorProduct(
+        R2.e_x, R2.e_y)(R2.x, R2.y) == R2.e_x(R2.x) * R2.e_y(R2.y) == 1
+    assert TensorProduct(R2.e_x, R2.e_y)(None, R2.y) == R2.e_x
+    assert TensorProduct(R2.e_x, R2.e_y)(R2.x, None) == R2.e_y
+    assert TensorProduct(R2.e_x, R2.e_y)(R2.x) == R2.e_y
+    assert TensorProduct(R2.x, R2.e_x) == R2.x * R2.e_x
+    assert TensorProduct(
+        R2.dx, R2.e_y)(R2.e_x, R2.y) == R2.dx(R2.e_x) * R2.e_y(R2.y) == 1
+    assert TensorProduct(R2.dx, R2.e_y)(None, R2.y) == R2.dx
+    assert TensorProduct(R2.dx, R2.e_y)(R2.e_x, None) == R2.e_y
+    assert TensorProduct(R2.dx, R2.e_y)(R2.e_x) == R2.e_y
+    assert TensorProduct(R2.x, R2.e_x) == R2.x * R2.e_x
+    assert TensorProduct(
+        R2.e_x, R2.dy)(R2.x, R2.e_y) == R2.e_x(R2.x) * R2.dy(R2.e_y) == 1
+    assert TensorProduct(R2.e_x, R2.dy)(None, R2.e_y) == R2.e_x
+    assert TensorProduct(R2.e_x, R2.dy)(R2.x, None) == R2.dy
+    assert TensorProduct(R2.e_x, R2.dy)(R2.x) == R2.dy
+    assert TensorProduct(R2.e_y,R2.e_x)(R2.x**2 + R2.y**2,R2.x**2 + R2.y**2) == 4*R2.x*R2.y
+
+    assert WedgeProduct(R2.dx, R2.dy)(R2.e_x, R2.e_y) == 1
+    assert WedgeProduct(R2.e_x, R2.e_y)(R2.x, R2.y) == 1
+
+
+def test_lie_derivative():
+    assert LieDerivative(R2.e_x, R2.y) == R2.e_x(R2.y) == 0
+    assert LieDerivative(R2.e_x, R2.x) == R2.e_x(R2.x) == 1
+    assert LieDerivative(R2.e_x, R2.e_x) == Commutator(R2.e_x, R2.e_x) == 0
+    assert LieDerivative(R2.e_x, R2.e_r) == Commutator(R2.e_x, R2.e_r)
+    assert LieDerivative(R2.e_x + R2.e_y, R2.x) == 1
+    assert LieDerivative(
+        R2.e_x, TensorProduct(R2.dx, R2.dy))(R2.e_x, R2.e_y) == 0
+
+
+@nocache_fail
+def test_covar_deriv():
+    ch = metric_to_Christoffel_2nd(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    cvd = BaseCovarDerivativeOp(R2_r, 0, ch)
+    assert cvd(R2.x) == 1
+    # This line fails if the cache is disabled:
+    assert cvd(R2.x*R2.e_x) == R2.e_x
+    cvd = CovarDerivativeOp(R2.x*R2.e_x, ch)
+    assert cvd(R2.x) == R2.x
+    assert cvd(R2.x*R2.e_x) == R2.x*R2.e_x
+
+
+def test_intcurve_diffequ():
+    t = symbols('t')
+    start_point = R2_r.point([1, 0])
+    vector_field = -R2.y*R2.e_x + R2.x*R2.e_y
+    equations, init_cond = intcurve_diffequ(vector_field, t, start_point)
+    assert str(equations) == '[f_1(t) + Derivative(f_0(t), t), -f_0(t) + Derivative(f_1(t), t)]'
+    assert str(init_cond) == '[f_0(0) - 1, f_1(0)]'
+    equations, init_cond = intcurve_diffequ(vector_field, t, start_point, R2_p)
+    assert str(
+        equations) == '[Derivative(f_0(t), t), Derivative(f_1(t), t) - 1]'
+    assert str(init_cond) == '[f_0(0) - 1, f_1(0)]'
+
+
+def test_helpers_and_coordinate_dependent():
+    one_form = R2.dr + R2.dx
+    two_form = Differential(R2.x*R2.dr + R2.r*R2.dx)
+    three_form = Differential(
+        R2.y*two_form) + Differential(R2.x*Differential(R2.r*R2.dr))
+    metric = TensorProduct(R2.dx, R2.dx) + TensorProduct(R2.dy, R2.dy)
+    metric_ambig = TensorProduct(R2.dx, R2.dx) + TensorProduct(R2.dr, R2.dr)
+    misform_a = TensorProduct(R2.dr, R2.dr) + R2.dr
+    misform_b = R2.dr**4
+    misform_c = R2.dx*R2.dy
+    twoform_not_sym = TensorProduct(R2.dx, R2.dx) + TensorProduct(R2.dx, R2.dy)
+    twoform_not_TP = WedgeProduct(R2.dx, R2.dy)
+
+    one_vector = R2.e_x + R2.e_y
+    two_vector = TensorProduct(R2.e_x, R2.e_y)
+    three_vector = TensorProduct(R2.e_x, R2.e_y, R2.e_x)
+    two_wp = WedgeProduct(R2.e_x,R2.e_y)
+
+    assert covariant_order(one_form) == 1
+    assert covariant_order(two_form) == 2
+    assert covariant_order(three_form) == 3
+    assert covariant_order(two_form + metric) == 2
+    assert covariant_order(two_form + metric_ambig) == 2
+    assert covariant_order(two_form + twoform_not_sym) == 2
+    assert covariant_order(two_form + twoform_not_TP) == 2
+
+    assert contravariant_order(one_vector) == 1
+    assert contravariant_order(two_vector) == 2
+    assert contravariant_order(three_vector) == 3
+    assert contravariant_order(two_vector + two_wp) == 2
+
+    raises(ValueError, lambda: covariant_order(misform_a))
+    raises(ValueError, lambda: covariant_order(misform_b))
+    raises(ValueError, lambda: covariant_order(misform_c))
+
+    assert twoform_to_matrix(metric) == Matrix([[1, 0], [0, 1]])
+    assert twoform_to_matrix(twoform_not_sym) == Matrix([[1, 0], [1, 0]])
+    assert twoform_to_matrix(twoform_not_TP) == Matrix([[0, -1], [1, 0]])
+
+    raises(ValueError, lambda: twoform_to_matrix(one_form))
+    raises(ValueError, lambda: twoform_to_matrix(three_form))
+    raises(ValueError, lambda: twoform_to_matrix(metric_ambig))
+
+    raises(ValueError, lambda: metric_to_Christoffel_1st(twoform_not_sym))
+    raises(ValueError, lambda: metric_to_Christoffel_2nd(twoform_not_sym))
+    raises(ValueError, lambda: metric_to_Riemann_components(twoform_not_sym))
+    raises(ValueError, lambda: metric_to_Ricci_components(twoform_not_sym))
+
+
+def test_correct_arguments():
+    raises(ValueError, lambda: R2.e_x(R2.e_x))
+    raises(ValueError, lambda: R2.e_x(R2.dx))
+
+    raises(ValueError, lambda: Commutator(R2.e_x, R2.x))
+    raises(ValueError, lambda: Commutator(R2.dx, R2.e_x))
+
+    raises(ValueError, lambda: Differential(Differential(R2.e_x)))
+
+    raises(ValueError, lambda: R2.dx(R2.x))
+
+    raises(ValueError, lambda: LieDerivative(R2.dx, R2.dx))
+    raises(ValueError, lambda: LieDerivative(R2.x, R2.dx))
+
+    raises(ValueError, lambda: CovarDerivativeOp(R2.dx, []))
+    raises(ValueError, lambda: CovarDerivativeOp(R2.x, []))
+
+    a = Symbol('a')
+    raises(ValueError, lambda: intcurve_series(R2.dx, a, R2_r.point([1, 2])))
+    raises(ValueError, lambda: intcurve_series(R2.x, a, R2_r.point([1, 2])))
+
+    raises(ValueError, lambda: intcurve_diffequ(R2.dx, a, R2_r.point([1, 2])))
+    raises(ValueError, lambda: intcurve_diffequ(R2.x, a, R2_r.point([1, 2])))
+
+    raises(ValueError, lambda: contravariant_order(R2.e_x + R2.dx))
+    raises(ValueError, lambda: covariant_order(R2.e_x + R2.dx))
+
+    raises(ValueError, lambda: contravariant_order(R2.e_x*R2.e_y))
+    raises(ValueError, lambda: covariant_order(R2.dx*R2.dy))
+
+def test_simplify():
+    x, y = R2_r.coord_functions()
+    dx, dy = R2_r.base_oneforms()
+    ex, ey = R2_r.base_vectors()
+    assert simplify(x) == x
+    assert simplify(x*y) == x*y
+    assert simplify(dx*dy) == dx*dy
+    assert simplify(ex*ey) == ex*ey
+    assert ((1-x)*dx)/(1-x)**2 == dx/(1-x)
+
+
+def test_issue_17917():
+    X = R2.x*R2.e_x - R2.y*R2.e_y
+    Y = (R2.x**2 + R2.y**2)*R2.e_x - R2.x*R2.y*R2.e_y
+    assert LieDerivative(X, Y).expand() == (
+        R2.x**2*R2.e_x - 3*R2.y**2*R2.e_x - R2.x*R2.y*R2.e_y)
+
+def test_deprecations():
+    m = Manifold('M', 2)
+    p = Patch('P', m)
+    with warns_deprecated_sympy():
+        CoordSystem('Car2d', p, names=['x', 'y'])
+
+    with warns_deprecated_sympy():
+        c = CoordSystem('Car2d', p, ['x', 'y'])
+
+    with warns_deprecated_sympy():
+        list(m.patches)
+
+    with warns_deprecated_sympy():
+        list(c.transforms)

pllava/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

pllava/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

pllava/lib/python3.10/site-packages/sympy/polys/__pycache__/polytools.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e190ab6d918a9035f73d1463ba8efa7d42f1f0174bce577ac0e32153d1a80cf
+size 186792

pllava/lib/python3.10/site-packages/sympy/polys/tests/__pycache__/test_polytools.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c150eaf47b23d11ece2b8f4fdcaae77a0f30d570cd09c7aa3a18b844277f441
+size 141252

pllava/lib/python3.10/site-packages/sympy/tensor/__init__.py

@@ -0,0 +1,23 @@
+"""A module to manipulate symbolic objects with indices including tensors
+
+"""
+from .indexed import IndexedBase, Idx, Indexed
+from .index_methods import get_contraction_structure, get_indices
+from .functions import shape
+from .array import (MutableDenseNDimArray, ImmutableDenseNDimArray,
+    MutableSparseNDimArray, ImmutableSparseNDimArray, NDimArray, tensorproduct,
+    tensorcontraction, tensordiagonal, derive_by_array, permutedims, Array,
+    DenseNDimArray, SparseNDimArray,)
+
+__all__ = [
+    'IndexedBase', 'Idx', 'Indexed',
+
+    'get_contraction_structure', 'get_indices',
+
+    'shape',
+
+    'MutableDenseNDimArray', 'ImmutableDenseNDimArray',
+    'MutableSparseNDimArray', 'ImmutableSparseNDimArray', 'NDimArray',
+    'tensorproduct', 'tensorcontraction', 'tensordiagonal', 'derive_by_array', 'permutedims',
+    'Array', 'DenseNDimArray', 'SparseNDimArray',
+]

pllava/lib/python3.10/site-packages/sympy/tensor/array/__init__.py

@@ -0,0 +1,271 @@
+r"""
+N-dim array module for SymPy.
+
+Four classes are provided to handle N-dim arrays, given by the combinations
+dense/sparse (i.e. whether to store all elements or only the non-zero ones in
+memory) and mutable/immutable (immutable classes are SymPy objects, but cannot
+change after they have been created).
+
+Examples
+========
+
+The following examples show the usage of ``Array``. This is an abbreviation for
+``ImmutableDenseNDimArray``, that is an immutable and dense N-dim array, the
+other classes are analogous. For mutable classes it is also possible to change
+element values after the object has been constructed.
+
+Array construction can detect the shape of nested lists and tuples:
+
+>>> from sympy import Array
+>>> a1 = Array([[1, 2], [3, 4], [5, 6]])
+>>> a1
+[[1, 2], [3, 4], [5, 6]]
+>>> a1.shape
+(3, 2)
+>>> a1.rank()
+2
+>>> from sympy.abc import x, y, z
+>>> a2 = Array([[[x, y], [z, x*z]], [[1, x*y], [1/x, x/y]]])
+>>> a2
+[[[x, y], [z, x*z]], [[1, x*y], [1/x, x/y]]]
+>>> a2.shape
+(2, 2, 2)
+>>> a2.rank()
+3
+
+Otherwise one could pass a 1-dim array followed by a shape tuple:
+
+>>> m1 = Array(range(12), (3, 4))
+>>> m1
+[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]
+>>> m2 = Array(range(12), (3, 2, 2))
+>>> m2
+[[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[8, 9], [10, 11]]]
+>>> m2[1,1,1]
+7
+>>> m2.reshape(4, 3)
+[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
+
+Slice support:
+
+>>> m2[:, 1, 1]
+[3, 7, 11]
+
+Elementwise derivative:
+
+>>> from sympy.abc import x, y, z
+>>> m3 = Array([x**3, x*y, z])
+>>> m3.diff(x)
+[3*x**2, y, 0]
+>>> m3.diff(z)
+[0, 0, 1]
+
+Multiplication with other SymPy expressions is applied elementwisely:
+
+>>> (1+x)*m3
+[x**3*(x + 1), x*y*(x + 1), z*(x + 1)]
+
+To apply a function to each element of the N-dim array, use ``applyfunc``:
+
+>>> m3.applyfunc(lambda x: x/2)
+[x**3/2, x*y/2, z/2]
+
+N-dim arrays can be converted to nested lists by the ``tolist()`` method:
+
+>>> m2.tolist()
+[[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[8, 9], [10, 11]]]
+>>> isinstance(m2.tolist(), list)
+True
+
+If the rank is 2, it is possible to convert them to matrices with ``tomatrix()``:
+
+>>> m1.tomatrix()
+Matrix([
+[0, 1,  2,  3],
+[4, 5,  6,  7],
+[8, 9, 10, 11]])
+
+Products and contractions
+-------------------------
+
+Tensor product between arrays `A_{i_1,\ldots,i_n}` and `B_{j_1,\ldots,j_m}`
+creates the combined array `P = A \otimes B` defined as
+
+`P_{i_1,\ldots,i_n,j_1,\ldots,j_m} := A_{i_1,\ldots,i_n}\cdot B_{j_1,\ldots,j_m}.`
+
+It is available through ``tensorproduct(...)``:
+
+>>> from sympy import Array, tensorproduct
+>>> from sympy.abc import x,y,z,t
+>>> A = Array([x, y, z, t])
+>>> B = Array([1, 2, 3, 4])
+>>> tensorproduct(A, B)
+[[x, 2*x, 3*x, 4*x], [y, 2*y, 3*y, 4*y], [z, 2*z, 3*z, 4*z], [t, 2*t, 3*t, 4*t]]
+
+In case you don't want to evaluate the tensor product immediately, you can use
+``ArrayTensorProduct``, which creates an unevaluated tensor product expression:
+
+>>> from sympy.tensor.array.expressions import ArrayTensorProduct
+>>> ArrayTensorProduct(A, B)
+ArrayTensorProduct([x, y, z, t], [1, 2, 3, 4])
+
+Calling ``.as_explicit()`` on ``ArrayTensorProduct`` is equivalent to just calling
+``tensorproduct(...)``:
+
+>>> ArrayTensorProduct(A, B).as_explicit()
+[[x, 2*x, 3*x, 4*x], [y, 2*y, 3*y, 4*y], [z, 2*z, 3*z, 4*z], [t, 2*t, 3*t, 4*t]]
+
+Tensor product between a rank-1 array and a matrix creates a rank-3 array:
+
+>>> from sympy import eye
+>>> p1 = tensorproduct(A, eye(4))
+>>> p1
+[[[x, 0, 0, 0], [0, x, 0, 0], [0, 0, x, 0], [0, 0, 0, x]], [[y, 0, 0, 0], [0, y, 0, 0], [0, 0, y, 0], [0, 0, 0, y]], [[z, 0, 0, 0], [0, z, 0, 0], [0, 0, z, 0], [0, 0, 0, z]], [[t, 0, 0, 0], [0, t, 0, 0], [0, 0, t, 0], [0, 0, 0, t]]]
+
+Now, to get back `A_0 \otimes \mathbf{1}` one can access `p_{0,m,n}` by slicing:
+
+>>> p1[0,:,:]
+[[x, 0, 0, 0], [0, x, 0, 0], [0, 0, x, 0], [0, 0, 0, x]]
+
+Tensor contraction sums over the specified axes, for example contracting
+positions `a` and `b` means
+
+`A_{i_1,\ldots,i_a,\ldots,i_b,\ldots,i_n} \implies \sum_k A_{i_1,\ldots,k,\ldots,k,\ldots,i_n}`
+
+Remember that Python indexing is zero starting, to contract the a-th and b-th
+axes it is therefore necessary to specify `a-1` and `b-1`
+
+>>> from sympy import tensorcontraction
+>>> C = Array([[x, y], [z, t]])
+
+The matrix trace is equivalent to the contraction of a rank-2 array:
+
+`A_{m,n} \implies \sum_k A_{k,k}`
+
+>>> tensorcontraction(C, (0, 1))
+t + x
+
+To create an expression representing a tensor contraction that does not get
+evaluated immediately, use ``ArrayContraction``, which is equivalent to
+``tensorcontraction(...)`` if it is followed by ``.as_explicit()``:
+
+>>> from sympy.tensor.array.expressions import ArrayContraction
+>>> ArrayContraction(C, (0, 1))
+ArrayContraction([[x, y], [z, t]], (0, 1))
+>>> ArrayContraction(C, (0, 1)).as_explicit()
+t + x
+
+Matrix product is equivalent to a tensor product of two rank-2 arrays, followed
+by a contraction of the 2nd and 3rd axes (in Python indexing axes number 1, 2).
+
+`A_{m,n}\cdot B_{i,j} \implies \sum_k A_{m, k}\cdot B_{k, j}`
+
+>>> D = Array([[2, 1], [0, -1]])
+>>> tensorcontraction(tensorproduct(C, D), (1, 2))
+[[2*x, x - y], [2*z, -t + z]]
+
+One may verify that the matrix product is equivalent:
+
+>>> from sympy import Matrix
+>>> Matrix([[x, y], [z, t]])*Matrix([[2, 1], [0, -1]])
+Matrix([
+[2*x,  x - y],
+[2*z, -t + z]])
+
+or equivalently
+
+>>> C.tomatrix()*D.tomatrix()
+Matrix([
+[2*x,  x - y],
+[2*z, -t + z]])
+
+Diagonal operator
+-----------------
+
+The ``tensordiagonal`` function acts in a similar manner as ``tensorcontraction``,
+but the joined indices are not summed over, for example diagonalizing
+positions `a` and `b` means
+
+`A_{i_1,\ldots,i_a,\ldots,i_b,\ldots,i_n} \implies A_{i_1,\ldots,k,\ldots,k,\ldots,i_n}
+\implies \tilde{A}_{i_1,\ldots,i_{a-1},i_{a+1},\ldots,i_{b-1},i_{b+1},\ldots,i_n,k}`
+
+where `\tilde{A}` is the array equivalent to the diagonal of `A` at positions
+`a` and `b` moved to the last index slot.
+
+Compare the difference between contraction and diagonal operators:
+
+>>> from sympy import tensordiagonal
+>>> from sympy.abc import a, b, c, d
+>>> m = Matrix([[a, b], [c, d]])
+>>> tensorcontraction(m, [0, 1])
+a + d
+>>> tensordiagonal(m, [0, 1])
+[a, d]
+
+In short, no summation occurs with ``tensordiagonal``.
+
+
+Derivatives by array
+--------------------
+
+The usual derivative operation may be extended to support derivation with
+respect to arrays, provided that all elements in the that array are symbols or
+expressions suitable for derivations.
+
+The definition of a derivative by an array is as follows: given the array
+`A_{i_1, \ldots, i_N}` and the array `X_{j_1, \ldots, j_M}`
+the derivative of arrays will return a new array `B` defined by
+
+`B_{j_1,\ldots,j_M,i_1,\ldots,i_N} := \frac{\partial A_{i_1,\ldots,i_N}}{\partial X_{j_1,\ldots,j_M}}`
+
+The function ``derive_by_array`` performs such an operation:
+
+>>> from sympy import derive_by_array
+>>> from sympy.abc import x, y, z, t
+>>> from sympy import sin, exp
+
+With scalars, it behaves exactly as the ordinary derivative:
+
+>>> derive_by_array(sin(x*y), x)
+y*cos(x*y)
+
+Scalar derived by an array basis:
+
+>>> derive_by_array(sin(x*y), [x, y, z])
+[y*cos(x*y), x*cos(x*y), 0]
+
+Deriving array by an array basis: `B^{nm} := \frac{\partial A^m}{\partial x^n}`
+
+>>> basis = [x, y, z]
+>>> ax = derive_by_array([exp(x), sin(y*z), t], basis)
+>>> ax
+[[exp(x), 0, 0], [0, z*cos(y*z), 0], [0, y*cos(y*z), 0]]
+
+Contraction of the resulting array: `\sum_m \frac{\partial A^m}{\partial x^m}`
+
+>>> tensorcontraction(ax, (0, 1))
+z*cos(y*z) + exp(x)
+
+"""
+
+from .dense_ndim_array import MutableDenseNDimArray, ImmutableDenseNDimArray, DenseNDimArray
+from .sparse_ndim_array import MutableSparseNDimArray, ImmutableSparseNDimArray, SparseNDimArray
+from .ndim_array import NDimArray, ArrayKind
+from .arrayop import tensorproduct, tensorcontraction, tensordiagonal, derive_by_array, permutedims
+from .array_comprehension import ArrayComprehension, ArrayComprehensionMap
+
+Array = ImmutableDenseNDimArray
+
+__all__ = [
+    'MutableDenseNDimArray', 'ImmutableDenseNDimArray', 'DenseNDimArray',
+
+    'MutableSparseNDimArray', 'ImmutableSparseNDimArray', 'SparseNDimArray',
+
+    'NDimArray', 'ArrayKind',
+
+    'tensorproduct', 'tensorcontraction', 'tensordiagonal', 'derive_by_array',
+
+    'permutedims', 'ArrayComprehension', 'ArrayComprehensionMap',
+
+    'Array',
+]

pllava/lib/python3.10/site-packages/sympy/tensor/array/array_derivatives.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from sympy.core.expr import Expr
+from sympy.core.function import Derivative
+from sympy.core.numbers import Integer
+from sympy.matrices.matrixbase import MatrixBase
+from .ndim_array import NDimArray
+from .arrayop import derive_by_array
+from sympy.matrices.expressions.matexpr import MatrixExpr
+from sympy.matrices.expressions.special import ZeroMatrix
+from sympy.matrices.expressions.matexpr import _matrix_derivative
+
+
+class ArrayDerivative(Derivative):
+
+    is_scalar = False
+
+    def __new__(cls, expr, *variables, **kwargs):
+        obj = super().__new__(cls, expr, *variables, **kwargs)
+        if isinstance(obj, ArrayDerivative):
+            obj._shape = obj._get_shape()
+        return obj
+
+    def _get_shape(self):
+        shape = ()
+        for v, count in self.variable_count:
+            if hasattr(v, "shape"):
+                for i in range(count):
+                    shape += v.shape
+        if hasattr(self.expr, "shape"):
+            shape += self.expr.shape
+        return shape
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @classmethod
+    def _get_zero_with_shape_like(cls, expr):
+        if isinstance(expr, (MatrixBase, NDimArray)):
+            return expr.zeros(*expr.shape)
+        elif isinstance(expr, MatrixExpr):
+            return ZeroMatrix(*expr.shape)
+        else:
+            raise RuntimeError("Unable to determine shape of array-derivative.")
+
+    @staticmethod
+    def _call_derive_scalar_by_matrix(expr: Expr, v: MatrixBase) -> Expr:
+        return v.applyfunc(lambda x: expr.diff(x))
+
+    @staticmethod
+    def _call_derive_scalar_by_matexpr(expr: Expr, v: MatrixExpr) -> Expr:
+        if expr.has(v):
+            return _matrix_derivative(expr, v)
+        else:
+            return ZeroMatrix(*v.shape)
+
+    @staticmethod
+    def _call_derive_scalar_by_array(expr: Expr, v: NDimArray) -> Expr:
+        return v.applyfunc(lambda x: expr.diff(x))
+
+    @staticmethod
+    def _call_derive_matrix_by_scalar(expr: MatrixBase, v: Expr) -> Expr:
+        return _matrix_derivative(expr, v)
+
+    @staticmethod
+    def _call_derive_matexpr_by_scalar(expr: MatrixExpr, v: Expr) -> Expr:
+        return expr._eval_derivative(v)
+
+    @staticmethod
+    def _call_derive_array_by_scalar(expr: NDimArray, v: Expr) -> Expr:
+        return expr.applyfunc(lambda x: x.diff(v))
+
+    @staticmethod
+    def _call_derive_default(expr: Expr, v: Expr) -> Expr | None:
+        if expr.has(v):
+            return _matrix_derivative(expr, v)
+        else:
+            return None
+
+    @classmethod
+    def _dispatch_eval_derivative_n_times(cls, expr, v, count):
+        # Evaluate the derivative `n` times.  If
+        # `_eval_derivative_n_times` is not overridden by the current
+        # object, the default in `Basic` will call a loop over
+        # `_eval_derivative`:
+
+        if not isinstance(count, (int, Integer)) or ((count <= 0) == True):
+            return None
+
+        # TODO: this could be done with multiple-dispatching:
+        if expr.is_scalar:
+            if isinstance(v, MatrixBase):
+                result = cls._call_derive_scalar_by_matrix(expr, v)
+            elif isinstance(v, MatrixExpr):
+                result = cls._call_derive_scalar_by_matexpr(expr, v)
+            elif isinstance(v, NDimArray):
+                result = cls._call_derive_scalar_by_array(expr, v)
+            elif v.is_scalar:
+                # scalar by scalar has a special
+                return super()._dispatch_eval_derivative_n_times(expr, v, count)
+            else:
+                return None
+        elif v.is_scalar:
+            if isinstance(expr, MatrixBase):
+                result = cls._call_derive_matrix_by_scalar(expr, v)
+            elif isinstance(expr, MatrixExpr):
+                result = cls._call_derive_matexpr_by_scalar(expr, v)
+            elif isinstance(expr, NDimArray):
+                result = cls._call_derive_array_by_scalar(expr, v)
+            else:
+                return None
+        else:
+            # Both `expr` and `v` are some array/matrix type:
+            if isinstance(expr, MatrixBase) or isinstance(v, MatrixBase):
+                result = derive_by_array(expr, v)
+            elif isinstance(expr, MatrixExpr) and isinstance(v, MatrixExpr):
+                result = cls._call_derive_default(expr, v)
+            elif isinstance(expr, MatrixExpr) or isinstance(v, MatrixExpr):
+                # if one expression is a symbolic matrix expression while the other isn't, don't evaluate:
+                return None
+            else:
+                result = derive_by_array(expr, v)
+        if result is None:
+            return None
+        if count == 1:
+            return result
+        else:
+            return cls._dispatch_eval_derivative_n_times(result, v, count - 1)

pllava/lib/python3.10/site-packages/sympy/tensor/array/dense_ndim_array.py

@@ -0,0 +1,206 @@
+import functools
+from typing import List
+
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.singleton import S
+from sympy.core.sympify import _sympify
+from sympy.tensor.array.mutable_ndim_array import MutableNDimArray
+from sympy.tensor.array.ndim_array import NDimArray, ImmutableNDimArray, ArrayKind
+from sympy.utilities.iterables import flatten
+
+
+class DenseNDimArray(NDimArray):
+
+    _array: List[Basic]
+
+    def __new__(self, *args, **kwargs):
+        return ImmutableDenseNDimArray(*args, **kwargs)
+
+    @property
+    def kind(self) -> ArrayKind:
+        return ArrayKind._union(self._array)
+
+    def __getitem__(self, index):
+        """
+        Allows to get items from N-dim array.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray([0, 1, 2, 3], (2, 2))
+        >>> a
+        [[0, 1], [2, 3]]
+        >>> a[0, 0]
+        0
+        >>> a[1, 1]
+        3
+        >>> a[0]
+        [0, 1]
+        >>> a[1]
+        [2, 3]
+
+
+        Symbolic index:
+
+        >>> from sympy.abc import i, j
+        >>> a[i, j]
+        [[0, 1], [2, 3]][i, j]
+
+        Replace `i` and `j` to get element `(1, 1)`:
+
+        >>> a[i, j].subs({i: 1, j: 1})
+        3
+
+        """
+        syindex = self._check_symbolic_index(index)
+        if syindex is not None:
+            return syindex
+
+        index = self._check_index_for_getitem(index)
+
+        if isinstance(index, tuple) and any(isinstance(i, slice) for i in index):
+            sl_factors, eindices = self._get_slice_data_for_array_access(index)
+            array = [self._array[self._parse_index(i)] for i in eindices]
+            nshape = [len(el) for i, el in enumerate(sl_factors) if isinstance(index[i], slice)]
+            return type(self)(array, nshape)
+        else:
+            index = self._parse_index(index)
+            return self._array[index]
+
+    @classmethod
+    def zeros(cls, *shape):
+        list_length = functools.reduce(lambda x, y: x*y, shape, S.One)
+        return cls._new(([0]*list_length,), shape)
+
+    def tomatrix(self):
+        """
+        Converts MutableDenseNDimArray to Matrix. Can convert only 2-dim array, else will raise error.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray([1 for i in range(9)], (3, 3))
+        >>> b = a.tomatrix()
+        >>> b
+        Matrix([
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1]])
+
+        """
+        from sympy.matrices import Matrix
+
+        if self.rank() != 2:
+            raise ValueError('Dimensions must be of size of 2')
+
+        return Matrix(self.shape[0], self.shape[1], self._array)
+
+    def reshape(self, *newshape):
+        """
+        Returns MutableDenseNDimArray instance with new shape. Elements number
+        must be        suitable to new shape. The only argument of method sets
+        new shape.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray([1, 2, 3, 4, 5, 6], (2, 3))
+        >>> a.shape
+        (2, 3)
+        >>> a
+        [[1, 2, 3], [4, 5, 6]]
+        >>> b = a.reshape(3, 2)
+        >>> b.shape
+        (3, 2)
+        >>> b
+        [[1, 2], [3, 4], [5, 6]]
+
+        """
+        new_total_size = functools.reduce(lambda x,y: x*y, newshape)
+        if new_total_size != self._loop_size:
+            raise ValueError('Expecting reshape size to %d but got prod(%s) = %d' % (
+                self._loop_size, str(newshape), new_total_size))
+
+        # there is no `.func` as this class does not subtype `Basic`:
+        return type(self)(self._array, newshape)
+
+
+class ImmutableDenseNDimArray(DenseNDimArray, ImmutableNDimArray): # type: ignore
+    def __new__(cls, iterable, shape=None, **kwargs):
+        return cls._new(iterable, shape, **kwargs)
+
+    @classmethod
+    def _new(cls, iterable, shape, **kwargs):
+        shape, flat_list = cls._handle_ndarray_creation_inputs(iterable, shape, **kwargs)
+        shape = Tuple(*map(_sympify, shape))
+        cls._check_special_bounds(flat_list, shape)
+        flat_list = flatten(flat_list)
+        flat_list = Tuple(*flat_list)
+        self = Basic.__new__(cls, flat_list, shape, **kwargs)
+        self._shape = shape
+        self._array = list(flat_list)
+        self._rank = len(shape)
+        self._loop_size = functools.reduce(lambda x,y: x*y, shape, 1)
+        return self
+
+    def __setitem__(self, index, value):
+        raise TypeError('immutable N-dim array')
+
+    def as_mutable(self):
+        return MutableDenseNDimArray(self)
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.simplify import simplify
+        return self.applyfunc(simplify)
+
+class MutableDenseNDimArray(DenseNDimArray, MutableNDimArray):
+
+    def __new__(cls, iterable=None, shape=None, **kwargs):
+        return cls._new(iterable, shape, **kwargs)
+
+    @classmethod
+    def _new(cls, iterable, shape, **kwargs):
+        shape, flat_list = cls._handle_ndarray_creation_inputs(iterable, shape, **kwargs)
+        flat_list = flatten(flat_list)
+        self = object.__new__(cls)
+        self._shape = shape
+        self._array = list(flat_list)
+        self._rank = len(shape)
+        self._loop_size = functools.reduce(lambda x,y: x*y, shape) if shape else len(flat_list)
+        return self
+
+    def __setitem__(self, index, value):
+        """Allows to set items to MutableDenseNDimArray.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray.zeros(2,  2)
+        >>> a[0,0] = 1
+        >>> a[1,1] = 1
+        >>> a
+        [[1, 0], [0, 1]]
+
+        """
+        if isinstance(index, tuple) and any(isinstance(i, slice) for i in index):
+            value, eindices, slice_offsets = self._get_slice_data_for_array_assignment(index, value)
+            for i in eindices:
+                other_i = [ind - j for ind, j in zip(i, slice_offsets) if j is not None]
+                self._array[self._parse_index(i)] = value[other_i]
+        else:
+            index = self._parse_index(index)
+            self._setter_iterable_check(value)
+            value = _sympify(value)
+            self._array[index] = value
+
+    def as_immutable(self):
+        return ImmutableDenseNDimArray(self)
+
+    @property
+    def free_symbols(self):
+        return {i for j in self._array for i in j.free_symbols}