Add files using upload-large-folder tool

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

@@ -0,0 +1,3 @@
+from sympy.liealgebras.cartan_type import CartanType
+
+__all__ = ['CartanType']

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

@@ -0,0 +1,25 @@
+from .cartan_type import CartanType
+
+def CartanMatrix(ct):
+    """Access the Cartan matrix of a specific Lie algebra
+
+    Examples
+    ========
+
+    >>> from sympy.liealgebras.cartan_matrix import CartanMatrix
+    >>> CartanMatrix("A2")
+    Matrix([
+    [ 2, -1],
+    [-1,  2]])
+
+    >>> CartanMatrix(['C', 3])
+    Matrix([
+    [ 2, -1,  0],
+    [-1,  2, -1],
+    [ 0, -2,  2]])
+
+    This method works by returning the Cartan matrix
+    which corresponds to Cartan type t.
+    """
+
+    return CartanType(ct).cartan_matrix()

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

@@ -0,0 +1,73 @@
+from sympy.core import Atom, Basic
+
+
+class CartanType_generator():
+    """
+    Constructor for actually creating things
+    """
+    def __call__(self, *args):
+        c = args[0]
+        if isinstance(c, list):
+            letter, n = c[0], int(c[1])
+        elif isinstance(c, str):
+            letter, n = c[0], int(c[1:])
+        else:
+            raise TypeError("Argument must be a string (e.g. 'A3') or a list (e.g. ['A', 3])")
+
+        if n < 0:
+            raise ValueError("Lie algebra rank cannot be negative")
+        if letter == "A":
+            from . import type_a
+            return type_a.TypeA(n)
+        if letter == "B":
+            from . import type_b
+            return type_b.TypeB(n)
+
+        if letter == "C":
+            from . import type_c
+            return type_c.TypeC(n)
+
+        if letter == "D":
+            from . import type_d
+            return type_d.TypeD(n)
+
+        if letter == "E":
+            if n >= 6 and n <= 8:
+                from . import type_e
+                return type_e.TypeE(n)
+
+        if letter == "F":
+            if n == 4:
+                from . import type_f
+                return type_f.TypeF(n)
+
+        if letter == "G":
+            if n == 2:
+                from . import type_g
+                return type_g.TypeG(n)
+
+CartanType = CartanType_generator()
+
+
+class Standard_Cartan(Atom):
+    """
+    Concrete base class for Cartan types such as A4, etc
+    """
+
+    def __new__(cls, series, n):
+        obj = Basic.__new__(cls)
+        obj.n = n
+        obj.series = series
+        return obj
+
+    def rank(self):
+        """
+        Returns the rank of the Lie algebra
+        """
+        return self.n
+
+    def series(self):
+        """
+        Returns the type of the Lie algebra
+        """
+        return self.series

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

@@ -0,0 +1,24 @@
+from .cartan_type import CartanType
+
+
+def DynkinDiagram(t):
+    """Display the Dynkin diagram of a given Lie algebra
+
+    Works by generating the CartanType for the input, t, and then returning the
+    Dynkin diagram method from the individual classes.
+
+    Examples
+    ========
+
+    >>> from sympy.liealgebras.dynkin_diagram import DynkinDiagram
+    >>> print(DynkinDiagram("A3"))
+    0---0---0
+    1   2   3
+
+    >>> print(DynkinDiagram("B4"))
+    0---0---0=>=0
+    1   2   3   4
+
+    """
+
+    return CartanType(t).dynkin_diagram()

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

@@ -0,0 +1,199 @@
+from .cartan_type import CartanType
+from sympy.core.basic import Atom
+
+class RootSystem(Atom):
+    """Represent the root system of a simple Lie algebra
+
+    Every simple Lie algebra has a unique root system.  To find the root
+    system, we first consider the Cartan subalgebra of g, which is the maximal
+    abelian subalgebra, and consider the adjoint action of g on this
+    subalgebra.  There is a root system associated with this action. Now, a
+    root system over a vector space V is a set of finite vectors Phi (called
+    roots), which satisfy:
+
+    1.  The roots span V
+    2.  The only scalar multiples of x in Phi are x and -x
+    3.  For every x in Phi, the set Phi is closed under reflection
+        through the hyperplane perpendicular to x.
+    4.  If x and y are roots in Phi, then the projection of y onto
+        the line through x is a half-integral multiple of x.
+
+    Now, there is a subset of Phi, which we will call Delta, such that:
+    1.  Delta is a basis of V
+    2.  Each root x in Phi can be written x = sum k_y y for y in Delta
+
+    The elements of Delta are called the simple roots.
+    Therefore, we see that the simple roots span the root space of a given
+    simple Lie algebra.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Root_system
+    .. [2] Lie Algebras and Representation Theory - Humphreys
+
+    """
+
+    def __new__(cls, cartantype):
+        """Create a new RootSystem object
+
+        This method assigns an attribute called cartan_type to each instance of
+        a RootSystem object.  When an instance of RootSystem is called, it
+        needs an argument, which should be an instance of a simple Lie algebra.
+        We then take the CartanType of this argument and set it as the
+        cartan_type attribute of the RootSystem instance.
+
+        """
+        obj = Atom.__new__(cls)
+        obj.cartan_type = CartanType(cartantype)
+        return obj
+
+    def simple_roots(self):
+        """Generate the simple roots of the Lie algebra
+
+        The rank of the Lie algebra determines the number of simple roots that
+        it has.  This method obtains the rank of the Lie algebra, and then uses
+        the simple_root method from the Lie algebra classes to generate all the
+        simple roots.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.root_system import RootSystem
+        >>> c = RootSystem("A3")
+        >>> roots = c.simple_roots()
+        >>> roots
+        {1: [1, -1, 0, 0], 2: [0, 1, -1, 0], 3: [0, 0, 1, -1]}
+
+        """
+        n = self.cartan_type.rank()
+        roots = {}
+        for i in range(1, n+1):
+            root = self.cartan_type.simple_root(i)
+            roots[i] = root
+        return roots
+
+
+    def all_roots(self):
+        """Generate all the roots of a given root system
+
+        The result is a dictionary where the keys are integer numbers.  It
+        generates the roots by getting the dictionary of all positive roots
+        from the bases classes, and then taking each root, and multiplying it
+        by -1 and adding it to the dictionary.  In this way all the negative
+        roots are generated.
+
+        """
+        alpha = self.cartan_type.positive_roots()
+        keys = list(alpha.keys())
+        k = max(keys)
+        for val in keys:
+            k += 1
+            root = alpha[val]
+            newroot = [-x for x in root]
+            alpha[k] = newroot
+        return alpha
+
+    def root_space(self):
+        """Return the span of the simple roots
+
+        The root space is the vector space spanned by the simple roots, i.e. it
+        is a vector space with a distinguished basis, the simple roots.  This
+        method returns a string that represents the root space as the span of
+        the simple roots, alpha[1],...., alpha[n].
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.root_system import RootSystem
+        >>> c = RootSystem("A3")
+        >>> c.root_space()
+        'alpha[1] + alpha[2] + alpha[3]'
+
+        """
+        n = self.cartan_type.rank()
+        rs = " + ".join("alpha["+str(i) +"]" for i in range(1, n+1))
+        return rs
+
+    def add_simple_roots(self, root1, root2):
+        """Add two simple roots together
+
+        The function takes as input two integers, root1 and root2.  It then
+        uses these integers as keys in the dictionary of simple roots, and gets
+        the corresponding simple roots, and then adds them together.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.root_system import RootSystem
+        >>> c = RootSystem("A3")
+        >>> newroot = c.add_simple_roots(1, 2)
+        >>> newroot
+        [1, 0, -1, 0]
+
+        """
+
+        alpha = self.simple_roots()
+        if root1 > len(alpha) or root2 > len(alpha):
+            raise ValueError("You've used a root that doesn't exist!")
+        a1 = alpha[root1]
+        a2 = alpha[root2]
+        newroot = [_a1 + _a2 for _a1, _a2 in zip(a1, a2)]
+        return newroot
+
+    def add_as_roots(self, root1, root2):
+        """Add two roots together if and only if their sum is also a root
+
+        It takes as input two vectors which should be roots.  It then computes
+        their sum and checks if it is in the list of all possible roots.  If it
+        is, it returns the sum.  Otherwise it returns a string saying that the
+        sum is not a root.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.root_system import RootSystem
+        >>> c = RootSystem("A3")
+        >>> c.add_as_roots([1, 0, -1, 0], [0, 0, 1, -1])
+        [1, 0, 0, -1]
+        >>> c.add_as_roots([1, -1, 0, 0], [0, 0, -1, 1])
+        'The sum of these two roots is not a root'
+
+        """
+        alpha = self.all_roots()
+        newroot = [r1 + r2 for r1, r2 in zip(root1, root2)]
+        if newroot in alpha.values():
+            return newroot
+        else:
+            return "The sum of these two roots is not a root"
+
+
+    def cartan_matrix(self):
+        """Cartan matrix of Lie algebra associated with this root system
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.root_system import RootSystem
+        >>> c = RootSystem("A3")
+        >>> c.cartan_matrix()
+        Matrix([
+            [ 2, -1,  0],
+            [-1,  2, -1],
+            [ 0, -1,  2]])
+        """
+        return self.cartan_type.cartan_matrix()
+
+    def dynkin_diagram(self):
+        """Dynkin diagram of the Lie algebra associated with this root system
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.root_system import RootSystem
+        >>> c = RootSystem("A3")
+        >>> print(c.dynkin_diagram())
+        0---0---0
+        1   2   3
+        """
+        return self.cartan_type.dynkin_diagram()

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_cartan_matrix.py

@@ -0,0 +1,10 @@
+from sympy.liealgebras.cartan_matrix import CartanMatrix
+from sympy.matrices import Matrix
+
+def test_CartanMatrix():
+    c = CartanMatrix("A3")
+    m = Matrix(3, 3, [2, -1, 0, -1, 2, -1, 0, -1, 2])
+    assert c == m
+    a = CartanMatrix(["G",2])
+    mt = Matrix(2, 2, [2, -1, -3, 2])
+    assert a == mt

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_cartan_type.py

@@ -0,0 +1,12 @@
+from sympy.liealgebras.cartan_type import CartanType, Standard_Cartan
+
+def test_Standard_Cartan():
+    c = CartanType("A4")
+    assert c.rank() == 4
+    assert c.series == "A"
+    m = Standard_Cartan("A", 2)
+    assert m.rank() == 2
+    assert m.series == "A"
+    b = CartanType("B12")
+    assert b.rank() == 12
+    assert b.series == "B"

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_dynkin_diagram.py

@@ -0,0 +1,9 @@
+from sympy.liealgebras.dynkin_diagram import DynkinDiagram
+
+def test_DynkinDiagram():
+    c = DynkinDiagram("A3")
+    diag = "0---0---0\n1   2   3"
+    assert c == diag
+    ct = DynkinDiagram(["B", 3])
+    diag2 = "0---0=>=0\n1   2   3"
+    assert ct == diag2

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_root_system.py

@@ -0,0 +1,18 @@
+from sympy.liealgebras.root_system import RootSystem
+from sympy.liealgebras.type_a import TypeA
+from sympy.matrices import Matrix
+
+def test_root_system():
+    c = RootSystem("A3")
+    assert c.cartan_type == TypeA(3)
+    assert c.simple_roots() ==  {1: [1, -1, 0, 0], 2: [0, 1, -1, 0], 3: [0, 0, 1, -1]}
+    assert c.root_space() == "alpha[1] + alpha[2] + alpha[3]"
+    assert c.cartan_matrix() == Matrix([[ 2, -1,  0], [-1,  2, -1], [ 0, -1,  2]])
+    assert c.dynkin_diagram() == "0---0---0\n1   2   3"
+    assert c.add_simple_roots(1, 2) == [1, 0, -1, 0]
+    assert c.all_roots() == {1: [1, -1, 0, 0], 2: [1, 0, -1, 0],
+            3: [1, 0, 0, -1], 4: [0, 1, -1, 0], 5: [0, 1, 0, -1],
+            6: [0, 0, 1, -1], 7: [-1, 1, 0, 0], 8: [-1, 0, 1, 0],
+            9: [-1, 0, 0, 1], 10: [0, -1, 1, 0],
+            11: [0, -1, 0, 1], 12: [0, 0, -1, 1]}
+    assert c.add_as_roots([1, 0, -1, 0], [0, 0, 1, -1]) == [1, 0, 0, -1]

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_type_A.py

@@ -0,0 +1,17 @@
+from sympy.liealgebras.cartan_type import CartanType
+from sympy.matrices import Matrix
+
+def test_type_A():
+    c = CartanType("A3")
+    m = Matrix(3, 3, [2, -1, 0, -1, 2, -1, 0, -1, 2])
+    assert m == c.cartan_matrix()
+    assert c.basis() == 8
+    assert c.roots() == 12
+    assert c.dimension() == 4
+    assert c.simple_root(1) == [1, -1, 0, 0]
+    assert c.highest_root() == [1, 0, 0, -1]
+    assert c.lie_algebra() == "su(4)"
+    diag = "0---0---0\n1   2   3"
+    assert c.dynkin_diagram() == diag
+    assert c.positive_roots() == {1: [1, -1, 0, 0], 2: [1, 0, -1, 0],
+            3: [1, 0, 0, -1], 4: [0, 1, -1, 0], 5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_type_B.py

@@ -0,0 +1,17 @@
+from sympy.liealgebras.cartan_type import CartanType
+from sympy.matrices import Matrix
+
+def test_type_B():
+    c = CartanType("B3")
+    m = Matrix(3, 3, [2, -1, 0, -1, 2, -2, 0, -1, 2])
+    assert m == c.cartan_matrix()
+    assert c.dimension() == 3
+    assert c.roots() == 18
+    assert c.simple_root(3) == [0, 0, 1]
+    assert c.basis() == 3
+    assert c.lie_algebra() == "so(6)"
+    diag = "0---0=>=0\n1   2   3"
+    assert c.dynkin_diagram() == diag
+    assert c.positive_roots() ==  {1: [1, -1, 0], 2: [1, 1, 0], 3: [1, 0, -1],
+            4: [1, 0, 1], 5: [0, 1, -1], 6: [0, 1, 1], 7: [1, 0, 0],
+            8: [0, 1, 0], 9: [0, 0, 1]}

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_type_C.py

@@ -0,0 +1,22 @@
+from sympy.liealgebras.cartan_type import CartanType
+from sympy.matrices import Matrix
+
+def test_type_C():
+    c = CartanType("C4")
+    m = Matrix(4, 4, [2, -1, 0, 0, -1, 2, -1, 0, 0, -1, 2, -1, 0, 0, -2, 2])
+    assert c.cartan_matrix() == m
+    assert c.dimension() == 4
+    assert c.simple_root(4) == [0, 0, 0, 2]
+    assert c.roots() == 32
+    assert c.basis() == 36
+    assert c.lie_algebra() == "sp(8)"
+    t = CartanType(['C', 3])
+    assert t.dimension() == 3
+    diag = "0---0---0=<=0\n1   2   3   4"
+    assert c.dynkin_diagram() == diag
+    assert c.positive_roots() == {1: [1, -1, 0, 0], 2: [1, 1, 0, 0],
+            3: [1, 0, -1, 0], 4: [1, 0, 1, 0], 5: [1, 0, 0, -1],
+            6: [1, 0, 0, 1], 7: [0, 1, -1, 0], 8: [0, 1, 1, 0],
+            9: [0, 1, 0, -1], 10: [0, 1, 0, 1], 11: [0, 0, 1, -1],
+            12: [0, 0, 1, 1], 13: [2, 0, 0, 0], 14: [0, 2, 0, 0], 15: [0, 0, 2, 0],
+            16: [0, 0, 0, 2]}

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_type_D.py

@@ -0,0 +1,19 @@
+from sympy.liealgebras.cartan_type import CartanType
+from sympy.matrices import Matrix
+
+
+
+def test_type_D():
+    c = CartanType("D4")
+    m = Matrix(4, 4, [2, -1, 0, 0, -1, 2, -1, -1, 0, -1, 2, 0, 0, -1, 0, 2])
+    assert c.cartan_matrix() == m
+    assert c.basis() == 6
+    assert c.lie_algebra() == "so(8)"
+    assert c.roots() == 24
+    assert c.simple_root(3) == [0, 0, 1, -1]
+    diag = "    3\n    0\n    |\n    |\n0---0---0\n1   2   4"
+    assert diag == c.dynkin_diagram()
+    assert c.positive_roots() == {1: [1, -1, 0, 0], 2: [1, 1, 0, 0],
+            3: [1, 0, -1, 0], 4: [1, 0, 1, 0], 5: [1, 0, 0, -1], 6: [1, 0, 0, 1],
+            7: [0, 1, -1, 0], 8: [0, 1, 1, 0], 9: [0, 1, 0, -1], 10: [0, 1, 0, 1],
+            11: [0, 0, 1, -1], 12: [0, 0, 1, 1]}

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_type_E.py

@@ -0,0 +1,19 @@
+from sympy.liealgebras.cartan_type import CartanType
+from sympy.matrices import Matrix
+
+def test_type_E():
+    c = CartanType("E6")
+    m = Matrix(6, 6, [2, 0, -1, 0, 0, 0, 0, 2, 0, -1, 0, 0,
+        -1, 0, 2, -1, 0, 0, 0, -1, -1, 2, -1, 0, 0, 0, 0,
+        -1, 2, -1, 0, 0, 0, 0, -1, 2])
+    assert c.cartan_matrix() == m
+    assert c.dimension() == 8
+    assert c.simple_root(6) == [0, 0, 0, -1, 1, 0, 0, 0]
+    assert c.roots() == 72
+    assert c.basis() == 78
+    diag = " "*8 + "2\n" + " "*8 + "0\n" + " "*8 + "|\n" + " "*8 + "|\n"
+    diag += "---".join("0" for i in range(1, 6))+"\n"
+    diag += "1   " + "   ".join(str(i) for i in range(3, 7))
+    assert c.dynkin_diagram() == diag
+    posroots = c.positive_roots()
+    assert posroots[8] == [1, 0, 0, 0, 1, 0, 0, 0]

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_type_F.py

@@ -0,0 +1,24 @@
+from sympy.liealgebras.cartan_type import CartanType
+from sympy.matrices import Matrix
+from sympy.core.backend import S
+
+def test_type_F():
+    c = CartanType("F4")
+    m = Matrix(4, 4, [2, -1, 0, 0, -1, 2, -2, 0, 0, -1, 2, -1, 0, 0, -1, 2])
+    assert c.cartan_matrix() == m
+    assert c.dimension() == 4
+    assert c.simple_root(1) == [1, -1, 0, 0]
+    assert c.simple_root(2) == [0, 1, -1, 0]
+    assert c.simple_root(3) == [0, 0, 0, 1]
+    assert c.simple_root(4) == [-S.Half, -S.Half, -S.Half, -S.Half]
+    assert c.roots() == 48
+    assert c.basis() == 52
+    diag = "0---0=>=0---0\n" + "   ".join(str(i) for i in range(1, 5))
+    assert c.dynkin_diagram() == diag
+    assert c.positive_roots() == {1: [1, -1, 0, 0], 2: [1, 1, 0, 0], 3: [1, 0, -1, 0],
+            4: [1, 0, 1, 0], 5: [1, 0, 0, -1], 6: [1, 0, 0, 1], 7: [0, 1, -1, 0],
+            8: [0, 1, 1, 0], 9: [0, 1, 0, -1], 10: [0, 1, 0, 1], 11: [0, 0, 1, -1],
+            12: [0, 0, 1, 1], 13: [1, 0, 0, 0], 14: [0, 1, 0, 0], 15: [0, 0, 1, 0],
+            16: [0, 0, 0, 1], 17: [S.Half, S.Half, S.Half, S.Half], 18: [S.Half, -S.Half, S.Half, S.Half],
+            19: [S.Half, S.Half, -S.Half, S.Half], 20: [S.Half, S.Half, S.Half, -S.Half], 21: [S.Half, S.Half, -S.Half, -S.Half],
+            22: [S.Half, -S.Half, S.Half, -S.Half], 23: [S.Half, -S.Half, -S.Half, S.Half], 24: [S.Half, -S.Half, -S.Half, -S.Half]}

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_type_G.py

@@ -0,0 +1,16 @@
+# coding=utf-8
+from sympy.liealgebras.cartan_type import CartanType
+from sympy.matrices import Matrix
+
+def test_type_G():
+    c = CartanType("G2")
+    m = Matrix(2, 2, [2, -1, -3, 2])
+    assert c.cartan_matrix() == m
+    assert c.simple_root(2) == [1, -2, 1]
+    assert c.basis() == 14
+    assert c.roots() == 12
+    assert c.dimension() == 3
+    diag = "0≡<≡0\n1   2"
+    assert diag == c.dynkin_diagram()
+    assert c.positive_roots() == {1: [0, 1, -1], 2: [1, -2, 1], 3: [1, -1, 0],
+            4: [1, 0, 1], 5: [1, 1, -2], 6: [2, -1, -1]}

llmeval-env/lib/python3.10/site-packages/sympy/liealgebras/tests/test_weyl_group.py

@@ -0,0 +1,35 @@
+from sympy.liealgebras.weyl_group import WeylGroup
+from sympy.matrices import Matrix
+
+def test_weyl_group():
+    c = WeylGroup("A3")
+    assert c.matrix_form('r1*r2') == Matrix([[0, 0, 1, 0], [1, 0, 0, 0],
+        [0, 1, 0, 0], [0, 0, 0, 1]])
+    assert c.generators() == ['r1', 'r2', 'r3']
+    assert c.group_order() == 24.0
+    assert c.group_name() == "S4: the symmetric group acting on 4 elements."
+    assert c.coxeter_diagram() == "0---0---0\n1   2   3"
+    assert c.element_order('r1*r2*r3') == 4
+    assert c.element_order('r1*r3*r2*r3') == 3
+    d = WeylGroup("B5")
+    assert d.group_order() == 3840
+    assert d.element_order('r1*r2*r4*r5') == 12
+    assert d.matrix_form('r2*r3') ==  Matrix([[0, 0, 1, 0, 0], [1, 0, 0, 0, 0],
+        [0, 1, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]])
+    assert d.element_order('r1*r2*r1*r3*r5') == 6
+    e = WeylGroup("D5")
+    assert e.element_order('r2*r3*r5') == 4
+    assert e.matrix_form('r2*r3*r5') == Matrix([[1, 0, 0, 0, 0], [0, 0, 0, 0, -1],
+        [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, -1, 0]])
+    f = WeylGroup("G2")
+    assert f.element_order('r1*r2*r1*r2') == 3
+    assert f.element_order('r2*r1*r1*r2') == 1
+
+    assert f.matrix_form('r1*r2*r1*r2') == Matrix([[0, 1, 0], [0, 0, 1], [1, 0, 0]])
+    g = WeylGroup("F4")
+    assert g.matrix_form('r2*r3') == Matrix([[1, 0, 0, 0], [0, 1, 0, 0],
+        [0, 0, 0, -1], [0, 0, 1, 0]])
+
+    assert g.element_order('r2*r3') == 4
+    h = WeylGroup("E6")
+    assert h.group_order() == 51840

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

@@ -0,0 +1,166 @@
+from sympy.liealgebras.cartan_type import Standard_Cartan
+from sympy.core.backend import eye
+
+
+class TypeA(Standard_Cartan):
+    """
+    This class contains the information about
+    the A series of simple Lie algebras.
+    ====
+    """
+
+    def __new__(cls, n):
+        if n < 1:
+            raise ValueError("n cannot be less than 1")
+        return Standard_Cartan.__new__(cls, "A", n)
+
+
+    def dimension(self):
+        """Dimension of the vector space V underlying the Lie algebra
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("A4")
+        >>> c.dimension()
+        5
+        """
+        return self.n+1
+
+
+    def basic_root(self, i, j):
+        """
+        This is a method just to generate roots
+        with a 1 iin the ith position and a -1
+        in the jth position.
+
+        """
+
+        n = self.n
+        root = [0]*(n+1)
+        root[i] = 1
+        root[j] = -1
+        return root
+
+    def simple_root(self, i):
+        """
+        Every lie algebra has a unique root system.
+        Given a root system Q, there is a subset of the
+        roots such that an element of Q is called a
+        simple root if it cannot be written as the sum
+        of two elements in Q.  If we let D denote the
+        set of simple roots, then it is clear that every
+        element of Q can be written as a linear combination
+        of elements of D with all coefficients non-negative.
+
+        In A_n the ith simple root is the root which has a 1
+        in the ith position, a -1 in the (i+1)th position,
+        and zeroes elsewhere.
+
+        This method returns the ith simple root for the A series.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("A4")
+        >>> c.simple_root(1)
+        [1, -1, 0, 0, 0]
+
+        """
+
+        return self.basic_root(i-1, i)
+
+    def positive_roots(self):
+        """
+        This method generates all the positive roots of
+        A_n.  This is half of all of the roots of A_n;
+        by multiplying all the positive roots by -1 we
+        get the negative roots.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("A3")
+        >>> c.positive_roots()
+        {1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
+                5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}
+        """
+
+        n = self.n
+        posroots = {}
+        k = 0
+        for i in range(0, n):
+            for j in range(i+1, n+1):
+               k += 1
+               posroots[k] = self.basic_root(i, j)
+        return posroots
+
+    def highest_root(self):
+        """
+        Returns the highest weight root for A_n
+        """
+
+        return self.basic_root(0, self.n)
+
+    def roots(self):
+        """
+        Returns the total number of roots for A_n
+        """
+        n = self.n
+        return n*(n+1)
+
+    def cartan_matrix(self):
+        """
+        Returns the Cartan matrix for A_n.
+        The Cartan matrix matrix for a Lie algebra is
+        generated by assigning an ordering to the simple
+        roots, (alpha[1], ...., alpha[l]).  Then the ijth
+        entry of the Cartan matrix is (<alpha[i],alpha[j]>).
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType('A4')
+        >>> c.cartan_matrix()
+        Matrix([
+        [ 2, -1,  0,  0],
+        [-1,  2, -1,  0],
+        [ 0, -1,  2, -1],
+        [ 0,  0, -1,  2]])
+
+        """
+
+        n = self.n
+        m = 2 * eye(n)
+        i = 1
+        while i < n-1:
+            m[i, i+1] = -1
+            m[i, i-1] = -1
+            i += 1
+        m[0,1] = -1
+        m[n-1, n-2] = -1
+        return m
+
+    def basis(self):
+        """
+        Returns the number of independent generators of A_n
+        """
+        n = self.n
+        return n**2 - 1
+
+    def lie_algebra(self):
+        """
+        Returns the Lie algebra associated with A_n
+        """
+        n = self.n
+        return "su(" + str(n + 1) + ")"
+
+    def dynkin_diagram(self):
+        n = self.n
+        diag = "---".join("0" for i in range(1, n+1)) + "\n"
+        diag += "   ".join(str(i) for i in range(1, n+1))
+        return diag

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

@@ -0,0 +1,172 @@
+from .cartan_type import Standard_Cartan
+from sympy.core.backend import eye
+
+class TypeB(Standard_Cartan):
+
+    def __new__(cls, n):
+        if n < 2:
+            raise ValueError("n cannot be less than 2")
+        return Standard_Cartan.__new__(cls, "B", n)
+
+    def dimension(self):
+        """Dimension of the vector space V underlying the Lie algebra
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("B3")
+        >>> c.dimension()
+        3
+        """
+
+        return self.n
+
+    def basic_root(self, i, j):
+        """
+        This is a method just to generate roots
+        with a 1 iin the ith position and a -1
+        in the jth position.
+
+        """
+        root = [0]*self.n
+        root[i] = 1
+        root[j] = -1
+        return root
+
+    def simple_root(self, i):
+        """
+        Every lie algebra has a unique root system.
+        Given a root system Q, there is a subset of the
+        roots such that an element of Q is called a
+        simple root if it cannot be written as the sum
+        of two elements in Q.  If we let D denote the
+        set of simple roots, then it is clear that every
+        element of Q can be written as a linear combination
+        of elements of D with all coefficients non-negative.
+
+        In B_n the first n-1 simple roots are the same as the
+        roots in A_(n-1) (a 1 in the ith position, a -1 in
+        the (i+1)th position, and zeroes elsewhere).  The n-th
+        simple root is the root with a 1 in the nth position
+        and zeroes elsewhere.
+
+        This method returns the ith simple root for the B series.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("B3")
+        >>> c.simple_root(2)
+        [0, 1, -1]
+
+        """
+        n = self.n
+        if i < n:
+            return self.basic_root(i-1, i)
+        else:
+            root = [0]*self.n
+            root[n-1] = 1
+            return root
+
+    def positive_roots(self):
+        """
+        This method generates all the positive roots of
+        A_n.  This is half of all of the roots of B_n;
+        by multiplying all the positive roots by -1 we
+        get the negative roots.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("A3")
+        >>> c.positive_roots()
+        {1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
+                5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}
+        """
+
+        n = self.n
+        posroots = {}
+        k = 0
+        for i in range(0, n-1):
+            for j in range(i+1, n):
+               k += 1
+               posroots[k] = self.basic_root(i, j)
+               k += 1
+               root = self.basic_root(i, j)
+               root[j] = 1
+               posroots[k] = root
+
+        for i in range(0, n):
+            k += 1
+            root = [0]*n
+            root[i] = 1
+            posroots[k] = root
+
+        return posroots
+
+    def roots(self):
+        """
+        Returns the total number of roots for B_n"
+        """
+
+        n = self.n
+        return 2*(n**2)
+
+    def cartan_matrix(self):
+        """
+        Returns the Cartan matrix for B_n.
+        The Cartan matrix matrix for a Lie algebra is
+        generated by assigning an ordering to the simple
+        roots, (alpha[1], ...., alpha[l]).  Then the ijth
+        entry of the Cartan matrix is (<alpha[i],alpha[j]>).
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType('B4')
+        >>> c.cartan_matrix()
+        Matrix([
+        [ 2, -1,  0,  0],
+        [-1,  2, -1,  0],
+        [ 0, -1,  2, -2],
+        [ 0,  0, -1,  2]])
+
+        """
+
+        n = self.n
+        m = 2* eye(n)
+        i = 1
+        while i < n-1:
+            m[i, i+1] = -1
+            m[i, i-1] = -1
+            i += 1
+        m[0, 1] = -1
+        m[n-2, n-1] = -2
+        m[n-1, n-2] = -1
+        return m
+
+    def basis(self):
+        """
+        Returns the number of independent generators of B_n
+        """
+
+        n = self.n
+        return (n**2 - n)/2
+
+    def lie_algebra(self):
+        """
+        Returns the Lie algebra associated with B_n
+        """
+
+        n = self.n
+        return "so(" + str(2*n) + ")"
+
+    def dynkin_diagram(self):
+        n = self.n
+        diag = "---".join("0" for i in range(1, n)) + "=>=0\n"
+        diag += "   ".join(str(i) for i in range(1, n+1))
+        return diag

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

@@ -0,0 +1,171 @@
+from .cartan_type import Standard_Cartan
+from sympy.core.backend import eye
+
+class TypeC(Standard_Cartan):
+
+    def __new__(cls, n):
+        if n < 3:
+            raise ValueError("n cannot be less than 3")
+        return Standard_Cartan.__new__(cls, "C", n)
+
+
+    def dimension(self):
+        """Dimension of the vector space V underlying the Lie algebra
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("C3")
+        >>> c.dimension()
+        3
+        """
+        n = self.n
+        return n
+
+    def basic_root(self, i, j):
+        """Generate roots with 1 in ith position and a -1 in jth position
+        """
+        n = self.n
+        root = [0]*n
+        root[i] = 1
+        root[j] = -1
+        return root
+
+    def simple_root(self, i):
+        """The ith simple root for the C series
+
+        Every lie algebra has a unique root system.
+        Given a root system Q, there is a subset of the
+        roots such that an element of Q is called a
+        simple root if it cannot be written as the sum
+        of two elements in Q.  If we let D denote the
+        set of simple roots, then it is clear that every
+        element of Q can be written as a linear combination
+        of elements of D with all coefficients non-negative.
+
+        In C_n, the first n-1 simple roots are the same as
+        the roots in A_(n-1) (a 1 in the ith position, a -1
+        in the (i+1)th position, and zeroes elsewhere).  The
+        nth simple root is the root in which there is a 2 in
+        the nth position and zeroes elsewhere.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("C3")
+        >>> c.simple_root(2)
+        [0, 1, -1]
+
+        """
+
+        n = self.n
+        if i < n:
+            return self.basic_root(i-1,i)
+        else:
+            root = [0]*self.n
+            root[n-1] = 2
+            return root
+
+
+    def positive_roots(self):
+        """Generates all the positive roots of A_n
+
+        This is half of all of the roots of C_n; by multiplying all the
+        positive roots by -1 we get the negative roots.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("A3")
+        >>> c.positive_roots()
+        {1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
+                5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}
+
+        """
+
+        n = self.n
+        posroots = {}
+        k = 0
+        for i in range(0, n-1):
+            for j in range(i+1, n):
+               k += 1
+               posroots[k] = self.basic_root(i, j)
+               k += 1
+               root = self.basic_root(i, j)
+               root[j] = 1
+               posroots[k] = root
+
+        for i in range(0, n):
+            k += 1
+            root = [0]*n
+            root[i] = 2
+            posroots[k] = root
+
+        return posroots
+
+    def roots(self):
+        """
+        Returns the total number of roots for C_n"
+        """
+
+        n = self.n
+        return 2*(n**2)
+
+    def cartan_matrix(self):
+        """The Cartan matrix for C_n
+
+        The Cartan matrix matrix for a Lie algebra is
+        generated by assigning an ordering to the simple
+        roots, (alpha[1], ...., alpha[l]).  Then the ijth
+        entry of the Cartan matrix is (<alpha[i],alpha[j]>).
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType('C4')
+        >>> c.cartan_matrix()
+        Matrix([
+        [ 2, -1,  0,  0],
+        [-1,  2, -1,  0],
+        [ 0, -1,  2, -1],
+        [ 0,  0, -2,  2]])
+
+        """
+
+        n = self.n
+        m = 2 * eye(n)
+        i = 1
+        while i < n-1:
+           m[i, i+1] = -1
+           m[i, i-1] = -1
+           i += 1
+        m[0,1] = -1
+        m[n-1, n-2] = -2
+        return m
+
+
+    def basis(self):
+        """
+        Returns the number of independent generators of C_n
+        """
+
+        n = self.n
+        return n*(2*n + 1)
+
+    def lie_algebra(self):
+        """
+        Returns the Lie algebra associated with C_n"
+        """
+
+        n = self.n
+        return "sp(" + str(2*n) + ")"
+
+    def dynkin_diagram(self):
+        n = self.n
+        diag = "---".join("0" for i in range(1, n)) + "=<=0\n"
+        diag += "   ".join(str(i) for i in range(1, n+1))
+        return diag

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

@@ -0,0 +1,175 @@
+from .cartan_type import Standard_Cartan
+from sympy.core.backend import eye
+
+class TypeD(Standard_Cartan):
+
+    def __new__(cls, n):
+        if n < 3:
+            raise ValueError("n cannot be less than 3")
+        return Standard_Cartan.__new__(cls, "D", n)
+
+
+    def dimension(self):
+        """Dmension of the vector space V underlying the Lie algebra
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("D4")
+        >>> c.dimension()
+        4
+        """
+
+        return self.n
+
+    def basic_root(self, i, j):
+        """
+        This is a method just to generate roots
+        with a 1 iin the ith position and a -1
+        in the jth position.
+
+        """
+
+        n = self.n
+        root = [0]*n
+        root[i] = 1
+        root[j] = -1
+        return root
+
+    def simple_root(self, i):
+        """
+        Every lie algebra has a unique root system.
+        Given a root system Q, there is a subset of the
+        roots such that an element of Q is called a
+        simple root if it cannot be written as the sum
+        of two elements in Q.  If we let D denote the
+        set of simple roots, then it is clear that every
+        element of Q can be written as a linear combination
+        of elements of D with all coefficients non-negative.
+
+        In D_n, the first n-1 simple roots are the same as
+        the roots in A_(n-1) (a 1 in the ith position, a -1
+        in the (i+1)th position, and zeroes elsewhere).
+        The nth simple root is the root in which there 1s in
+        the nth and (n-1)th positions, and zeroes elsewhere.
+
+        This method returns the ith simple root for the D series.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("D4")
+        >>> c.simple_root(2)
+        [0, 1, -1, 0]
+
+        """
+
+        n = self.n
+        if i < n:
+            return self.basic_root(i-1, i)
+        else:
+            root = [0]*n
+            root[n-2] = 1
+            root[n-1] = 1
+            return root
+
+
+    def positive_roots(self):
+        """
+        This method generates all the positive roots of
+        A_n.  This is half of all of the roots of D_n
+        by multiplying all the positive roots by -1 we
+        get the negative roots.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("A3")
+        >>> c.positive_roots()
+        {1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
+                5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}
+        """
+
+        n = self.n
+        posroots = {}
+        k = 0
+        for i in range(0, n-1):
+            for j in range(i+1, n):
+               k += 1
+               posroots[k] = self.basic_root(i, j)
+               k += 1
+               root = self.basic_root(i, j)
+               root[j] = 1
+               posroots[k] = root
+        return posroots
+
+    def roots(self):
+        """
+        Returns the total number of roots for D_n"
+        """
+
+        n = self.n
+        return 2*n*(n-1)
+
+    def cartan_matrix(self):
+        """
+        Returns the Cartan matrix for D_n.
+        The Cartan matrix matrix for a Lie algebra is
+        generated by assigning an ordering to the simple
+        roots, (alpha[1], ...., alpha[l]).  Then the ijth
+        entry of the Cartan matrix is (<alpha[i],alpha[j]>).
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType('D4')
+        >>> c.cartan_matrix()
+            Matrix([
+            [ 2, -1,  0,  0],
+            [-1,  2, -1, -1],
+            [ 0, -1,  2,  0],
+            [ 0, -1,  0,  2]])
+
+        """
+
+        n = self.n
+        m = 2*eye(n)
+        i = 1
+        while i < n-2:
+           m[i,i+1] = -1
+           m[i,i-1] = -1
+           i += 1
+        m[n-2, n-3] = -1
+        m[n-3, n-1] = -1
+        m[n-1, n-3] = -1
+        m[0, 1] = -1
+        return m
+
+    def basis(self):
+        """
+        Returns the number of independent generators of D_n
+        """
+        n = self.n
+        return n*(n-1)/2
+
+    def lie_algebra(self):
+        """
+        Returns the Lie algebra associated with D_n"
+        """
+
+        n = self.n
+        return "so(" + str(2*n) + ")"
+
+    def dynkin_diagram(self):
+        n = self.n
+        diag = " "*4*(n-3) + str(n-1) + "\n"
+        diag += " "*4*(n-3) + "0\n"
+        diag += " "*4*(n-3) +"|\n"
+        diag += " "*4*(n-3) + "|\n"
+        diag += "---".join("0" for i in range(1,n)) + "\n"
+        diag += "   ".join(str(i) for i in range(1, n-1)) + "   "+str(n)
+        return diag

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

@@ -0,0 +1,287 @@
+from .cartan_type import Standard_Cartan
+from sympy.core.backend import eye, Rational
+
+
+class TypeE(Standard_Cartan):
+
+    def __new__(cls, n):
+        if n < 6 or n > 8:
+            raise ValueError("Invalid value of n")
+        return Standard_Cartan.__new__(cls, "E", n)
+
+    def dimension(self):
+        """Dimension of the vector space V underlying the Lie algebra
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("E6")
+        >>> c.dimension()
+        8
+        """
+
+        return 8
+
+    def basic_root(self, i, j):
+        """
+        This is a method just to generate roots
+        with a -1 in the ith position and a 1
+        in the jth position.
+
+        """
+
+        root = [0]*8
+        root[i] = -1
+        root[j] = 1
+        return root
+
+    def simple_root(self, i):
+        """
+        Every lie algebra has a unique root system.
+        Given a root system Q, there is a subset of the
+        roots such that an element of Q is called a
+        simple root if it cannot be written as the sum
+        of two elements in Q.  If we let D denote the
+        set of simple roots, then it is clear that every
+        element of Q can be written as a linear combination
+        of elements of D with all coefficients non-negative.
+
+        This method returns the ith simple root for E_n.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("E6")
+        >>> c.simple_root(2)
+        [1, 1, 0, 0, 0, 0, 0, 0]
+        """
+        n = self.n
+        if i == 1:
+            root = [-0.5]*8
+            root[0] = 0.5
+            root[7] = 0.5
+            return root
+        elif i == 2:
+            root = [0]*8
+            root[1] = 1
+            root[0] = 1
+            return root
+        else:
+            if i in (7, 8) and n == 6:
+                raise ValueError("E6 only has six simple roots!")
+            if i == 8 and n == 7:
+                raise ValueError("E7 has only 7 simple roots!")
+
+            return self.basic_root(i - 3, i - 2)
+
+    def positive_roots(self):
+        """
+        This method generates all the positive roots of
+        A_n.  This is half of all of the roots of E_n;
+        by multiplying all the positive roots by -1 we
+        get the negative roots.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("A3")
+        >>> c.positive_roots()
+        {1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
+                5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}
+        """
+        n = self.n
+        if n == 6:
+            posroots = {}
+            k = 0
+            for i in range(n-1):
+                for j in range(i+1, n-1):
+                    k += 1
+                    root = self.basic_root(i, j)
+                    posroots[k] = root
+                    k += 1
+                    root = self.basic_root(i, j)
+                    root[i] = 1
+                    posroots[k] = root
+
+            root = [Rational(1, 2), Rational(1, 2), Rational(1, 2), Rational(1, 2), Rational(1, 2),
+                    Rational(-1, 2), Rational(-1, 2), Rational(1, 2)]
+            for a in range(0, 2):
+                for b in range(0, 2):
+                    for c in range(0, 2):
+                        for d in range(0, 2):
+                            for e in range(0, 2):
+                                if (a + b + c + d + e)%2 == 0:
+                                    k += 1
+                                    if a == 1:
+                                        root[0] = Rational(-1, 2)
+                                    if b == 1:
+                                        root[1] = Rational(-1, 2)
+                                    if c == 1:
+                                        root[2] = Rational(-1, 2)
+                                    if d == 1:
+                                        root[3] = Rational(-1, 2)
+                                    if e == 1:
+                                        root[4] = Rational(-1, 2)
+                                    posroots[k] = root
+
+            return posroots
+        if n == 7:
+            posroots = {}
+            k = 0
+            for i in range(n-1):
+                for j in range(i+1, n-1):
+                    k += 1
+                    root = self.basic_root(i, j)
+                    posroots[k] = root
+                    k += 1
+                    root = self.basic_root(i, j)
+                    root[i] = 1
+                    posroots[k] = root
+
+            k += 1
+            posroots[k] = [0, 0, 0, 0, 0, 1, 1, 0]
+            root = [Rational(1, 2), Rational(1, 2), Rational(1, 2), Rational(1, 2), Rational(1, 2),
+                    Rational(-1, 2), Rational(-1, 2), Rational(1, 2)]
+            for a in range(0, 2):
+                for b in range(0, 2):
+                    for c in range(0, 2):
+                        for d in range(0, 2):
+                            for e in range(0, 2):
+                                for f in range(0, 2):
+                                    if (a + b + c + d + e + f)%2 == 0:
+                                        k += 1
+                                        if a == 1:
+                                            root[0] = Rational(-1, 2)
+                                        if b == 1:
+                                            root[1] = Rational(-1, 2)
+                                        if c == 1:
+                                            root[2] = Rational(-1, 2)
+                                        if d == 1:
+                                            root[3] = Rational(-1, 2)
+                                        if e == 1:
+                                            root[4] = Rational(-1, 2)
+                                        if f == 1:
+                                            root[5] = Rational(1, 2)
+                                        posroots[k] = root
+
+            return posroots
+        if n == 8:
+            posroots = {}
+            k = 0
+            for i in range(n):
+                for j in range(i+1, n):
+                    k += 1
+                    root = self.basic_root(i, j)
+                    posroots[k] = root
+                    k += 1
+                    root = self.basic_root(i, j)
+                    root[i] = 1
+                    posroots[k] = root
+
+            root = [Rational(1, 2), Rational(1, 2), Rational(1, 2), Rational(1, 2), Rational(1, 2),
+                    Rational(-1, 2), Rational(-1, 2), Rational(1, 2)]
+            for a in range(0, 2):
+                for b in range(0, 2):
+                    for c in range(0, 2):
+                        for d in range(0, 2):
+                            for e in range(0, 2):
+                                for f in range(0, 2):
+                                    for g in range(0, 2):
+                                        if (a + b + c + d + e + f + g)%2 == 0:
+                                            k += 1
+                                            if a == 1:
+                                                root[0] = Rational(-1, 2)
+                                            if b == 1:
+                                                root[1] = Rational(-1, 2)
+                                            if c == 1:
+                                                root[2] = Rational(-1, 2)
+                                            if d == 1:
+                                                root[3] = Rational(-1, 2)
+                                            if e == 1:
+                                                root[4] = Rational(-1, 2)
+                                            if f == 1:
+                                                root[5] = Rational(1, 2)
+                                            if g == 1:
+                                                root[6] = Rational(1, 2)
+                                            posroots[k] = root
+
+            return posroots
+
+
+
+    def roots(self):
+        """
+        Returns the total number of roots of E_n
+        """
+
+        n = self.n
+        if n == 6:
+            return 72
+        if n == 7:
+            return 126
+        if n == 8:
+            return 240
+
+
+    def cartan_matrix(self):
+        """
+        Returns the Cartan matrix for G_2
+        The Cartan matrix matrix for a Lie algebra is
+        generated by assigning an ordering to the simple
+        roots, (alpha[1], ...., alpha[l]).  Then the ijth
+        entry of the Cartan matrix is (<alpha[i],alpha[j]>).
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType('A4')
+        >>> c.cartan_matrix()
+        Matrix([
+        [ 2, -1,  0,  0],
+        [-1,  2, -1,  0],
+        [ 0, -1,  2, -1],
+        [ 0,  0, -1,  2]])
+
+
+        """
+
+        n = self.n
+        m = 2*eye(n)
+        i = 3
+        while i < n-1:
+            m[i, i+1] = -1
+            m[i, i-1] = -1
+            i += 1
+        m[0, 2] = m[2, 0] = -1
+        m[1, 3] = m[3, 1] = -1
+        m[2, 3] = -1
+        m[n-1, n-2] = -1
+        return m
+
+
+    def basis(self):
+        """
+        Returns the number of independent generators of E_n
+        """
+
+        n = self.n
+        if n == 6:
+            return 78
+        if n == 7:
+            return 133
+        if n == 8:
+            return 248
+
+    def dynkin_diagram(self):
+        n = self.n
+        diag = " "*8 + str(2) + "\n"
+        diag += " "*8 + "0\n"
+        diag += " "*8 + "|\n"
+        diag += " "*8 + "|\n"
+        diag += "---".join("0" for i in range(1, n)) + "\n"
+        diag += "1   " + "   ".join(str(i) for i in range(3, n+1))
+        return diag

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

@@ -0,0 +1,162 @@
+from .cartan_type import Standard_Cartan
+from sympy.core.backend import Matrix, Rational
+
+
+class TypeF(Standard_Cartan):
+
+    def __new__(cls, n):
+        if n != 4:
+            raise ValueError("n should be 4")
+        return Standard_Cartan.__new__(cls, "F", 4)
+
+    def dimension(self):
+        """Dimension of the vector space V underlying the Lie algebra
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("F4")
+        >>> c.dimension()
+        4
+        """
+
+        return 4
+
+
+    def basic_root(self, i, j):
+        """Generate roots with 1 in ith position and -1 in jth position
+
+        """
+
+        n = self.n
+        root = [0]*n
+        root[i] = 1
+        root[j] = -1
+        return root
+
+    def simple_root(self, i):
+        """The ith simple root of F_4
+
+        Every lie algebra has a unique root system.
+        Given a root system Q, there is a subset of the
+        roots such that an element of Q is called a
+        simple root if it cannot be written as the sum
+        of two elements in Q.  If we let D denote the
+        set of simple roots, then it is clear that every
+        element of Q can be written as a linear combination
+        of elements of D with all coefficients non-negative.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("F4")
+        >>> c.simple_root(3)
+        [0, 0, 0, 1]
+
+        """
+
+        if i < 3:
+            return self.basic_root(i-1, i)
+        if i == 3:
+            root = [0]*4
+            root[3] = 1
+            return root
+        if i == 4:
+            root = [Rational(-1, 2)]*4
+            return root
+
+    def positive_roots(self):
+        """Generate all the positive roots of A_n
+
+        This is half of all of the roots of F_4; by multiplying all the
+        positive roots by -1 we get the negative roots.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("A3")
+        >>> c.positive_roots()
+        {1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
+                5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}
+
+        """
+
+        n = self.n
+        posroots = {}
+        k = 0
+        for i in range(0, n-1):
+            for j in range(i+1, n):
+               k += 1
+               posroots[k] = self.basic_root(i, j)
+               k += 1
+               root = self.basic_root(i, j)
+               root[j] = 1
+               posroots[k] = root
+
+        for i in range(0, n):
+            k += 1
+            root = [0]*n
+            root[i] = 1
+            posroots[k] = root
+
+        k += 1
+        root = [Rational(1, 2)]*n
+        posroots[k] = root
+        for i in range(1, 4):
+            k += 1
+            root = [Rational(1, 2)]*n
+            root[i] = Rational(-1, 2)
+            posroots[k] = root
+
+        posroots[k+1] = [Rational(1, 2), Rational(1, 2), Rational(-1, 2), Rational(-1, 2)]
+        posroots[k+2] = [Rational(1, 2), Rational(-1, 2), Rational(1, 2), Rational(-1, 2)]
+        posroots[k+3] = [Rational(1, 2), Rational(-1, 2), Rational(-1, 2), Rational(1, 2)]
+        posroots[k+4] = [Rational(1, 2), Rational(-1, 2), Rational(-1, 2), Rational(-1, 2)]
+
+        return posroots
+
+
+    def roots(self):
+        """
+        Returns the total number of roots for F_4
+        """
+        return 48
+
+    def cartan_matrix(self):
+        """The Cartan matrix for F_4
+
+        The Cartan matrix matrix for a Lie algebra is
+        generated by assigning an ordering to the simple
+        roots, (alpha[1], ...., alpha[l]).  Then the ijth
+        entry of the Cartan matrix is (<alpha[i],alpha[j]>).
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType('A4')
+        >>> c.cartan_matrix()
+        Matrix([
+        [ 2, -1,  0,  0],
+        [-1,  2, -1,  0],
+        [ 0, -1,  2, -1],
+        [ 0,  0, -1,  2]])
+        """
+
+        m = Matrix( 4, 4, [2, -1, 0, 0, -1, 2, -2, 0, 0,
+            -1, 2, -1, 0, 0, -1, 2])
+        return m
+
+    def basis(self):
+        """
+        Returns the number of independent generators of F_4
+        """
+        return 52
+
+    def dynkin_diagram(self):
+        diag = "0---0=>=0---0\n"
+        diag += "   ".join(str(i) for i in range(1, 5))
+        return diag

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

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+
+from .cartan_type import Standard_Cartan
+from sympy.core.backend import Matrix
+
+class TypeG(Standard_Cartan):
+
+    def __new__(cls, n):
+        if n != 2:
+            raise ValueError("n should be 2")
+        return Standard_Cartan.__new__(cls, "G", 2)
+
+
+    def dimension(self):
+        """Dimension of the vector space V underlying the Lie algebra
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("G2")
+        >>> c.dimension()
+        3
+        """
+        return 3
+
+    def simple_root(self, i):
+        """The ith simple root of G_2
+
+        Every lie algebra has a unique root system.
+        Given a root system Q, there is a subset of the
+        roots such that an element of Q is called a
+        simple root if it cannot be written as the sum
+        of two elements in Q.  If we let D denote the
+        set of simple roots, then it is clear that every
+        element of Q can be written as a linear combination
+        of elements of D with all coefficients non-negative.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("G2")
+        >>> c.simple_root(1)
+        [0, 1, -1]
+
+        """
+        if i == 1:
+            return [0, 1, -1]
+        else:
+            return [1, -2, 1]
+
+    def positive_roots(self):
+        """Generate all the positive roots of A_n
+
+        This is half of all of the roots of A_n; by multiplying all the
+        positive roots by -1 we get the negative roots.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("A3")
+        >>> c.positive_roots()
+        {1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
+                5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}
+
+        """
+
+        roots = {1: [0, 1, -1], 2: [1, -2, 1], 3: [1, -1, 0], 4: [1, 0, 1],
+                5: [1, 1, -2], 6: [2, -1, -1]}
+        return roots
+
+    def roots(self):
+        """
+        Returns the total number of roots of G_2"
+        """
+        return 12
+
+    def cartan_matrix(self):
+        """The Cartan matrix for G_2
+
+        The Cartan matrix matrix for a Lie algebra is
+        generated by assigning an ordering to the simple
+        roots, (alpha[1], ...., alpha[l]).  Then the ijth
+        entry of the Cartan matrix is (<alpha[i],alpha[j]>).
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.cartan_type import CartanType
+        >>> c = CartanType("G2")
+        >>> c.cartan_matrix()
+        Matrix([
+            [ 2, -1],
+            [-3,  2]])
+
+        """
+
+        m = Matrix( 2, 2, [2, -1, -3, 2])
+        return m
+
+    def basis(self):
+        """
+        Returns the number of independent generators of G_2
+        """
+        return 14
+
+    def dynkin_diagram(self):
+        diag = "0≡<≡0\n1   2"
+        return diag

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

@@ -0,0 +1,403 @@
+# -*- coding: utf-8 -*-
+
+from .cartan_type import CartanType
+from mpmath import fac
+from sympy.core.backend import Matrix, eye, Rational, igcd
+from sympy.core.basic import Atom
+
+class WeylGroup(Atom):
+
+    """
+    For each semisimple Lie group, we have a Weyl group.  It is a subgroup of
+    the isometry group of the root system.  Specifically, it's the subgroup
+    that is generated by reflections through the hyperplanes orthogonal to
+    the roots.  Therefore, Weyl groups are reflection groups, and so a Weyl
+    group is a finite Coxeter group.
+
+    """
+
+    def __new__(cls, cartantype):
+        obj = Atom.__new__(cls)
+        obj.cartan_type = CartanType(cartantype)
+        return obj
+
+    def generators(self):
+        """
+        This method creates the generating reflections of the Weyl group for
+        a given Lie algebra.  For a Lie algebra of rank n, there are n
+        different generating reflections.  This function returns them as
+        a list.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.weyl_group import WeylGroup
+        >>> c = WeylGroup("F4")
+        >>> c.generators()
+        ['r1', 'r2', 'r3', 'r4']
+        """
+        n = self.cartan_type.rank()
+        generators = []
+        for i in range(1, n+1):
+            reflection = "r"+str(i)
+            generators.append(reflection)
+        return generators
+
+    def group_order(self):
+        """
+        This method returns the order of the Weyl group.
+        For types A, B, C, D, and E the order depends on
+        the rank of the Lie algebra.  For types F and G,
+        the order is fixed.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.weyl_group import WeylGroup
+        >>> c = WeylGroup("D4")
+        >>> c.group_order()
+        192.0
+        """
+        n = self.cartan_type.rank()
+        if self.cartan_type.series == "A":
+            return fac(n+1)
+
+        if self.cartan_type.series in ("B", "C"):
+            return fac(n)*(2**n)
+
+        if self.cartan_type.series == "D":
+            return fac(n)*(2**(n-1))
+
+        if self.cartan_type.series == "E":
+            if n == 6:
+                return 51840
+            if n == 7:
+                return 2903040
+            if n == 8:
+                return 696729600
+        if self.cartan_type.series == "F":
+            return 1152
+
+        if self.cartan_type.series == "G":
+            return 12
+
+    def group_name(self):
+        """
+        This method returns some general information about the Weyl group for
+        a given Lie algebra.  It returns the name of the group and the elements
+        it acts on, if relevant.
+        """
+        n = self.cartan_type.rank()
+        if self.cartan_type.series == "A":
+            return "S"+str(n+1) + ": the symmetric group acting on " + str(n+1) + " elements."
+
+        if self.cartan_type.series in ("B", "C"):
+            return "The hyperoctahedral group acting on " + str(2*n) + " elements."
+
+        if self.cartan_type.series == "D":
+            return "The symmetry group of the " + str(n) + "-dimensional demihypercube."
+
+        if self.cartan_type.series == "E":
+            if n == 6:
+                return "The symmetry group of the 6-polytope."
+
+            if n == 7:
+                return "The symmetry group of the 7-polytope."
+
+            if n == 8:
+                return "The symmetry group of the 8-polytope."
+
+        if self.cartan_type.series == "F":
+            return "The symmetry group of the 24-cell, or icositetrachoron."
+
+        if self.cartan_type.series == "G":
+            return "D6, the dihedral group of order 12, and symmetry group of the hexagon."
+
+    def element_order(self, weylelt):
+        """
+        This method returns the order of a given Weyl group element, which should
+        be specified by the user in the form of products of the generating
+        reflections, i.e. of the form r1*r2 etc.
+
+        For types A-F, this method current works by taking the matrix form of
+        the specified element, and then finding what power of the matrix is the
+        identity.  It then returns this power.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.weyl_group import WeylGroup
+        >>> b = WeylGroup("B4")
+        >>> b.element_order('r1*r4*r2')
+        4
+        """
+        n = self.cartan_type.rank()
+        if self.cartan_type.series == "A":
+            a = self.matrix_form(weylelt)
+            order = 1
+            while a != eye(n+1):
+                a *= self.matrix_form(weylelt)
+                order += 1
+            return order
+
+        if self.cartan_type.series == "D":
+            a = self.matrix_form(weylelt)
+            order = 1
+            while a != eye(n):
+                a *= self.matrix_form(weylelt)
+                order += 1
+            return order
+
+        if self.cartan_type.series == "E":
+            a = self.matrix_form(weylelt)
+            order = 1
+            while a != eye(8):
+                a *= self.matrix_form(weylelt)
+                order += 1
+            return order
+
+        if self.cartan_type.series == "G":
+            elts = list(weylelt)
+            reflections = elts[1::3]
+            m = self.delete_doubles(reflections)
+            while self.delete_doubles(m) != m:
+                m = self.delete_doubles(m)
+                reflections = m
+            if len(reflections) % 2 == 1:
+                return 2
+
+            elif len(reflections) == 0:
+                return 1
+
+            else:
+                if len(reflections) == 1:
+                    return 2
+                else:
+                    m = len(reflections) // 2
+                    lcm = (6 * m)/ igcd(m, 6)
+                order = lcm / m
+                return order
+
+
+        if self.cartan_type.series == 'F':
+            a = self.matrix_form(weylelt)
+            order = 1
+            while a != eye(4):
+                a *= self.matrix_form(weylelt)
+                order += 1
+            return order
+
+
+        if self.cartan_type.series in ("B", "C"):
+            a = self.matrix_form(weylelt)
+            order = 1
+            while a != eye(n):
+                a *= self.matrix_form(weylelt)
+                order += 1
+            return order
+
+    def delete_doubles(self, reflections):
+        """
+        This is a helper method for determining the order of an element in the
+        Weyl group of G2.  It takes a Weyl element and if repeated simple reflections
+        in it, it deletes them.
+        """
+        counter = 0
+        copy = list(reflections)
+        for elt in copy:
+            if counter < len(copy)-1:
+                if copy[counter + 1] == elt:
+                    del copy[counter]
+                    del copy[counter]
+            counter += 1
+
+
+        return copy
+
+
+    def matrix_form(self, weylelt):
+        """
+        This method takes input from the user in the form of products of the
+        generating reflections, and returns the matrix corresponding to the
+        element of the Weyl group.  Since each element of the Weyl group is
+        a reflection of some type, there is a corresponding matrix representation.
+        This method uses the standard representation for all the generating
+        reflections.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.weyl_group import WeylGroup
+        >>> f = WeylGroup("F4")
+        >>> f.matrix_form('r2*r3')
+        Matrix([
+        [1, 0, 0,  0],
+        [0, 1, 0,  0],
+        [0, 0, 0, -1],
+        [0, 0, 1,  0]])
+
+        """
+        elts = list(weylelt)
+        reflections = elts[1::3]
+        n = self.cartan_type.rank()
+        if self.cartan_type.series == 'A':
+            matrixform = eye(n+1)
+            for elt in reflections:
+                a = int(elt)
+                mat = eye(n+1)
+                mat[a-1, a-1] = 0
+                mat[a-1, a] = 1
+                mat[a, a-1] = 1
+                mat[a, a] = 0
+                matrixform *= mat
+            return matrixform
+
+        if self.cartan_type.series == 'D':
+            matrixform = eye(n)
+            for elt in reflections:
+                a = int(elt)
+                mat = eye(n)
+                if a < n:
+                    mat[a-1, a-1] = 0
+                    mat[a-1, a] = 1
+                    mat[a, a-1] = 1
+                    mat[a, a] = 0
+                    matrixform *= mat
+                else:
+                    mat[n-2, n-1] = -1
+                    mat[n-2, n-2] = 0
+                    mat[n-1, n-2] = -1
+                    mat[n-1, n-1] = 0
+                    matrixform *= mat
+            return matrixform
+
+        if self.cartan_type.series == 'G':
+            matrixform = eye(3)
+            for elt in reflections:
+                a = int(elt)
+                if a == 1:
+                    gen1 = Matrix([[1, 0, 0], [0, 0, 1], [0, 1, 0]])
+                    matrixform *= gen1
+                else:
+                    gen2 = Matrix([[Rational(2, 3), Rational(2, 3), Rational(-1, 3)],
+                                   [Rational(2, 3), Rational(-1, 3), Rational(2, 3)],
+                                   [Rational(-1, 3), Rational(2, 3), Rational(2, 3)]])
+                    matrixform *= gen2
+            return matrixform
+
+        if self.cartan_type.series == 'F':
+            matrixform = eye(4)
+            for elt in reflections:
+                a = int(elt)
+                if a == 1:
+                    mat = Matrix([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]])
+                    matrixform *= mat
+                elif a == 2:
+                    mat = Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
+                    matrixform *= mat
+                elif a == 3:
+                    mat = Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]])
+                    matrixform *= mat
+                else:
+
+                    mat = Matrix([[Rational(1, 2), Rational(1, 2), Rational(1, 2), Rational(1, 2)],
+                        [Rational(1, 2), Rational(1, 2), Rational(-1, 2), Rational(-1, 2)],
+                        [Rational(1, 2), Rational(-1, 2), Rational(1, 2), Rational(-1, 2)],
+                        [Rational(1, 2), Rational(-1, 2), Rational(-1, 2), Rational(1, 2)]])
+                    matrixform *= mat
+            return matrixform
+
+        if self.cartan_type.series == 'E':
+            matrixform = eye(8)
+            for elt in reflections:
+                a = int(elt)
+                if a == 1:
+                    mat = Matrix([[Rational(3, 4), Rational(1, 4), Rational(1, 4), Rational(1, 4),
+                        Rational(1, 4), Rational(1, 4), Rational(1, 4), Rational(-1, 4)],
+                        [Rational(1, 4), Rational(3, 4), Rational(-1, 4), Rational(-1, 4),
+                            Rational(-1, 4), Rational(-1, 4), Rational(1, 4), Rational(-1, 4)],
+                        [Rational(1, 4), Rational(-1, 4), Rational(3, 4), Rational(-1, 4),
+                        Rational(-1, 4), Rational(-1, 4), Rational(-1, 4), Rational(1, 4)],
+                        [Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(3, 4),
+                        Rational(-1, 4), Rational(-1, 4), Rational(-1, 4), Rational(1, 4)],
+                        [Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
+                        Rational(3, 4), Rational(-1, 4), Rational(-1, 4), Rational(1, 4)],
+                        [Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
+                        Rational(-1, 4), Rational(3, 4), Rational(-1, 4), Rational(1, 4)],
+                        [Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
+                        Rational(-1, 4), Rational(-1, 4), Rational(-3, 4), Rational(1, 4)],
+                        [Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
+                        Rational(-1, 4), Rational(-1, 4), Rational(-1, 4), Rational(3, 4)]])
+                    matrixform *= mat
+                elif a == 2:
+                    mat = eye(8)
+                    mat[0, 0] = 0
+                    mat[0, 1] = -1
+                    mat[1, 0] = -1
+                    mat[1, 1] = 0
+                    matrixform *= mat
+                else:
+                    mat = eye(8)
+                    mat[a-3, a-3] = 0
+                    mat[a-3, a-2] = 1
+                    mat[a-2, a-3] = 1
+                    mat[a-2, a-2] = 0
+                    matrixform *= mat
+            return matrixform
+
+
+        if self.cartan_type.series in ("B", "C"):
+            matrixform = eye(n)
+            for elt in reflections:
+                a = int(elt)
+                mat = eye(n)
+                if a == 1:
+                    mat[0, 0] = -1
+                    matrixform *= mat
+                else:
+                    mat[a - 2, a - 2] = 0
+                    mat[a-2, a-1] = 1
+                    mat[a - 1, a - 2] = 1
+                    mat[a -1, a - 1] = 0
+                    matrixform *= mat
+            return matrixform
+
+
+
+    def coxeter_diagram(self):
+        """
+        This method returns the Coxeter diagram corresponding to a Weyl group.
+        The Coxeter diagram can be obtained from a Lie algebra's Dynkin diagram
+        by deleting all arrows; the Coxeter diagram is the undirected graph.
+        The vertices of the Coxeter diagram represent the generating reflections
+        of the Weyl group, $s_i$.  An edge is drawn between $s_i$ and $s_j$ if the order
+        $m(i, j)$ of $s_is_j$ is greater than two.  If there is one edge, the order
+        $m(i, j)$ is 3.  If there are two edges, the order $m(i, j)$ is 4, and if there
+        are three edges, the order $m(i, j)$ is 6.
+
+        Examples
+        ========
+
+        >>> from sympy.liealgebras.weyl_group import WeylGroup
+        >>> c = WeylGroup("B3")
+        >>> print(c.coxeter_diagram())
+        0---0===0
+        1   2   3
+        """
+        n = self.cartan_type.rank()
+        if self.cartan_type.series in ("A", "D", "E"):
+            return self.cartan_type.dynkin_diagram()
+
+        if self.cartan_type.series in ("B", "C"):
+            diag = "---".join("0" for i in range(1, n)) + "===0\n"
+            diag += "   ".join(str(i) for i in range(1, n+1))
+            return diag
+
+        if self.cartan_type.series == "F":
+            diag = "0---0===0---0\n"
+            diag += "   ".join(str(i) for i in range(1, 5))
+            return diag
+
+        if self.cartan_type.series == "G":
+            diag = "0≡≡≡0\n1   2"
+            return diag

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

@@ -0,0 +1,47 @@
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.vector.vector import (Vector, VectorAdd, VectorMul,
+                                 BaseVector, VectorZero, Cross, Dot, cross, dot)
+from sympy.vector.dyadic import (Dyadic, DyadicAdd, DyadicMul,
+                                 BaseDyadic, DyadicZero)
+from sympy.vector.scalar import BaseScalar
+from sympy.vector.deloperator import Del
+from sympy.vector.functions import (express, matrix_to_vector,
+                                    laplacian, is_conservative,
+                                    is_solenoidal, scalar_potential,
+                                    directional_derivative,
+                                    scalar_potential_difference)
+from sympy.vector.point import Point
+from sympy.vector.orienters import (AxisOrienter, BodyOrienter,
+                                    SpaceOrienter, QuaternionOrienter)
+from sympy.vector.operators import Gradient, Divergence, Curl, Laplacian, gradient, curl, divergence
+from sympy.vector.implicitregion import ImplicitRegion
+from sympy.vector.parametricregion import (ParametricRegion, parametric_region_list)
+from sympy.vector.integrals import (ParametricIntegral, vector_integrate)
+
+__all__ = [
+    'Vector', 'VectorAdd', 'VectorMul', 'BaseVector', 'VectorZero', 'Cross',
+    'Dot', 'cross', 'dot',
+
+    'Dyadic', 'DyadicAdd', 'DyadicMul', 'BaseDyadic', 'DyadicZero',
+
+    'BaseScalar',
+
+    'Del',
+
+    'CoordSys3D',
+
+    'express', 'matrix_to_vector', 'laplacian', 'is_conservative',
+    'is_solenoidal', 'scalar_potential', 'directional_derivative',
+    'scalar_potential_difference',
+
+    'Point',
+
+    'AxisOrienter', 'BodyOrienter', 'SpaceOrienter', 'QuaternionOrienter',
+
+    'Gradient', 'Divergence', 'Curl', 'Laplacian', 'gradient', 'curl',
+    'divergence',
+
+    'ParametricRegion', 'parametric_region_list', 'ImplicitRegion',
+
+    'ParametricIntegral', 'vector_integrate',
+]

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

@@ -0,0 +1,365 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from sympy.simplify import simplify as simp, trigsimp as tsimp  # type: ignore
+from sympy.core.decorators import call_highest_priority, _sympifyit
+from sympy.core.assumptions import StdFactKB
+from sympy.core.function import diff as df
+from sympy.integrals.integrals import Integral
+from sympy.polys.polytools import factor as fctr
+from sympy.core import S, Add, Mul
+from sympy.core.expr import Expr
+
+if TYPE_CHECKING:
+    from sympy.vector.vector import BaseVector
+
+
+class BasisDependent(Expr):
+    """
+    Super class containing functionality common to vectors and
+    dyadics.
+    Named so because the representation of these quantities in
+    sympy.vector is dependent on the basis they are expressed in.
+    """
+
+    zero: BasisDependentZero
+
+    @call_highest_priority('__radd__')
+    def __add__(self, other):
+        return self._add_func(self, other)
+
+    @call_highest_priority('__add__')
+    def __radd__(self, other):
+        return self._add_func(other, self)
+
+    @call_highest_priority('__rsub__')
+    def __sub__(self, other):
+        return self._add_func(self, -other)
+
+    @call_highest_priority('__sub__')
+    def __rsub__(self, other):
+        return self._add_func(other, -self)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__rmul__')
+    def __mul__(self, other):
+        return self._mul_func(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__mul__')
+    def __rmul__(self, other):
+        return self._mul_func(other, self)
+
+    def __neg__(self):
+        return self._mul_func(S.NegativeOne, self)
+
+    @_sympifyit('other', NotImplemented)
+    @call_highest_priority('__rtruediv__')
+    def __truediv__(self, other):
+        return self._div_helper(other)
+
+    @call_highest_priority('__truediv__')
+    def __rtruediv__(self, other):
+        return TypeError("Invalid divisor for division")
+
+    def evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False):
+        """
+        Implements the SymPy evalf routine for this quantity.
+
+        evalf's documentation
+        =====================
+
+        """
+        options = {'subs':subs, 'maxn':maxn, 'chop':chop, 'strict':strict,
+                'quad':quad, 'verbose':verbose}
+        vec = self.zero
+        for k, v in self.components.items():
+            vec += v.evalf(n, **options) * k
+        return vec
+
+    evalf.__doc__ += Expr.evalf.__doc__  # type: ignore
+
+    n = evalf
+
+    def simplify(self, **kwargs):
+        """
+        Implements the SymPy simplify routine for this quantity.
+
+        simplify's documentation
+        ========================
+
+        """
+        simp_components = [simp(v, **kwargs) * k for
+                           k, v in self.components.items()]
+        return self._add_func(*simp_components)
+
+    simplify.__doc__ += simp.__doc__  # type: ignore
+
+    def trigsimp(self, **opts):
+        """
+        Implements the SymPy trigsimp routine, for this quantity.
+
+        trigsimp's documentation
+        ========================
+
+        """
+        trig_components = [tsimp(v, **opts) * k for
+                           k, v in self.components.items()]
+        return self._add_func(*trig_components)
+
+    trigsimp.__doc__ += tsimp.__doc__  # type: ignore
+
+    def _eval_simplify(self, **kwargs):
+        return self.simplify(**kwargs)
+
+    def _eval_trigsimp(self, **opts):
+        return self.trigsimp(**opts)
+
+    def _eval_derivative(self, wrt):
+        return self.diff(wrt)
+
+    def _eval_Integral(self, *symbols, **assumptions):
+        integral_components = [Integral(v, *symbols, **assumptions) * k
+                               for k, v in self.components.items()]
+        return self._add_func(*integral_components)
+
+    def as_numer_denom(self):
+        """
+        Returns the expression as a tuple wrt the following
+        transformation -
+
+        expression -> a/b -> a, b
+
+        """
+        return self, S.One
+
+    def factor(self, *args, **kwargs):
+        """
+        Implements the SymPy factor routine, on the scalar parts
+        of a basis-dependent expression.
+
+        factor's documentation
+        ========================
+
+        """
+        fctr_components = [fctr(v, *args, **kwargs) * k for
+                           k, v in self.components.items()]
+        return self._add_func(*fctr_components)
+
+    factor.__doc__ += fctr.__doc__  # type: ignore
+
+    def as_coeff_Mul(self, rational=False):
+        """Efficiently extract the coefficient of a product."""
+        return (S.One, self)
+
+    def as_coeff_add(self, *deps):
+        """Efficiently extract the coefficient of a summation."""
+        l = [x * self.components[x] for x in self.components]
+        return 0, tuple(l)
+
+    def diff(self, *args, **kwargs):
+        """
+        Implements the SymPy diff routine, for vectors.
+
+        diff's documentation
+        ========================
+
+        """
+        for x in args:
+            if isinstance(x, BasisDependent):
+                raise TypeError("Invalid arg for differentiation")
+        diff_components = [df(v, *args, **kwargs) * k for
+                           k, v in self.components.items()]
+        return self._add_func(*diff_components)
+
+    diff.__doc__ += df.__doc__  # type: ignore
+
+    def doit(self, **hints):
+        """Calls .doit() on each term in the Dyadic"""
+        doit_components = [self.components[x].doit(**hints) * x
+                           for x in self.components]
+        return self._add_func(*doit_components)
+
+
+class BasisDependentAdd(BasisDependent, Add):
+    """
+    Denotes sum of basis dependent quantities such that they cannot
+    be expressed as base or Mul instances.
+    """
+
+    def __new__(cls, *args, **options):
+        components = {}
+
+        # Check each arg and simultaneously learn the components
+        for i, arg in enumerate(args):
+            if not isinstance(arg, cls._expr_type):
+                if isinstance(arg, Mul):
+                    arg = cls._mul_func(*(arg.args))
+                elif isinstance(arg, Add):
+                    arg = cls._add_func(*(arg.args))
+                else:
+                    raise TypeError(str(arg) +
+                                    " cannot be interpreted correctly")
+            # If argument is zero, ignore
+            if arg == cls.zero:
+                continue
+            # Else, update components accordingly
+            if hasattr(arg, "components"):
+                for x in arg.components:
+                    components[x] = components.get(x, 0) + arg.components[x]
+
+        temp = list(components.keys())
+        for x in temp:
+            if components[x] == 0:
+                del components[x]
+
+        # Handle case of zero vector
+        if len(components) == 0:
+            return cls.zero
+
+        # Build object
+        newargs = [x * components[x] for x in components]
+        obj = super().__new__(cls, *newargs, **options)
+        if isinstance(obj, Mul):
+            return cls._mul_func(*obj.args)
+        assumptions = {'commutative': True}
+        obj._assumptions = StdFactKB(assumptions)
+        obj._components = components
+        obj._sys = (list(components.keys()))[0]._sys
+
+        return obj
+
+
+class BasisDependentMul(BasisDependent, Mul):
+    """
+    Denotes product of base- basis dependent quantity with a scalar.
+    """
+
+    def __new__(cls, *args, **options):
+        from sympy.vector import Cross, Dot, Curl, Gradient
+        count = 0
+        measure_number = S.One
+        zeroflag = False
+        extra_args = []
+
+        # Determine the component and check arguments
+        # Also keep a count to ensure two vectors aren't
+        # being multiplied
+        for arg in args:
+            if isinstance(arg, cls._zero_func):
+                count += 1
+                zeroflag = True
+            elif arg == S.Zero:
+                zeroflag = True
+            elif isinstance(arg, (cls._base_func, cls._mul_func)):
+                count += 1
+                expr = arg._base_instance
+                measure_number *= arg._measure_number
+            elif isinstance(arg, cls._add_func):
+                count += 1
+                expr = arg
+            elif isinstance(arg, (Cross, Dot, Curl, Gradient)):
+                extra_args.append(arg)
+            else:
+                measure_number *= arg
+        # Make sure incompatible types weren't multiplied
+        if count > 1:
+            raise ValueError("Invalid multiplication")
+        elif count == 0:
+            return Mul(*args, **options)
+        # Handle zero vector case
+        if zeroflag:
+            return cls.zero
+
+        # If one of the args was a VectorAdd, return an
+        # appropriate VectorAdd instance
+        if isinstance(expr, cls._add_func):
+            newargs = [cls._mul_func(measure_number, x) for
+                       x in expr.args]
+            return cls._add_func(*newargs)
+
+        obj = super().__new__(cls, measure_number,
+                              expr._base_instance,
+                              *extra_args,
+                              **options)
+        if isinstance(obj, Add):
+            return cls._add_func(*obj.args)
+        obj._base_instance = expr._base_instance
+        obj._measure_number = measure_number
+        assumptions = {'commutative': True}
+        obj._assumptions = StdFactKB(assumptions)
+        obj._components = {expr._base_instance: measure_number}
+        obj._sys = expr._base_instance._sys
+
+        return obj
+
+    def _sympystr(self, printer):
+        measure_str = printer._print(self._measure_number)
+        if ('(' in measure_str or '-' in measure_str or
+                '+' in measure_str):
+            measure_str = '(' + measure_str + ')'
+        return measure_str + '*' + printer._print(self._base_instance)
+
+
+class BasisDependentZero(BasisDependent):
+    """
+    Class to denote a zero basis dependent instance.
+    """
+    components: dict['BaseVector', Expr] = {}
+    _latex_form: str
+
+    def __new__(cls):
+        obj = super().__new__(cls)
+        # Pre-compute a specific hash value for the zero vector
+        # Use the same one always
+        obj._hash = (S.Zero, cls).__hash__()
+        return obj
+
+    def __hash__(self):
+        return self._hash
+
+    @call_highest_priority('__req__')
+    def __eq__(self, other):
+        return isinstance(other, self._zero_func)
+
+    __req__ = __eq__
+
+    @call_highest_priority('__radd__')
+    def __add__(self, other):
+        if isinstance(other, self._expr_type):
+            return other
+        else:
+            raise TypeError("Invalid argument types for addition")
+
+    @call_highest_priority('__add__')
+    def __radd__(self, other):
+        if isinstance(other, self._expr_type):
+            return other
+        else:
+            raise TypeError("Invalid argument types for addition")
+
+    @call_highest_priority('__rsub__')
+    def __sub__(self, other):
+        if isinstance(other, self._expr_type):
+            return -other
+        else:
+            raise TypeError("Invalid argument types for subtraction")
+
+    @call_highest_priority('__sub__')
+    def __rsub__(self, other):
+        if isinstance(other, self._expr_type):
+            return other
+        else:
+            raise TypeError("Invalid argument types for subtraction")
+
+    def __neg__(self):
+        return self
+
+    def normalize(self):
+        """
+        Returns the normalized version of this vector.
+        """
+        return self
+
+    def _sympystr(self, printer):
+        return '0'

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

@@ -0,0 +1,517 @@
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.vector.deloperator import Del
+from sympy.vector.scalar import BaseScalar
+from sympy.vector.vector import Vector, BaseVector
+from sympy.vector.operators import gradient, curl, divergence
+from sympy.core.function import diff
+from sympy.core.singleton import S
+from sympy.integrals.integrals import integrate
+from sympy.simplify.simplify import simplify
+from sympy.core import sympify
+from sympy.vector.dyadic import Dyadic
+
+
+def express(expr, system, system2=None, variables=False):
+    """
+    Global function for 'express' functionality.
+
+    Re-expresses a Vector, Dyadic or scalar(sympyfiable) in the given
+    coordinate system.
+
+    If 'variables' is True, then the coordinate variables (base scalars)
+    of other coordinate systems present in the vector/scalar field or
+    dyadic are also substituted in terms of the base scalars of the
+    given system.
+
+    Parameters
+    ==========
+
+    expr : Vector/Dyadic/scalar(sympyfiable)
+        The expression to re-express in CoordSys3D 'system'
+
+    system: CoordSys3D
+        The coordinate system the expr is to be expressed in
+
+    system2: CoordSys3D
+        The other coordinate system required for re-expression
+        (only for a Dyadic Expr)
+
+    variables : boolean
+        Specifies whether to substitute the coordinate variables present
+        in expr, in terms of those of parameter system
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D
+    >>> from sympy import Symbol, cos, sin
+    >>> N = CoordSys3D('N')
+    >>> q = Symbol('q')
+    >>> B = N.orient_new_axis('B', q, N.k)
+    >>> from sympy.vector import express
+    >>> express(B.i, N)
+    (cos(q))*N.i + (sin(q))*N.j
+    >>> express(N.x, B, variables=True)
+    B.x*cos(q) - B.y*sin(q)
+    >>> d = N.i.outer(N.i)
+    >>> express(d, B, N) == (cos(q))*(B.i|N.i) + (-sin(q))*(B.j|N.i)
+    True
+
+    """
+
+    if expr in (0, Vector.zero):
+        return expr
+
+    if not isinstance(system, CoordSys3D):
+        raise TypeError("system should be a CoordSys3D \
+                        instance")
+
+    if isinstance(expr, Vector):
+        if system2 is not None:
+            raise ValueError("system2 should not be provided for \
+                                Vectors")
+        # Given expr is a Vector
+        if variables:
+            # If variables attribute is True, substitute
+            # the coordinate variables in the Vector
+            system_list = {x.system for x in expr.atoms(BaseScalar, BaseVector)} - {system}
+            subs_dict = {}
+            for f in system_list:
+                subs_dict.update(f.scalar_map(system))
+            expr = expr.subs(subs_dict)
+        # Re-express in this coordinate system
+        outvec = Vector.zero
+        parts = expr.separate()
+        for x in parts:
+            if x != system:
+                temp = system.rotation_matrix(x) * parts[x].to_matrix(x)
+                outvec += matrix_to_vector(temp, system)
+            else:
+                outvec += parts[x]
+        return outvec
+
+    elif isinstance(expr, Dyadic):
+        if system2 is None:
+            system2 = system
+        if not isinstance(system2, CoordSys3D):
+            raise TypeError("system2 should be a CoordSys3D \
+                            instance")
+        outdyad = Dyadic.zero
+        var = variables
+        for k, v in expr.components.items():
+            outdyad += (express(v, system, variables=var) *
+                        (express(k.args[0], system, variables=var) |
+                         express(k.args[1], system2, variables=var)))
+
+        return outdyad
+
+    else:
+        if system2 is not None:
+            raise ValueError("system2 should not be provided for \
+                                Vectors")
+        if variables:
+            # Given expr is a scalar field
+            system_set = set()
+            expr = sympify(expr)
+            # Substitute all the coordinate variables
+            for x in expr.atoms(BaseScalar):
+                if x.system != system:
+                    system_set.add(x.system)
+            subs_dict = {}
+            for f in system_set:
+                subs_dict.update(f.scalar_map(system))
+            return expr.subs(subs_dict)
+        return expr
+
+
+def directional_derivative(field, direction_vector):
+    """
+    Returns the directional derivative of a scalar or vector field computed
+    along a given vector in coordinate system which parameters are expressed.
+
+    Parameters
+    ==========
+
+    field : Vector or Scalar
+        The scalar or vector field to compute the directional derivative of
+
+    direction_vector : Vector
+        The vector to calculated directional derivative along them.
+
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D, directional_derivative
+    >>> R = CoordSys3D('R')
+    >>> f1 = R.x*R.y*R.z
+    >>> v1 = 3*R.i + 4*R.j + R.k
+    >>> directional_derivative(f1, v1)
+    R.x*R.y + 4*R.x*R.z + 3*R.y*R.z
+    >>> f2 = 5*R.x**2*R.z
+    >>> directional_derivative(f2, v1)
+    5*R.x**2 + 30*R.x*R.z
+
+    """
+    from sympy.vector.operators import _get_coord_systems
+    coord_sys = _get_coord_systems(field)
+    if len(coord_sys) > 0:
+        # TODO: This gets a random coordinate system in case of multiple ones:
+        coord_sys = next(iter(coord_sys))
+        field = express(field, coord_sys, variables=True)
+        i, j, k = coord_sys.base_vectors()
+        x, y, z = coord_sys.base_scalars()
+        out = Vector.dot(direction_vector, i) * diff(field, x)
+        out += Vector.dot(direction_vector, j) * diff(field, y)
+        out += Vector.dot(direction_vector, k) * diff(field, z)
+        if out == 0 and isinstance(field, Vector):
+            out = Vector.zero
+        return out
+    elif isinstance(field, Vector):
+        return Vector.zero
+    else:
+        return S.Zero
+
+
+def laplacian(expr):
+    """
+    Return the laplacian of the given field computed in terms of
+    the base scalars of the given coordinate system.
+
+    Parameters
+    ==========
+
+    expr : SymPy Expr or Vector
+        expr denotes a scalar or vector field.
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D, laplacian
+    >>> R = CoordSys3D('R')
+    >>> f = R.x**2*R.y**5*R.z
+    >>> laplacian(f)
+    20*R.x**2*R.y**3*R.z + 2*R.y**5*R.z
+    >>> f = R.x**2*R.i + R.y**3*R.j + R.z**4*R.k
+    >>> laplacian(f)
+    2*R.i + 6*R.y*R.j + 12*R.z**2*R.k
+
+    """
+
+    delop = Del()
+    if expr.is_Vector:
+        return (gradient(divergence(expr)) - curl(curl(expr))).doit()
+    return delop.dot(delop(expr)).doit()
+
+
+def is_conservative(field):
+    """
+    Checks if a field is conservative.
+
+    Parameters
+    ==========
+
+    field : Vector
+        The field to check for conservative property
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D
+    >>> from sympy.vector import is_conservative
+    >>> R = CoordSys3D('R')
+    >>> is_conservative(R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k)
+    True
+    >>> is_conservative(R.z*R.j)
+    False
+
+    """
+
+    # Field is conservative irrespective of system
+    # Take the first coordinate system in the result of the
+    # separate method of Vector
+    if not isinstance(field, Vector):
+        raise TypeError("field should be a Vector")
+    if field == Vector.zero:
+        return True
+    return curl(field).simplify() == Vector.zero
+
+
+def is_solenoidal(field):
+    """
+    Checks if a field is solenoidal.
+
+    Parameters
+    ==========
+
+    field : Vector
+        The field to check for solenoidal property
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D
+    >>> from sympy.vector import is_solenoidal
+    >>> R = CoordSys3D('R')
+    >>> is_solenoidal(R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k)
+    True
+    >>> is_solenoidal(R.y * R.j)
+    False
+
+    """
+
+    # Field is solenoidal irrespective of system
+    # Take the first coordinate system in the result of the
+    # separate method in Vector
+    if not isinstance(field, Vector):
+        raise TypeError("field should be a Vector")
+    if field == Vector.zero:
+        return True
+    return divergence(field).simplify() is S.Zero
+
+
+def scalar_potential(field, coord_sys):
+    """
+    Returns the scalar potential function of a field in a given
+    coordinate system (without the added integration constant).
+
+    Parameters
+    ==========
+
+    field : Vector
+        The vector field whose scalar potential function is to be
+        calculated
+
+    coord_sys : CoordSys3D
+        The coordinate system to do the calculation in
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D
+    >>> from sympy.vector import scalar_potential, gradient
+    >>> R = CoordSys3D('R')
+    >>> scalar_potential(R.k, R) == R.z
+    True
+    >>> scalar_field = 2*R.x**2*R.y*R.z
+    >>> grad_field = gradient(scalar_field)
+    >>> scalar_potential(grad_field, R)
+    2*R.x**2*R.y*R.z
+
+    """
+
+    # Check whether field is conservative
+    if not is_conservative(field):
+        raise ValueError("Field is not conservative")
+    if field == Vector.zero:
+        return S.Zero
+    # Express the field exntirely in coord_sys
+    # Substitute coordinate variables also
+    if not isinstance(coord_sys, CoordSys3D):
+        raise TypeError("coord_sys must be a CoordSys3D")
+    field = express(field, coord_sys, variables=True)
+    dimensions = coord_sys.base_vectors()
+    scalars = coord_sys.base_scalars()
+    # Calculate scalar potential function
+    temp_function = integrate(field.dot(dimensions[0]), scalars[0])
+    for i, dim in enumerate(dimensions[1:]):
+        partial_diff = diff(temp_function, scalars[i + 1])
+        partial_diff = field.dot(dim) - partial_diff
+        temp_function += integrate(partial_diff, scalars[i + 1])
+    return temp_function
+
+
+def scalar_potential_difference(field, coord_sys, point1, point2):
+    """
+    Returns the scalar potential difference between two points in a
+    certain coordinate system, wrt a given field.
+
+    If a scalar field is provided, its values at the two points are
+    considered. If a conservative vector field is provided, the values
+    of its scalar potential function at the two points are used.
+
+    Returns (potential at point2) - (potential at point1)
+
+    The position vectors of the two Points are calculated wrt the
+    origin of the coordinate system provided.
+
+    Parameters
+    ==========
+
+    field : Vector/Expr
+        The field to calculate wrt
+
+    coord_sys : CoordSys3D
+        The coordinate system to do the calculations in
+
+    point1 : Point
+        The initial Point in given coordinate system
+
+    position2 : Point
+        The second Point in the given coordinate system
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D
+    >>> from sympy.vector import scalar_potential_difference
+    >>> R = CoordSys3D('R')
+    >>> P = R.origin.locate_new('P', R.x*R.i + R.y*R.j + R.z*R.k)
+    >>> vectfield = 4*R.x*R.y*R.i + 2*R.x**2*R.j
+    >>> scalar_potential_difference(vectfield, R, R.origin, P)
+    2*R.x**2*R.y
+    >>> Q = R.origin.locate_new('O', 3*R.i + R.j + 2*R.k)
+    >>> scalar_potential_difference(vectfield, R, P, Q)
+    -2*R.x**2*R.y + 18
+
+    """
+
+    if not isinstance(coord_sys, CoordSys3D):
+        raise TypeError("coord_sys must be a CoordSys3D")
+    if isinstance(field, Vector):
+        # Get the scalar potential function
+        scalar_fn = scalar_potential(field, coord_sys)
+    else:
+        # Field is a scalar
+        scalar_fn = field
+    # Express positions in required coordinate system
+    origin = coord_sys.origin
+    position1 = express(point1.position_wrt(origin), coord_sys,
+                        variables=True)
+    position2 = express(point2.position_wrt(origin), coord_sys,
+                        variables=True)
+    # Get the two positions as substitution dicts for coordinate variables
+    subs_dict1 = {}
+    subs_dict2 = {}
+    scalars = coord_sys.base_scalars()
+    for i, x in enumerate(coord_sys.base_vectors()):
+        subs_dict1[scalars[i]] = x.dot(position1)
+        subs_dict2[scalars[i]] = x.dot(position2)
+    return scalar_fn.subs(subs_dict2) - scalar_fn.subs(subs_dict1)
+
+
+def matrix_to_vector(matrix, system):
+    """
+    Converts a vector in matrix form to a Vector instance.
+
+    It is assumed that the elements of the Matrix represent the
+    measure numbers of the components of the vector along basis
+    vectors of 'system'.
+
+    Parameters
+    ==========
+
+    matrix : SymPy Matrix, Dimensions: (3, 1)
+        The matrix to be converted to a vector
+
+    system : CoordSys3D
+        The coordinate system the vector is to be defined in
+
+    Examples
+    ========
+
+    >>> from sympy import ImmutableMatrix as Matrix
+    >>> m = Matrix([1, 2, 3])
+    >>> from sympy.vector import CoordSys3D, matrix_to_vector
+    >>> C = CoordSys3D('C')
+    >>> v = matrix_to_vector(m, C)
+    >>> v
+    C.i + 2*C.j + 3*C.k
+    >>> v.to_matrix(C) == m
+    True
+
+    """
+
+    outvec = Vector.zero
+    vects = system.base_vectors()
+    for i, x in enumerate(matrix):
+        outvec += x * vects[i]
+    return outvec
+
+
+def _path(from_object, to_object):
+    """
+    Calculates the 'path' of objects starting from 'from_object'
+    to 'to_object', along with the index of the first common
+    ancestor in the tree.
+
+    Returns (index, list) tuple.
+    """
+
+    if from_object._root != to_object._root:
+        raise ValueError("No connecting path found between " +
+                         str(from_object) + " and " + str(to_object))
+
+    other_path = []
+    obj = to_object
+    while obj._parent is not None:
+        other_path.append(obj)
+        obj = obj._parent
+    other_path.append(obj)
+    object_set = set(other_path)
+    from_path = []
+    obj = from_object
+    while obj not in object_set:
+        from_path.append(obj)
+        obj = obj._parent
+    index = len(from_path)
+    i = other_path.index(obj)
+    while i >= 0:
+        from_path.append(other_path[i])
+        i -= 1
+    return index, from_path
+
+
+def orthogonalize(*vlist, orthonormal=False):
+    """
+    Takes a sequence of independent vectors and orthogonalizes them
+    using the Gram - Schmidt process. Returns a list of
+    orthogonal or orthonormal vectors.
+
+    Parameters
+    ==========
+
+    vlist : sequence of independent vectors to be made orthogonal.
+
+    orthonormal : Optional parameter
+                  Set to True if the vectors returned should be
+                  orthonormal.
+                  Default: False
+
+    Examples
+    ========
+
+    >>> from sympy.vector.coordsysrect import CoordSys3D
+    >>> from sympy.vector.functions import orthogonalize
+    >>> C = CoordSys3D('C')
+    >>> i, j, k = C.base_vectors()
+    >>> v1 = i + 2*j
+    >>> v2 = 2*i + 3*j
+    >>> orthogonalize(v1, v2)
+    [C.i + 2*C.j, 2/5*C.i + (-1/5)*C.j]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Gram-Schmidt_process
+
+    """
+
+    if not all(isinstance(vec, Vector) for vec in vlist):
+        raise TypeError('Each element must be of Type Vector')
+
+    ortho_vlist = []
+    for i, term in enumerate(vlist):
+        for j in range(i):
+            term -= ortho_vlist[j].projection(vlist[i])
+        # TODO : The following line introduces a performance issue
+        # and needs to be changed once a good solution for issue #10279 is
+        # found.
+        if simplify(term).equals(Vector.zero):
+            raise ValueError("Vector set not linearly independent")
+        ortho_vlist.append(term)
+
+    if orthonormal:
+        ortho_vlist = [vec.normalize() for vec in ortho_vlist]
+
+    return ortho_vlist