200 lines
6.6 KiB
Python
200 lines
6.6 KiB
Python
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()
|