Integrable Representations of Affine Lie Algebras¶
-
class
sage.combinat.root_system.integrable_representations.
IntegrableRepresentation
(Lam)¶ Bases:
sage.structure.category_object.CategoryObject
,sage.structure.unique_representation.UniqueRepresentation
An irreducible integrable highest weight representation of an affine Lie algebra.
INPUT:
Lam
– a dominant weight in an extended weight lattice of affine type
REFERENCES:
[Kac] (1, 2, 3, 4, 5, 6, 7) Kac, Infinite-dimensional Lie algebras, Third Edition. Cambridge, 1990. [KMPS] Kass, Moody, Patera and Slansky, Affine Lie algebras, weight multiplicities, and branching rules. Vols. 1, 2. University of California Press, Berkeley, CA, 1990. [KacPeterson] (1, 2) Kac and Peterson. Infinite-dimensional Lie algebras, theta functions and modular forms. Adv. in Math. 53 (1984), no. 2, 125-264. If
is a dominant integral weight for an affine root system, there exists a unique integrable representation
of highest weight
. If
is another weight, let
denote the multiplicity of the weight
in this representation. The set
of
such that
is contained in the paraboloid
where
is the invariant inner product on the weight lattice and
is the Weyl vector. Moreover if
then
differs from
by an element of the root lattice ([Kac], Propositions 11.3 and 11.4).
Let
be the nullroot, which is the lowest positive imaginary root. Then by [Kac], Proposition 11.3 or Corollary 11.9, for fixed
the function
is a monotone increasing function of
. It is useful to take
to be such that this function is nonzero if and only if
. Therefore we make the following definition. If
is such that
but
then
is called maximal.
Since
is fixed under the action of the affine Weyl group, and since the weight multiplicities are Weyl group invariant, the function
is unchanged if
is replaced by an equivalent weight. Therefore in tabulating these functions, we may assume that
is dominant. There are only a finite number of dominant maximal weights.
Since every nonzero weight multiplicity appears in the string
for one of the finite number of dominant maximal weights
, it is important to be able to compute these. We may do this as follows.
EXAMPLES:
sage: Lambda = RootSystem(['A',3,1]).weight_lattice(extended=true).fundamental_weights() sage: IntegrableRepresentation(Lambda[1]+Lambda[2]+Lambda[3]).print_strings() 2*Lambda[0] + Lambda[2]: 4 31 161 665 2380 7658 22721 63120 166085 417295 1007601 2349655 Lambda[0] + 2*Lambda[1]: 2 18 99 430 1593 5274 16005 45324 121200 308829 754884 1779570 Lambda[0] + 2*Lambda[3]: 2 18 99 430 1593 5274 16005 45324 121200 308829 754884 1779570 Lambda[1] + Lambda[2] + Lambda[3]: 1 10 60 274 1056 3601 11199 32354 88009 227555 563390 1343178 3*Lambda[2] - delta: 3 21 107 450 1638 5367 16194 45687 121876 310056 757056 1783324 sage: Lambda = RootSystem(['D',4,1]).weight_lattice(extended=true).fundamental_weights() sage: IntegrableRepresentation(Lambda[0]+Lambda[1]).print_strings() # long time Lambda[0] + Lambda[1]: 1 10 62 293 1165 4097 13120 38997 109036 289575 735870 1799620 Lambda[3] + Lambda[4] - delta: 3 25 136 590 2205 7391 22780 65613 178660 463842 1155717 2777795
In this example, we construct the extended weight lattice of Cartan type
, then define
Lambda
to be the fundamental weights. We find there are 5 maximal dominant weights in irreducible representation of highest weight
, and we determine their strings.
It was shown in [KacPeterson] that each string is the set of Fourier coefficients of a modular form.
Every weight
such that the weight multiplicity
is nonzero has the form
where the
are nonnegative integers. This is represented internally as a tuple
. If you want an individual multiplicity you use the method
m()
and supply it with this tuple:sage: Lambda = RootSystem(['C',2,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(2*Lambda[0]); V Integrable representation of ['C', 2, 1] with highest weight 2*Lambda[0] sage: V.m((3,5,3)) 18
The
IntegrableRepresentation
class has methodsto_weight()
andfrom_weight()
to convert between this internal representation and the weight lattice:sage: delta = V.weight_lattice().null_root() sage: V.to_weight((4,3,2)) -3*Lambda[0] + 6*Lambda[1] - Lambda[2] - 4*delta sage: V.from_weight(-3*Lambda[0] + 6*Lambda[1] - Lambda[2] - 4*delta) (4, 3, 2)
To get more values, use the depth parameter:
sage: L0 = RootSystem(["A",1,1]).weight_lattice(extended=true).fundamental_weight(0); L0 Lambda[0] sage: IntegrableRepresentation(4*L0).print_strings(depth=20) 4*Lambda[0]: 1 1 3 6 13 23 44 75 131 215 354 561 889 1368 2097 3153 4712 6936 10151 14677 2*Lambda[0] + 2*Lambda[1] - delta: 1 2 5 10 20 36 66 112 190 310 501 788 1230 1880 2850 4256 6303 9222 13396 19262 4*Lambda[1] - 2*delta: 1 2 6 11 23 41 75 126 215 347 561 878 1368 2082 3153 4690 6936 10121 14677 21055
An example in type
:
sage: Lambda = RootSystem(['C',2,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(2*Lambda[0]) sage: V.print_strings() # long time 2*Lambda[0]: 1 2 9 26 77 194 477 1084 2387 5010 10227 20198 Lambda[0] + Lambda[2] - delta: 1 5 18 55 149 372 872 1941 4141 8523 17005 33019 2*Lambda[1] - delta: 1 4 15 44 122 304 721 1612 3469 7176 14414 28124 2*Lambda[2] - 2*delta: 2 7 26 72 194 467 1084 2367 5010 10191 20198 38907
-
branch
(i=None, weyl_character_ring=None, sequence=None, depth=5)¶ Return the branching rule on
self
.Removing any node from the extended Dynkin diagram of the affine Lie algebra results in the Dynkin diagram of a classical Lie algebra, which is therefore a Lie subalgebra. For example removing the
node from the Dynkin diagram of type
[X, r, 1]
produces the classical Dynkin diagram of[X, r]
.Thus for each
in the index set, we may restrict
self
to the corresponding classical subalgebra. Of courseself
is an infinite dimensional representation, but each weightis assigned a grading by the number of times the simple root
appears in
. Thus the branched representation is graded and we get sequence of finite-dimensional representations which this method is able to compute.
OPTIONAL:
i
– (default: 0) an element of the index setweyl_character_ring
– a WeylCharacterRingsequence
– a dictionarydepth
– (default: 5) an upper bound fordetermining how many terms to give
In the default case where
, you do not need to specify anything else, though you may want to increase the depth if you need more terms.
EXAMPLES:
sage: Lambda = RootSystem(['A',2,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(2*Lambda[0]) sage: b = V.branch(); b [A2(0,0), A2(1,1), A2(0,0) + 2*A2(1,1) + A2(2,2), 2*A2(0,0) + 2*A2(0,3) + 4*A2(1,1) + 2*A2(3,0) + 2*A2(2,2), 4*A2(0,0) + 3*A2(0,3) + 10*A2(1,1) + 3*A2(3,0) + A2(1,4) + 6*A2(2,2) + A2(4,1), 6*A2(0,0) + 9*A2(0,3) + 20*A2(1,1) + 9*A2(3,0) + 3*A2(1,4) + 12*A2(2,2) + 3*A2(4,1) + A2(3,3)]
If the parameter
weyl_character_ring
is omitted, the ring may be recovered as the parent of one of the branched coefficients:sage: A2 = b[0].parent(); A2 The Weyl Character Ring of Type A2 with Integer Ring coefficients
If
is not zero then you should specify the
WeylCharacterRing
that you are branching to. This is determined by the Dynkin diagram:sage: Lambda = RootSystem(['B',3,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(Lambda[0]) sage: V.cartan_type().dynkin_diagram() O 0 | | O---O=>=O 1 2 3 B3~
In this example, we observe that removing the
node from the Dynkin diagram produces a reducible diagram of type
A1xA1xA1
. Thus we have a branching to:
sage: A1xA1xA1 = WeylCharacterRing("A1xA1xA1",style="coroots") sage: V.branch(i=2,weyl_character_ring=A1xA1xA1) [A1xA1xA1(1,0,0), A1xA1xA1(0,1,2), A1xA1xA1(1,0,0) + A1xA1xA1(1,2,0) + A1xA1xA1(1,0,2), A1xA1xA1(2,1,2) + A1xA1xA1(0,1,0) + 2*A1xA1xA1(0,1,2), 3*A1xA1xA1(1,0,0) + 2*A1xA1xA1(1,2,0) + A1xA1xA1(1,2,2) + 2*A1xA1xA1(1,0,2) + A1xA1xA1(1,0,4) + A1xA1xA1(3,0,0), A1xA1xA1(2,1,0) + 3*A1xA1xA1(2,1,2) + 2*A1xA1xA1(0,1,0) + 5*A1xA1xA1(0,1,2) + A1xA1xA1(0,1,4) + A1xA1xA1(0,3,2)]
If the nodes of the two Dynkin diagrams are not in the same order, you must specify an additional parameter,
sequence
which gives a dictionary to the affine Dynkin diagram to the classical one.EXAMPLES:
sage: Lambda = RootSystem(['F',4,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(Lambda[0]) sage: V.cartan_type().dynkin_diagram() O---O---O=>=O---O 0 1 2 3 4 F4~ sage: A1xC3=WeylCharacterRing("A1xC3",style="coroots") sage: A1xC3.dynkin_diagram() O 1 O---O=<=O 2 3 4 A1xC3
Observe that removing the
node from the
F4~
Dynkin diagram gives theA1xC3
diagram, but the roots are in a different order. The nodesof
F4~
correspond to1, 4, 3, 2
ofA1xC3
and so we encode this in a dictionary:sage: V.branch(i=1,weyl_character_ring=A1xC3,sequence={0:1,2:4,3:3,4:2}) # long time [A1xC3(1,0,0,0), A1xC3(0,0,0,1), A1xC3(1,0,0,0) + A1xC3(1,2,0,0), A1xC3(2,0,0,1) + A1xC3(0,0,0,1) + A1xC3(0,1,1,0), 2*A1xC3(1,0,0,0) + A1xC3(1,0,1,0) + 2*A1xC3(1,2,0,0) + A1xC3(1,0,2,0) + A1xC3(3,0,0,0), 2*A1xC3(2,0,0,1) + A1xC3(2,1,1,0) + A1xC3(0,1,0,0) + 3*A1xC3(0,0,0,1) + 2*A1xC3(0,1,1,0) + A1xC3(0,2,0,1)]
The branch method gives a way of computing the graded dimension of the integrable representation:
sage: Lambda = RootSystem("A1~").weight_lattice(extended=true).fundamental_weights() sage: V=IntegrableRepresentation(Lambda[0]) sage: r = [x.degree() for x in V.branch(depth=15)]; r [1, 3, 4, 7, 13, 19, 29, 43, 62, 90, 126, 174, 239, 325, 435, 580] sage: oeis(r) # optional -- internet 0: A029552: Expansion of phi(x) / f(-x) in powers of x where phi(), f() are Ramanujan theta functions.
-
cartan_type
()¶ Return the Cartan type of
self
.EXAMPLES:
sage: Lambda = RootSystem(['F',4,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(Lambda[0]) sage: V.cartan_type() ['F', 4, 1]
-
coxeter_number
()¶ Return the Coxeter number of the Cartan type of
self
.The Coxeter number is defined in [Kac] Chapter 6, and commonly denoted
.
EXAMPLES:
sage: Lambda = RootSystem(['F',4,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(Lambda[0]) sage: V.coxeter_number() 12
-
dominant_maximal_weights
()¶ Return the dominant maximal weights of
self
.A weight
is maximal if it has nonzero multiplicity but
has multiplicity zero. There are a finite number of dominant maximal weights. Indeed, [Kac] Proposition 12.6 shows that the dominant maximal weights are in bijection with the classical weights in
where
is the fundamental alcove and
is the level. The construction used in this method is based on that Proposition.
EXAMPLES:
sage: Lambda = RootSystem(['C',3,1]).weight_lattice(extended=true).fundamental_weights() sage: IntegrableRepresentation(2*Lambda[0]).dominant_maximal_weights() (2*Lambda[0], Lambda[0] + Lambda[2] - delta, 2*Lambda[1] - delta, Lambda[1] + Lambda[3] - 2*delta, 2*Lambda[2] - 2*delta, 2*Lambda[3] - 3*delta)
-
dual_coxeter_number
()¶ Return the dual Coxeter number of the Cartan type of
self
.The dual Coxeter number is defined in [Kac] Chapter 6, and commonly denoted
.
EXAMPLES:
sage: Lambda = RootSystem(['F',4,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(Lambda[0]) sage: V.dual_coxeter_number() 9
-
from_weight
(mu)¶ Return the tuple
such that
mu
equalsin
self
, whereis the highest weight of
self
.EXAMPLES:
sage: Lambda = RootSystem(['A',2,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(2*Lambda[2]) sage: V.to_weight((1,0,0)) -2*Lambda[0] + Lambda[1] + 3*Lambda[2] - delta sage: delta = V.weight_lattice().null_root() sage: V.from_weight(-2*Lambda[0] + Lambda[1] + 3*Lambda[2] - delta) (1, 0, 0)
-
highest_weight
()¶ Returns the highest weight of
self
.EXAMPLES:
sage: Lambda = RootSystem(['D',4,1]).weight_lattice(extended=true).fundamental_weights() sage: IntegrableRepresentation(Lambda[0]+2*Lambda[2]).highest_weight() Lambda[0] + 2*Lambda[2]
-
level
()¶ Return the level of
self
.The level of a highest weight representation
is defined as
See [Kac] section 12.4.
EXAMPLES:
sage: Lambda = RootSystem(['G',2,1]).weight_lattice(extended=true).fundamental_weights() sage: [IntegrableRepresentation(Lambda[i]).level() for i in [0,1,2]] [1, 1, 2]
-
m
(n)¶ Return the multiplicity of the weight
in
self
, where.
INPUT:
n
– a tuple representing a weight.
EXAMPLES:
sage: Lambda = RootSystem(['E',6,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(Lambda[0]) sage: u = V.highest_weight() - V.weight_lattice().null_root() sage: V.from_weight(u) (1, 1, 2, 2, 3, 2, 1) sage: V.m(V.from_weight(u)) 6
-
modular_characteristic
(mu=None)¶ Return the modular characteristic of
self
.The modular characteristic is a rational number introduced by Kac and Peterson [KacPeterson], required to interpret the string functions as Fourier coefficients of modular forms. See [Kac] Section 12.7. Let
be the level, and let
be the dual Coxeter number. Then
If
is a weight, then
OPTIONAL:
mu
– a weight; or alternatively:n
– a tuple representing a weight.
If no optional parameter is specified, this returns
. If
mu
is specified, it returns. You may use the tuple
n
to specify. If you do this,
is
.
EXAMPLES:
sage: Lambda = RootSystem(['A',1,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(3*Lambda[0]+2*Lambda[1]) sage: [V.modular_characteristic(x) for x in V.dominant_maximal_weights()] [11/56, -1/280, 111/280]
-
print_strings
(depth=12)¶ Print the strings of
self
.See also
EXAMPLES:
sage: Lambda = RootSystem(['A',1,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(2*Lambda[0]) sage: V.print_strings(depth=25) 2*Lambda[0]: 1 1 3 5 10 16 28 43 70 105 161 236 350 501 722 1016 1431 1981 2741 3740 5096 6868 9233 12306 16357 2*Lambda[1] - delta: 1 2 4 7 13 21 35 55 86 130 196 287 420 602 858 1206 1687 2331 3206 4368 5922 7967 10670 14193 18803
-
root_lattice
()¶ Return the root lattice associated to
self
.EXAMPLES:
sage: V=IntegrableRepresentation(RootSystem(['F',4,1]).weight_lattice(extended=true).fundamental_weight(0)) sage: V.root_lattice() Root lattice of the Root system of type ['F', 4, 1]
-
s
(n, i)¶ Return the action of the
i
-th simple reflection on the internal representation of weights by tuplesn
inself
.EXAMPLES:
sage: V = IntegrableRepresentation(RootSystem(['A',2,1]).weight_lattice(extended=true).fundamental_weight(0)) sage: [V.s((0,0,0),i) for i in V._index_set] [(1, 0, 0), (0, 0, 0), (0, 0, 0)]
-
string
(max_weight, depth=12)¶ Return the list of multiplicities
in
self
, whereis
max_weight
andruns from
to
depth
.INPUT:
max_weight
– a dominant maximal weightdepth
– (default: 12) the maximum value of
EXAMPLES:
sage: Lambda = RootSystem(['A',2,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(2*Lambda[0]) sage: V.string(2*Lambda[0]) [1, 2, 8, 20, 52, 116, 256, 522, 1045, 1996, 3736, 6780] sage: V.string(Lambda[1] + Lambda[2]) [0, 1, 4, 12, 32, 77, 172, 365, 740, 1445, 2736, 5041]
-
strings
(depth=12)¶ Return the set of dominant maximal weights of
self
, together with the string coefficients for each.OPTIONAL:
depth
– (default: 12) a parameter indicating how far to push computations
EXAMPLES:
sage: Lambda = RootSystem(['A',1,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(2*Lambda[0]) sage: S = V.strings(depth=25) sage: for k in S: ....: print "{}: {}".format(k, ' '.join(str(x) for x in S[k])) 2*Lambda[0]: 1 1 3 5 10 16 28 43 70 105 161 236 350 501 722 1016 1431 1981 2741 3740 5096 6868 9233 12306 16357 2*Lambda[1] - delta: 1 2 4 7 13 21 35 55 86 130 196 287 420 602 858 1206 1687 2331 3206 4368 5922 7967 10670 14193 18803
-
to_dominant
(n)¶ Return the dominant weight in
self
equivalent ton
under the affine Weyl group.EXAMPLES:
sage: Lambda = RootSystem(['A',2,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(3*Lambda[0]) sage: n = V.to_dominant((13,11,7)); n (4, 3, 3) sage: V.to_weight(n) Lambda[0] + Lambda[1] + Lambda[2] - 4*delta
-
to_weight
(n)¶ Return the weight associated to the tuple
n
inself
.If
n
is the tuple, then the associated weight is
, where
is the weight of the representation.
INPUT:
n
– a tuple representing a weight
EXAMPLES:
sage: Lambda = RootSystem(['A',2,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(2*Lambda[2]) sage: V.to_weight((1,0,0)) -2*Lambda[0] + Lambda[1] + 3*Lambda[2] - delta
-
weight_lattice
()¶ Return the weight lattice associated to
self
.EXAMPLES:
sage: V=IntegrableRepresentation(RootSystem(['E',6,1]).weight_lattice(extended=true).fundamental_weight(0)) sage: V.weight_lattice() Extended weight lattice of the Root system of type ['E', 6, 1]