Weyl Character Rings

sage.combinat.root_system.weyl_characters.FusionRing

Return the Fusion Ring (Verlinde Algebra) of level k.

INPUT:

  • ct – the Cartan type of a simple (finite-dimensional) Lie algebra
  • k – a nonnegative integer

This algebra has a basis indexed by the weights of level \(\leq k\). It is implemented as a variant of the WeylCharacterRing.

EXAMPLES:

sage: A22 = FusionRing("A2",2)
sage: [f1, f2] = A22.fundamental_weights()
sage: M = [A22(x) for x in [0*f1, 2*f1, 2*f2, f1+f2, f2, f1]]
sage: [M[3] * x for x in M]
[A22(1,1),
 A22(0,1),
 A22(1,0),
 A22(0,0) + A22(1,1),
 A22(0,1) + A22(2,0),
 A22(1,0) + A22(0,2)]

You may assign your own labels to the basis elements. In the next example, we create the \(SO(5)\) fusion ring of level \(2\), check the weights of the basis elements, then assign new labels to them:

sage: B22 = FusionRing("B2", 2)
sage: sorted(B22.basis(), key=str)
[B22(0,0), B22(0,1), B22(0,2), B22(1,0), B22(1,1), B22(2,0)]
sage: sorted([x.highest_weight() for x in B22.basis()], key=str)
[(0, 0), (1, 0), (1, 1), (1/2, 1/2), (2, 0), (3/2, 1/2)]
sage: B22.fusion_labels(['1','X','Y1','Z','Xp','Y2'])
sage: list(B22.basis())
[1, X, Y1, Z, Xp, Y2]
sage: X*Y1
X + Xp
sage: Z*Z
1

sage: C22 = FusionRing("C2", 2)
sage: sorted(C22.basis(), key=str)
[C22(0,0), C22(0,1), C22(0,2), C22(1,0), C22(1,1), C22(2,0)]

REFERENCES:

sage.combinat.root_system.weyl_characters.WeightRing

The weight ring, which is the group algebra over a weight lattice.

A Weyl character may be regarded as an element of the weight ring. In fact, an element of the weight ring is an element of the Weyl character ring if and only if it is invariant under the action of the Weyl group.

The advantage of the weight ring over the Weyl character ring is that one may conduct calculations in the weight ring that involve sums of weights that are not Weyl group invariant.

EXAMPLES:

sage: A2 = WeylCharacterRing(['A',2])
sage: a2 = WeightRing(A2)
sage: wd = prod(a2(x/2)-a2(-x/2) for x in a2.space().positive_roots()); wd
a2(-1,1,0) - a2(-1,0,1) - a2(1,-1,0) + a2(1,0,-1) + a2(0,-1,1) - a2(0,1,-1)
sage: chi = A2([5,3,0]); chi
A2(5,3,0)
sage: a2(chi)
a2(1,2,5) + 2*a2(1,3,4) + 2*a2(1,4,3) + a2(1,5,2) + a2(2,1,5)
+ 2*a2(2,2,4) + 3*a2(2,3,3) + 2*a2(2,4,2) + a2(2,5,1) + 2*a2(3,1,4)
+ 3*a2(3,2,3) + 3*a2(3,3,2) + 2*a2(3,4,1) + a2(3,5,0) + a2(3,0,5)
+ 2*a2(4,1,3) + 2*a2(4,2,2) + 2*a2(4,3,1) + a2(4,4,0) + a2(4,0,4)
+ a2(5,1,2) + a2(5,2,1) + a2(5,3,0) + a2(5,0,3) + a2(0,3,5)
+ a2(0,4,4) + a2(0,5,3)
sage: a2(chi)*wd
-a2(-1,3,6) + a2(-1,6,3) + a2(3,-1,6) - a2(3,6,-1) - a2(6,-1,3) + a2(6,3,-1)
sage: sum((-1)^w.length()*a2([6,3,-1]).weyl_group_action(w) for w in a2.space().weyl_group())
-a2(-1,3,6) + a2(-1,6,3) + a2(3,-1,6) - a2(3,6,-1) - a2(6,-1,3) + a2(6,3,-1)
sage: a2(chi)*wd == sum((-1)^w.length()*a2([6,3,-1]).weyl_group_action(w) for w in a2.space().weyl_group())
True
sage.combinat.root_system.weyl_characters.WeylCharacterRing

A class for rings of Weyl characters.

Let \(K\) be a compact Lie group, which we assume is semisimple and simply-connected. Its complexified Lie algebra \(L\) is the Lie algebra of a complex analytic Lie group \(G\). The following three categories are equivalent: finite-dimensional representations of \(K\); finite-dimensional representations of \(L\); and finite-dimensional analytic representations of \(G\). In every case, there is a parametrization of the irreducible representations by their highest weight vectors. For this theory of Weyl, see (for example):

  • Adams, Lectures on Lie groups
  • Broecker and Tom Dieck, Representations of Compact Lie groups
  • Bump, Lie Groups
  • Fulton and Harris, Representation Theory
  • Goodman and Wallach, Representations and Invariants of the Classical Groups
  • Hall, Lie Groups, Lie Algebras and Representations
  • Humphreys, Introduction to Lie Algebras and their representations
  • Procesi, Lie Groups
  • Samelson, Notes on Lie Algebras
  • Varadarajan, Lie groups, Lie algebras, and their representations
  • Zhelobenko, Compact Lie Groups and their Representations.

Computations that you can do with these include computing their weight multiplicities, products (thus decomposing the tensor product of a representation into irreducibles) and branching rules (restriction to a smaller group).

There is associated with \(K\), \(L\) or \(G\) as above a lattice, the weight lattice, whose elements (called weights) are characters of a Cartan subgroup or subalgebra. There is an action of the Weyl group \(W\) on the lattice, and elements of a fixed fundamental domain for \(W\), the positive Weyl chamber, are called dominant. There is for each representation a unique highest dominant weight that occurs with nonzero multiplicity with respect to a certain partial order, and it is called the highest weight vector.

EXAMPLES:

sage: L = RootSystem("A2").ambient_space()
sage: [fw1,fw2] = L.fundamental_weights()
sage: R = WeylCharacterRing(['A',2], prefix="R")
sage: [R(1),R(fw1),R(fw2)]
[R(0,0,0), R(1,0,0), R(1,1,0)]

Here R(1), R(fw1), and R(fw2) are irreducible representations with highest weight vectors \(0\), \(\Lambda_1\), and \(\Lambda_2\) respectively (the first two fundamental weights).

For type \(A\) (also \(G_2\), \(F_4\), \(E_6\) and \(E_7\)) we will take as the weight lattice not the weight lattice of the semisimple group, but for a larger one. For type \(A\), this means we are concerned with the representation theory of \(K = U(n)\) or \(G = GL(n, \CC)\) rather than \(SU(n)\) or \(SU(n, \CC)\). This is useful since the representation theory of \(GL(n)\) is ubiquitous, and also since we may then represent the fundamental weights (in sage.combinat.root_system.root_system) by vectors with integer entries. If you are only interested in \(SL(3)\), say, use WeylCharacterRing(['A',2]) as above but be aware that R([a,b,c]) and R([a+1,b+1,c+1]) represent the same character of \(SL(3)\) since R([1,1,1]) is the determinant.

For more information, see the thematic tutorial Lie Methods and Related Combinatorics in Sage, available at:

https://doc.sagemath.org/html/en/thematic_tutorials/lie.html

sage.combinat.root_system.weyl_characters.irreducible_character_freudenthal(hwv, debug=False)

Return the dictionary of multiplicities for the irreducible character with highest weight \(\lambda\).

The weight multiplicities are computed by the Freudenthal multiplicity formula. The algorithm is based on recursion relation that is stated, for example, in Humphrey’s book on Lie Algebras. The multiplicities are invariant under the Weyl group, so to compute them it would be sufficient to compute them for the weights in the positive Weyl chamber. However after some testing it was found to be faster to compute every weight using the recursion, since the use of the Weyl group is expensive in its current implementation.

INPUT:

  • hwv – a dominant weight in a weight lattice.
  • L – the ambient space

EXAMPLES:

sage: WeylCharacterRing("A2")(2,1,0).weight_multiplicities() # indirect doctest
{(1, 1, 1): 2, (1, 2, 0): 1, (1, 0, 2): 1, (2, 1, 0): 1,
 (2, 0, 1): 1, (0, 1, 2): 1, (0, 2, 1): 1}