Lie ART

Version of Record: https://www.sciencedirect.
com/science/article/pii/S0010465515000119
Manuscript_013560ddcb3b68c08de1be1fa77ec5e3
LieART – A Mathematica Application for Lie Algebras and Representation

Theory
Robert Fegera,∗, Thomas W. Kephartb
a Universität Würzburg, Institut für Theoretische Physik und Astrophysik, Emil-Hilb-Weg 22, 97074 Würzburg, Germany
b Department of Physics and Astronomy, Vanderbilt University, Nashville, TN 37235
Abstract
We present the Mathematica application “LieART” (Lie Algebras and Representation Theory) for computa-
tions frequently encountered in Lie algebras and representation theory, such as tensor product decomposition
and subalgebra branching of irreducible representations. LieART can handle all classical and exceptional Lie
algebras. It computes root systems of Lie algebras, weight systems and several other properties of irreducible
representations. LieART’s user interface has been created with a strong focus on usability and thus allows
the input of irreducible representations via their dimensional name, while the output is in the textbook style
used in most particle-physics publications. The unique Dynkin labels of irreducible representations are used
internally and can also be used for input and output. LieART exploits the Weyl reflection group for most of
the calculations, resulting in fast computations and a low memory consumption. Extensive tables of proper-
ties, tensor products and branching rules of irreducible representations are included as online supplementary
material.
Keywords: Lie algebra; Lie group; representation theory; irreducible representation; tensor product;
branching rule; GUT; model building
Contents
1 Introduction 4
2 Download and Installation 5

2.1 Download . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Automatic Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Manual Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.4 Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.5 LATEX Package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3 Quick Start 6
3.1 Entering Irreducible Representations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 Decomposing Tensor Products . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3 Decomposition to Subalgebras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
∗ Correspondingauthor
Email addresses: [email protected] (Robert Feger), [email protected]
(Thomas W. Kephart)
Preprint submitted to Computer Physics Communications February 24, 2015
© 2018 published by Elsevier. This manuscript is made available under the Elsevier user license
https://www.elsevier.com/open-access/userlicense/1.0/
3.4 Young Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4 Theoretical Background and Implementation 10

4.1 Algebras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.1.1 Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.1.2 Roots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.1.3 Classification of Lie Algebras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.1.4 Bases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.1.5 Scalar Product . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.1.6 Representation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2 Weyl Group Orbits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.3 Roots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.4 Representations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.4.1 Weight System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.4.2 Properties of Irreducible Representations . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.4.3 Representation Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.5 Tensor Product Decomposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.5.1 Generic Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.5.2 Algorithm Based on Klimyk’s Formula . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.5.3 SU(N ) Decomposition via Young Tableaux . . . . . . . . . . . . . . . . . . . . . . . . 31
4.6 Subalgebra Decomposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.6.1 Branching Rules and Maximal Subalgebras . . . . . . . . . . . . . . . . . . . . . . . . 34
5 Benchmarks 39
6 LATEX Package 40
7 Conclusions and Outlook 40
8 Acknowledgments 40
2
Program Summary
Authors: Robert Feger, Thomas W. Kephart

Program Title: LieART
Licensing provisions: GNU Lesser General Public License (LGPL)
Programming language: Mathematica
Computer: x86, x86_64, PowerPC
Operating system: cross-platform
RAM: ≥ 1 GB recommended. Memory usage depends strongly on the Lie algebra’s rank and type, as well
as the dimensionality of the representations in the computation.
Keywords: Lie algebra; Lie group; representation theory; irreducible representation; tensor product; branch-
ing rule; GUT; model building
Classification: 4.2, 11.1
External routines/libraries: Wolfram Mathematica 8–10
Nature of problem: The use of Lie algebras and their representations is widespread in physics, especially in
particle physics. The description of nature in terms of gauge theories requires the assignment of fields
to representations of compact Lie groups and their Lie algebas. Mass and interaction terms in the
Lagrangian give rise to the need for computing tensor products of representations of Lie algebras. The
mechanism of spontaneous symmetry breaking leads to the application of subalgebra decomposition.
This computer code was designed for the purpose of Grand Unified Theory (GUT) Model building,
where compact Lie groups beyond the U(1), SU(2) and SU(3) of the Standard Model of particle physics
are needed. Tensor product decomposition and subalgebra decomposition have been implemented for
all classical Lie groups SU(N ), SO(N ) and Sp(2N ) and the exceptionals E6 , E7 , E8 , F4 and G2 .
Solution method: LieART generates the weight system of an irreducible representation (irrep) of a Lie algebra
by exploiting the Weyl reflection groups, which is inherent in all simple Lie algebras. Tensor products
are computed by the application of Klimyk’s formula, except for SU(N )’s, where the Young-tableaux
algorithm is used. Subalgebra decomposition of SU(N )’s are performed by projection matrices, which
are generated from an algorithm to determine maximal subalgebras as originally developed by Dynkin
[1, 2].
Restrictions: Internally irreps are represented by their unique Dynkin label. LieART’s default behavior
in TraditionalForm is to print the dimensional name, which is the labeling preferred by physicist.
Most Lie algebras can have more than one irrep of the same dimension and different irreps with the same
dimension are usually distinguished by one or more primes (e.g. 175 and 1750 of A4 ). To determine
the need for one or more primes of an irrep a brute-force loop over other irreps must be performed to
search for irreps with the same dimensionality. Since Lie algebras have an infinite number of irreps,
this loop must be cut off, which is done by limiting the maximum Dynkin digit in the loop. In rare
cases for irreps of high dimensionality in high-rank algebras, if the cutoff used is too low, then the
assignment of primes will be incorrect, but the problem can be avoided by raising the cutoff. However,
in either case, this can only affect the display of the irrep because all computations involving this irrep
are correct, since the internal unique representation of Dynkin labels is used.
Running time: From less than a second to hours depending on the Lie algebra’s rank and type and/or the
dimensionality of the representations in the computation.
3
1. Introduction
Lie groups are a key ingredient in modern physics, while smaller Lie groups like SU(2) and SO(3, 1), enter the
quantum mechanics of elementary chemistry and condensed matter physics, the full spectrum of Lie groups,
i.e., the classical groups SU(N ), SO(N ) and Sp(2N ) and the exceptionals E6 , E7 , E8 , F4 and G2 , have all
appeared with varying degrees of frequency in particle physics. Lie groups have many other application e.g.,
to the theoretical physics of gravity, string theory, etc. as well as applications to engineering and elsewhere.
Here we will focus on the Lie algebras of the compact forms of Lie groups that are most useful for particle
physics. Most of the results are easily extended to the non-compact forms.
Shortly after the Standard Model was completed, Grand Unified Theories (GUTs) were proposed, where the
Standard-Model gauge group SU(3)C ×SU(2)L ×U(1)Y is embedded in a higher symmetry, typically SU(5)
[3], SO(10) [4, 5] or E6 [6], although other choices have been tried. Major reviews appeared on the uses of
Lie algebras [7, 8], including tables of irreducible representations (irreps) and their invariants. There are
also a number of useful textbooks that cover the topic [9, 10, 11]. While extensive tables already exist for
building GUT models, it has sometimes been necessary to go beyond what is tabulated in the literature.
Our purpose here is to give extended tables that will satisfy most modern model-building requirements,
but also provide the software that allows one to go further as the situation may require. In describing the
software we will incorporate a review of most of the necessary group-theory background. This includes root
and weight systems, the associated Weyl groups for all the classical and exceptional Lie algebras, orthogonal
basis systems, and Weyl-group orbits, which are used in our method of calculating tensor products and irrep
decompositions.
The theory of Lie algebras is in a mature state and many algorithms have been established to facilitate com-
putations in representation theory. The correspondence of irreps to Young tableaux, especially for SU(N )’s,
with algorithms for decomposing tensor products and subalgebra decomposition, even allows complex calcu-
lations involving high-dimensional irreps by hand. Lie-algebra related computations have been implemented
multiple times on the computer in many different programming languages. Popular programs with a similar
aim as the software presented here are [12, 13, 14]. However, at the time we started the project no such
implementation existed for the computer-algebra system Mathematica. (Meanwhile a package for compu-
tations in finite-dimensional and affine Lie algebras has been published [15] that has a similar intention
as our software, as well as a package for the calculation of the 2-loop renormalization-group equations of
supersymmetric models based on gauge groups incorporating many Lie algebra related computations [16]).
Mathematica® is a computer algebra software by Wolfram Research, Inc. which is widely used especially
among particle physicists.
Originally intended as an in-house solution for a computerized grand-unified-model scan of SU(N )’s in
Mathematica [17], we present here the Mathematica application LieART (Lie Algebras and Representation
Theory), that makes tensor products and subalgebra branching of irreps of the classical and exceptional
Lie algebras available for this platform. LieART’s code exploits the Weyl reflection group, inherent in all
simple Lie algebras, in many parts of the algorithms, which makes computations fast and at the same time
economical on memory. We also focused on the usability of LieART with a particle physicist as user in
mind: Irreps can be entered by their dimensional name, a nomenclature that physicists prefer over the more
unique Dynkin label. LieART displays results in textbook style used in most particle-physics publications,
e.g., 10 for the conjugated 10-dimensional irrep of SU(5) instead of the corresponding Dynkin label (0010).
The Dynkin label is used internally, but can also be used as input and output. LieART can also display
results in terms of LATEX commands, that are defined in a supplemental LATEX style file for the inclusion of
results in publications.
The paper is organized as follows: In Section 2 we give instructions for downloading and installing LieART, as
well as locating its documentation integrated in Mathematica’s help system. Section 3 comprises a quick-start
tutorial for LieART, introducing the most important functions for the most common tasks in an example-
based fashion. Section 4 presents a self-contained overview of the Lie algebra theory used in LieART and
gives notes on its implementation. Section 5 gives benchmarks for a few tensor-product decompositions and
a subalgebra decomposition of a large irrep. In Section 6 we present a LATEX style file included in LieART
for displaying weights, roots and irreps properly. In Section 7 we conclude and give an outlook on future
versions. As online supplementary material we include an extensive collection of tables with properties of
4
irreps, tensor products and branching rules. These tables follow [7] in selection and presentation style, but
extend most of the results. We plan to maintain and further extend our tables, which can be used directly
as lookup tables without the aid of LieART.
2. Download and Installation
2.1. Download
LieART is hosted by Hepforge, IPPP Durham. The LieART project home page is
http://lieart.hepforge.org/
and the LieART Mathematica application can be downloaded as tar.gz archive from
http://www.hepforge.org/downloads/lieart/
2.2. Automatic Installation

Start Mathematica and in the front end select the menu entry
File → Install...
In the appearing dialog select Application as Type of Item to Install and the tar.gz file in the
open file dialog from Source. (It is not necessary to decompress the tar.gz archive since Mathematica does
this automatically.) Choose whether you want to install LieART for an individual user or system wide. For
a system-wide installation you might be asked for the superuser password.
2.3. Manual Installation

The above procedure in Mathematica 7 only allows you to automatically install the Mathematica package
file (LieART.m) of LieART without the documentation. We therefore suggest a manual installation of the
LieART application in Mathematica 7 and in Mathematica 8 through 10 if problems with the automatic
installation occur.
Extract the archive to the subdirectory AddOns/Applications of the directory to which
$UserBaseDirectory is set for a user-only installation. For a system-wide installation place it in the
according subdirectory of $InstallationDirectory. Restart Mathematica to allow it to integrate
LieART’s documentation in its help system.
2.4. Documentation
The documentation of LieART is integrated in Mathematica’s help system. After restarting Mathematica
the following path should lead to LieART’s documentation:
Help → Documentation Center
→ Add-Ons & Packages (at the bottom)
→ LieART, Button labeled "Documentation"
(Alternatively, a search for “LieART” (with the correct case) in the Documentation Center leads to the
same page.) The displayed page serves as the documentation home of LieART and includes links to the
descriptions of its most important functions.
The documentation of LieART includes a Quick Start Tutorial for the impatient, which can be found
near the bottom of LieART’s documentation home under the section Tutorials.
Tables of representation properties, tensor products and branching rules generated by LieART can be found
in the section Tables at the bottom of LieART’s documentation home.
2.5. LATEX Package

LieART comes with a LATEX package that defines commands to display irreps, roots and weights properly.
The style file lieart.sty can be found in the subdirectory latex/ of the LieART project tree. Please
copy it to a location where your LATEX installation can find it.
5
3. Quick Start
This section provides a tutorial introducing the most important and frequently used functions of LieART
for Lie-algebra and representation-theory related calculations. The functions are introduced based on simple
examples that can easily be modified and extended to the user’s desired application. Most examples use
irreducible representations (irreps) of SU(5), which most textbooks use in examples since it is less trivial
than SU(3), but small enough to return results almost instantly on any recent computer. Also, SU(5)
frequently appears in unified model building since the Standard-Model gauge group is one of its maximal
subgroups. This tutorial can also be found in the LieART documentation integrated into the Mathematica
Documentation Center as “Quick Start Tutorial” under the section “Tutorials” on the LieART documentation
home.
This loads the package:
In[1]:= « LieART‘
3.1. Entering Irreducible Representations

Irreps are internally described by their Dynkin label with a combined head of Irrep and the Lie algebra.
Irrep[algebraClass][label ] irrep described by its algebraClass and Dynkin label .

Entering irreps by Dynkin label.
The algebraClass follows the Dynkin classification of simple Lie algebras and can only be A, B, C, D for the
classical algebras and E6, E7, E8, F4 and G2 for the exceptional algebras. The precise classical algebra is
determined by the length of the Dynkin label.
Entering the 10 of SU(5) by its Dynkin label and algebra class:
In[2]:= Irrep[A][0,0,1,0]//FullForm
Out[2]:= Irrep[A][0,0,1,0]
In StandardForm the irrep is displayed in the textbook notation of Dynkin labels:

In[3]:= Irrep[A][0,0,1,0]//StandardForm
Out[3]:= (0010)
In TraditionalForm (default) the irrep is displayed by its dimensional name:

In[4]:= Irrep[A][0,0,1,0]
Out[4]:= 10
The default output format type of LieART is TraditionalForm. The associated user setting is overwritten
for the notebook LieART that is loaded in. For StandardForm as output format type please set the global
variable $DefaultOutputForm=StandardForm.
As an example for entering an irrep of an exceptional algebra, consider the 27 of E6 :
In[5]:= Irrep[E6][1,0,0,0,0,0]
Out[5]:= 27
Irreps may also be entered by their dimensional name. The package transforms the irrep into its Dynkin
label. Since the algebra of an irrep of a classical Lie algebra becomes ambiguous with only the dimensional
name, it has to be specified.
Irrep[algebra][dimname] irrep entered by its algebra and dimensional name dimname.

Entering irreps by dimensional name.
6
Entering the 10 of SU(5) by its dimensional name specifying the algebra by its Dynkin classification A4 :
In[6]:= Irrep[A4][Bar[10]]//InputForm
Out[6]:= Irrep[A][0,0,1,0]
The traditional name of the algebra SU(5) may also be used:

In[7]:= Irrep[SU5][Bar[10]]//InputForm
Out[7]:= Irrep[A][0,0,1,0]
Irreps of product algebras like SU(3)⊗SU(2)⊗U(1) are specified by ProductIrrep with the individual
irreps of simple Lie algebras as arguments.
ProductIrrep[irreps] head of product irreps, gathering irreps of simple Lie algebras.

Product irreps.
The product irrep (3, 3) of SU(3)⊗SU(3):

In[8]:= ProductIrrep[Irrep[SU3][3],Irrep[SU3][Bar[3]]]
Out[8]:= (3,3)
In[9]:= %//InputForm
Out[9]:= ProductIrrep[Irrep[A][1,0],Irrep[A][0,1]]
In[10]:= ProductIrrep[Irrep[A][1,0],Irrep[A][0,1]]
Out[10]:= (3,3)
Take for example the left-handed quark doublet in the Standard-Model gauge group SU(3)⊗SU(2)⊗U(1)
(The U(1) charge is not typeset in bold face):
In[11]:= ProductIrrep[Irrep[SU3][3],Irrep[SU2][2],Irrep[U1][1/3]]
Out[11]:= (3,2)(1/3)
Out[12]:= ProductIrrep[Irrep[A][1,0],Irrep[A][1],Irrep[U][1/3]]
3.2. Decomposing Tensor Products
DecomposeProduct[irreps] decomposes the tensor product of several irreps.

Tensor product decomposition.
Decompose the tensor product 3⊗3 of SU(3):

In[13]:= DecomposeProduct[Irrep[SU3][3],Irrep[SU3][Bar[3]]]
Out[13]:= 1+8
Decompose the tensor product 27⊗27 of E6 :

In[14]:= DecomposeProduct[Irrep[E6][27],Irrep[E6][Bar[27]]]
Out[14]:= 1 + 78 + 650
Decompose the tensor product 3⊗3⊗3 of SU(3):

In[15]:= DecomposeProduct[Irrep[SU3][3],Irrep[SU3][3],Irrep[SU3][3]]
Out[15]:= 1 + 2(8) + 10
7
Decompose the tensor product 8⊗8 of SU(3):
In[16]:= DecomposeProduct[Irrep[SU3][8],Irrep[SU3][8]]
Out[16]:= 1 + 2(8) + 10 + 10 + 27
Internally a sum of irreps is represented by IrrepPlus and IrrepTimes, an analog of the built-in functions
Plus and Times:
IrrepPlus[Irrep[A][0,0], IrrepTimes[2, Irrep[A][1,1]],
Out[17]:=
Irrep[A][3, 0], Irrep[A][0,3], Irrep[A][2,2]]
Results can be transformed into a list of irreps with IrrepList, suitable for further processing with
Mathematica built-in functions like Select or Cases:
In[18]:= %//IrrepList
Out[18]:= {1,8,8,10,10,27}
Decompose the tensor product 4⊗4⊗6⊗15 of SU(4):
In[19]:= DecomposeProduct[Irrep[SU4][4],Irrep[SU4][4],Irrep[SU4][6],Irrep[SU4][15]]
Out[19]:= 2(1) + 7(15) + 4(200 ) + 35 + 5(45) + 3(45) + 3(84) + 2(175) + 256
The Mathematica built-in command Times for products is replaced by DecomposeProduct for irreps as
arguments. E.g., decompose the tensor product 10⊗24⊗45 of SU(5):
In[20]:= Irrep[SU5][Bar[10]]*Irrep[SU5][24]*Irrep[SU5][45]
00 0 0
Out[20]:= 3(5)+6(45)+3(50)+5(70)+2(105)+175 +6(280)+2(280 )+420+450 +3(480)+2(720)+1120+2520
For powers of irreps the Mathematica built-in command Power may be used. E.g., decompose the tensor
product 27⊗27⊗27 of E6 :
In[21]:= Irrep[E6][27]^3
Out[21]:= 1 + 2(78) + 3(650) + 2925 + 3003 + 2(5824)
Decompose tensor products of product irreps (3, 3, 1)⊗(3, 3, 1) of SU(3)⊗SU(3)⊗SU(3):

In[22]:= DecomposeProduct[
ProductIrrep[Irrep[SU3][3],Irrep[SU3][Bar[3]],Irrep[SU3][1]],
ProductIrrep[Irrep[SU3][Bar[3]],Irrep[SU3][3],Irrep[SU3][1]]]
Out[22]:= (1, 1, 1) + (8, 1, 1) + (1, 8, 1) + (8, 8, 1)
Decompose the tensor products (3, 2)⊗(3, 1) of SU(3)⊗SU(2):

In[23]:= DecomposeProduct[
ProductIrrep[Irrep[SU3][3],Irrep[SU2][2]],
ProductIrrep[Irrep[SU3][Bar[3]],Irrep[SU2][1]]]
Out[23]:= (1, 2) + (8, 2)
3.3. Decomposition to Subalgebras
DecomposeIrrep[irrep, subalgebra] decomposes irrep to the specified subalgebra.

DecomposeIrrep[pirrep, subalgebra, pos] decomposes the product irrep pirrep at position pos.
Decompose irreps and product irreps.
Decompose the 10 of SU(5) to SU(3)⊗SU(2)⊗U(1):

In[24]:= DecomposeIrrep[Irrep[SU5][Bar[10]],ProductAlgebra[SU3,SU2,U1]]
Out[24]:= (1, 1)(6) + (3, 1)(−4) + (3, 2)(1)
8
Decompose the 10 and the 5 of SU(5) to SU(3)⊗SU(2)⊗U(1) (DecomposeIrrep is Listable):
In[25]:= DecomposeIrrep[{Irrep[SU5][10],Irrep[SU5][Bar[5]]},ProductAlgebra[SU3,SU2,U1]]
Out[25]:= {(3, 1)(4) + (3, 2)(−1) + (1, 1)(−6), (3, 1)(−2) + (1, 2)(3)}
Decompose the 16 of SO(10) to SU(5)⊗U(1):

In[26]:= DecomposeIrrep[Irrep[SO10][16],ProductAlgebra[SU5,U1]]
Out[26]:= (1)(−5) + (5)(3) + (10)(−1)
Decompose the 27 of E6 to SU(3)⊗SU(3)⊗SU(3):

In[27]:= DecomposeIrrep[Irrep[E6][27],ProductAlgebra[SU3,SU3,SU3]]
Out[27]:= (3, 1, 3) + (1, 3, 3) + (3, 3, 1)
Decompose the SU(3) irrep 3 in (24, 3)(−3) of SU(5)⊗SU(3)⊗U(1) to SU(2)⊗U0 (1),

i.e., SU(5)⊗SU(3)⊗U(1) → SU(5)⊗SU(2)⊗U0 (1)⊗U(1):
In[28]:= DecomposeIrrep[ProductIrrep[Irrep[SU5][24],Irrep[SU3][3],Irrep[U1][-3]],
ProductAlgebra[SU2,U1],2]
Out[28]:= (24, 1)(−2)(−3) + (24, 2)(1)(−3)
The same decomposition as above displayed as branching rule:

In[29]:= IrrepRule[#,DecomposeIrrep[#,ProductAlgebra[SU2,U1],2]]&@
ProductIrrep[Irrep[SU5][24],Irrep[SU3][3],Irrep[U1][-3]]
Out[29]:= (24, 3)(−3) → (24, 1)(−2)(−3) + (24, 2)(1)(−3)
Branching rules for all totally antisymmetric irreps, so-called basic irreps, of SU(6) to SU(3)⊗SU(3)⊗U(1):
In[30]:= IrrepRule[#,DecomposeIrrep[#,ProductAlgebra[SU3,SU3,U1]]]&/@
BasicIrreps[SU6]//TableForm
6 → (3, 1)(1) + (1, 3)(−1)
15 → (3, 1)(2) + (1, 3)(−2) + (3, 3)(0)
20 → (1, 1)(3) + (1, 1)(−3) + (3, 3)(−1) + (3, 3)(1)
Out[30]:=
15 → (3, 1)(−2) + (1, 3)(2) + (3, 3)(0)
6 → (3, 1)(−1) + (1, 3)(1)
3.4. Young Tableaux

The irreps of SU(N ) have a correspondence to Young tableaux, which can be displayed by YoungTableau.
YoungTableau[irrep] Displays the Young tableau associated with an SU(N ) irrep.

Young tableaux.
Young tableau of the 720 of SU(5):

In[31]:= YoungTableau[Irrep[A][1,2,0,1]]
Out[31]:=
Display Young tableaux of SU(4) irreps with a maximum of one column per box count:
In[32]:= Row[Row[{#,": ",YoungTableau[#]}]&/@
SortBy[Irrep[A]@@@Tuples[{0,1},3],Dim],Spacer[10]]
Out[32]:= 1: • 4: 4: 6: 15 : 20 : 20 : 64 :
9
4. Theoretical Background and Implementation
In this section we give a self-contained overview of the Lie algebra theory used and implemented in LieART. It
is subdivided into parts discussing basic properties of Lie algebras, roots, weights, Weyl orbits, representations
and decompositions. Every subsection begins with a list of the relevant LieART functions followed by text
that introduces the necessary theory with reference to the functions and notes on their implementation. This
section is not intended as a pedagogical introduction to Lie algebras and we refer the reader to the excellent
literature serving this purpose [7, 9, 11].
4.1. Algebras
Rank[expr ] gives the rank of the algebra of expr , which can be

an irrep, a weight a root or an algebra itself.
Algebra[algebraClass][rank ] represents a classical algebra of the type algebra-
Class, which can only be A, B, C or D, with rank
rank .
Algebra[expr ] gives the algebra (classical or exceptional) of expr ,
which may be an irrep, a weight or a root in any
basis.
OrthogonalSimpleRoots[algebra] gives the simple roots of algebra in the orthogonal
basis.
CartanMatrix[algebra] gives the Cartan matrix of algebra.
OmegaMatrix[algebra] gives the matrix of fundamental weights of algebra
as rows.
OrthogonalFundamentalWeights[algebra] gives the fundamental weights of algebra in the or-
thogonal basis.
OrthogonalBasis[expr ] transforms expr from any basis into the orthogonal
basis.
OmegaBasis[expr ] transforms expr from any basis into the ω-basis.
AlphaBasis[expr ] transforms expr from any basis into the α-basis.
DMatrix[algebra] gives a matrix with inverse length factors of simple
roots on the main diagonal.
ScalarProduct[weight1 ,weight2 ] gives the scalar product of expr1 and expr2 in any
basis. expr1 and expr2 may be weights or roots.
MetricTensor[algebra] gives the metric tensor or quadratic-form matrix of
algebra.
Basic Algebra Properties.
4.1.1. Definition
A Lie Algebra is a vector space g over a field F with the Lie bracket [·, ·] as binary operation, which is
bilinear, alternating and fulfills the Jacoby identity. The Lie bracket is often referred to as the commutator.
The Lie brackets of the generators ti of the Lie algebra are
[ti , tj ] = fijk tk (1)
with the so-called structure constants fijk , that fully determine the algebra. A Lie algebra is called simple
when it contains no non-trivial ideals. A semi-simple Lie algebra is a sum of simple ones.
10
6
1 2 3 n−1 n
An E6
1 2 3 4 5
7
1 2 3 n−1 n
Bn E7
1 2 3 4 5 6
8
1 2 3 n−1 n
Cn E8
1 2 3 4 5 6 7
n−1 F4
1 2 3 n−2
1 2 3 4
Dn
n G2
1 2
Figure 1: Dynkin Diagrams of classical and exceptional simple Lie algebras.
4.1.2. Roots
The generators ti of a simple Lie algebra in the Cartan-Weyl basis fall into two sets: The so-called Cartan
subalgebra, H, contains all simultaneously diagonalizable generators hi , i.e., the generators are Hermitian
and mutually commute (the Cartan subalgebra is abelian):
hi = h†i , [hi , hj ] = 0, i, j = 1, . . . , n. (2)
The number of simultaneously diagonalizable generators n is called the rank of the algebra, and can be
determined by the function Rank[expr ] in LieART. We denote all other generators as eα . They satisfy n
eigenvalue equations with the generators of the Cartan subalgebra hi :
[hi , eα ] = αi eα , i = 1, . . . , n, (3)
which is a subset of (1) and thus the αi are structure constants, which are real numbers due to the hermiticity
of the hi ’s. Since the αi are the solutions to the eigenvalue equation (3) the vectors α=(α1 , . . . , αn ) are called
the root vectors, which lie in an n-dimensional euclidian space, called the root space. Roots are functionals
mapping the Cartan subalgebra H onto the real numbers (the eigenvalues), for all generators ti , which also
includes the hi where the eigenvalues are zero. Thus, a Lie algebra has as many roots as generators. The
roots are labeled by the root vectors, which we will use in its place from now on.
A zero root with an n-fold degeneracy is associated with the Cartan subalgebra. In the Cartan-Weyl basis
the other generators come in conjugated pairs e†α =e−α and correspond to the ladder operators of SU(2).
So-called positive roots correspond to the raising operator eα and negative roots to the lowering operators
e−α . If α is a root so is −α.
Some of the positive roots can be written as sum of others. Those for which this is not possible are called
simple roots and a Lie algebra has as many simple roots as its rank. It is clear that specifying the simple
roots fully determines a Lie algebra and thus can be used to replace (1), because all structure constants can
be derived therefrom.
11
Type Cartan Name Rank Description
classical An SU(n+1) n≥1 Special unitary algebras of n+1 complex dimension
Bn SO(2n+1) n≥3 Special orthogonal algebras of odd (2n+1) real dimension
Cn Sp(2n) n≥2 Symplectic algebras of even (2n) complex dimension
Dn SO(2n) n≥4 Special orthogonal algebras of even (2n) real dimension
exceptional E6 E6 6 Exceptional algebra of rank 6
E7 E7 7 Exceptional algebra of rank 7
E8 E8 8 Exceptional algebra of rank 8
F4 F4 4 Exceptional algebra of rank 4
G2 G2 2 Exceptional algebra of rank 2
Table 4.1: Classification of simple Lie algebras.
4.1.3. Classification of Lie Algebras

Using the commutation relations and the Jacobi identity to analyze the generators, constraints on the roots
can be derived and eventually all possible root systems found, which is identical to identifying all allowed
Lie algebras. It turns out that simple roots can only come in at most two lengths in one Lie algebra and
at four different angles between any pair of them. The simple roots are in particular not orthogonal. The
so-called Dynkin diagrams are an ingenious way to depict these relations: simple roots are represented by
dots, which are open, #, for the longer roots or for all roots if they only come in one length, and filled,
, for the shorter roots. Angles between two simple roots are represented by lines connecting the dots: no
line for an angle of 90°, one line for 120°, two lines for 135° and three for 150°. Figure 1 shows the Dynkin
diagrams for all simple Lie algebras. Semi-simple Lie algebras have disjoint parts and can thus be reduced
to two or more Dynkin diagrams of simple Lie algebras.
The simple Lie algebras fall into two types: four families of infinite series algebras, An , Bn , Cn and Dn , also
called the classical Lie algebras and five so-called exceptional algebras, E6 , E7 , E8 , F4 and G2 , with their
rank as subscript (see Table 4.1). The labels are according to the classification by Cartan. The classical
Lie algebras are internally represented (i.e., in FullForm) in LieART by Algebra[algebraClass][n], with
algebraClass being either A, B, C or D and n being the rank. The exceptional algebras are defined in LieART
as E6, E7, E8, F4 and G2 and short forms of the classical algebras are predefined up to rank 30 for the
Cartan classification, i.e., A1, . . . ,A30, B3, . . . ,B30, C2, . . . ,C30, D4, . . . ,D30, and up to dimension 30 for
the conventional name, i.e., SU2, . . . ,SU30, SO7, . . . ,SO30 and Sp4, Sp6, . . . ,Sp30. In StandardForm
the Cartan classification is explicitly displayed and in TraditionalForm the Lie algebra is written by its
conventional name.
Note the isomorphisms for low-dimension algebras:
SU(2) ∼ SO(3) ∼ Sp(2) (A1 ∼ B1 ∼ C1 ), (4a)

SO(4) ∼ SU(2) ⊗ SU(2) (D2 ∼ A1 ⊗ A1 ), (4b)
SO(5) ∼ Sp(4) (B2 ∼ C2 ), (4c)
SO(6) ∼ SU(4) (D3 ∼ A3 ). (4d)
When these low-dimension Lie algebras occur in a calculation, choose the SU(2) form in (4a) and (4b), the
Sp(4) form in (4c) and the SU(4) form in (4d) when using LieART.
4.1.4. Bases
With respect to the Weyl reflection group, inherent in all compact Lie algebras, as we will explain later, it
is convenient to express the root space in an orthogonal coordinate system, which is a subspace of Euclidian
space. The specific subspace varies with the Lie algebra. For An it is a subspace of Rn+1 , where the
coordinates sum to one. As the simple roots define the Lie algebra, they are explicitly specified in LieART
12
using orthogonal coordinates and can be retrieved by OrthogonalSimpleRoots[algebra]. E.g., the four
simple roots of A4 (SU(5)) in orthogonal coordinates are:
In[33]:= OrthogonalSimpleRoots[A4]//Column
(1, −1, 0, 0, 0)
(0, 1, −1, 0, 0)
Out[33]:=
(0, 0, 1, −1, 0)
(0, 0, 0, 1, −1)
The so-called Cartan matrix exhibits the non-orthogonality of the simple roots. It is defined as
2 (αi , αj )
Aij = i, j = 1, . . . , n (5)
(αj , αj )
where the scalar product (·, ·) is the ordinary scalar product of Rn+1 in the case of An . Most textbooks
translate the Dynkin diagrams to the corresponding Cartan matrix as a starting point. And in fact, the rows
of the Cartan matrix are the simple roots in the so-called ω-basis, which is the bases of fundamental weights,
also called the Dynkin basis. (Weights will be introduced later in the context of representations.) The Cartan
matrix is implemented in LieART as the function CartanMatrix[algebra] following the definition of (5).
The Cartan matrix for A4 reads:
In[34]:= CartanMatrix[A4]
 
2 −1 0 0
−1 2 −1 0
Out[34]:=  
0 −1 2 −1
0 0 −1 2
Besides the orthogonal basis, and the ω-basis, the α-basis is also useful. As the name indicates it is the basis
of simple roots and it explicitly shows how, e.g., a root is composed out of simple roots. Neither the ω-basis
nor the α-basis is orthogonal. The Cartan matrix mediates between the ω- and α-bases:
n
X n
X
αi = Aij ωj , ωi = (A−1 )ij αj . (6)
j=1 j=1
where the ωi are the fundamental weights, which we will define later. These bases are dual to each other in
the sense that
2 (αi , ωj )
≡ (αi∨ , ωj ) = δij , i, j = 1, . . . , n (7)
(αi , αi )
where αi∨ is the so-called coroot of αi defined as
2α
α∨ = . (8)
(α, α)
The transformation to the orthogonal basis can be derived from (7): Expressing αi and ωj in orthogonal
coordinates as α̂i and ω̂j (7) reads
2α̂i · ω̂j
≡ α̂i∨ · ω̂j = δij , i, j = 1, . . . , n (9)
α̂i · α̂i
using the ordinary scalar product of Rm , where m is the dimension of the orthogonal subspace. Using the
matrices Â and Ω̂ with the simple coroots α̂i∨ and the fundamental weights ω̂j as rows, we can write (9) as
the matrix equation:
ÂΩ̂T = In (10)
where both Â and Ω̂ are n×m matrices, where Ω̂ is defined below in 12. Please note that the dimension of
the orthogonal space m is not necessarily the same as the rank of the algebra n. These exceptions are: An
with m=n + 1, E6 with m=8, E7 with m=8 and G2 with m=3. For all others m=n holds. The matrix of the
simple coroots in the orthogonal basis Â is easily calculated from the simple roots given in LieART, but the
13
matrix of fundamental weights in the orthogonal basis Ω̂ must be determined by (10). In the cases where Â
is not a square matrix its inverse does not exist. Because the rows of Â, which are the simple coroots in the
orthogonal basis, are linear independent, ÂÂT is invertible and the so-called right-inverse Â+ can be found
via
Â+ = ÂT (ÂÂT )−1 (11)
which satisfies: ÂÂ+ =In , i.e., by comparing with (10) the matrix Ω̂T can be identified with Â+, in other
words the fundamental weights as rows of Ω̂ in terms of simple coroots as rows of Â are
Ω̂ = (Â+)T = (ÂÂT )−1 Â (12)
The Mathematica built-in function PseudoInverse[matrix ] yields the right-inverse for our case of a
matrix with linear independent rows, i.e., the implementation of the second equality in (12) is not needed.
The matrix of the fundamental weights Ω̂ is implemented as OmegaMatrix[algebra], e.g., for A4 :
In[35]:= OmegaMatrix[A4]
4 
5
− 15 − 15 − 15 − 15
3 3
− 25 − 25 − 25 

5 5
Out[35]:= 2 
2 2
5 5 5
− 35 − 35 
1 1 1 1
5 5 5 5
− 45
and the function OrthogonalFundamentalWeights[algebra] adds the proper heads to the rows of Ω̂,
to identify them as weights is the orthogonal basis. We will discuss (fundamental) weights in Section 4.1.6
in more detail.
The matrix of the fundamental weights in the orthogonal basis Ω̂ mediates between the ω-basis and the
orthogonal basis:
Xn Xn
ωi = Ω̂ij ej , ei = (Ω̂−1 )ij ωj . (13)
j=1 j=1
The LieART functions AlphaBasis[weightOrRoot], OmegaBasis[weightOrRoot] and

OrthogonalBasis[weightOrRoot] transform weightOrRoot from any basis into the α-basis, the ω-basis
and the orthogonal basis, respectively. It is obvious how the simple roots in the α-basis look:
In[36]:= AlphaBasis[OrthogonalSimpleRoots[A4]]//Column
(1, 0, 0, 0)
(0, 1, 0, 0)
Out[36]:=
(0, 0, 1, 0)
(0, 0, 0, 1)
and likewise the fundamental weights in the ω-basis:
In[37]:= OmegaBasis[OrthogonalFundamentalWeights[A4]]//Column
1 0 0 0
0 1 0 0
Out[37]:=
0 0 1 0
0 0 0 1
(Roots and weights in the ω-basis are displayed with framed boxes following the notation of most textbooks.)
A root in LieART is represented by three different heads: RootOrthogonal[algebraClass][label ] for
a root in the orthogonal basis, RootOmega[algebraClass][label ] in the ω-basis and in the α-basis by
RootAlpha[algebraClass][label ]. The algebraClass can only be A, B, C or D to indicate a classical Lie
algebra or E6, E7, E8, F4 or G2 for the exceptionals. The label stands for the comma-separated coordinates.
This form of the roots is displayed in InputForm and FullForm. E.g., the first simple root of A4 in all
three bases reads:
In[38]:= {#,OmegaBasis[#],AlphaBasis[#]}&@First[OrthogonalSimpleRoots[A4]]//InputForm
Out[38]:= {RootOrthogonal[A][1,-1,0,0,0], RootOmega[A][2,-1,0,0], RootAlpha[A][1,0,0,0]}
14
4.1.5. Scalar Product
The standard choice for the length factors (αj , αj ) in (5) is 2 for the longer roots, if there are two root
lengths. The factors 2/ (αj , αj ) can only take three different values which are: 1 for all roots of An , Dn ,
E6 , E7 , E8 and for the long roots of Bn , Cn , F4 and G2 ; 2 for the short roots of Bn , Cn and F4 and 3 for
the short root of G2 . Their implementation in LieART is in the form of diagonal matrices with the inverse
factors for the simple roots corresponding to the row on the main diagonal, i.e.,

1 1
D = diag (α1 , α1 ) , . . . , (αn , αn ) (14)
2 2
as defined in [18]. E.g., for F4 , to avoid a trivial example, we have:
In[39]:= DMatrix[F4]
 
1 0 0 0
0 1 0 0 
Out[39]:= 
0 0 1 0 

2
0 0 0 12
In the ω-basis the scalar product used in (5) becomes:

n
X n
X
(x, y) = xi (A−1 )ij Dj yj = xi Gij yj (15)
i,j i,j
where the xi and yj are coordinates of x and y in the ω-basis. The matrix
(αj , αj )
Gij = (A−1 )ij = (A−1 )ij Dj (16)
2
is called quadratic-form matrix or metric tensor of the Lie algebra. The scalar product is available in
LieART as ScalarProduct[weightOrRoot1 ,weightOrRoot2 ], where weightOrRoot1 and weightOrRoot2
may be roots or weights in the orthogonal basis, the α-basis or the ω-basis. The function recognizes the
basis by the heads of weightOrRoot1 and weightOrRoot2 . The LieART function for the metric tensor G is
MetricTensor[algebra], e.g., for A4 :
In[40]:= MetricTensor[A4]
4 3 2 1
5 5 5 5
3 6 4 2
5 5 5 5
Out[40]:= 2 
5 4 6 3
5 5 5
1 2 3 4
5 5 5 5
4.1.6. Representation
A representation is a linear map of the Lie algebra into the general linear group, i.e., the matrix group,
that preserves the Lie bracket relations. It is a homomorphism that maps the generators ti onto invertible
matrices Ti , that satisfy the same “commutation” relations as the Lie algebra, namely
[Ti , Tj ] = fijk Tk , (17)
where the [·, ·] is now the commutator.
Points in the vector space that the matrices act on can be labeled by the set of eigenvalues of the matrices
representing the generators of the Cartan subalgebra. Such a set of eigenvalues is called a weight vector, and
the associated functional weight, denoted by λ. They are defined in root space which is called weight space in
this context. The weights and weight vectors of a representation correspond to roots and root vectors of the
algebra. In fact, weights can be expressed as rational linear combinations of roots, and, as pointed out in this
section, eventually by simple roots. In particular, the structure functions themselves form a representation
of the algebra: the adjoint representation, which has the same dimension as the algebra, namely the number
of roots.
15
4.2. Weyl Group Orbits
Reflect[weightOrRoot,simpleroots] reflects weightOrRoot at the hyperplanes orthogonal to the

specified simpleroots.
Reflect[weightOrRoot] reflects weightOrRoot at the hyperplanes orthogonal to all
simple roots of the Lie algebra of weightOrRoot.
ReflectionMatrices[algebra] gives the reflection matrices of the Weyl group of algebra.
Orbit[weightOrRoot,simpleroots] generates the Weyl group orbit of weightOrRoot using only
the specified simpleroots.
Orbit[weightOrRoot] generates the full Weyl group orbit of weightOrRoot using
all simple roots of the Lie algebra of weightOrRoot.
DimOrbit[weightOrRoot,simpleroots] gives the size of the orbit of weightOrRoot using only the
simpleroots.
DimOrbit[weightOrRoot] gives the size of the orbit of weightOrRoot using all simple
roots of the Lie algebra of weightOrRoot.
Weyl Group Orbits
The finite group W (L), called the Weyl group of the Lie algebra L, is a reflection group inherent in the
root systems of all simple Lie algebras. The Coxeter groups are an abstraction of reflection groups and
the so-called Coxeter-Dynkin diagram describing Coxeter groups are closely related to the Dynkin diagrams
presented here. In fact the Coxeter-Dynkin diagram corresponding to the Dynkin diagram describes the
Weyl group of the Lie algebra.
The transformations ri generating the Weyl group are reflections of a vector x in root space at the hyperplanes
orthogonal to the simple roots αi of the Lie algebra defined by
2 (x, αi )
ri x = x − αi , i = 1, . . . , n, x ∈ Rn . (18)
(αi , αi )
The LieART function Reflect[weightOrRoot,simpleroots] implements the reflections ri with weightOr-

Root as x and simpleroots as a list of simple roots αi . The result is a list of weights, because the reflection
is performed with several roots simultaneously.
If weightOrRoots are in the orthogonal basis and ought to be reflected using all roots, the function pattern
is Reflect[weightOrRoot], without the simple roots as second argument. Instead of the definition with
scalar products following (18), the implementation multiplies the orthogonal coordinates with precomputed
reflection matrices, which have a simple form in the orthogonal basis. The function computing the reflec-
tion matrices is ReflectionMatrices[algebra] and simply applies the built-in Mathematica command
ReflectionMatrix to all simple roots and saves the result as DownValues of
ReflectionMatrices[algebra]. E.g., the reflection matrices for A4 (in the 5-dimensional orthogonal
basis) are:
In[41]:= Row[MatrixForm /@ ReflectionMatrices[A4]]
    
0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0
1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0
    
0 0 1 0 0 0 1 0 0 0 0 0 0 1 0
Out[41]:=  0 0 1 0 0

   
0 0 0 1 0 0 0 0 1 0 0 0 1 0 0  0 0 0 0 1
0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0
The Weyl group of An is particularly simple in the orthogonal basis: It is the symmetric group Sn+1 . The
reflection matrices for A4 above represent the generators of S5 , i.e., the coordinate permutations (12), (23),
(34) and (45), respectively.
Acting on a vector x in root space by all elements of the Weyl group gives a set of points, of which some may
coincide. The subset of distinct points is called the orbit of x and denoted as O(x). The LieART function
Orbit[weightOrRoot,simpleroots] gives the orbit of weightOrRoot using the simpleroots. If the second
16
argument is omitted, all simple roots of the algebra associated with weightOrRoot are used. The function
applies Reflect in a nested fashion and removes duplicate points in every step. The orbit of an An root
or weight is constructed in a special way for performance reasons: The weightOrRoot is transformed to the
orthogonal basis and the other points of its orbit are constructed by permuting its coordinates using the
built-in Mathematica function Permutations. For example, the orbit of the first simple root of A4 is
In[42]:= Orbit[First[OrthogonalSimpleRoots[A4]]]
{(−1, 0, 0, 0, 1),(−1, 0, 0, 1, 0),(−1, 0, 1, 0, 0),(−1, 1, 0, 0, 0),(0, −1, 0, 0, 1),
(0, −1, 0, 1, 0),(0, −1, 1, 0, 0),(0, 0, −1, 0, 1),(0, 0, −1, 1, 0),(0, 0, 0, −1, 1),
Out[42]:=
(0, 0, 0, 1, −1),(0, 0, 1, −1, 0),(0, 0, 1, 0, −1),(0, 1, −1, 0, 0),(0, 1, 0, −1, 0),
(0, 1, 0, 0, −1),(1, −1, 0, 0, 0),(1, 0, −1, 0, 0),(1, 0, 0, −1, 0),(1, 0, 0, 0, −1)}
which is in fact the A4 root system without the zero roots.
With the same set of Weyl group generators, defined by the roots used, every vector is uniquely associated
with only one orbit. In turn every element of an orbit allows us to generate the entire orbit by reflecting at
the hyperplanes defined by the roots. The hyperplanes divide the space into so-called Weyl chambers. An
orbit has no more than one distinct element in every chamber and the Weyl group permutes the chambers.
The so-called dominant chamber has elements with only positive coordinates in the ω-basis, which serves as
a definite element for the orbits associated with them. The test function DominantQ[weightOrRoot] gives
True if weightOrRoot is in the dominant chamber and False otherwise. The dominant root of Out[42]
in the ω-basis is
In[43]:= OmegaBasis[Select[%, DominantQ]]
n o
Out[43]:= 1 0 0 1
If an orbit is created by LieART it is saved as a DownValue of Orbit associated with its dominant root or
weight. Whenever an orbit of a non-dominant weight or root is needed, LieART first seeks the DownValues
of Orbit for the weight or root, to see if the orbit has already been generated. Reusing computed orbits
saves CPU time especially for Lie algebras other than An and the described procedure avoids saving the
same orbit multiple times as DownValue involving different roots or weights.
The size of the orbit, i.e., its numbers of elements, denoted by |O(x)|, is implemented as the function
DimOrbit[weightOrRoot,simpleroots] or DimOrbit[weightOrRoot] if all simple roots of the associated
Lie algebras should be used. The size of the orbit in Out[42] is
In[44]:= DimOrbit[First[OrthogonalSimpleRoots[A4]]]
Out[44]:= 20
4.3. Roots
RootSystem[algebra] root system of algebra

ZeroRoots[algebra] zero roots associated with the Cartan subalgebra of algebra
Height[root] height of a root within the root system
HighestRoot[algebra] highest root of the root system of algebra
PositiveRootQ[root] gives True if root is a positive root and False otherwise
NumberOfPositiveRoots[algebra] number of positive roots of algebra
PositiveRoots[algebra] gives only the positive roots of algebra
Roots
The roots of a Lie algebra can be built from the simple roots. There are two traditional approaches:
(a) building the roots from linear combinations of simple roots. Since not all linear combinations of simple
roots are roots, the difficulty lies in filtering out combinations that are roots. (b) Starting from a highest
root the roots can be constructed by subtracting simple roots. LieART uses yet another approach: It builds
the orbits of the simple roots by applying the Weyl group of the Lie algebra and adds the n-fold degenerated
zero roots corresponding to the Cartan subalgebra. The simple roots of the same length belong to the same
17
orbit, e.g., for An there is only one orbit besides the zero orbit (see Out[42]). Nevertheless, the orbits of
all simple roots are generated and then united. The fact that non-zero roots are non-degenerate allows us
to remove duplicate roots obtained by the described procedure.
The function RootSystem[algebra] constructs the root system by the procedure described above. As a
non-trivial example we demonstrate the procedure on G2 , which has two non-trivial orbits and the zero
orbit: The two simple roots of G2
In[45]:= OmegaBasis[OrthogonalSimpleRoots[G2]]
n o
Out[45]:= 2 −1 , −3 2
have different lengths:

In[46]:= DMatrix[G2]
1
3
0
Out[46]:=
0 1
Generating the Weyl group orbits of each of the simple roots
In[47]:= Orbit /@ OmegaBasis[OrthogonalSimpleRoots[G2]]
!
−2 1 −1 0 −1 1 1 −1 1 0 2 −1
Out[47]:=
−3 1 −3 2 0 −1 0 1 3 −2 3 −1
and adding the twofold degenerated zero roots constructed by ZeroRoots[algebra]

In[48]:= ZeroRoots[G2]
n o
Out[48]:= 0 0 , 0 0
yields the full G2 root system, displayed in spindle shape, as defined below in section 4.4.1
In[49]:= RootSystem[G2, SpindleShape -> True]
0 1
3 −1
1 0
−1 1
−3 2 2 −1
Out[49]:= 0 0 0 0
−2 1 3 −2
1 −1
−1 0
−3 1
0 −1
where a row stands for the same height of the roots. The height of a root is defined as the sum of coefficients
in its linear combination of simple roots, i.e., the sum of coordinates in the α-basis. It is implemented by
Height[root]. The highest root has the largest height, implemented in LieART as HighestRoot[algebra],
which simply returns the first root of the root system, since the latter is sorted by the height of the roots
decreasingly. E.g. for G2 :
In[50]:= HighestRoot[G2]
Out[50]:= 0 1
The positive roots are the roots that are only positive linear combinations of simple roots, i.e., the coordinates
in the α-basis are all positive, with at least one being non-zero, to exclude the zero roots. The function
PositiveRootQ[root] tests if root is positive. The root may be in any basis and will be transformed
into the α-basis, where its coordinates are tested accordingly. The number of positive roots are explicitly
18
stated as NumberOfPositiveRoots[algebra] in LieART. It serves as a limiter to the nested reflections
for the generation of Weyl group orbits. There is a theorem stating that the maximum number of reflections
building an element of the Weyl group is equal to the number of positive roots of the corresponding Lie
algebra.
Since the root system is sorted by height, the positive roots come first. PositiveRoots[algebra] extracts
only those with the use of NumberOfPositiveRoots[algebra]. E.g., for G2 :
In[51]:= PositiveRoots[G2]
n o
Out[51]:= 0 1 , 3 −1 , 1 0 , −1 1 , −3 2 , 2 −1
4.4. Representations
WeightOrthogonal[algebraClass][label ] weight in the orthogonal basis defined by its algebra

algebraClass and Dynkin label
WeightAlpha[algebraClass][label ] weight in the α-basis defined by its algebra algebraClass
and Dynkin label
Weight[algebraClass][label ] weight in the ω-basis defined by its algebra algebraClass
and Dynkin label
Irrep[algebraClass][label ] irrep described by its algebra algebraClass and Dynkin
label
WeightLevel[weight,irrep] Level of the weight within the irrep
Height[irrep] height of irrep
SingleDominantWeightSystem[irrep] dominant weights of irrep without their multiplicities
WeightMultiplicity[weight,irrep] computes the multiplicity of weight within irrep
DominantWeightSystem[irrep] dominant weights of irrep with their multiplicities
WeightSystem[irrep] full weight system of irrep
Irrep[algebra][dimname] irrep entered by its algebra and dimname
ProductIrrep[irreps] head of product irreps
Delta[algebra] half the sum of positive roots of algebra (δ=(1, 1, . . .))
WeylDimensionFormula[algebra] explicit Weyl dimension formula for algebra
Dim[irrep] dimension of irrep
DimName[irrep] dimensional name of irrep
Index[irrep] index of irrep
CongruencyClass[irrep] congruency class number of irrep
Basic Properties of Irreps
As explained in Section 4.1.6 a representation is a set of matrices that satisfies the same commutation
relations as the algebra. Each of the matrices can be labeled by the weight vector with the eigenvalues of the
matrices corresponding to the generators of the Cartan subalgebra, and we will refer to the weight vector
simply as weight. The weight vector has the dimension of the Cartan subalgebra, i.e., the rank of the algebra,
and not the dimension of the space the matrices act on. The latter depends on the particular representation.
The weights λ can be written as linear combination of simple roots and a crucial theorem states that the
so-called Dynkin labels ai defined as
2 (λ, αi )
ai = , i = 1, . . . , n (19)
(αi , αi )
are integers for all simple roots αi . (Please note that this is also true if λ is replaced by any simple root,
since this constitutes an element of the Cartan matrix as defined in (5).) The Dynkin labels are in particular
used to label weights (and roots). The smallest non-zero weights with ai ≥ 0 are called the fundamental
19
weights ωi . They define the ω-basis or Dynkin basis already introduced. They are implemented in LieART
as OrthogonalFundamentalWeights[algebra] in the orthogonal basis and we have given an example
for A4 in Out[37]. The Dynkin labels ai of a weight λ are the coefficients of its linear combination of
fundamental weights, i.e., the ai are the coordinates in the ω-basis, which can be displayed as a row vector
with comma separated entries or as a framed box following the convention of some textbooks:
n
X
λ= ai ωi = (a1 , a2 , . . . , an ) = a1 a2 . . . an . (20)
i=1
A weight in LieART is represented by three different heads, depending on its basis, in analogy with the
roots: WeightOrthogonal[algebraClass][label ] for a weight in the orthogonal basis, in the α-basis
WeightAlpha[algebraClass][label ] and simply Weight[algebraClass][label ] in the ω-basis, where we
omit the explicit “Omega” for brevity, because the ω-basis is the natural basis for weights. (The same can
be said for the α-basis for roots, favoring the shorter head Root instead of RootAlpha in the α-basis.
Unfortunately this would clash with the built-in Mathematica function Root[f ,k ] representing the k th
root of a polynomial equation defined by f [x] = 0.) The algebraClass can only be A, B, C or D to indicate a
classical Lie algebra or E6, E7, E8, F4 or G2 for the exceptionals. The label stands for the comma-separated
coordinates. This form of the weight is displayed in InputForm and FullForm. E.g., the first fundamental
weight of A4 in all three bases reads:
In[52]:= {#,AlphaBasis[#],OmegaBasis[#]}&
@First[OrthogonalFundamentalWeights[A4]]//InputForm
{WeightOrthogonal[A][4/5,-1/5,-1/5,-1/5,-1/5], WeightAlpha[A][4/5,3/5,2/5,1/5],
Out[52]:=
Weight[A][1,0,0,0]}
Since weights are linear combinations of roots, many properties of roots translate to weights. The Weyl
group also applies to weights and the weight space is also divided into Weyl chambers. A weight with only
positive coordinates lies in the dominant Weyl chamber and is called a dominant weight. In analogy with
the highest root, every irreducible representation (irrep) has a non-degenerate highest weight, denoted as
Λ, which is also a dominant weight, but not necessarily the only dominant weight of the irrep. The weight
system of the irrep can be computed from the highest weight Λ by subtracting simple roots. Thus, a highest
weight Λ uniquely defines the irrep, and since a particular Lie algebra has infinitely many irreps, it serves
as a label for the irrep itself using the same denotation, Λ.
In LieART an irrep is represented by Irrep[algebraClass][label ], where algebraClass defines the Lie
algebra class in the same manner as for weights and roots, and label is the comma-separated label of the
highest weight of the irrep. E.g., the 10 dimensional irrep of A4 has the highest weight (0, 1, 0, 0) and thus
the irrep can be entered as Irrep[A][0,1,0,0].
The so-called Dynkin label of an irrep is similar to the notation of a weight, but since the highest weight has
only positive label entries the commas between them can be ommitted, as long as this is unambiguous. The
Dynkin label in LieART is displayed in StandardForm, e.g., the 10 of A4 :
In[53]:= Irrep[A][0,1,0,0]//StandardForm
Out[53]:= (0100)
If at least one of the entries in the Dynkin labels has more than a single digit, all entries are separated by
commas to avoid ambiguities, which is the standard textbook convention:
In[54]:= Irrep[A][0, 10, 3, 1] // StandardForm
Out[54]:= (0, 10, 3, 1)
4.4.1. Weight System

The conventional approach to computing all weights of an irrep is to subtract simple roots from the highest
weight Λ that defines the irrep. The Dynkin label of the highest weight Λ = (a1 , a2 , . . . , an ) reveals how
many times each simple root can be subtracted: the ith root can be subtracted ai times. The level of a
weight is the number of simple root that need to be subtracted from the highest weight to obtain it. A weight
20
may be obtained by different subtraction routes, but it always involves the same number of simple roots,
thus its level is unique. As explained earlier, the α-basis exhibits the coefficients of the linear combination of
simple roots, which are rational numbers in general. The difference between these coefficients of the weight
and the highest weight show how many times each simple roots has been subtracted from the latter. The
sum over these differences, for each simple root, gives the level of the weight:
n
X
(21)

L(λ, Λ) = Λ̄i − λ̄i
i=1
where λ = (λ̄1 , . . . , λ̄n ) and Λ = (Λ̄1 , . . . , Λ̄n ) is the weight and highest weight in the α-basis, respectively.
The LieART function WeightLevel[weight,irrep] implements this procedure. The highest level of an
irrep is called its height. Please note that the highest weight has the lowest level, which is zero. The weight
with the highest level has the coefficients of the highest weight in the alpha basis, with negative sign and
rearranged (if the irrep is complex), i.e., the sum over them is the negative of the sum of the highest weight.
Thus, the height of an irrep with highest weight Λ is
n
X
ht(Λ) = 2 Λ̄i , (22)
i=1
which is available in LieART as Height[irrep].

The algorithm to compute the weight system used in LieART is an implementation of the scheme developed
in [19]. It deviates from the traditional procedure described above for performance reasons. Some weights of
an irrep may be degenerated and the procedure with subtracting simple roots only yields an upper limit of
this degeneracy, which is the number of subtraction routes that lead to a weight. To compute the multiplicity
mλ of a weight λ of the irrep with highest weight Λ, the so-called Freudenthal recursion formula is usually
used: X X
2 (λ+kα, α) mλ+kα = [(Λ+δ, Λ+δ) − (λ+δ, λ+δ)] mλ (23)
α∈∆+ k≥0
where ∆ denotes the positive root system, δ=(1, 1, . . . , 1) is half the sum of all positive roots in the ω-basis
+
and mλ+kα is the already computed multiplicity of a weight λ + kα that is higher than λ. The sum over k
is finite because the weight λ + kα must be a member of the weight system of the irrep under consideration.
The recursive nature of the Freudenthal formula makes the computation of weight multiplicities the most
CPU time consuming procedure in the determination of the weight system of an irrep. The algorithm
developed in [19] exploits the Weyl group in both the weight and the root system. The weight system of
an irrep is a collection of Weyl group orbits, represented by their unique dominant weight. The multiplicity
of the dominant weight is the same for all weights of the associated orbit. Thus, a weight system can be
constructed by (a) determining the dominant weights of the irrep, (b) computing their multiplicity and (c)
generating the orbits of the dominants weights with the same multiplicity by application of the Weyl group
of the associated algebra.
In LieART the function SingleDominantWeightSystem[irrep] determines the dominant weights of irrep
by successively subtracting positive roots starting from the highest weight and keeping only the dominant
weight of the result in every step. This process terminates, because there are smallest dominant weights,
i.e., the fundamental weights, constituting a lower boundary. E.g., the 40 of A4 has two distinct dominant
weights:
In[55]:= SingleDominantWeightSystem[Irrep[A][0, 0, 1, 1]]
Out[55]:= { 0 0 1 1 , 0 1 0 0 }
Thus, an improved version of the Freudenthal formula considers only dominant weights λ. The second
exploitable property is the existence of a stabilizer of the weight, a subgroup of its Weyl group W that fixes
the weight:
StabW (λ) = WT := {w ∈ W | wλ = λ} . (24)
The stabilizer WT reduces the number of independent scalar products and previous computed multiplicities,
because for w ∈ WT , (λ+kα, α) = (w(λ+kαi ), wαi ) = ((λ+kwαi ), wαi ) and mλ+kαi =mw(λ+kαi ) =mλ+kwαi .
21
Since the elements of the Weyl group W are reflections at simple roots, the stabilizer group is defined by
the reflection at simple roots that Pmap λ onto itself. Because of (18) this is the case, when (λ, αi ) = 0. If λ
is expressed in the ω-basis as λ= ni ωi the scalar product with the ith simple root is zero, when ni = 0.
Let T be a set of these indices, i.e., T = {i | ni =0}, and let ∆T be the root system based on the simple roots
labeled by T .
The group ŴT , which is the inclusion of WT and the negative identity element w=−1 as ŴT = hWT , −1i,
decomposes the root system into orbits o1 , . . . , or , defined by ŴT αi . Each orbit has a unique representative
ξi in the positive roots (ξi ∈∆+ ). The ξi ’s are those P positive roots, that have non-zero coefficients in the
ω-basis at the positions where λ has zeros, i.e., ξi = mi ωi with mi ≥0 for i∈T .
The computation of the multiplicity mλ of the dominant weight λ is then accomplished by the modified
Freudenthal formula:
n
X ∞
X
|oi | (λ+kξi , ξi ) mλ+kξi = [(Λ+δ, Λ+δ) − (λ+δ, λ+δ)] mλ (25)
i=1 k=1
where |oi | are the sizes of the orbits. It is important to note that these sizes are |oi | = |WT ξi | if ξi ∈∆T and
|oi | =2 |WT ξT | if ξi ∈∆
/ T , because in the former case the negative roots are included in WT ξi , i.e., the −1,
while only positive roots are in the orbit WT ξi if ξi ∈∆/ T , requiring a factor of 2 for the same reason as on
the left-hand side of (23). It is ξi ∈∆T if (λ, ξi ) =0.
The higher weight λ + kξi is not necessarily a dominant weight, but can always be reflected to the dominant
chamber to obtain the corresponding multiplicity that is already computed.
The computation of weight multiplicities is implemented in LieART as WeightMultiplicity[weight,irrep]
following the above algorithm, using several helper functions: T[weight] gives the set T , the positions of
zeros of the coefficients of weight in the ω-basis, Xis[algebra,t] determines the ξ’s based on the set T
which should be supplied via the argument t, Alphas[algebra,t] gives αi with i ∈ T to construct the orbit
WT ξi . XisAndMul[algebra,t] yields a list of the ξi ’s together with their associated orbit size |oi |. Since
the possible subsets T of zeros in the weight coefficients for a specific algebra are limited, we follow the
suggestion of [19] and save this in list form as XisAndMul for reuse upon first evaluation in the course of a
calculation. Saved values of XisAndMul can be retrieved by Definition[XisAndMul].
Take for example the dominant weight 0 1 0 0 of the 40 of A4 from Out[55]. The set of indices T is
In[56]:= T[Weight[A][0,1,0,0]]
 
1
Out[56]:= 3
4
or in InputForm: {{1},{3},{4}}. (The structure as “list of lists” is due to the use of the Mathematica
built-in functions Position and Extract.) The ξi ’s and the sizes of their associated orbits |oi | are
In[57]:= XisAndMul[A4, T[Weight[A][0,1,0,0]]]
 
1 0 0 1 12
 
Out[57]:=  0 −1 1 1 6
 
2 −1 0 0 2
and the weight multiplicity of the dominant weight in the 40 of A4 is:
In[58]:= WeightMultiplicity[Weight[A][0,1,0,0], Irrep[A][0,0,1,1]]
Out[58]:= 2
The LieART function DominantWeightSystem[irrep] gives a list of the dominant weights of irrep along
with their multiplicities:
In[59]:= DominantWeightSystem[Irrep[A][0,0,1,1]]
!
0 0 1 1 1
Out[59]:=
0 1 0 0 2
22
Thus, the weight system of the 40 consists of the Weyl group orbit of 0 0 1 1 and 0 1 0 0 , where
every weight of the latter has a multiplicity of two. The function WeightSystem[irrep] generates these
orbits based on DominantWeightSystem and explicitly duplicates weights according to the multiplicity. If
no further processing is intended the option SpindleShape->True turns the output into a spindle shape
display, with weights of the same level in one row. E.g., the weight system of the 40 of A4 in spindle shape
is
In[60]:= WeightSystem[Irrep[A][0,0,1,1]]
0 0 1 1
0 0 2 −1 0 1 −1 2
0 1 0 0 0 1 0 0 1 −1 0 2
−1 0 0 2 0 1 1 −2 0 2 −2 1 1 −1 1 0 1 −1 1 0
−1 0 1 0 −1 0 1 0 0 2 −1 −1 1 −1 2 −2 1 0 −1 1 1 0 −1 1
Out[60]:= −1 0 2 −2 −1 1 −1 1 −1 1 −1 1 1 0 0 −1 1 0 0 −1 2 −2 0 1
−1 1 0 −1 −1 1 0 −1 0 −1 0 1 0 −1 0 1 1 1 −2 0 2 −2 1 −1
−2 0 0 1 −1 2 −2 0 0 −1 1 −1 0 −1 1 −1 2 −1 −1 0
−2 0 1 −1 0 0 −1 0 0 0 −1 0
−2 1 −1 0 1 −2 0 0
−1 −1 0 0
4.4.2. Properties of Irreducible Representations

Dimension. The dimension of an irrep, i.e., the number of its weights, can be calculated without explicitly
generating the weight system. The Weyl dimension formula, which is a special case of Weyl’s charac-
ter formula, gives the dimension of an irrep in terms of its highest weight Λ, positive roots α∈∆+ and
δ=(1, 1, . . . , 1):
Y (α, Λ + δ)
dim(Λ) = . (26)
+
(α, δ)
α∈∆
It is implemented in LieART as Dim[irrep]. E.g., the dimension of the 40 of A4 can be obtained by
In[61]:= Dim[Irrep[A][0,0,1,1]]
Out[61]:= 40
The Dynkin label of irrep does not need to be numerical. By using variables the simple structure of the
formula becomes explicit, e.g., for a general irrep of A4 :
In[62]:= Dim[Irrep[A][a,b,c,d]]
1
Out[62]:= (a + 1)(b + 1)(c + 1)(d + 1)(a + b + 2)(b + c + 2)(c + d + 2)(a + b + c + 3)(b + c + d + 3)(a + b + c + d + 4)
288
Internally, the Weyl dimension formula is computed by WeylDimensionFormula[algebra] as a pure func-
tion with the digits of the Dynkin label as parameters. E.g. for A4 :
In[63]:= WeylDimensionFormula[A4]//InputForm
Function[{a1,a2,a3,a4},((1+a1)*(1+a2)*(1+a3)*(1+a4)*(2+a1+a2)*(2+a2+a3)
Out[63]:=
*(2+a3+a4)*(3+a1+a2+a3)*(3+a2+a3+a4)*(4+a1+a2+a3+a4))/288]
The function Dim[irrep] acts only as a wrapper applying the pure function to the specified Dynkin label in
the argument of Dim.
Index. Another important property of an irrep Λ is its index, denoted as l(Λ), which is an eigenvalue of the
Casimir invariant normalized to be an integer:
dim(Λ)
l(Λ) = (Λ, Λ + 2δ) , (27)
ord(L)
23
where ord(L) is the order of the Lie algebra L, which is equivalent to the number of roots or the dimension
of the adjoint irrep. The index is related to the length of the weights and has applications in renormalization
group equations and elsewhere. The corresponding LieART function is Index[irrep]. E.g., the index of
the 40 of A4 is:
In[64]:= Index[Irrep[A][0,0,1,1]]
Out[64]:= 22
The label of irrep does not need to be numerical, similar to Dim.
Congruency Class. The congruency class expands the concept of n-ality of SU(N ), which in turn is a gener-
alization of SU(3) triality, to all other simple Lie algebras. LieART uses congruency classes to characterize
irreps, especially for the distinction of irreps of the same dimension and with the same index. We follow the
definitions of [8, 20], labeling the congruency class by the congruency number, which is a single number for
An , Bn , Cn , E6 , E7 , E8 , F4 and G2 and a two component vector for Dn . For an irreducible representation
(a1 a2 . . . an ) the congruency number (vector) c is:
n
X
An : c= kak (mod n + 1) (28a)
k=1
Bn : c = an (mod 2) (28b)
b n−1
2 c
X
Cn : c= a2k+1 (mod 2) (28c)
k=0
 
an−1 + an (mod 2)
Dn : c=
 b n−3
2 c

(28d)
P
a2k+1 + (n − 2)an−1 + nan (mod 4)

2
k=0
E6 : c = a1 − a2 + a4 − a5 (mod 3) (28e)
E7 : c = a4 + a6 + a7 (mod 2) (28f)
E 8 , F4 , G2 : c=0 (28g)
Please note that the congruency class definitions of [8, 20], which we use, differ from [7] for the Dn ’s : For
D4 , i.e. SO(8), the second component of [7] is half of the definition above. The congruency class for D5 is
only a single number in [7], which is the same as the second component of the D5 congruency class vector of
our definition from [8, 20] (with no factor of 2).
These congruency numbers (vectors) c are implemented as CongruencyClass[irrep] in LieART. E.g., the
congruency numbers of the three eight dimensional irreps of SO(8) are all distiguished by their congruency
number vector:
In[65]:= CongruencyClass[{Irrep[D][1,0,0,0], Irrep[D][0,0,1,0], Irrep[D][0,0,0,1]}]
Out[65]:= {(02),(12),(10)}
The head of a congruency vector is CongruencyVector and it is displayed as (c1 c2 ), i.e. without commas
separating the two components similar to the Dynkin label of irreps.
4.4.3. Representation Names

The Dynkin label of an irreducible representation together with its Lie algebra uniquely specifies it, e.g.,
(0011) of A4 . An irrep in LieART is also represented (FullForm) by the Dynkin label and a Mathematica
head that indicates the algebra class. E.g., the irrep (0011) of A4 is represented by Irrep[A][0,0,1,1]
in LieART.
However, it is common practice to name representations by their dimension, the dimensional name, which is
often times shorter. The dimension of a representation is not unique, i.e., there are different irreps with the
same dimensions, which might be accidental or because of a relation between them. If it is accidental, irreps
24
with the same dimension have primes (dim0 ) in their dimensional name, e.g., the 1750 of A4 is unrelated to
the 175. Irreps can be related by conjugation, when they are complex. One of the irreps is written with an
overbar (dim). E.g., the 10 of A4 is the conjugate of the 10. Due to the high symmetry of SO(8) irrep,
more than two related irreps of the same dimension exist. In the case of SO(8) subscripts specify the irreps
completely.
The introduced properties of representations, the dimension, the index and the congruency class serve us
well to discriminate between irreps with the same dimension. LieART has an algorithm implemented that
determines the dimensional name of an irrep, following the naming conventions of [7]:
1. To determine the dimensional name of a specific irrep, LieART collects other irreps of the same di-
mensionality by brute-force scanning through a generated set of irreps.
2. Irreps that are related by conjugation or the symmetry of SO(8) not only have the same dimension, but
also the same index. Unrelated irreps of equal dimension have different indices and can be organized
and labeled by their indices. They are sorted by ascending index and labeled with primes (dim0 )
accordingly, starting with no prime. E.g., the names of the two unrelated 70 dimensional irreps of A4
are (the congruency class of A4 is called “Quintality”):
Dynkin Dimension Index Quintality Name

(2001) 70 49 1 70
(0004) 70 84 1 700
3. Related irreps of the same dimensionality have the same index, but mostly (see below) different con-
gruency class numbers. For Lie algebras other than SO(8), only the conjugate of complex irreps are
related. The convention here is that the irrep with higher congruency class number of the conjugated
pair is labeled with an overbar (dim). Since e.g. the 700 is a complex irrep it has a related conjugated
0
irrep, the 70 , i.e., overbars and primes may both appear in the labeling of an irrep. The above table
for the determination of the primes involves only the lower congruency class number irreps of same
0
dimensional and same index irreps. Consider the 700 and its conjugate, the 70 :

(0004) 70 84 1 700
0
(4000) 70 84 4 70
If the congruency class number of a complex irrep is zero, it conjugate also has a congruency class
number of zero. In this case, where all three, the dimension, the index and the congruency class number
are the same, the structure of the Dynkin labels are consulted: With the Dynkin label interpreted as
digits of an integer number, the smaller “number” is labeled with the overbar. E.g., the 126 dimensional
irreps of A4 are

(2010) 126 105 0 126
(0102) 126 105 0 126
(5000) 126 210 0 1260
0
(0005) 126 210 0 126
0
Observe that this rule only applies for zero congruency class number: The 70 has a “larger” number
(4000) than the 700 with (0004).
4. For SO(8) irreps the convention for the labeling with primes are the same as for all other Lie algebras.
Due to the three-fold symmetry most irreps come in sets of three with the same dimension and index.
If only one digit of the Dynkin label is non-zero it is called the spinor, vector or conjugate irrep,
depending on the dot in the Dynkin diagram it corresponds to. Usually they can be distinguished by
the congruency class number, which is a two component vector for SO(8): (01) for a vector irrep, (10)
for a spinor and (11) for the conjugate. The irrep is then labeled by the subscripts “v”, “s” and “c”,
resp. E.g., the three 8 dimensional irreps of SO(8) are
25
Dynkin Dimension Index Congruency vector Name
(1000) 8 1 (01) 8v
(0001) 8 1 (10) 8s
(0010) 8 1 (11) 8c
Some irreps with more than one non-zero digit of the Dynkin label with the same congruency vectors
as above are labeled the same way if they are unique. However, if there is more than one irrep with
the same dimension, index and also congruency vector, there is more than one digit of the Dynkin
label non-zero. The subscript label is then a mixture like “sv”, and the ordering is determined by the
Dynkin digit beginning with the largest. E.g. the 224 dimensional irreps of SO(8):

(2010) 224 100 (12) 224vc
(2001) 224 100 (10) 224vs
(1020) 224 100 (02) 224cv
(1002) 224 100 (02) 224sv
(0021) 224 100 (10) 224cs
(0012) 224 100 (12) 224sc
There are also cases where the congruency vector is zero in both components for all irreps of the same
dimension and index. In this case subtracting the same integer from every Dynkin digit to obtain irreps
with non-zero congruency class vector has proven to be a reliable way to label the irreps. E.g., the
35 dimensional irreps can be related to the 8 dimensional ones and, e.g., the primed 840 dimensional
irreps to the 56 dimensional ones:

(1000) 8 1 (02) 8v
(0010) 8 1 (12) 8c
(0001) 8 1 (10) 8s
(2000) 35 10 (00) 35v
(0020) 35 10 (00) 35c
(0002) 35 10 (00) 35s
(1010) 56 15 (10) 56s
(1001) 56 15 (12) 56c
(0011) 56 15 (02) 56v
(2020) 840 540 (00) 8400s
(2002) 840 540 (00) 8400c
(0022) 840 540 (00) 8400v
In LieART the function DimName[irrep] determines the dimensional name according to the algorithm de-
scribed above, which is automatically displayed if an irrep is displayed in TraditionalForm. Several inter-
nal helper functions are called by DimName. The function GetIrrepByDim[algebra,dim,maxDynkinDigit]
provides irreps with the same dimension, which are then gathered into sublists by DimName. The function
SortSameDimAndIndex sorts the irreps of same dimension and index by their congruency class, and au-
tomatically by the Dynkin label viewed as “numbers”, if the congruency class numbers are the same. The
positions of the lists of same-index irreps determines the number of primes to apply and the position of
the irrep within the same-index list, whether it should be labeled by an overbar. In case of an SO(8) irrep
DimName branches to the function SO8Label[irrep], which uses SimpleSO8Label to give a subscript of
“v”, “s” and “c” in the case where the congruency vector in unique. If the congruency vector is not unique,
but non-zero, ConcatSO8Label concatenates the mixed subscripts like “sv” in the correct ordering. If the
congruency vector is zero in both components the irrep is related to irreps with non-zero congruency vector
by ReducedDynkinLabel.
26
Limitations. The determination of the primes has one limitation, which requires explanation: The function
GetIrrepByDim[algebra,dim,maxDynkinDigit] determines irreps of the same dimension. In a brute-force
fashion it generates “all” irreps and extracts only those that have the dimension dim. Since there are infinite
many irreps of any Lie algebra, it must be constrained. This is done by imposing a maximum Dynkin digit
to use for the generation of Dynkin labels. Since the numbers of possible Dynkin labels grow rapidly with
the maximum Dynkin digit allowed, the limit should be very low. To compare the irrep in question with
others it should be at least its maximum Dynkin digit, e.g., for (2031) it is “3”. The related irreps only have
a permutation of the Dynkin label, thus they are included in the generated list of irreps up to a Dynkin
digit of “3” in the example. However, for the determination of the primes for the unrelated irreps it may
not suffice to generate irreps only up to the maximum Dynkin digit of the irrep in question: The number of
primes are determined by the position in a list of same-dimensional irreps sorted by the index. If there is an
irrep with a higher maximal Dynkin digit, e.g., “4” in our example, but at the same time has a lower index
than the irrep it question, this procedure would give the irrep in question too few primes. This situation
rarely happens, especially in An ’s, but e.g. for G2 it happens as early as the 77 dimensional irrep:
Dynkin Dimension Index Congruency number Name

(30) 77 44 0 77
(02) 77 55 0 770
When determining the name of (02) of G2 the Dynkin labels would only be generated up to a maximum
Dynkin digit of “2”, the (30) would not appear and thus the (02) would be labeled without any prime. The
determination of the name of (30) would “see” the (02), but would determine no prime for (30) because
of its lower index compared to (02). For these two irreps the problem can be solved by generating irreps
up to the maximum Dynkin digit plus one for the irrep in question, i.e., up to “3” for (02). Because the
Dynkin label of a G2 irrep is small, this is easily manageable. In fact, we have implemented the addition of
three to the maximum Dynkin digit for G2 , because for some higher dimensions the problem will reappear.
However, for Lie algebras with long Dynkin labels, the number of generated Dynkin labels becomes large
and its construction slows LieART down and consumes a large amount of memory. We have found a balance
between accuracy and efficiency, which pushes this problem to very high dimensional irreps, by defining the
following number to add to the maximum Dynkin digit of the irrep in question: 1 for An ,Bn ,Cn and Dn with
n ≤ 4, 0 for An ,Bn ,Cn and Dn with n ≥ 5, 1 for E6 and F4 , 0 for E7 and E8 and 3 for G2 . Please note that
this limitation is only connected to the labeling of irreps with primes. Computations in LieART are always
performed using the Dynkin label as in the FullForm. If in doubt one can always use the Dynkin label
displayed in StandardForm, InputForm and FullForm which serves as the unique identifier of an irrep.
Besides its Dynkin label, the alternative definition of Irrep as Irrep[algebra][dimname] can be used
to specify an irrep by its dimensional name as dimname and its algebra as algebra. The algebra must be
fully specified, such as A4, SU5, E6, not only the algebra class such as A. The dimname is an integer for
the dimension with a Bar[dim] wrapped around it for a conjugated irrep or an IrrepPrime[dim,n] for
an irrep with n primes. If only one prime is needed the second argument n may be omitted. The Bar and
0
IrrepPrime can be combined in any sequence. E.g., the 175 can be entered by
In[66]:= Irrep[A4][IrrepPrime[Bar[175]]]//InputForm
Out[66]:= Irrep[A][0, 0, 2, 1]
Alternatives are Irrep[SU5][IrrepPrime[Bar[175]]], Irrep[SU5][Bar[IrrepPrime[175]]]
and Irrep[A4][IrrepPrime[Bar[175],1]]. Internally the function GetIrrepByDimName[algebra,
dimname] determines the corresponding Dynkin label. It uses the function GetIrrepByDim mentioned
above to find all irreps with the same dimension and then extract the irrep with the identical dimensional
name. If the user specifies an irrep that does not exist, e.g. an 11 of A4 , the comparison must stop at some
point. It has been chosen that GetIrrepByDim generates only irreps with a maximum Dynkin digit as set
by the global variable $MaxDynkinDigit. The default is $MaxDynkinDigit=3. The consequence is that
the determination of the correct Dynkin label of the entered irrep may abort, because the irrep does not
exist or that it involves a Dynkin digit higher that $MaxDynkinDigit=3. The latter is the case for the
700 with a Dynkin label of (0004). LieART prints an error message indicating the two possible scenarios:
27
In[67]:= Irrep[A4][IrrepPrime[70]]//InputForm
Irrep::noirrep: Either an irrep with the dimension name 700 does not exist
Out[67]:= in SU(5) or it has at least one Dynkin digit higher than 3. Try with
$MaxDynkinDigit set to a higher value than 3. »
Increasing $MaxDynkinDigit to 4 resolves the issue:
In[68]:= $MaxDynkinDigit=4;
Irrep[A4][IrrepPrime[70]]//InputForm
Out[68]:= Irrep[A][0,0,0,4]
4.5. Tensor Product Decomposition
DecomposeProduct[irreps] decomposes the tensor product of irreps

DominantWeightsAndMul[weights] filters and tallies dominant weights of
weights by multiplicities
SortOutIrrep[dominantWeightsAndMul ] sorts out the irrep of largest height from
the collection of dominant weights domi-
nantWeightsAndMul
WeightSystemWithMul[irrep] full weight system of irrep with multiplic-
ities
TrivialStabilizerWeights[weights] drops weights that lie on a chamber wall
ReflectToDominantWeightWithMul[weightAndMul ] reflects weightAndMul to the dominant
chamber and multiplies the parity of the
reflection to the multiplicity
Tensor product decomposition.
Tensor products of irreps can be decomposed into a direct sum of irreps. The product of two irreps R1 and
R2 can be decomposed as X
R1 ⊗ R2 = mi Ri (29)
i
with the following dimension and index sum rules:

X
dim(R1 ⊗ R2 ) = dim(R1 ) · dim(R2 ) = mi dim(Ri ) (30)
i
X
l(R1 ⊗ R2 ) = l(R1 ) dim(R2 ) + dim(R1 )l(R2 ) = mi l(Ri ). (31)
i
4.5.1. Generic Algorithm

A straight-forward method to compute the right-side of (29) is the following: Add all weights of R2 to each
weight of R1 . The resulting dim(R1 ) · dim(R2 ) weights belong to the different irreps Ri , which must be
sorted out. Instead of all weights, one can consider just the dominant weights in the product, as each of
the dominant weights represents an orbit in the irreps Ri . As an irrep is a collection of orbits, some of
the dominant weights in the product represent the highest weight of an irrep in the decomposition. There
is a unique dominant weight that represents the irrep of largest height in the decomposition. The sorting
procedure should start with this dominant weight viewed as the highest weight of an irrep and then construct
the dominant weight system of the corresponding irrep. The dominant weight system of the irrep with largest
height should then be subtracted from the combined dominant weights of the product to filter it out. The
same procedure is applied recursively to the remaining set of dominant weights until it is empty, i.e., all
irreps have been filtered out.
LieART provides the function DecomposeProduct[irreps] for the decomposition of the tensor product of
arbitrary many irreps of any classical or exceptional Lie algebra as argument. As a demonstration of generic
algorithm we consider the decomposition of the SU(3) tensor product 8⊗8, which is
28
In[69]:= DecomposeProduct[Irrep[SU3][8], Irrep[SU3][8]]
Out[69]:= 1 + 2(8) + 10 + 10 + 27
In the straight forward approach one adds all weights of the second 8 to each weight of the first 8, using
the built-in Mathematica function Outer. One filters out only the dominant weights and tallies multiple
occurrences thereof using the LieART function DominantWeightsAndMul[weights], which also sorts the
weights according to their height, when viewed as a highest weight of an irrep. For the SU(3) tensor product
8⊗8 the dominant weights along with their multiplicities are
In[70]:= DominantWeightsAndMul[Flatten[Outer[Plus, WeightSystem[Irrep[SU3][8]],
WeightSystem[Irrep[SU3][8]]]]]
 
2 2 1
 
 0 3 2
 
 3 0 2
 
Out[70]:=
 
 1 1 6
 
0 0 10
The dominant weight with the largest height 2 2 must be the highest weight of an irrep. The dominant
weight system of the (22) (the 27) of SU(3) is
In[71]:= DominantWeightSystem[Irrep[A][2, 2]]
 
2 2 1
 
 0 3 1
 
 3 0 1
 
Out[71]:=
 
 1 1 2
 
0 0 3
It contains all dominant weights appearing in the tensor product, but with mostly smaller multiplicities.
The irrep (22) can be filtered out by subtracting the multiplicities in Out[71] from Out[70]. The LieART
function SortOutIrrep[dominantWeightsAndMul ] performs the task of computing the dominant weight
system of the irrep corresponding to the largest height weight and subtracting it from the tensor product. It
returns the dominant weights of the tensor product with the ones of the irrep removed and passes the latter
using the Sow and Reap mechanism of Mathematica:
In[72]:= Reap[SortOutIrrep[%%]]
 
0 3 1
 
 3 0 1
Out[72]:= {
 1 1
 , (27)}
 4

0 0 7
The function SortOutIrrep is applied recursively until the list of dominant weights with multiplicities of
the tensor product is empty. E.g., applying SortOutIrrep to the dominants weights of Out[72] filters
out the (03) (the 10) of SU(3):
In[73]:= Reap[SortOutIrrep[First[%]]]
 
3 0 1
 
Out[73]:= {
 1 1  , (10)}
3
0 0 6
The irreps filtered out by SortOutIrrep are collected by the LieART function GetIrreps and can be
displayed as the result of the decomposition. However, LieART computes the tensor product decomposition
by an implementation of Klimyk’s formula, which is far more efficient than the straight-forward procedure
described above, but the sorting-out algorithm is still used for subalgebra decomposition in Section 4.6.
29
4.5.2. Algorithm Based on Klimyk’s Formula
Adding all weights of R2 to each weight of R1 is costly for large irreps. LieART’s algorithm to decom-
pose tensor-product implements Klimyk’s formula [21, 22], which improves the runtime of tensor product
decompositions considerably: Let λ1 and λ2 be weights and Λ1 and Λ2 the highest weights of R1 and R2 ,
respectively. Instead of adding all weights λ1 to each weight λ2 , the weights λ1 are added only to the highest
weight Λ2 of R2 together with half the sum of positive simple roots, δ=(1, . . . , 1), building the set of weights
µ = λ1 + Λ2 + δ. (32)
Each µ is reflected to the dominant chamber, yielding a highest weight denoted as {µ}, with sgn(µ) as the
parity of the reflection. Of these dominant weights all that lie on a chamber wall are dropped. The irreps in
the decomposition are R({µ} − δ). Klimyk’s formula reads
X
R1 (Λ1 ) ⊗ R2 (Λ2 ) = m1λ1 t(λ1 + Λ2 + δ)R({λ1 + Λ2 + δ} − δ), (33)
λ1
where m1λ1 denotes the multiplicity of λ1 in R1 . We define t(µ) to be sgn(µ) if µ has a trivial-stabilizer
subgroup Stab(µ) = {1} (see (24)), and zero if the stabilizer subgroup is non-trivial, i.e. the weight lies on
a chamber wall:
sgn(µ) : Stab(µ) = {1}

t(µ) = . (34)
0 : else
We will demonstrate this algorithm with LieART in the following paragraphs.
As a demonstration of the algorithm implemented we consider the decomposition of the SU(3) tensor product
6⊗3, which is
In[74]:= DecomposeProduct[Irrep[SU3][6], Irrep[SU3][3]]
Out[74]:= 8 + 10
LieART normally reorders the arguments of DecomposeProduct by their dimension, which usually sim-
plifies the application of Klimyk’s formula. But for didactical reasons we assume in the following that the
irreps are not reordered. LieART generates the weight system with weight multiplicities of the 6:
In[75]:= WeightSystemWithMul[Irrep[SU3][6]]
 
2 0 1
 −2 2
 
1
 
 0 −2 1
 
Out[75]:=  
 0 1 1
 
 1 −1 1
 
−1 0 1
We add all weights of the 6 to the highest weight of the 3, i.e. HighestWeight[Irrep[SU3][3]] = 1 0 ,
and Delta[SU3]= 1 1 , according to (32). The highest weight Λ2 and δ can be added directly, but to add
the sum to all weights in the weight system with multiplicities LieART provides the command Add:
In[76]:= mu = Add[WeightSystemWithMul[Irrep[SU3][6]], HighestWeight[Irrep[SU3][3]] +
Delta[SU3]]
 
4 1 1
 
 0 3 1
 
 2 −1 1
 
Out[76]:=  
 2 2 1
 
 3 0 1
 
1 1 1
LieART reflects these weights to the dominant chamber yielding the corresponding dominant weights and
30
the parity of the reflection, i.e. sgn(µ) = (−1)l , where l is the number of reflections needed to reach the
dominant chamber:
In[77]:= ReflectToDominantWeightWithMul /@ mu
 
4 1 1
 
 0 3 1 
 
 1 1
 − 1

Out[77]:=  
 2 2 1 
 
 3 0 1 
 
1 1 1
The weights 4 1 , 0 3 , 2 2 , 3 0 and 1 1 were already in the dominant chamber, while 2 − 1

needed one reflection to become the dominant weight 1 1 with a parity of −1.
Weights on walls of the dominant chamber do not contribute in Klimyk’s formula and must be dropped.
Weights not lying on a chamber wall have a trivial-stabilizer subgroup. To keep only these weights LieART
applies the command TrivialStabilizerWeights, which drops all weights containing at least one zero
anywhere in their Dynkin label, which corresponds to lying on a chamber wall:
In[78]:= TrivialStabilizerWeights[ReflectToDominantWeightWithMul /@ mu]
 
4 1 1
− 1
 
 1 1
Out[78]:= 
 2 2

 1 

1 1 1
LieART subtracts δ yielding highest weights and constructs the irreps in the decomposition R({λ1 +Λ2 +δ}−δ):
In[79]:= ToIrrep/@Add[TrivialStabilizerWeights[ReflectToDominantWeightWithMul/@mu],
-delta]
 
10 1
1 − 1
Out[79]:= 
8

1 
1 1
While the irreps in the left column correspond to R({λ1 + Λ2 + δ} − δ) in Klimyks formula, the multiplicities
in the right column correspond to m1λ1 sgn(λ1 + Λ2 + δ). Summing up the decomposition accordingly we
see that the 1 drops out and we obtain the result 8 + 10 as already stated in Out[74].
4.5.3. SU(N ) Decomposition via Young Tableaux

A correspondence of SU(N ) irreps and Young tableaux is very useful for the calculation of tensor products
and subalgebra decomposition by hand. We have found that the algorithm for the SU(N ) tensor product
decomposition via Young tableaux also performs better on the computer, with respect to CPU time and
memory consumption, than the procedure described in the previous section. Thus, LieART uses the Young
tableaux algorithm for the tensor-product decomposition of SU(N ) irreps and the procedure of adding weights
and filtering out irreps for all other classical and exceptional Lie algebras.
A Young tableau is a left-aligned set of boxes, with successive rows having an equal or smaller number of
boxes. Young tableaux correspond to the symmetry of the tensors of SU(N ) irreps, by first writing each index
of the tensor into one box of a Young tableau and the prescription that they ought to be first symmetrized
in the rows and then antisymmetrized in the columns. Please see Out[31] in Section 3 for a non-trivial
example for a Young tableau displayed by LieART.
To demonstrate the algorithm for the tensor product decomposition via Young tableaux we use the same
SU(3) tensor product as in Section 4.5.1, 8⊗8.
The construction principle (by hand) is to put the Young tableau with the most boxes to the left and bump
all boxes of the right Young tableau row by row to the left one following certain rules. To understand these
31
rules label the boxes of each row of the right Young tableau alphabetically:
8⊗8 = ⊗ a a (35)
b
Bump the boxes of the first row of the right tableau (labeled with a’s) to the ends of the left tableau to form
valid Young tableaux and the additional condition that no a’s are in the same column, as this would change
symmetric indices to antisymmetric ones. (see crossed out tableau, which is also not a valid SU(3) tableau,
because it has four (or N +1 in general for SU(N )) boxes in a column):
 
a
⊗ a a = a a ⊕ a ⊕ (36)
 
⊕ a ⊕  ⊗ b
b  a a
a a
a
As the next step bump the boxes of the next row to all tableaux obtained by the first step obeying the same
rules, but keep only tableaux with an admissible sequence of letters, when reading the letters from right to
left, row by row. A sequence of letters is admissible if at any point at least as many a’s have occurred as b’s
and likewise for b’s and c’s, etc. The sequences abcd, aaabc, abab are admissible, but abba, acb are not. In
our example only the sequence baa is not admissible, which appears in the four crossed-out tableaux:
a a
⊗ a a =
a
a
b ⊕ a a ⊕ ⊕
b b
b
a
a
b ⊕ a ⊕ ⊕

a a
a b
b
(37)
a
b
a
⊕ ⊕

b
a

a
b
a ⊕ a
a a b
Removing the labeling with a’s and b’s, we obtain the SU(3) tensor product decomposition of 8⊗8 in terms
of Young tableaux:
⊗ = ⊕ ⊕ ⊕ ⊕ ⊕ (38)
Finally we knock out triples (full columns with three boxes) to find:
⊗ = ⊕ ⊕ ⊕ ⊕ ⊕ •
(39)
8 ⊗ 8 = 27 ⊕ 10 ⊕ 10 ⊕ 8 ⊕ 8 ⊕1
In LieART the Young tableau algorithm is automatically applied to tensor products of SU(N ) irreps using
DecomposeProduct[irreps]. After sorting the irrep with fewer boxes to the right (which we will call irrep2
opposed to the first one named irrep1 ), the function processes through irrep2 ’s rows to bump boxes to irrep1 .
The function BoxesToBump[irrep2 , row ] gives the number of boxes in the current row to bump to the
tableau of irrep1 . The function AllowedRows[irrep1 , nboxes] determines the rows of irrep1 that are
allowed to bump boxes to yielding a valid young tableau with an admissible sequence. The latter is checked
by the helper function AllowedCombination. The function AddToTableau[irrep1 , rowcombinations]
performs the bumping of the boxes of one row of irrep2 in all allowed combinations (rowcombinations) to
irrep1 . The result of the bumping is directly expressed in terms of a changed Dynkin label.
32
4.6. Subalgebra Decomposition
DecomposeIrrep[irrep, subalgebra] decomposes irrep to the specified subal-

gebra.
DecomposeIrrep[productIrrep, subalgebra, pos] decomposes productIrrep at position
pos.
ProjectionMatrix[origin,target] defines the projection matrix for the
algebra-subalgebra pair specified by ori-
gin and target
Project[projectionMatrix ,weights] applies the projectionMatrix to the
weights
GroupProjectedWeights[projectedWeights,target] groups the projected weights according
to the subalgebra specified in target
NonSemiSimpleSubalgebra[origin,simpleRootToDrop] computes the projection matrix of a
maximal non-semi-simple subalgebra by
dropping one dot of the Dynkin diagram
simpleRootToDrop and turning it into a
U(1) charge
SemiSimpleSubalgebra[origin,simpleRootToDrop] computes the projection matrix of
a maximal semi-simple subalgebra by
dropping one dot from the extended
Dynkin diagram.
ExtendedWeightScheme[algebra,simpleRootToDrop] adds the Dynkin label associated with
the extended simple root −γ to each
weight of the lowest orbit of algebra
and drops the simple root simpleRoot-
ToDrop
SpecialSubalgebra[origin,targetirreps] computes the projection matrix of a
maximal special subalgebra by specify-
ing the branching rule of the generating
irrep.
Subalgebra decomposition of irreps and product algebra irreps.
The LieART function DecomposeIrrep[irrep, subalgebra] decomposes an irrep of a simple Lie algebra
into a maximal subalgebra specified by subalgebra, which can be simple, semi-simple or non-semi-simple. To
decompose an irrep of a semi-simple or non-semi-simple irrep, a third argument pos allows one to specify
which part of productIrrep should be decomposed into the subalgebra.
The implementation of DecomposeIrrep in LieART uses so-called projection matrices. These matrices
project the weights of an irrep into the specified subalgebra. The resulting weights are further processed
in the same manner as in Section 4.6: Only the dominant weights of the decomposed weights are kept,
because they uniquely define the orbits of the subalgebra and thus its irreps. In the next step the irreps
comprised in the collection of dominant weights are sorted out using the same LieART functions as for
the generic tensor product decomposition, discussed in section 4.5.1. It is clear that the major task is the
determination of the projection matrices. They are different for each algebra-maximal-subalgebra pair and
are not unique. I.e., a projection is not unique and thus the matrices are not unique in general. Our
matrices are correct and consistent, but one may find different projection matrices in the literature, which
are also correct. (An extensive collection of projection matrices can be found in [23] for the Lie algebra An
and in [24] for the Lie algebras Bn , Cn and Dn .) Once a projection matrix is known it can be used for
the decomposition of all irreps of the algebra-maximal-subalgebra pair. E.g., the projection matrix for the
branching SU(5) → SU(3)⊗SU(2)⊗U(1) is
In[80]:= ProjectionMatrix[SU5,ProductAlgebra[SU3,SU2,U1]]
33
 
1 0 0 0
0 1 0 0
Out[80]:= 
0

0 0 1
2 4 6 3
The determination of the projection matrices is closely connected to the problem of finding maximal subalge-
bras and we defer the description of its implementation in LieART to the next section. Taking the projection
matrix Out[80] as given we demonstrate the algorithm of DecomposeIrrep to find the branching rule
for the 10 of SU(5) to SU(3)⊗SU(2)⊗U(1), which is
In[81]:= DecomposeIrrep[Irrep[SU5][10],ProductAlgebra[SU3,SU2,U1]]
Out[81]:= (1, 1)(−6) + (3, 1)(4) + (3, 2)(−1)
The LieART function Project[projectionMatrix ,weights] applies the projectionMatrix to each of the
weights and a subsequent GroupProjectedWeights[projectedWeights,target] groups the Dynkin label
of each of the projectedWeights according to the subalgebra specified by target. In the case of our example
each weight of the 10 of SU(5) decomposes to SU(3)⊗SU(2)⊗U(1) as:
In[82]:= IrrepRule @@@ Transpose[{WeightSystem[Irrep[SU5][10]],
Row/@GroupProjectedWeights[Project[ProjectionMatrix[SU5,
ProductAlgebra[SU3,SU2,U1]],WeightSystem[Irrep[SU5][10]]],
ProductAlgebra[SU3,SU2,U1]]}]
0 1 0 0 → 0 1 0 4
1 −1 1 0 → 1 −1 0 4
−1 0 1 0 → −1 0 0 4
1 0 −1 1 → 1 0 1 −1
−1 1 −1 1 → −1 1 1 −1
Out[82]:=
1 0 0 −1 → 1 0 −1 −1
−1 1 0 −1 → −1 1 −1 −1
0 −1 0 1 → 0 −1 1 −1
0 −1 1 −1 → 0 −1 −1 −1
0 0 −1 0 → 0 0 0 −6
The algorithm of DecomposeIrrep differs slightly and keeps only the dominant weights after projection
and groups only them yielding
 
0 1 0 4
 1 0 1 −1  (40)
 
0 0 0 −6
for our example. A combination of the functions GetAllProductIrrep and GetProductIrrep filter
out the product irreps, (3, 1)(4), (1, 1)(−6) and (3, 2)(−1) in our case, by applying the function GetIrrep
known from section 4.5.1 to the weights.
4.6.1. Branching Rules and Maximal Subalgebras

To determine the projection matrices we start with the algorithm to find maximal subalgebras. Subalgebras
fall into two classes: regular and special subalgebras, with the first one being further categorized into non-
semisimple and semisimple subalgebras. In the following we describe the derivation of the three types
of maximal subalgebras: regular non-semisimple, regular semisimple and special subalgebras, originally
developed by Dynkin [1, 2] and demonstrate how it is utilized by LieART to determine the projection
matrices.
Non-Semisimple Subalgebras. A non-semisimple subalgebra is a semisimple subalgebra times a U(1) fac-

tor, e.g. SU(3)⊗SU(2)⊗U(1). A subalgebra of this type is obtained by removing a dot from the Dynkin
diagram. The resulting two or more disconnected Dynkin diagrams symbolize the semisimple subalgebra
34
and the removed dot, i.e., simple root, becomes the U(1) generator. E.g., the non-semisimple subalgebra
SU(3)⊗SU(2)⊗U(1) can be obtained from SU(5) by removing the third dot from its Dynkin diagram:
SU(5) SU(3) U(1) SU(2)
1 2 3 4 1 2 1
Since the Dynkin label of a weight represents it composition of simple roots (explicitly in the α-basis),
dropping a simple root (dot) from the Dynkin diagram corresponds to dropping the associated digit from
the Dynkin label. The U(1) charge is the coefficient of the dropped simple root in the weight’s linear
combination of simple roots, i.e., the associated digit of the Dynkin label in the α-basis, which is often
normalized to give integer values. Accordingly, in Out[82] the third Dynkin digit of the weight of the 10
has been removed after the projection and by expressing the weight system in the α-basis
In[83]:= AlphaBasis[WeightSystem[Irrep[SU5][10]]]//Column
(3/5, 6/5, 4/5, 2/5)
(3/5, 1/5, 4/5, 2/5)
(-2/5, 1/5, 4/5, 2/5)
(3/5, 1/5, -1/5, 2/5)
(-2/5, 1/5, -1/5, 2/5)
Out[83]:=
(3/5, 1/5, -1/5, -3/5)
(-2/5, 1/5, -1/5, -3/5)
(-2/5, -4/5, -1/5, 2/5)
(-2/5, -4/5, -1/5, -3/5)
(-2/5, -4/5, -6/5, -3/5)
we see that the U(1) charge at the end are the third coordinate of the weight in the α-basis multiplied by
5 to give integer values. To summarize, the third Dynkin digit has been moved to the end (i.e., third and
forth digits have been interchanged) and only it has been projected into the α basis and rescaled.
Writing the weights of the 10 as columns of a matrix Ŵ and the weights with the third digit expressed in
non-normalized α-basis coordinates moved to the end as rows of a matrix Ŵ 0 , the projection matrix P̂ can
be determined from
P̂ Ŵ = Ŵ 0 (41)
with the right-inverse Ŵ+ of Ŵ (see section 4.1.4), since Ŵ is in general not a rectangular matrix:
P̂ = Ŵ 0 Ŵ+ . (42)
As mentioned above the projection matrix found by this procedure can now be used to decompose any SU(5)
irrep into SU(3)⊗SU(2)⊗U(1). The 10 is actually not the smallest irrep needed for the determination of the
projection matrix. The 10 as well as all other irreps can be built from tensor products of the 5, which we
call the generating irrep of SU(5). In the orthogonal algebras only tensor products of the so-called spinor
representations can construct all other irreps of the algebra. Thus, they must be used for the determination
of the projection matrices. The generating irreps of representative Lie algebras are listed in Table 4.2.
In fact LieART excludes the zero-weights from the generating irreps, if any, i.e., only the lowest non-trivial
orbit is needed for the determination of the projection matrices.
The calculation of a projection requires the knowledge of the simple root to drop from the Dynkin diagram for
a specified algebra-subalgebra pair. LieART provides an extra package file called BranchingRules.m, list-
ing this information for the implemented branching rules along with special embeddings to be discussed later.
The file will be extended to encompass more branching rules in future versions of LieART, but may also be
extended by the user. The definition for the more general branching rule SU(n) → SU(N −k)⊗SU(k)⊗U(1),
including the demonstrated case SU(5) → SU(3)⊗SU(2)⊗U(1), reads:
ProjectionMatrix[origin:Algebra[A][n_],
ProductAlgebra[Algebra[A][m_],Algebra[A][k_],Algebra[U][1]]] :=
NonSemiSimpleSubalgebra[origin,-k-1] /; m==(n-k-1)
35
Algebra Irrep Irrep
(Dynkin) (Name)
A4 (SU(5)) (1000) 5
B4 (SO(9)) (0001) 16
C4 (Sp(8)) (1000) 8
D4 (SO(8)) (0001) 8s
E6 (100000) 27
E7 (0000010) 56
E8 (00000010) 248
F4 (0001) 26
G2 (10) 7
Table 4.2: Generating Irreps of representative Lie algebras
Semisimple Subalgebras. To obtain a semisimple subalgebra without a U(1) generator, a root from the so-
called extended Dynkin diagram is removed. The extended Dynkin diagram is constructed by adding the
most negative root to the set of simple roots. (The negative of the highest root γ gives the most negative root
−γ to form the extended Dynkin diagram.) The resulting set of roots is linearly dependent, but removing
one root restores the linear independence yielding a valid system of simple root of a subalgebra, which in
general is semisimple. The highest roots γ and the according extended root −γ for representative Lie algebras
are listed in Table 4.3. The non-zero entries in the Dynkin label of −γ prescribe to which existing dot in
Algebra Highest Root Extended Root

(γ) (−γ)
A4 (SU(5)) 1 0 0 1 −1 0 0 −1
B4 (SO(9)) 0 1 0 0 0 −1 0 0
C4 (Sp(8)) 2 0 0 0 −2 0 0 0
D4 (SO(8)) 0 1 0 0 0 −1 0 0
E6 0 0 0 0 0 1 0 0 0 0 0 −1
E7 1 0 0 0 0 0 0 −1 0 0 0 0 0 0
E8 0 0 0 0 0 0 1 0 0 0 0 0 0 0 −1 0
F4 1 0 0 0 −1 0 0 0
G2 0 1 0 −1
Table 4.3: Highest roots γ and most negative roots −γ of representative Lie algebras.
the Dynkin diagram it should connect, since the Dynkin label in the ω-basis encode the angle between two
simple roots. A “1” is an angle of 120°, symbolized by a single connected line in the Dynkin diagram. A “2”
is an angle of 135°, expressed by a double line in the Dynkin diagram. The minus sign gives negative angles
or reverses the order of roots. The extended Dynkin diagrams for all classical and exceptional Lie Algebras
are shown in Figure 2. Please note that the double line connecting the extended root −γ for Cn is according
to the “−2” in its Dynkin label.
To demonstrate the determination of the projection matrix from using the generating irrep, we cannot use an
irrep of SU(N ), because dropping a root from the extended Dynkin diagram of SU(N ) returns SU(N ). Thus,
SU(N ) has no regular maximal semisimple subalgebra. (Please note that some SU(N )’s have special maximal
semisimple subalgebras, e.g., SU(4) → SU(2)⊗SU(2).) Instead we consider the subalgebra branching of
SO(7)→SU(2)⊗SU(2)⊗SU(2) (B3 →A1 ⊗A1 ⊗A1 ). The maximal subalgebra SU(2)⊗SU(2)⊗SU(2) is obtained
from the extended Dynkin diagram of SO(7) (B3 ) by removing the second dot:
36
−γ
−γ
6
An E6
1 2 3 n−1 n 1 2 3 4 5
1 7
2 3 4 n−1 n
Bn E7
−γ 1 2 3 4 5 6
−γ 8
−γ 1 2 3 n−1 n
Cn E8
1 2 3 4 5 6 7 −γ
1
n−1 F4
2 3 4 n−2
−γ 1 2 3 4
Dn
n G2
−γ
−γ 2 3
Figure 2: Extended Dynkin Diagrams of classical and exceptional simple Lie algebras.
1
SU(2) SU(2) SU(2)
2 3
SO(7)
1 1 1
−γ
To derive the projection matrix, we investigate the decomposition of the SO(7) generating irrep (the 8)
into three SU(2)s. Extending the Dynkin diagram with −γ has the effect that each weight w gets extended
by one entry with the coefficient of the weight relative to −γ, obtained by their scalar product: (w, −γ).
The so-called extended weight scheme of the lowest non-trivial orbit of a generating irrep is determined
by the LieART function ExtendedWeightScheme[algebra,simpleRootToDrop], which directly removes
the Dynkin digits associated to the simple root to drop, specified by simpleRootToDrop. For the lowest
non-trivial orbit of the generating irrep of SO(7) these two steps are:
0 0 1 0 −1 0 1 0 −1 1
0 1 −1 0 −1 1 −1 0 −1 −1
1 −1 1 1 0 −1 1 1 0 1
−1 0 1 insert −γ −1 0 0 1 drop 2 −1 0 1
−−−−−−→ −−−−→ (43)
1 0 −1 1 0 0 −1 1 0 −1
−1 1 −1 −1 0 1 −1 −1 0 −1
0 −1 1 0 1 −1 1 0 1 1
0 0 −1 0 1 0 −1 0 1 −1
With the weight of the SO(7) generating irrep as columns of the matrix Ŵ and the weights in the 3 SU(2)
decomposition (right-hand side of (43)) as columns of Ŵ 0 the projection matrix P̂ is computed as described
for non-semisimple regular subalgebras as P̂ =Ŵ 0 Ŵ+ with the right-inverse Ŵ+ of Ŵ .
37
The definition for the branching rule SO(7)→SU(2)⊗SU(2)⊗SU(2) in the file BranchingRules.m reads:
ProjectionMatrix[origin:Algebra[B][3],
ProductAlgebra[Algebra[A][1],Algebra[A][1],Algebra[A][1]]]:=
SemiSimpleSubalgebra[origin,2]
Special Subalgebras. Special maximal subalgebras cannot be derived from the root system. The embedding
of a special subalgebra does not follow a general pattern and must be derived for every algebra-subalgebra
pair individually. Generating irreps are also used to derive the subalgebra embedding, which may be simple
or semisimple and can involve more than one irrep of the subalgebra. LieART is not equipped with an
algorithm to determine the maximal special subalgebras, but provides an interface to declare the embeddings
(BranchingRules.m), which can be taken from the literature [7, 8].
As an example we consider SO(7) (B3 ) again, which has G2 as special maximal subalgebra. The generating
spinor irrep of SO(7), the 8, decomposes to the G2 singlet plus the 7. The weights of the 8 of SO(7) and
the weights of both the 1 and 7 of G2 are brought into lexicographical order to define the projection matrix:
1 0 −1 → 2 −1
1 −1 1 → 1 0
0 1 −1 → 1 −1
0 0 1 → 0 0
(44)
0 0 −1 → 0 0
0 −1 1 → −1 1
−1 1 −1 → −1 0
−1 0 1 → −2 1
Arranging the weights on the left-hand side of (44) as columns of Ŵ and the weights of the right-hand side
as columns of Ŵ 0 , the projection matrix P̂ is again computed via P̂ =Ŵ 0 Ŵ+ with the right-inverse Ŵ+ of
Ŵ .
These procedures are performed by the LieART function SpecialSubalgebra[origin,targetirreps]. The
definition for the branching rule SO(7)→G2 in the file BranchingRules.m reads:
ProjectionMatrix[origin:Algebra[B][3],ProductAlgebra[G2]]:=
SpecialSubalgebra[origin,
{ProductIrrep[Irrep[G2][0,0]],ProductIrrep[Irrep[G2][1,0]]}]
Please note that irreps of the subalgebra must be gathered in a list ({. . . }), even if it is a single irrep. The
projection matrix for SO(7)→G2 is
In[84]:= ProjectionMatrix[B3,ProductAlgebra[G2]]

2 1 0
Out[84]:=
−1 −1 0
38
5. Benchmarks
In this section we give runtime benchmarks for the tensor-product decomposition. Because exceptional
algebras have complicated Weyl reflection groups of high orders, computations involving them are much
more CPU and memory demanding than with classical algebras of equal rank. In Table 5.1 we give runtime
benchmarks for the tensor-product decomposition of exceptional algebra irrep powers. We compute 27 n
for n = 2, . . . , 8 and 78 n for n = 2, . . . , 7 in E6 and 248 n for n = 2, . . . , 7 in E8 . For the timings we
use the Mathematica command Timing[], which gives the CPU time spent in the Mathematica kernel
in seconds. The command Timing[] does not include the time needed for the display of results in the
front end. As pointed out in Section 4.4.3, in TraditionalForm irreps are displayed by their dimensional
names, while computations are performed by their Dynkin labels. The determination of the dimensional
name can be very time consuming depending on the algebra and the irrep. This time is allotted to the
display of computation results and thus not measured with Timing[]. For most of the examples in Table
5.1 computed in TraditionalForm you will find significant differences between the displayed time and
the wall-clock time due to this effect, but this is intended as we want to give an estimate of the actual time
needed for decompositions and not the display of results. With StandardForm as output setting this effect
can be circumvented since this will display only the Dynkin digits of the irreps that are used internally and
no dimensional-name determination is performed.
Please note that each of the timings in Table 5.1 are taken with a newly launched Kernel to avoid speedup
due to caching of intermediate results from previous computations.
Product n # Terms Timing (s)

27 nE6 2 3 0.14
3 6 0.14
4 11 0.44
5 19 0.72
6 34 1.5
7 52 13
8 82 94
78 nE6 2 5 0.18
3 11 0.20
4 26 2.3
5 49 5.3
6 93 15
7 158 330
248 nE8 2 5 0.85
3 10 0.88
4 20 32
5 35 50
6 62 90
7 102 7600
Table 5.1: Timings for tensor product decomposition of powers of 27 E6 , 78 E6 and 248 E8 . The second column gives the
power and the third the number of terms in the decomposition (i.e., the number of distinct irreps in the decomposition, where
the multiplicity can be quite high. For example there are 630 copies of the 1728 irrep in 277 of E6 .). The last column shows
the timing of the computation in seconds taken with Mathematica 8.0.1 on an Apple® iMac® with an Intel® Core™ i5 750
(2.66 GHz) processor and 4 GB RAM.
39
6. LATEX Package
LieART comes with a LATEX package (lieart.sty in the subdirectory latex/) that defines commands
to display irreps, roots and weights properly (see Table 6.1), which are displayed by LieART using the
LaTeXForm on an appropriate expression, e.g.:
In[85]:= DecomposeProduct[Irrep[SU3][8],Irrep[SU3][8]]//LaTeXForm
Out[85]:= $\irrep{1}+2(\irrep{8})+\irrep{10}+\irrepbar{10}+\irrep{27}$
Command Example Output Description

\irrep{10} 10 dimensional name of irrep
\irrepbar{10} 10 dimensional name of conjugated irrep
\irrep[2]{175} 17500 number of primes as optional parameter
\irrepsub{8}{s} 8s irrep with subscript, e.g., irreps of SO(8)
\irrepbarsub{10}{a} 10a conjugated irrep with subscript, e.g., for labeling anti-
symmetric product
\dynkin{0,1,0,0} (0100) Dynkin label of irrep
\dynkincomma{0,10,0,0} (0, 10, 0, 0) for Dynkin labels with at least one digit larger then 9
(also available as \root, \rootorthogonal,
\weightalpha and \weightorthogonal
for negative integers)
\weight{0,1,0,-1} 0 1 0 −1 weight in ω-basis
\rootomega{-1,2,-1,0} −1 2 −1 0 root in ω-basis
Table 6.1: LATEX commands defined in supplemental style file lieart.sty
7. Conclusions and Outlook
We have programmed the Mathematica application LieART, which brings Lie-algebra and representation-
theory related computations to Mathematica. It provides functions for the decomposition of tensor products
and branching rules of irreducible representations, which are of high interest in particle physics, especially
unified model building. LieART exploits the Weyl reflection group in most of its applications, making it fast
and memory efficient. The user interface focuses on usability, allowing one to enter irreducible representations
by their dimensional name and giving results in textbook style. We have reproduced and extended existing
tabulated data on irreducible representations, their tensor products and branching rules.
In future versions we plan to add more branching rules to LieART. Currently, only a selection of common
branching rules used in the tables are implemented. We consider the tables given as online supplementary
material as dynamical: They are included in LieART as Mathematica notebooks and can easily modified and
extended by the user. Tables for algebras of high rank and/or higher dimensional irreducible representations
have large CPU time and high memory consumption. Nevertheless, we plan to extend the tables even further
and make them available online in a standard format (pdf and/or html).
8. Acknowledgments
We thank Carl Albright for many useful discussions that led to the development of LieART. We also thank
Tanja Feger for checking the tables against those found in [7]. We thank Savdeep Sethi and Bruce Westbury
for runtime comparisons with LiE [12], which led to the implementation of Klymik’s formula for tensor
products. We thank Florian Hartmann, Constantin Sluka and Giulia Ferlito for reporting bugs in the initial
version.
Most of the work was performed while RPF was affiliated with the Department of Physics and Astronomy,
Vanderbilt University, Nashville, and his work was supported by a fellowship within the Postdoc-Programme
of the German Academic Exchange Service (DAAD). The work of RPF and TWK was supported by US
DOE grant # E-FG05-85ER40226. The work of TWK was also supported by DoE grant # DE-SC0011981.
40
References
[1] E. Dynkin, Semisimple subalgebras of semisimple Lie algebras, Trans.Am.Math.Soc. 6 (1957) 111.
[2] E. Dynkin, Maximal subgroups of the classical groups, Trans.Am.Math.Soc. 6 (1957) 245.
[3] H. Georgi, S. Glashow, Unity of All Elementary Particle Forces, Phys.Rev.Lett. 32 (1974) 438–441.
doi:10.1103/PhysRevLett.32.438.
[4] H. Georgi. Particles And Fields: Williamsburg 1974. AIP Conference Proceedings No. 23 - C. E. Carlson
(eds.).
[5] H. Fritzsch, P. Minkowski, Unified Interactions of Leptons and Hadrons, Annals Phys. 93 (1975) 193–
266. doi:10.1016/0003-4916(75)90211-0.
[6] F. Gursey, P. Ramond, P. Sikivie, A Universal Gauge Theory Model Based on E6, Phys.Lett. B60 (1976)
177. doi:10.1016/0370-2693(76)90417-2.
[7] R. Slansky, Group Theory for Unified Model Building, Phys.Rept. 79 (1981) 1–128. doi:10.1016/
0370-1573(81)90092-2.
[8] W. G. McKay, J. Patera, Tables of dimensions, indices, and branching rules for representations of simple
Lie algebras, Lecture Notes in Pure and Applied Mathematics, Dekker, New York, NY, 1981.
[9] H. Georgi, Lie Algebras in Particle Physics. from Isospin to Unified Theories, Front.Phys. 54 (1982)
1–255.
[10] P. Ramond, Group theory: A physicist’s survey, Cambridge University Press, Cambridge, UK, 2010.
[11] R. Cahn, Semi-simple lie algebras and their representations, Vol. 59 of Front.Phys., Benjamin Cummings,
Menlo Park, CA, 1984.
[12] M. van Leeuwen, A. Cohen, B. Lisser, LiE, A Package for Lie Group Computations, Computer Algebra
Nederland, Amsterdam, 1992.
URL http://young.sp2mi.univ-poitiers.fr/~marc/LiE/
[13] B. G. Wybourne, Schur (2002).
URL http://smc.vnet.net/Schur.html
[14] T. Nutma, Simplie (2009).
URL http://code.google.com/p/simplie/
[15] A. Nazarov, Affine.m - Mathematica package for computations in representation theory of finite-
dimensional and affine Lie algebrasarXiv:1107.4681.
[16] R. M. Fonseca, Calculating the renormalisation group equations of a susy model with susyno, Computer
Physics Communications 183 (10) (2012) 2298 – 2306. arXiv:1106.5016, doi:10.1016/j.cpc.
2012.05.017.
[17] C. H. Albright, R. P. Feger, T. W. Kephart, An explicit SU(12) family and flavor unification model
with natural fermion masses and mixings, Phys.Rev. D86 (2012) 015012. arXiv:1204.5471, doi:
10.1103/PhysRevD.86.015012.
[18] A. Klimyk, J. Patera, Orbit Functions, SIGMA 2 (2006) 6–66. arXiv:math-ph/0601037, doi:
10.3842/SIGMA.2006.006.
[19] R. V. Moody, J. Patera, Fast Recursion Formula for Weight Multiplicities, Bull.Amer.Math.Soc.(N.S.)
7 (1) (1982) 237–242.
[20] F. Lemire, J. Patera, Congruence number, a generalization of SU(3) triality, J.Math.Phys. 21 (8) (1980)
2026. doi:10.1063/1.524711.
41
[21] A. U. Klimyk, Decomposition of the direct product of irreducible representations of a semisimple Lie
algebra into irreducible representations, American Mathematical Society Translations: Series 2 76 (1967)
63.
[22] J. Humphreys, Introduction to Lie Algebras and Representation Theory, Springer, New York, 1972.
[23] M. Larouche, M. Nesterenko, J. Patera, Branching rules for the Weyl group orbits of the Lie algebra A(n),
J. Phys. A: Math. Theor. 42 (48) (2009) 485203. arXiv:0909.2337, doi:10.1088/1751-8113/
42/48/485203.
[24] M. Larouche, J. Patera, Branching rules for Weyl group orbits of simple Lie algebras B(n), C(n)
and D(n), J. Phys. A: Math. Theor. 44 (11) (2011) 115203. arXiv:1101.6043, doi:10.1088/
1751-8113/44/11/115203.
42

Lie ART

Uploaded by

Copyright:

Available Formats

Lie ART

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lie ART

Uploaded by

Copyright:

Available Formats

Version of Record: https://www.sciencedirect.

LieART – A Mathematica Application for Lie Algebras and Representation

Robert Fegera,∗, Thomas W. Kephartb

2 Download and Installation 5

Preprint submitted to Computer Physics Communications February 24, 2015

4 Theoretical Background and Implementation 10

7 Conclusions and Outlook 40

Authors: Robert Feger, Thomas W. Kephart

2. Download and Installation

2.2. Automatic Installation

2.3. Manual Installation

2.5. LATEX Package

3.1. Entering Irreducible Representations

Irrep[algebraClass][label ] irrep described by its algebraClass and Dynkin label .

In StandardForm the irrep is displayed in the textbook notation of Dynkin labels:

In TraditionalForm (default) the irrep is displayed by its dimensional name:

Irrep[algebra][dimname] irrep entered by its algebra and dimensional name dimname.

The traditional name of the algebra SU(5) may also be used:

ProductIrrep[irreps] head of product irreps, gathering irreps of simple Lie algebras.

The product irrep (3, 3) of SU(3)⊗SU(3):

3.2. Decomposing Tensor Products

DecomposeProduct[irreps] decomposes the tensor product of several irreps.

Decompose the tensor product 3⊗3 of SU(3):

Decompose the tensor product 27⊗27 of E6 :

Decompose the tensor product 3⊗3⊗3 of SU(3):

Decompose tensor products of product irreps (3, 3, 1)⊗(3, 3, 1) of SU(3)⊗SU(3)⊗SU(3):

Decompose the tensor products (3, 2)⊗(3, 1) of SU(3)⊗SU(2):

3.3. Decomposition to Subalgebras

DecomposeIrrep[irrep, subalgebra] decomposes irrep to the specified subalgebra.

Decompose the 10 of SU(5) to SU(3)⊗SU(2)⊗U(1):

Decompose the 16 of SO(10) to SU(5)⊗U(1):

Decompose the 27 of E6 to SU(3)⊗SU(3)⊗SU(3):

Decompose the SU(3) irrep 3 in (24, 3)(−3) of SU(5)⊗SU(3)⊗U(1) to SU(2)⊗U0 (1),

The same decomposition as above displayed as branching rule:

3.4. Young Tableaux

YoungTableau[irrep] Displays the Young tableau associated with an SU(N ) irrep.

Young tableau of the 720 of SU(5):

Rank[expr ] gives the rank of the algebra of expr , which can be

[ti , tj ] = fijk tk (1)

hi = h†i , [hi , hj ] = 0, i, j = 1, . . . , n. (2)

Table 4.1: Classification of simple Lie algebras.

4.1.3. Classification of Lie Algebras

SU(2) ∼ SO(3) ∼ Sp(2) (A1 ∼ B1 ∼ C1 ), (4a)

The LieART functions AlphaBasis[weightOrRoot], OmegaBasis[weightOrRoot] and

In the ω-basis the scalar product used in (5) becomes:

Reflect[weightOrRoot,simpleroots] reflects weightOrRoot at the hyperplanes orthogonal to the

The LieART function Reflect[weightOrRoot,simpleroots] implements the reflections ri with weightOr-

RootSystem[algebra] root system of algebra

have different lengths:

and adding the twofold degenerated zero roots constructed by ZeroRoots[algebra]

WeightOrthogonal[algebraClass][label ] weight in the orthogonal basis defined by its algebra

4.4.1. Weight System

which is available in LieART as Height[irrep].

4.4.2. Properties of Irreducible Representations

4.4.3. Representation Names

Dynkin Dimension Index Quintality Name

Dynkin Dimension Index Quintality Name

Dynkin Dimension Index Quintality Name

Dynkin Dimension Index Congruency vector Name

Dynkin Dimension Index Congruency vector Name