#15806: Integrable representations of (affine) Kac-Moody Lie Algebras
-------------------------------------+-------------------------------------
Reporter: bump | Owner: bump
Type: enhancement | Status: needs_review
Priority: major | Milestone: sage-6.4
Component: combinatorics | Resolution:
Keywords: Kac-Moody, | Merged in:
Integrable Representation, Affine | Reviewers:
Lie Algebra | Work issues:
Authors: bump | Commit:
Report Upstream: N/A | c1aae477f9b8eb4acbb638d64524a467351f512f
Branch: | Stopgaps:
public/combinat/integrable-15806 |
Dependencies: |
-------------------------------------+-------------------------------------
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, modular characteristics and branching rules
> (1990) gave tables of these for affine Lie algebras. We may duplicate
> their tables of modular characteristics and weight multiplicities using
> Sage.
>
> This patch creates a class for integrable representations of untwisted
> affine Lie algebras.
>
> {{{
> 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.
>
> Only untwisted affine Cartan types are implemented in this patch. A
> number of other methods such as the modular characteristic are available
> as methods of the class.
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, modular characteristics and branching rules (1990) gave
tables of these for affine Lie algebras. We may duplicate their tables of
modular characteristics and weight multiplicities using Sage.
This patch creates a class for integrable representations of untwisted
affine Lie algebras.
{{{
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.
Only untwisted affine Cartan types are implemented in this patch. A number
of other methods such as the modular characteristic are available as
methods of the class. We can do the branching rules as follows:
{{{
sage: Lambda =
RootSystem(['D',4,1]).weight_lattice(extended=true).fundamental_weights()
sage: v = IntegrableRepresentation(Lambda[2])
sage: v.cartan_type().dynkin_diagram()
O 4
|
|
O---O---O
1 |2 3
|
O 0
D4~
sage: A1xA1xA1xA1 = WeylCharacterRing("A1xA1xA1xA1",style="coroots")
sage: v.branch(i=2,weyl_character_ring=A1xA1xA1xA1)
[A1xA1xA1xA1(0,0,0,0),
A1xA1xA1xA1(1,1,1,1),
A1xA1xA1xA1(0,0,0,0) + A1xA1xA1xA1(2,0,0,0) + A1xA1xA1xA1(2,2,0,0) +
A1xA1xA1xA1(2,0,2,0) + A1xA1xA1xA1(2,0,0,2) + A1xA1xA1xA1(0,2,0,0) +
A1xA1xA1xA1(0,2,2,0) + A1xA1xA1xA1(0,2,0,2) + A1xA1xA1xA1(0,0,2,0) + A1x\
A1xA1xA1(0,0,2,2) + A1xA1xA1xA1(0,0,0,2),
7*A1xA1xA1xA1(1,1,1,1) + A1xA1xA1xA1(1,1,1,3) + A1xA1xA1xA1(1,1,3,1) +
A1xA1xA1xA1(1,3,1,1) + A1xA1xA1xA1(3,1,1,1),
7*A1xA1xA1xA1(0,0,0,0) + 5*A1xA1xA1xA1(2,0,0,0) + 4*A1xA1xA1xA1(2,2,0,0)
+ 3*A1xA1xA1xA1(2,2,2,0) + A1xA1xA1xA1(2,2,2,2) + 3*A1xA1xA1xA1(2,2,0,2) +
4*A1xA1xA1xA1(2,0,2,0) + 3*A1xA1xA1xA1(2,0,2,2) + 4*A1xA1xA1xA\
1(2,0,0,2) + A1xA1xA1xA1(4,0,0,0) + 5*A1xA1xA1xA1(0,2,0,0) +
4*A1xA1xA1xA1(0,2,2,0) + 3*A1xA1xA1xA1(0,2,2,2) + 4*A1xA1xA1xA1(0,2,0,2) +
A1xA1xA1xA1(0,4,0,0) + 5*A1xA1xA1xA1(0,0,2,0) + 4*A1xA1xA1xA1(0,0,2,2) +
A1\
xA1xA1xA1(0,0,4,0) + 5*A1xA1xA1xA1(0,0,0,2) + A1xA1xA1xA1(0,0,0,4),
30*A1xA1xA1xA1(1,1,1,1) + 8*A1xA1xA1xA1(1,1,1,3) + 8*A1xA1xA1xA1(1,1,3,1)
+ A1xA1xA1xA1(1,1,3,3) + 8*A1xA1xA1xA1(1,3,1,1) + A1xA1xA1xA1(1,3,1,3) +
A1xA1xA1xA1(1,3,3,1) + 8*A1xA1xA1xA1(3,1,1,1) + A1xA1xA1xA1(3,1\
,1,3) + A1xA1xA1xA1(3,1,3,1) + A1xA1xA1xA1(3,3,1,1)]
}}}
--
Comment (by bump):
I think everything I wanted to implement is now implemented.
Here is a link to the reference manual documentation for this patch.
http://sporadic.stanford.edu/reference/combinat/sage/combinat/root_system/integrable_representations.html
--
Ticket URL: <http://trac.sagemath.org/ticket/15806#comment:50>
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.
