representationWeights -- computes the weights of the basis of a Lie algebra module from an explicit representation

Usage:

representationWeights(rho)
Inputs:
- rho, an instance of the type LieAlgebraRepresentation,
Outputs:
- L, a list,

Description

Let $\rho: \mathfrak{g} \rightarrow \mathfrak{gl}(V)$ be a Lie algebra representation.

This function first checks that for the Cartan subalgebra elements $H_i$ in the basis of $\mathfrak{g}$, the image $\rho(H_i)$ is a diagonal matrix. If not, this function returns an error that the basis of $V$ in use is not an eigenbasis for the Cartan subalgebra. Otherwise, this function returns the list of weights of these basis elements, which are obtained from the diagonal entries of the matrices $\rho(H_i)$.

In the example below, we compute the weights of the Gelfand-Tsetlin basis for the adjoint representation of $sl_3$.

i1 : sl3 = simpleLieAlgebra("A",2);

i2 : V=irreducibleLieAlgebraModule({1,1},sl3);

i3 : LAB = lieAlgebraBasis("A",2);

i4 : L1 = GTrepresentationMatrices(V);

i5 : rho = lieAlgebraRepresentation(V,LAB,L1);

i6 : L2 = representationWeights(rho)

o6 = {{1, 1}, {-1, 2}, {2, -1}, {0, 0}, {-2, 1}, {0, 0}, {1, -2}, {-1, -1}}

o6 : List

We can check that this agrees with the weight of the Gelfand-Tsetlin pattern labelling each basis element.

i7 : dynkinToPartition("A",{1,1})

o7 = {2, 1, 0}

o7 : List

i8 : L3 = gtPatterns("A",{2,1,0})

o8 = {{2, 1, 0, 2, 1, 2}, {2, 1, 0, 2, 1, 1}, {2, 1, 0, 2, 0, 2}, {2, 1, 0,
     ------------------------------------------------------------------------
     2, 0, 1}, {2, 1, 0, 2, 0, 0}, {2, 1, 0, 1, 1, 1}, {2, 1, 0, 1, 0, 1},
     ------------------------------------------------------------------------
     {2, 1, 0, 1, 0, 0}}

o8 : List

Right now, the entries of L3 are just lists. We turn them into objects of type GTPattern, and then get their weights.

i9 : L3 = apply(L3, x -> (gtPatternFromEntries("A",x))#"weight")

o9 = {{1, 1}, {-1, 2}, {2, -1}, {0, 0}, {-2, 1}, {0, 0}, {1, -2}, {-1, -1}}

o9 : List

i10 : L2==L3

o10 = true

Finally, we check that this agrees with the weight diagram of V.

i11 : tally(L3)

o11 = Tally{{-1, -1} => 1}
            {-1, 2} => 1
            {-2, 1} => 1
            {0, 0} => 2
            {1, -2} => 1
            {1, 1} => 1
            {2, -1} => 1

o11 : Tally

i12 : weightDiagram(V)

o12 = VirtualTally{{-1, -1} => 1}
                   {-1, 2} => 1
                   {-2, 1} => 1
                   {0, 0} => 2
                   {1, -2} => 1
                   {1, 1} => 1
                   {2, -1} => 1

o12 : VirtualTally

i13 : weightDiagram(V) === new VirtualTally from tally(L3)

o13 = true

Ways to use representationWeights:

representationWeights(LieAlgebraRepresentation)

For the programmer

The object representationWeights is a method function.

The source of this document is in LieAlgebraRepresentations/documentation.m2:1763:0.