gutfeeling / liepy

Computes representation matrices for Lie groups

LiePy

Computes representation matrices for Lie groups.

How do I get set up?

Clone the repo

git clone https://github.com/gutfeeling/liepy.git
cd liepy

Install dependencies

1. Create a virtualenv

• If you want to use python 2

  virtualenv venv
  

• If you want to use python 3

  virtualenv -p python3 venv
  

2. Activate the virtualenv

source venv/bin/activate

3. Install the python modules

pip install -r requirements.txt

You are good to go

1. Fire up an interpreter and import the important classes

>>> from groups import LieGroup
>>> from representations import Representation

liepy's Issues

Weyl Dimension and related stuff

Additional Feature

The Weyl dimension formula calculates the dimension of a representation using the highest weight and the list of positive roots. The calculation also requires the sum of all positive roots frequently. Thus it makes sense to add delta=sum of positive roots as a data in LieAlgebra/LieGroup class itself. Further, the representation class should first calculate the Weyl dimension of a given representation and make decisions/suggestions in subsequent methods for any further optimization or for bravely giving up the calculation of representation matrix large dimensions.

Representation Matrix as a Sparse Matrix

Speed+Memory Optimization

The representation matrices for the roots are usually very sparse. Thus it makes more sense to use one of the standard sparse-matrix representation to store these matrices. This reduces the memory needed to store these representation matrices and also speedup the matrix multiplication required for computation of commutators.

Positive roots as a commutator

Speed Optimization request:

A positive root can be written in two ways:
(1) as a nested commutator of the simple root
(2)a commutator of simple root with another positive root lower in weight by one simple root.

The latter representation require only one commutator calculation for each positive root higher than simple root and best suited for computation. We should change the positive root representation to the second type.

list and tuples

We are converting lists to tuples many times because lists cannot be used as dictionary keys. We can try to minimize this conversion (by using tuples wherever possible) and see if this improves runtime.

Speed up scalar product computations

Computing the scalar product for the state given by the lowering chain [2, 3, 5, 4, 6, 3, 4, 2, 3, 1, 0, 2, 1, 5, 3, 4, 2, 3, 5, 6, 4, 3, 2, 1, 0] in the E7 representation [0,0,0,0,0,0,1] takes more than a full minute. This function needs to be optimized somehow.