#15806: Integrable representations of (affine) Kac-Moody Lie Algebras
-------------------------------------+-------------------------------------
Reporter: bump | Owner: bump
Type: enhancement | Status: new
Priority: major | Milestone: sage-6.4
Component: combinatorics | Resolution:
Keywords: Kac-Moody, | Merged in:
Integrable Representation, Affine | Reviewers:
Lie Algebra | Work issues: The dominant_maximal
Authors: bump | method will be reimplemented.
Report Upstream: N/A | Commit:
Branch: | 0aa8bb15e816f904bfff506453b7ef5721806a70
public/combinat/integrable-15806 | Stopgaps:
Dependencies: |
-------------------------------------+-------------------------------------
Changes (by bump):
* keywords: Kac-Moody => Kac-Moody, Integrable Representation, Affine Lie
Algebra
* work_issues:
Due to a recursive caching scheme, it can crash for hard computations.
Obviously this should be fixed. Not all docstrings have doctests.
=> The dominant_maximal method will be reimplemented.
Old description:
> Integrable representations of Kac-Moody Lie algebras are parametrized by
> dominant weights. They satisfy a character formula which is a
> straightforward generalization of the Weyl character formula. See Kac,
> Infinite-dimensional Lie algebras, Chapter 10. The weight multiplicities
> may be computed using the Freudenthal multiplicity formula, and Kass,
> Moody, Patera and Slansky (KMPS) in their book Affine Lie algebras,
> weight multiplicities, and branching rules (1990) gave tables of these
> for affine Lie algebras. We may duplicate their tables using Sage.
>
> You can do the following with this code:
>
> {{{
> sage: Lambda =
> RootSystem(['A',3,1]).weight_lattice(extended=true).fundamental_weights()
> sage: IntegrableRepresentation(Lambda[1]+Lambda[2]+Lambda[3]).strings()
> 3*Lambda[2] - delta: 3 21 107 450 1638 5367 16194 45687 121876 310056
> 757056 1783324
> 2*Lambda[0] + Lambda[2]: 4 31 161 665 2380 7658 22721 63120 166085 417295
> 1007601 2349655
> Lambda[1] + Lambda[2] + Lambda[3]: 1 10 60 274 1056 3601 11199 32354
> 88009 227555 563390 1343178
> Lambda[0] + 2*Lambda[3]: 2 18 99 430 1593 5274 16005 45324 121200 308829
> 754884 1779570
> Lambda[0] + 2*Lambda[1]: 2 18 99 430 1593 5274 16005 45324 121200 308829
> 754884 1779570
> }}}
>
> This creates the representation of `A_3^{(1)}` with highest weight
> ``Lambda[1]+Lambda[2]+Lambda[3]``. It then computes the five dominant
> maximal weights and the corresponding weight strings. Every weight
> multiplicity occurs in one of these strings, and by results of Kac and
> Peterson, they are the Fourier coefficients of modular forms. The code is
> reasonably fast and I've tested it up to rank 8, comparing the output
> with the tables of KMPS.
>
> For other untwisted Cartan types besides Type A, it now seems to work
> correctly. In many cases I can push the results farther than KMPS.
> Unfortunately for ``['E',8,1]`` it is not fast enough to compute very
> many weights, so for E8 I cannot duplicate their results.
>
> Due to a recursive caching scheme it can crash if pushed too hard.
> Obviously this should be fixed.
New description:
Integrable representations of Kac-Moody Lie algebras are parametrized by
dominant weights. They satisfy a character formula which is a
straightforward generalization of the Weyl character formula. See Kac,
Infinite-dimensional Lie algebras, Chapter 10. The weight multiplicities
may be computed using the Freudenthal multiplicity formula, and Kass,
Moody, Patera and Slansky (KMPS) in their book Affine Lie algebras, weight
multiplicities, and branching rules (1990) gave tables of these for affine
Lie algebras. We may duplicate their tables using Sage.
You can do the following with this code:
{{{
sage: Lambda =
RootSystem(['A',3,1]).weight_lattice(extended=true).fundamental_weights()
sage: IntegrableRepresentation(Lambda[1]+Lambda[2]+Lambda[3]).strings()
3*Lambda[2] - delta: 3 21 107 450 1638 5367 16194 45687 121876 310056
757056 1783324
2*Lambda[0] + Lambda[2]: 4 31 161 665 2380 7658 22721 63120 166085 417295
1007601 2349655
Lambda[1] + Lambda[2] + Lambda[3]: 1 10 60 274 1056 3601 11199 32354 88009
227555 563390 1343178
Lambda[0] + 2*Lambda[3]: 2 18 99 430 1593 5274 16005 45324 121200 308829
754884 1779570
Lambda[0] + 2*Lambda[1]: 2 18 99 430 1593 5274 16005 45324 121200 308829
754884 1779570
}}}
This creates the representation of `A_3^{(1)}` with highest weight
``Lambda[1]+Lambda[2]+Lambda[3]``. It then computes the five dominant
maximal weights and the corresponding weight strings. Every weight
multiplicity occurs in one of these strings, and by results of Kac and
Peterson, they are the Fourier coefficients of modular forms. The code is
reasonably fast and I've tested it up to rank 8, comparing the output with
the tables of KMPS.
--
--
Ticket URL: <http://trac.sagemath.org/ticket/15806#comment:31>
Sage <http://www.sagemath.org>
Sage: Creating a Viable Open Source Alternative to Magma, Maple, Mathematica,
and MATLAB
--
You received this message because you are subscribed to the Google Groups
"sage-trac" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/sage-trac.
For more options, visit https://groups.google.com/d/optout.
