Personal Details

My name is Mary Clark. I'm finishing my first year of my PhD at the University of Glasgow.

Email: [email protected]

github: meclark256

irc: meclark256

I have no real plans for the summer; I'll be doing work on my PhD, but I expect I'll still be about to put 35-40 hours a week into sympy if I am accepted.

Background and Programming Experience

I graduated in 2012 from the University of Edinburgh with a degree in Mathematics. In my undergraduate degree, I've taken courses Lie Groups and Algebras, Advanced Group theory, Numerical Algorithms, Fourier analysis, and multiple others, and I did my thesis in representation theory. As part of my PhD, I've also taken graduate level courses in analysis, geometry and topology, and algebra. My research is in mathematical physics, and heavily involves Lie algebras. I also have a strong physics background; I've taken courses in quantum mechanics, general relativity, relativistic quantum dynamics, the Standard Model, and relativistic electrodynamics.

I've been programming in python for the last five or so years. I've done approximately 80 Project Euler programs in python, as well as doing some of the computer science Coursera courses in python. I also have experience with Java and C++. We coded in python during my undergraduate degree, and during the summer of 2011, I had REU at Fermilab where I overhauled a section of the MINERvA experiment's Monte Carlo simulation, which was in C++.

I usually work on my laptop, which is a Macbook Pro, and my editor of choice is vim. Possibly my favourite feature of python, besides its general ease of use, is the fact that you don't need to declare a size for your lists. I'm honestly not sure what is the most advanced feature of python that I've used; perhaps classes? I also am somewhat familiar with git; I just started using it this year, so I'm sure that I still have many things to learn.

Patch requirement

Here is the patch I've done; it was adding information about some of the named groups.

#Project

Lie algebras (and by extension) Lie groups are an integral part of mathematics. Lie groups allow for expressing continuous symmetries for geometric objects; Lie algebras are the linearisation of Lie groups, and are much easier objects with which to work. Furthermore, Lie algebras come up all over mathematics. My research currently makes use of Lie algebras and Weyl groups, and is to do with lattice paths. Another example is the correspondence between finite cluster algebras and Cartan-Killing classification of semisimple Lie algebras and finite root systems.

Unfortunately, for higher dimensions, (i.e. > n = 3 or so) working with Lie algebras can be computationally difficult. Computation of the root system, the simple roots, reflections, and working with the Cartan matrix can all be computationally intensive when you get into the higher dimensions.

Have a Lie algebra module in Sympy will make it attractive for mathematicians working in research, as well as attractive to students and others who need to do computations involving these objects. This module will also have applications to other areas of sympy, such as the quantum mechanics module, since working with symmetries will be easier using this module, because the most common symmetry groups are covered with the classical Lie algebras.

Deliverables

• Output the root system of the Classical and Exception Lie algebras for a given dimension $n$
• Allow basic operations on the roots: addition, subtraction, etc
• Output the simple roots
• Return the Weyl group of the Lie algebra
• Output the Cartan matrix and the Dynkin diagram
• Return the rank of a given Lie algebra, and whether or not it is finite
• Return the Coxeter matrix
• Return the commutation relations of the basis of the algebra

These functions are all intrinsic properties of the simple Lie algebras. The classical algebras I want to implement are the A, B, C, and D series. I will also implement the Exception Lie algebras, which are G2, F4, and E6, E7, and E8. The A (n >=1) series corresponds for a given n to the special unitary group SU(n+1). The B (n >= 2) series corresponds to the special orthogonal group, SO(2n+1). The C (n >= 2) series corresponds to the symplectic group, Sp(2n). The D (n >= 4) series corresponds to the special orthogonal group SO(2n).

The specifics

I'd like to implement the following three classes:

• CartanType
• RootSystem
• WeylGroup

Additionally there would be subclasses in CartanType to implement the Cartan Matrix and the Dynkin diagram. Obviously there will also be classes for each of the types of Lie algebras, called Type_A, Type_B,

CartanType

This will be one of the most basic classes. It will be called as follows:

 >>> L = CartanType('A4')
 >>> L
    'A4'

where the user will specify which series and the dimension. After specifying a Lie algebra, one can gets its Dynkin diagram and Cartan Matrix:

>>> DynkinDiagram(L)
    O---O---O---O
    1   2   3   4
>>> L.DynkinDiagram
    O---O---O---O
    1   2   3   4

>>> T = CartanType('G2')
>>> CartanMatrix(T)
    [2, -3]
    [-1, 2]

One will also be able to obtain the Lie algebra associated with each series from the CartanType, the size of its basis, and the commutation relations:

>>> L = CartanType('A1')
>>> L.LieAlgebra
    SU(2)
>>> L.basis
    3
>>> L.CommutationRelations
    [u1,u2] = 2(u3)
    [u3,u1] = 2(u2)
    [u2,u3] = 2(u1) 

The class CartanType allows for the basic interaction with the Lie algebras. While the classes Type_A, Type_B, etc store the necessary information about the Lie algebras, CartanType allows the user to access this information. The subclasses Dynkin Diagram and CartanMatrix will be to format and display these entities.

RootSystem

The root system of a Lie algebra will be represented by lists. This class be able to the simple roots, and hopefully coroots and will allow for operations on them. One will also be able to get a vector representation of the roots, as vectors in R^{n+1}. If I get time, I'd also like to allow for operations on the simple reflections.

Example of how this will be called:

>>> R = RootSystem('A3')
>>> SimpleRoots(R)
    [alpha[1], alpha[2], alpha[3]]
>>> alpha[1]
    [1,-1,0,0]
>>> RootSpace(R)
    alpha[1] + alpha[2] + alpha[3]

WeylGroup

The Weyl group of a Lie algebra is a subgroup of the isometry group of its root system. It is generated by reflections through hyperplanes orthogonal to the roots. It will output the name of the group (for example for the A series it is the symmetric group of order n), give the order, and output the simple reflections which generate the group. If time allows, I'd like to also be able to actually output elements of the group, in the form of matrices.

Classes of Lie algebra types

The classes A_Type, B_Type, etc will contain the information on how to construct the Cartan matrix, and the roots and so on and so forth. Sympy users will not interact with them directly.

Timeline

Here is a rough timeline of when I expect to do things:

Weeks 1-3: Build the classes A_Type, B_Type, etc. Continue to familiarise myself with the Sympy framework.

Weeks 4: Write the CartanType class

Week 5: Write the CartanMatrix subclass

Week 6: Write the Dynkin Diagram subclass. Do tests at least with the A series to make sure things are bug free for CartanType

Week 7: Implement the basics of the WeylGroup class

Week 8-9: Write the RootSystem class, do testing for CartanType and WeylGroup

Week 10-11: Add in the advanced functionality for the WeylGroup class: displaying elements of the Weyl group, etc

Week 12: Write the tests for all the classes up

Week 13: Documentation, documentation, documentation. Also a tutorial for this module.

In terms of when I'd create pull requests, I think that after week 3 and week 6 would be two very good places, as well as after week 7 and week 8-9.

Post GSoC

After GSoC is over, I'd really like to continue working with this module. I'd love to include more functionality with weight spaces and representations of the Lie algebras.

References

Introduction to Lie Algebras and Representation Theory by Humphreys http://arxiv.org/pdf/math/0208229.pdf Lie Algebras: Theory and Algorithm by W.A. de Graaf