#15806: Integrable representations of (affine) Kac-Moody Lie Algebras
-------------------------------------+-------------------------------------
       Reporter:  bump               |        Owner:  bump
           Type:  enhancement        |       Status:  needs_review
       Priority:  major              |    Milestone:  sage-6.7
      Component:  combinatorics      |   Resolution:
       Keywords:  Kac-Moody,         |    Merged in:
  Integrable Representation, Affine  |    Reviewers:
  Lie Algebra                        |  Work issues:
        Authors:  bump               |       Commit:
Report Upstream:  N/A                |  0cf5be88ef55251e5e032b1f2045dfdec13f8583
         Branch:                     |     Stopgaps:
  public/combinat/integrable-15806   |
   Dependencies:                     |
-------------------------------------+-------------------------------------
Description changed by bump:

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. 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)]
> }}}

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, weight multiplicities and branching rules 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)]
 }}}

--

--
Ticket URL: <http://trac.sagemath.org/ticket/15806#comment:54>
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.

Reply via email to