This is LieTypes.info, produced by Macaulay2, version 1.20

LieTypes -- Common types for Lie groups and Lie algebras
********************************************************

Description
===========

This package defines types used by the ConformalBlocks package and may someday
be used by other packages as well.  If you would like to see a type or function
added to this package (or better yet, if you would like to write types or
functions for this package), please contact Dan Grayson, Mike Stillman, or Dave
Swinarski.

Author
======

  * Dave Swinarski <dswinarski@fordham.edu>

Certification a gold star
=========================

Version 0.5 of this package was accepted for publication in volume 8 (see
https://msp.org/jsag/2018/8-1/ ) of The Journal of Software for Algebra and
Geometry (see http://j-sag.org/ ) on 2 August 2018, in the article Software for
computing conformal block divisors on bar M_0,n (see
https://msp.org/jsag/2018/8-1/p08.xhtml ). That version can be obtained from
the journal (see https://msp.org/jsag/2018/8-1/jsag-v8-n1-x08-LieTypes.m2 ) or
from the Macaulay2 source code repository (see
http://github.com/Macaulay2/M2/blob/923fbcc7c77b23f510bb0d740e00fc1722a2f397/M2
/Macaulay2/packages/LieTypes.m2 ).

Version
=======

This documentation describes version 0.5 of LieTypes.

Source code
===========

The source code from which this documentation is derived is in the file
LieTypes.m2 (see common/share/Macaulay2/LieTypes.m2 ).

Exports
=======

  * Types
      * LieAlgebra -- class for Lie algebras
      * LieAlgebraModule -- class for Lie algebra
        modules
  * Functions and commands
      * casimirScalar -- computes the scalar by which the
        Casimir operator acts on an irreducible Lie algebra module
      * dualCoxeterNumber -- returns the dual Coxeter
        number of a simple Lie algebra
      * fusionCoefficient -- computes the
        multiplicity of W in the fusion product of U and V
      * fusionProduct -- computes the multiplicities of
        irreducibles in the decomposition of the fusion product of U and V
      * highestRoot -- returns the highest root of a simple
        Lie algebra
      * irreducibleLieAlgebraModule, --
        construct the irreducible Lie algebra module with given highest weight
      * isIsomorphic -- tests whether two Lie algebra
        modules are isomorphic
      * KillingForm -- computes the scaled Killing form
        applied to two weights
      * positiveRoots -- returns the positive roots of a
        simple Lie algebra
      * simpleLieAlgebra -- construct a simple Lie
        algebra
      * starInvolution -- computes w* for a weight w
      * tensorCoefficient -- computes the
        multiplicity of W in U tensor V
      * weightDiagram -- computes the weights in a Lie
        algebra module and their multiplicities
      * weylAlcove -- the dominant integral weights of level
        less than or equal to l
  * Methods
      * "casimirScalar(LieAlgebraModule)" -- see casimirScalar,
        -- computes the scalar by which the Casimir operator
        acts on an irreducible Lie algebra module
      * "casimirScalar(String,ZZ,List)" -- see casimirScalar,
        -- computes the scalar by which the Casimir operator
        acts on an irreducible Lie algebra module
      * dim(LieAlgebraModule) -- computes the
        dimension of a Lie algebra module as a vector space over the ground
        field
      * "dualCoxeterNumber(LieAlgebra)" -- see dualCoxeterNumber,
        -- returns the dual Coxeter number of a simple Lie
        algebra
      * "dualCoxeterNumber(String,ZZ)" -- see dualCoxeterNumber,
        -- returns the dual Coxeter number of a simple Lie
        algebra
      * "fusionCoefficient(LieAlgebraModule,LieAlgebraModule,LieAlgebraModule,
        ZZ)" -- see fusionCoefficient, -- computes the
        multiplicity of W in the fusion product of U and V
      * "fusionProduct(LieAlgebraModule,LieAlgebraModule,ZZ)" -- see
        fusionProduct, -- computes the multiplicities of
        irreducibles in the decomposition of the fusion product of U and V
      * "highestRoot(LieAlgebra)" -- see highestRoot, --
        returns the highest root of a simple Lie algebra
      * "highestRoot(String,ZZ)" -- see highestRoot, --
        returns the highest root of a simple Lie algebra
      * "irreducibleLieAlgebraModule(List,LieAlgebra)" -- see
        irreducibleLieAlgebraModule, -- construct
        the irreducible Lie algebra module with given highest weight
      * "KillingForm(LieAlgebra,List,List)" -- see KillingForm,
        -- computes the scaled Killing form applied to two weights
      * "KillingForm(String,ZZ,List,List)" -- see KillingForm,
        -- computes the scaled Killing form applied to two weights
      * LieAlgebra == LieAlgebra -- tests
        equality of LieAlgebra
      * LieAlgebraModule ** LieAlgebraModule
        -- tensor product of LieAlgebraModules
      * LieAlgebraModule ++ LieAlgebraModule
        -- direct sum of LieAlgebraModules
      * multiplicity(List,LieAlgebraModule)
        -- compute the multiplicity
        of a weight in a Lie algebra module
      * "positiveRoots(LieAlgebra)" -- see positiveRoots,
        -- returns the positive roots of a simple Lie algebra
      * "positiveRoots(String,ZZ)" -- see positiveRoots,
        -- returns the positive roots of a simple Lie algebra
      * "simpleLieAlgebra(String,ZZ)" -- see simpleLieAlgebra,
        -- construct a simple Lie algebra
      * "starInvolution(List,LieAlgebra)" -- see starInvolution,
        -- computes w* for a weight w
      * "starInvolution(String,ZZ,List)" -- see starInvolution,
        -- computes w* for a weight w
      * "tensorCoefficient(LieAlgebraModule,LieAlgebraModule,LieAlgebraModule)"
        -- see tensorCoefficient, -- computes the
        multiplicity of W in U tensor V
      * "weightDiagram(LieAlgebraModule)" -- see weightDiagram,
        -- computes the weights in a Lie algebra module and
        their multiplicities
      * "weightDiagram(String,ZZ,List)" -- see weightDiagram,
        -- computes the weights in a Lie algebra module and
        their multiplicities
      * "weylAlcove(String,ZZ,ZZ)" -- see weylAlcove, -- the
        dominant integral weights of level less than or equal to l
      * "weylAlcove(ZZ,LieAlgebra)" -- see weylAlcove, -- the
        dominant integral weights of level less than or equal to l
  * Symbols
      * MaxWordLength -- Optional argument to specify the
        allowable length of words in the affine Weyl group when computing
        fusion products.

For the programmer
==================

The object LieTypes, is a package (Macaulay2Doc).

casimirScalar -- computes the scalar by which the Casimir operator acts on an irreducible Lie algebra module
************************************************************************************************************

Synopsis
========

  * Usage:
        casimirScalar(V)
  * Inputs:
      * V, an instance of the type LieAlgebraModule,
  * Outputs:
      * k, a rational number (Macaulay2Doc),

Description
===========

The Casimir operator is an element of the universal enveloping algebra that
acts by a scalar on each irreducible Lie algebra module.  One has $c(\mu) =
(\mu,\mu) + 2(\mu,\rho)$, where $\rho$ is half the sum of the positive weights
and (,) is the Killing form scaled so that $(\theta,\theta)=2$, where $\theta$
is the highest root.  See Di Francesco, Mathieu, and Senechal, Conformal Field
Theory, Springer Graduate Texts in Theoretical Physics, (13.127) p. 512, and
(13.46) p. 499.

In the example below, we see that the Casimir operator acts as multiplication
by 8/3 on the standard representation of $sl_3$.

+-------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2)             |
|                                           |
|o1 = g                                     |
|                                           |
|o1 : LieAlgebra                            |
+-------------------------------------------+
|i2 : V=irreducibleLieAlgebraModule({1,0},g)|
|                                           |
|o2 = V                                     |
|                                           |
|o2 : g module                              |
+-------------------------------------------+
|i3 : casimirScalar(V)                      |
|                                           |
|     8                                     |
|o3 = -                                     |
|     3                                     |
|                                           |
|o3 : QQ                                    |
+-------------------------------------------+

Ways to use casimirScalar :
===========================

  * "casimirScalar(LieAlgebraModule)"
  * "casimirScalar(String,ZZ,List)"

For the programmer
==================

The object casimirScalar, is a method function (Macaulay2Doc).

dim(LieAlgebraModule) -- computes the dimension of a Lie algebra module as a vector space over the ground field
***************************************************************************************************************

Synopsis
========

  * Function: dim (Macaulay2Doc),
  * Usage:
        dim(V)
  * Inputs:
      * V, an instance of the type LieAlgebraModule,
  * Outputs:
      * k, an integer (Macaulay2Doc),

Description
===========

+-------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2)             |
|                                           |
|o1 = g                                     |
|                                           |
|o1 : LieAlgebra                            |
+-------------------------------------------+
|i2 : V=irreducibleLieAlgebraModule({1,0},g)|
|                                           |
|o2 = V                                     |
|                                           |
|o2 : g module                              |
+-------------------------------------------+
|i3 : dim(V)                                |
|                                           |
|o3 = 3                                     |
+-------------------------------------------+

Ways to use this method:
========================

  * dim(LieAlgebraModule) -- computes the
    dimension of a Lie algebra module as a vector space over the ground field

dualCoxeterNumber -- returns the dual Coxeter number of a simple Lie algebra
****************************************************************************

Synopsis
========

  * Usage:
        dualCoxeterNumber(g)
  * Inputs:
      * g, an instance of the type LieAlgebra, a simple Lie
        algebra
  * Outputs:
      * n, an integer (Macaulay2Doc), the dual Coxeter number of g

Description
===========

The dual Coxeter number is defined as the sum of the comarks plus 1.  See Di
Francesco, Mathieu, and Senechal, Conformal Field Theory, Springer Graduate
Texts in Theoretical Physics, Formula (13.35) and Appendix A.

+------------------------------+
|i1 : dualCoxeterNumber("A",2) |
|                              |
|o1 = 3                        |
+------------------------------+
|i2 : g=simpleLieAlgebra("A",2)|
|                              |
|o2 = g                        |
|                              |
|o2 : LieAlgebra               |
+------------------------------+
|i3 : dualCoxeterNumber(g)     |
|                              |
|o3 = 3                        |
+------------------------------+

Ways to use dualCoxeterNumber :
===============================

  * "dualCoxeterNumber(LieAlgebra)"
  * "dualCoxeterNumber(String,ZZ)"

For the programmer
==================

The object dualCoxeterNumber, is a method function (Macaulay2Doc).

fusionCoefficient -- computes the multiplicity of W in the fusion product of U and V
************************************************************************************

Synopsis
========

  * Usage:
        fusionCoefficient(U,V,W,l)
  * Inputs:
      * U, an instance of the type LieAlgebraModule,
      * V, an instance of the type LieAlgebraModule,
      * W, an instance of the type LieAlgebraModule,
      * l, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * MaxWordLength,
        => ..., default value 10, Optional argument to specify the
        allowable length of words in the affine Weyl group when computing
        fusion products.

Description
===========

This function implements the Kac-Walton algorithm; see Di Francesco, Mathieu,
and Senechal, Conformal Field Theory, Springer Graduate Texts in Theoretical
Physics, Section 16.2.2.

Given three irreducible Lie algebra modules $U$, $V$, and $W$, the function
returns the multiplicity of $W$ in the fusion product of $U$ and $V$ at level
$l$.  (We are abusing notation and terminology a little here; the fusion
product is really a product for modules over an affine Lie algebra.  However,
since the Kac-Walton algorithm is defined entirely using the combinatorics of
the root system of the underlying finite-dimensional Lie algebra, we may
therefore use the Kac-Walton algorithm to define a product on Lie algebra
modules as well.)

The Weyl group of a simple Lie algebra is finite; in contrast, the affine Weyl
group of an affine Lie algebra is infinite.  To keep Macaulay2 from trying to
compute infinitely long words in this group, the default length of allowed
words is set to 10.   The user may override this with the optional argument
MaxWordLength.

The example below shows that for $g=sl_3$ and $\lambda=2 \omega_1 + \omega_2$,
$\mu= \omega_1 + 2 \omega_2$, and $\nu= \omega_1 +  \omega_2$, the level 3
fusion product  $V_{\lambda} \otimes_3  V_{\mu}$ contains one copy of
$V_{\nu}$.

+--------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2);             |
+--------------------------------------------+
|i2 : U=irreducibleLieAlgebraModule({2,1},g);|
+--------------------------------------------+
|i3 : V=irreducibleLieAlgebraModule({1,2},g);|
+--------------------------------------------+
|i4 : W=irreducibleLieAlgebraModule({1,1},g);|
+--------------------------------------------+
|i5 : fusionCoefficient(U,V,W,3)             |
|                                            |
|o5 = 1                                      |
+--------------------------------------------+

Ways to use fusionCoefficient :
===============================

  * "fusionCoefficient(LieAlgebraModule,LieAlgebraModule,LieAlgebraModule,ZZ)"

For the programmer
==================

The object fusionCoefficient, is a method function with options (Macaulay2Doc).

fusionCoefficient(...,MaxWordLength=>...) -- Optional argument to specify the allowable length of words in the affine Weyl group when computing fusion products.
****************************************************************************************************************************************************************

Description
===========

The Weyl group of a simple Lie algebra is finite; in contrast, the affine Weyl
group of an affine Lie algebra is infinite.  To keep Macaulay2 from trying to
compute infinitely long words in this group, the default length of allowed
words is set to 10.   The user may override this with the optional argument
"MaxWordLength".  If the word length is too small, the program will return an
error.

Further information
===================

  * Default value: 10
  * Function: fusionCoefficient, -- computes the
    multiplicity of W in the fusion product of U and V
  * Option key: MaxWordLength, -- Optional argument to
    specify the allowable length of words in the affine Weyl group when
    computing fusion products.

Functions with optional argument named MaxWordLength :
======================================================

  * fusionCoefficient(...,MaxWordLength=>...)
    -- Optional
    argument to specify the allowable length of words in the affine Weyl group
    when computing fusion products.
  * fusionProduct(...,MaxWordLength=>...)
    -- Optional
    argument to specify the allowable length of words in the affine Weyl group
    when computing fusion products.

fusionProduct -- computes the multiplicities of irreducibles in the decomposition of the fusion product of U and V
******************************************************************************************************************

Synopsis
========

  * Usage:
        fusionProduct(U,V,l)
  * Inputs:
      * U, an instance of the type LieAlgebraModule,
      * V, an instance of the type LieAlgebraModule,
      * l, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * MaxWordLength,
        => ..., default value 10, Optional argument to specify the
        allowable length of words in the affine Weyl group when computing
        fusion products.

Description
===========

This function implements the Kac-Walton algorithm; see Di Francesco, Mathieu,
and Senechal, Conformal Field Theory, Springer Graduate Texts in Theoretical
Physics, Section 16.2.2.

Given two irreducible Lie algebra modules $U$ and $V$, the function returns the
fusion product of $U$ and $V$ at level $l$.  (We are abusing notation and
terminology a little here; the fusion product is really a product for modules
over an affine Lie algebra.  However, since the Kac-Walton algorithm is defined
entirely using the combinatorics of the root system of the underlying
finite-dimensional Lie algebra, we may therefore use the Kac-Walton algorithm
to define a product on Lie algebra modules as well.)

The Weyl group of a simple Lie algebra is finite; in contrast, the affine Weyl
group of an affine Lie algebra is infinite.  To keep Macaulay2 from trying to
compute infinitely long words in this group, the default length of allowed
words is set to 10.   The user may override this with the optional argument
MaxWordLength.

The example below shows that for $g=sl_3$ and $\lambda=2 \omega_1 + \omega_2 =
(2,1)$, $\mu= \omega_1 + 2 \omega_2 = (1,2)$, the level 3 fusion product
$V_{(2,1)} \otimes_3  V_{(1,2)}$ contains one copy of $V_{(0,0)}$ and one copy
of $V_{(1,1)}$.

+--------------------------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2);                               |
+--------------------------------------------------------------+
|i2 : U=irreducibleLieAlgebraModule({2,1},g);                  |
+--------------------------------------------------------------+
|i3 : V=irreducibleLieAlgebraModule({1,2},g);                  |
+--------------------------------------------------------------+
|i4 : fusionProduct(U,V,3)                                     |
|                                                              |
|o4 = {LieAlgebra => g                                        }|
|      isIrreducible => false                                  |
|      DecompositionIntoIrreducibles => HashTable{{0, 0} => 1} |
|                                                 {1, 1} => 1  |
|                                                              |
|o4 : g module                                                 |
+--------------------------------------------------------------+

Ways to use fusionProduct :
===========================

  * "fusionProduct(LieAlgebraModule,LieAlgebraModule,ZZ)"

For the programmer
==================

The object fusionProduct, is a method function with options (Macaulay2Doc).

fusionProduct(...,MaxWordLength=>...) -- Optional argument to specify the allowable length of words in the affine Weyl group when computing fusion products.
************************************************************************************************************************************************************

Description
===========

The Weyl group of a simple Lie algebra is finite; in contrast, the affine Weyl
group of an affine Lie algebra is infinite.  To keep Macaulay2 from trying to
compute infinitely long words in this group, the default length of allowed
words is set to max \{10, rank($\mathbf{g}$)+1\}.   The user may override this
with the optional argument "MaxWordLength".  If the word length is too small,
the program will return an error.

Further information
===================

  * Default value: 10
  * Function: fusionProduct, -- computes the
    multiplicities of irreducibles in the decomposition of the fusion product
    of U and V
  * Option key: MaxWordLength, -- Optional argument to
    specify the allowable length of words in the affine Weyl group when
    computing fusion products.

Functions with optional argument named MaxWordLength :
======================================================

  * fusionCoefficient(...,MaxWordLength=>...)
    -- Optional
    argument to specify the allowable length of words in the affine Weyl group
    when computing fusion products.
  * fusionProduct(...,MaxWordLength=>...)
    -- Optional
    argument to specify the allowable length of words in the affine Weyl group
    when computing fusion products.

highestRoot -- returns the highest root of a simple Lie algebra
***************************************************************

Synopsis
========

  * Usage:
        highestRoot(g), highestRoot("A",2)
  * Inputs:
      * g, an instance of the type LieAlgebra,
  * Outputs:
      * t, a list (Macaulay2Doc),

Description
===========

Let R be an irreducible root system of rank m, and choose a base of simple
roots $\Delta = \{\alpha_1,...,\alpha_m\}$.  Then there is a unique root
$\theta$ such that when $\theta$ is expanded in terms of the simple roots, i.e.
$\theta= \sum c_i \alpha_i$, the sum $\sum c_i$ is maximized.  The formulas
implemented here are taken from the tables following Bourbaki's Lie Groups and
Lie Algebras Chapter 6.

In the example below, we see that for $sl_3$, the highest root $\theta$ is
$\omega_1+ \omega_2$, where $\omega_1$ and $\omega_2$ are the fundamental
dominant weights.

+-----------------------+
|i1 : highestRoot("A",2)|
|                       |
|o1 = {1, 1}            |
|                       |
|o1 : List              |
+-----------------------+

Ways to use highestRoot :
=========================

  * "highestRoot(LieAlgebra)"
  * "highestRoot(String,ZZ)"

For the programmer
==================

The object highestRoot, is a method function (Macaulay2Doc).

irreducibleLieAlgebraModule -- construct the irreducible Lie algebra module with given highest weight
*****************************************************************************************************

Synopsis
========

  * Usage:
        irreducibleLieAlgebraModule(w,g)
  * Inputs:
      * w, a list (Macaulay2Doc), the highest weight of the desired
        module
      * g, an instance of the type LieAlgebra,
  * Outputs:
      * M, an instance of the type LieAlgebraModule,

Description
===========

This function creates the irreducible Lie algebra module with a given highest
weight.

+--------------------------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2)                                |
|                                                              |
|o1 = g                                                        |
|                                                              |
|o1 : LieAlgebra                                               |
+--------------------------------------------------------------+
|i2 : irreducibleLieAlgebraModule({1,1},g)                     |
|                                                              |
|o2 = {LieAlgebra => g                                        }|
|      isIrreducible => true                                   |
|      highestWeight => {1, 1}                                 |
|      DecompositionIntoIrreducibles => HashTable{{1, 1} => 1} |
|                                                              |
|o2 : g module                                                 |
+--------------------------------------------------------------+

Ways to use irreducibleLieAlgebraModule :
=========================================

  * "irreducibleLieAlgebraModule(List,LieAlgebra)"

For the programmer
==================

The object irreducibleLieAlgebraModule, is a
method function (Macaulay2Doc).

isIsomorphic -- tests whether two Lie algebra modules are isomorphic
********************************************************************

Synopsis
========

  * Usage:
        isIsomorphic(V,W)
  * Inputs:
      * V, an instance of the type LieAlgebraModule,
      * W, an instance of the type LieAlgebraModule,
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

Description
===========

To test whether two Lie algebra modules are isomorphic, we first test whether
they are modules over the same Lie algebra, and if so, then test whether they
have the same decomposition into irreducible Lie algebra modules.

+-------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2)             |
|                                           |
|o1 = g                                     |
|                                           |
|o1 : LieAlgebra                            |
+-------------------------------------------+
|i2 : M=irreducibleLieAlgebraModule({2,1},g)|
|                                           |
|o2 = M                                     |
|                                           |
|o2 : g module                              |
+-------------------------------------------+
|i3 : N=irreducibleLieAlgebraModule({1,2},g)|
|                                           |
|o3 = N                                     |
|                                           |
|o3 : g module                              |
+-------------------------------------------+
|i4 : Z=irreducibleLieAlgebraModule({0,0},g)|
|                                           |
|o4 = Z                                     |
|                                           |
|o4 : g module                              |
+-------------------------------------------+
|i5 : isIsomorphic(M,N)                     |
|                                           |
|o5 = false                                 |
+-------------------------------------------+
|i6 : isIsomorphic(M,M)                     |
|                                           |
|o6 = true                                  |
+-------------------------------------------+
|i7 : isIsomorphic(M,M**Z)                  |
|                                           |
|o7 = true                                  |
+-------------------------------------------+
|i8 : isIsomorphic(M**N,N**M)               |
|                                           |
|o8 = true                                  |
+-------------------------------------------+

Ways to use isIsomorphic :
==========================

  * "isIsomorphic(LieAlgebraModule,LieAlgebraModule)"

For the programmer
==================

The object isIsomorphic, is a method function (Macaulay2Doc).

KillingForm -- computes the scaled Killing form applied to two weights
**********************************************************************

Synopsis
========

  * Usage:
        KillingForm(g,v,w)
  * Inputs:
      * g, an instance of the type LieAlgebra,
      * v, a list (Macaulay2Doc),
      * w, a list (Macaulay2Doc),

Description
===========

Let $\mathbf{g}$ be a Lie algebra.  The Killing form on $\mathbf{g}$ is the
symmetric bilinear form given by $(x,y) = Tr(ad x ad y)$.  It can restricted to
a Cartan subalgebra $\mathbf{h}$ and transferred to $\mathbf{h}^*$, yielding a
symmetric bilinear form on weights.  One popular convention is to scale the
Killing form so that $(\theta,\theta) =2$, where $\theta$ is the highest root.

+-------------------------------+
|i1 : g=simpleLieAlgebra("A",2) |
|                               |
|o1 = g                         |
|                               |
|o1 : LieAlgebra                |
+-------------------------------+
|i2 : KillingForm(g,{1,0},{0,1})|
|                               |
|     1                         |
|o2 = -                         |
|     3                         |
|                               |
|o2 : QQ                        |
+-------------------------------+

Ways to use KillingForm :
=========================

  * "KillingForm(LieAlgebra,List,List)"
  * "KillingForm(String,ZZ,List,List)"

For the programmer
==================

The object KillingForm, is a method function (Macaulay2Doc).

LieAlgebra -- class for Lie algebras
************************************

Description
===========

This class represents Lie algebras.  Currently only simple Lie algebras over
the complex numbers are supported.  An object of type LieAlgebra is a hash
table whose keys record whether the Lie algebra is simple, the rank of the Lie
algebra, and the type of the root system.

+------------------------------+
|i1 : g=simpleLieAlgebra("A",1)|
|                              |
|o1 = g                        |
|                              |
|o1 : LieAlgebra               |
+------------------------------+
|i2 : g=simpleLieAlgebra("E",6)|
|                              |
|o2 = g                        |
|                              |
|o2 : LieAlgebra               |
+------------------------------+

Functions and methods returning an object of class LieAlgebra :
===============================================================

  * simpleLieAlgebra -- construct a simple Lie algebra

Methods that use an object of class LieAlgebra :
================================================

  * "dualCoxeterNumber(LieAlgebra)" -- see dualCoxeterNumber,
    -- returns the dual Coxeter number of a simple Lie
    algebra
  * expression(LieAlgebra) (missing documentation)
  * "highestRoot(LieAlgebra)" -- see highestRoot, -- returns
    the highest root of a simple Lie algebra
  * "irreducibleLieAlgebraModule(List,LieAlgebra)" -- see
    irreducibleLieAlgebraModule, -- construct the
    irreducible Lie algebra module with given highest weight
  * "KillingForm(LieAlgebra,List,List)" -- see KillingForm,
    -- computes the scaled Killing form applied to two weights
  * LieAlgebra == LieAlgebra -- tests equality
    of LieAlgebra
  * net(LieAlgebra) (missing documentation)
  * "positiveRoots(LieAlgebra)" -- see positiveRoots, --
    returns the positive roots of a simple Lie algebra
  * "starInvolution(List,LieAlgebra)" -- see starInvolution,
    -- computes w* for a weight w
  * "weylAlcove(ZZ,LieAlgebra)" -- see weylAlcove, -- the
    dominant integral weights of level less than or equal to l

For the programmer
==================

The object LieAlgebra, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc), < Thing (Macaulay2Doc).

LieAlgebra == LieAlgebra -- tests equality of LieAlgebra
********************************************************

Synopsis
========

  * Operator: == (Macaulay2Doc),
  * Usage:
        g == h
  * Inputs:
      * g, an instance of the type LieAlgebra,
      * h, an instance of the type LieAlgebra,
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

Description
===========

This function tests equality of the underlying hash tables of $g$ and $h$ are
the same.

+------------------------------+
|i1 : g=simpleLieAlgebra("A",2)|
|                              |
|o1 = g                        |
|                              |
|o1 : LieAlgebra               |
+------------------------------+
|i2 : h=simpleLieAlgebra("A",2)|
|                              |
|o2 = g                        |
|                              |
|o2 : LieAlgebra               |
+------------------------------+
|i3 : g==h                     |
|                              |
|o3 = true                     |
+------------------------------+

Ways to use this method:
========================

  * LieAlgebra == LieAlgebra -- tests equality
    of LieAlgebra

LieAlgebraModule -- class for Lie algebra modules
*************************************************

Description
===========

This class represents Lie algebra modules.  Currently only modules over simple
Lie algebras over the complex numbers are supported.  An object of type
LieAlgebraModule is a hash table recording the Lie algebra and the
decomposition of the module into irreducible Lie algebra modules, which are
indexed by their highest weights.

+-------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2)             |
|                                           |
|o1 = g                                     |
|                                           |
|o1 : LieAlgebra                            |
+-------------------------------------------+
|i2 : M=irreducibleLieAlgebraModule({1,1},g)|
|                                           |
|o2 = M                                     |
|                                           |
|o2 : g module                              |
+-------------------------------------------+

Functions and methods returning an object of class LieAlgebraModule :
=====================================================================

  * irreducibleLieAlgebraModule, --
    construct the irreducible Lie algebra module with given highest weight

Methods that use an object of class LieAlgebraModule :
======================================================

  * "casimirScalar(LieAlgebraModule)" -- see casimirScalar,
    -- computes the scalar by which the Casimir operator acts on
    an irreducible Lie algebra module
  * dim(LieAlgebraModule) -- computes the
    dimension of a Lie algebra module as a vector space over the ground field
  * expression(LieAlgebraModule) (missing documentation)
  * "fusionCoefficient(LieAlgebraModule,LieAlgebraModule,LieAlgebraModule,ZZ)"
    -- see fusionCoefficient, -- computes the
    multiplicity of W in the fusion product of U and V
  * "fusionProduct(LieAlgebraModule,LieAlgebraModule,ZZ)" -- see
    fusionProduct, -- computes the multiplicities of
    irreducibles in the decomposition of the fusion product of U and V
  * LieAlgebraModule ** LieAlgebraModule
    -- tensor product of LieAlgebraModules
  * LieAlgebraModule ++ LieAlgebraModule
    -- direct sum of LieAlgebraModules
  * multiplicity(List,LieAlgebraModule)
    -- compute the multiplicity of a
    weight in a Lie algebra module
  * net(LieAlgebraModule) (missing documentation)
  * "tensorCoefficient(LieAlgebraModule,LieAlgebraModule,LieAlgebraModule)" --
    see tensorCoefficient, -- computes the
    multiplicity of W in U tensor V
  * "weightDiagram(LieAlgebraModule)" -- see weightDiagram,
    -- computes the weights in a Lie algebra module and their
    multiplicities

For the programmer
==================

The object LieAlgebraModule, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

LieAlgebraModule ** LieAlgebraModule -- tensor product of LieAlgebraModules
***************************************************************************

Synopsis
========

  * Operator: ** (Macaulay2Doc),
  * Usage:
        U ** V
  * Inputs:
      * U, an instance of the type LieAlgebraModule,
      * V, an instance of the type LieAlgebraModule,
  * Outputs:
      * W, an instance of the type LieAlgebraModule,

Description
===========

Computes the tensor product of two Lie algebra modules.

+--------------------------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2)                                |
|                                                              |
|o1 = g                                                        |
|                                                              |
|o1 : LieAlgebra                                               |
+--------------------------------------------------------------+
|i2 : U=irreducibleLieAlgebraModule({4,2},g)                   |
|                                                              |
|o2 = U                                                        |
|                                                              |
|o2 : g module                                                 |
+--------------------------------------------------------------+
|i3 : V=irreducibleLieAlgebraModule({3,1},g)                   |
|                                                              |
|o3 = V                                                        |
|                                                              |
|o3 : g module                                                 |
+--------------------------------------------------------------+
|i4 : U**V                                                     |
|                                                              |
|o4 = {LieAlgebra => g                                        }|
|      isIrreducible => false                                  |
|      DecompositionIntoIrreducibles => HashTable{{0, 5} => 1} |
|                                                 {1, 3} => 1  |
|                                                 {1, 6} => 1  |
|                                                 {2, 1} => 1  |
|                                                 {2, 4} => 2  |
|                                                 {3, 2} => 2  |
|                                                 {3, 5} => 1  |
|                                                 {4, 0} => 1  |
|                                                 {4, 3} => 2  |
|                                                 {5, 1} => 2  |
|                                                 {5, 4} => 1  |
|                                                 {6, 2} => 2  |
|                                                 {7, 0} => 1  |
|                                                 {7, 3} => 1  |
|                                                 {8, 1} => 1  |
|                                                              |
|o4 : g module                                                 |
+--------------------------------------------------------------+

See also
========

  * tensorCoefficient -- computes the multiplicity of
    W in U tensor V

Ways to use this method:
========================

  * LieAlgebraModule ** LieAlgebraModule
    -- tensor product of LieAlgebraModules

LieAlgebraModule ++ LieAlgebraModule -- direct sum of LieAlgebraModules
***********************************************************************

Synopsis
========

  * Operator: ++ (Macaulay2Doc),
  * Usage:
        U ++ V
  * Inputs:
      * U, an instance of the type LieAlgebraModule,
      * V, an instance of the type LieAlgebraModule,
  * Outputs:
      * W, an instance of the type LieAlgebraModule,

Description
===========

Computes the direct sum of two Lie algebra modules.

+--------------------------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2)                                |
|                                                              |
|o1 = g                                                        |
|                                                              |
|o1 : LieAlgebra                                               |
+--------------------------------------------------------------+
|i2 : U=irreducibleLieAlgebraModule({4,2},g)                   |
|                                                              |
|o2 = U                                                        |
|                                                              |
|o2 : g module                                                 |
+--------------------------------------------------------------+
|i3 : V=irreducibleLieAlgebraModule({3,1},g)                   |
|                                                              |
|o3 = V                                                        |
|                                                              |
|o3 : g module                                                 |
+--------------------------------------------------------------+
|i4 : U++V                                                     |
|                                                              |
|o4 = {LieAlgebra => g                                        }|
|      isIrreducible => false                                  |
|      DecompositionIntoIrreducibles => HashTable{{3, 1} => 1} |
|                                                 {4, 2} => 1  |
|                                                              |
|o4 : g module                                                 |
+--------------------------------------------------------------+

Ways to use this method:
========================

  * LieAlgebraModule ++ LieAlgebraModule
    -- direct sum of LieAlgebraModules

MaxWordLength -- Optional argument to specify the allowable length of words in the affine Weyl group when computing fusion products.
************************************************************************************************************************************

Description
===========

The Weyl group of a simple Lie algebra is finite; in contrast, the affine Weyl
group of an affine Lie algebra is infinite.  To keep Macaulay2 from trying to
compute infinitely long words in this group, the default length of allowed
words is set to 10.   The user may override this with the optional argument
"MaxWordLength".  If the word length is too small, the program will return an
error.

Functions with optional argument named MaxWordLength :
======================================================

  * fusionCoefficient(...,MaxWordLength=>...)
    -- Optional
    argument to specify the allowable length of words in the affine Weyl group
    when computing fusion products.
  * fusionProduct(...,MaxWordLength=>...)
    -- Optional
    argument to specify the allowable length of words in the affine Weyl group
    when computing fusion products.

For the programmer
==================

The object MaxWordLength, is a symbol (Macaulay2Doc).

multiplicity(List,LieAlgebraModule) -- compute the multiplicity of a weight in a Lie algebra module
***************************************************************************************************

Synopsis
========

  * Function: multiplicity (ReesAlgebra),
  * Usage:
        multiplicity(v,M)
  * Inputs:
      * v, a list (Macaulay2Doc),
      * M, an instance of the type LieAlgebraModule,
  * Optional inputs (Macaulay2Doc),:
      * BasisElementLimit (ReesAlgebra),
        => ..., default value infinity, null
      * DegreeLimit (ReesAlgebra),
        => ..., default value {}, null
      * MinimalGenerators (ReesAlgebra),
        => ..., default value true, null
      * PairLimit (ReesAlgebra),
        => ..., default value infinity, null
      * Strategy (ReesAlgebra),
        => ..., default value null, null
      * Variable (ReesAlgebra),
        => ..., default value "w", null
  * Outputs:
      * k, an integer (Macaulay2Doc),

Description
===========

This function implements Freudenthal's recursive algorithm; see Humphreys,
Introduction to Lie Algebras and Representation Theory, Section 22.3. This
function returns the multiplicity of the weight v in the irreducible Lie
algebra module M.  For Type A (that is, $g = sl_k$), these multiplicities are
related to the Kostka numbers (though in this package, irreducible
representations are indexed by the Dynkin labels of their highest weights,
rather than by partitions).

The example below shows that the $sl_3$ module with highest weight $(2,1)$
contains the weight $(-1,1)$ with multiplicity 2.

+-------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2)             |
|                                           |
|o1 = g                                     |
|                                           |
|o1 : LieAlgebra                            |
+-------------------------------------------+
|i2 : V=irreducibleLieAlgebraModule({2,1},g)|
|                                           |
|o2 = V                                     |
|                                           |
|o2 : g module                              |
+-------------------------------------------+
|i3 : multiplicity({-1,1},V)                |
|                                           |
|o3 = 2                                     |
+-------------------------------------------+

See also
========

  * weightDiagram -- computes the weights in a Lie
    algebra module and their multiplicities

Ways to use this method:
========================

  * multiplicity(List,LieAlgebraModule)
    -- compute the multiplicity of a
    weight in a Lie algebra module

positiveRoots -- returns the positive roots of a simple Lie algebra
*******************************************************************

Synopsis
========

  * Usage:
        positiveRoots(g), positiveRoots("A",2)
  * Inputs:
      * g, an instance of the type LieAlgebra,
  * Outputs:
      * t, a list (Macaulay2Doc),

Description
===========

Let R be an irreducible root system of rank m, and choose a base of simple
roots $\Delta = \{\alpha_1,...,\alpha_m\}$.  This function returns all the
roots that are nonnegative linear combinations of the simple roots.    The
formulas implemented here are taken from the tables following Bourbaki's Lie
Groups and Lie Algebras Chapter 6.

In the example below, we see that for $sl_3$, the positive roots are
$\alpha_1$, $\alpha_2$, and $\alpha_1+\alpha_2$.

+--------------------------------+
|i1 : sl3=simpleLieAlgebra("A",2)|
|                                |
|o1 = sl3                        |
|                                |
|o1 : LieAlgebra                 |
+--------------------------------+
|i2 : positiveRoots(sl3)         |
|                                |
|o2 = {{2, -1}, {1, 1}, {-1, 2}} |
|                                |
|o2 : List                       |
+--------------------------------+

Ways to use positiveRoots :
===========================

  * "positiveRoots(LieAlgebra)"
  * "positiveRoots(String,ZZ)"

For the programmer
==================

The object positiveRoots, is a method function (Macaulay2Doc).

simpleLieAlgebra -- construct a simple Lie algebra
**************************************************

Synopsis
========

  * Usage:
        simpleLieAlgebra("A",1)
  * Inputs:
      * t, a string (Macaulay2Doc), the type of the root system
        of the desired Lie algebra
      * k, an integer (Macaulay2Doc), the rank of the desired Lie
        algebra
  * Outputs:
      * g, an instance of the type LieAlgebra, the simple
        Lie algebra with the given rank and type

Description
===========

The classification of simple Lie algebras over the complex numbers is well
known.  There are four infinite families (types A, B, C, D) corresponding to
the Lie algebras $sl(n+1,\mathbb{C})$, $so(2n+1,\mathbb{C})$,
$sp(2n,\mathbb{C})$, $so(2n,\mathbb{C})$ respectively, and five exceptional
simple Lie algebras, E6, E7, E8, F4, G2.

+---------------------------------------+
|i1 : simpleLieAlgebra("A",1)           |
|                                       |
|o1 = Simple Lie algebra, type A, rank 1|
|                                       |
|o1 : LieAlgebra                        |
+---------------------------------------+
|i2 : simpleLieAlgebra("E",6)           |
|                                       |
|o2 = Simple Lie algebra, type E, rank 6|
|                                       |
|o2 : LieAlgebra                        |
+---------------------------------------+

Ways to use simpleLieAlgebra :
==============================

  * "simpleLieAlgebra(String,ZZ)"

For the programmer
==================

The object simpleLieAlgebra, is a method function (Macaulay2Doc).

starInvolution -- computes w* for a weight w
********************************************

Synopsis
========

  * Usage:
        starInvolution(w,g)
  * Inputs:
      * w, a list (Macaulay2Doc),
      * g, an instance of the type LieAlgebra,

Description
===========

Let $\mathbf{g}$ be a Lie algebra.  We give three equivalent descriptions of an
involution * on the weights of $\mathbf{g}$:

1. The involution * is given by $-w_0$, where $w_0$ is the longest word in the
Weyl group $W(\mathbf{g})$.

2. If $\mu$ is a dominant integral weight, and $V_{\mu}$ is the irreducible Lie
algebra module with highest weight $\mu$, then $\mu^*$ is the highest weight of
the dual module $(V_{\mu})^*$.

3. If the Dynkin diagram of $\mathbf{g}$ has an involution, then * corresponds
to the action of this involution on weights.

The formulas implemented have been adapted from Di Francesco, Mathieu, and
Senechal, Conformal Field Theory, Springer Graduate Texts in Theoretical
Physics, p. 511.  Some changes are needed because we use the Bourbaki ordering
of the roots in type E instead of the [DMS] ordering.

In the example below, we see that for $sl_3$, $\omega_1^* = \omega_2.$

+------------------------------+
|i1 : g=simpleLieAlgebra("A",2)|
|                              |
|o1 = g                        |
|                              |
|o1 : LieAlgebra               |
+------------------------------+
|i2 : starInvolution({1,0},g)  |
|                              |
|o2 = {0, 1}                   |
|                              |
|o2 : List                     |
+------------------------------+

Ways to use starInvolution :
============================

  * "starInvolution(List,LieAlgebra)"
  * "starInvolution(String,ZZ,List)"

For the programmer
==================

The object starInvolution, is a method function (Macaulay2Doc).

tensorCoefficient -- computes the multiplicity of W in U tensor V
*****************************************************************

Synopsis
========

  * Usage:
        tensorCoefficient(U,V,W)
  * Inputs:
      * U, an instance of the type LieAlgebraModule,
      * V, an instance of the type LieAlgebraModule,
      * W, an instance of the type LieAlgebraModule,
  * Outputs:
      * k, an integer (Macaulay2Doc),

Description
===========

This function implements the Racah-Speiser algorithm; see Di Francesco,
Mathieu, and Senechal, Conformal Field Theory, Springer Graduate Texts in
Theoretical Physics, Section 13.5.2.

Given three irreducible Lie algebra modules $U$, $V$, and $W$, the function
returns the multiplicity of $W$ in $U \otimes V$.  In Type A, these are related
to the Littlewood-Richardson coefficients (though in this package, irreducible
representations are indexed by the Dynkin labels of their highest weights,
rather than by partitions).

The example below shows that for $g=sl_3$ and $\lambda=2 \omega_1 + \omega_2$,
$\mu= \omega_1 + 2 \omega_2$, and $\nu= 2 \omega_1 + 2 \omega_2$, the tensor
product of $sl_3$ modules $V_{\lambda} \otimes V_{\mu}$ contains two copies of
$V_{\nu}$.

+-------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2)             |
|                                           |
|o1 = g                                     |
|                                           |
|o1 : LieAlgebra                            |
+-------------------------------------------+
|i2 : U=irreducibleLieAlgebraModule({2,1},g)|
|                                           |
|o2 = U                                     |
|                                           |
|o2 : g module                              |
+-------------------------------------------+
|i3 : V=irreducibleLieAlgebraModule({1,2},g)|
|                                           |
|o3 = V                                     |
|                                           |
|o3 : g module                              |
+-------------------------------------------+
|i4 : W=irreducibleLieAlgebraModule({2,2},g)|
|                                           |
|o4 = W                                     |
|                                           |
|o4 : g module                              |
+-------------------------------------------+
|i5 : tensorCoefficient(U,V,W)              |
|                                           |
|o5 = 2                                     |
+-------------------------------------------+

See also
========

  * LieAlgebraModule ** LieAlgebraModule
    -- tensor product of LieAlgebraModules

Ways to use tensorCoefficient :
===============================

  * "tensorCoefficient(LieAlgebraModule,LieAlgebraModule,LieAlgebraModule)"

For the programmer
==================

The object tensorCoefficient, is a method function (Macaulay2Doc).

weightDiagram -- computes the weights in a Lie algebra module and their multiplicities
**************************************************************************************

Synopsis
========

  * Usage:
        weightDiagram(V)
  * Inputs:
      * V, an instance of the type LieAlgebraModule,
  * Outputs:
      * T, a hash table (Macaulay2Doc),

Description
===========

This function implements Freudenthal's recursive algorithm; see Humphreys,
Introduction to Lie Algebras and Representation Theory, Section 22.3.  Let $V$
be the irreducible $\mathbf{g}$-module with highest weight $v$.  This function
returns a hash table whose keys are the weights appearing in $V$ and whose
values are the multiplicities of these weights.  The character of $V$ can be
easily computed from this information (but characters of Lie algebra modules
have not been implemented in this version of LieTypes).

+-------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2)             |
|                                           |
|o1 = g                                     |
|                                           |
|o1 : LieAlgebra                            |
+-------------------------------------------+
|i2 : V=irreducibleLieAlgebraModule({2,1},g)|
|                                           |
|o2 = V                                     |
|                                           |
|o2 : g module                              |
+-------------------------------------------+
|i3 : weightDiagram(V)                      |
|                                           |
|o3 = HashTable{{-1, -2} => 1}              |
|               {-1, 1} => 2                |
|               {-2, 0} => 1                |
|               {-2, 3} => 1                |
|               {-3, 2} => 1                |
|               {0, -1} => 2                |
|               {0, 2} => 1                 |
|               {1, -3} => 1                |
|               {1, 0} => 2                 |
|               {2, -2} => 1                |
|               {2, 1} => 1                 |
|               {3, -1} => 1                |
|                                           |
|o3 : HashTable                             |
+-------------------------------------------+

See also
========

  * multiplicity(List,LieAlgebraModule) (missing documentation)

Ways to use weightDiagram :
===========================

  * "weightDiagram(LieAlgebraModule)"
  * "weightDiagram(String,ZZ,List)"

For the programmer
==================

The object weightDiagram, is a method function (Macaulay2Doc).

weylAlcove -- the dominant integral weights of level less than or equal to l
****************************************************************************

Synopsis
========

  * Usage:
        weylAlcove(l,g)
  * Inputs:
      * l, an integer (Macaulay2Doc),
      * g, an instance of the type LieAlgebra,

Description
===========

Let $\mathbf{g}$ be a Lie algebra, and let $l$ be a nonnegative integer.
Choose a Cartan subalgebra $\mathbf{h}$ and a base $\Delta= \{
\alpha_1,\ldots,\alpha_n\}$ of simple roots of $\mathbf{g}$.  These choices
determine a highest root $\theta$. (See highestRoot).   Let
$\mathbf{h}_{\mathbf{R}}^*$ be the real span of $\Delta$, and let $(,)$ denote
the Killing form, normalized so that $(\theta,\theta)=2$.  The fundamental Weyl
chamber is $C^{+} = \{ \lambda \in \mathbf{h}_{\mathbf{R}}^*  :
$(\lambda,\alpha_i)$ >= 0, i=1,\ldots,n \}$.  The fundamental Weyl alcove is
the subset of the fundamental Weyl chamber such that $(\lambda,\theta) \leq l$.
This function computes the set of integral weights in the fundamental Weyl
alcove.

In the example below, we see that the Weyl alcove of $sl_3$ at level 3 contains
10 integral weights.

+-----------------------------------------------------------------------------+
|i1 : g=simpleLieAlgebra("A",2)                                               |
|                                                                             |
|o1 = g                                                                       |
|                                                                             |
|o1 : LieAlgebra                                                              |
+-----------------------------------------------------------------------------+
|i2 : weylAlcove(3,g)                                                         |
|                                                                             |
|o2 = {{0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 1}, {1, 2}, {2, 0}, {2, 1},|
|     ------------------------------------------------------------------------|
|     {3, 0}}                                                                 |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use weylAlcove :
========================

  * "weylAlcove(String,ZZ,ZZ)"
  * "weylAlcove(ZZ,LieAlgebra)"

For the programmer
==================

The object weylAlcove, is a method function (Macaulay2Doc).