minuscule_weights.html

Introduction

The purpose of this worksheet is to explore the action of the Weyl groups (associated with simple Lie algebras) on weights of representations (particularly minuscule representations). Specifically, we want to know what kind of cycle structures appear when we view the Weyl group's action as a permutations of weights.

In general, a representation's weights may split up into several orbits. This can happen even when the representation is irreducible. In fact, since the Weyl group action preserves inner products (and thus preserves lengths), we must have multiple orbits in some cases. For example, anytime the zero vector is a weight, it is the sole occupant of its orbit. However, in the case of minuscule representations, all weights lie in a single orbit.

A minuscule representation is an irreducible representation in which all weights lie in a single Weyl group orbit. The highest weight of such a representation is said to be a minuscule weight. The highest weight space is always one-dimensional. Also, if two weights are in the same Weyl group orbit, then their weight spaces must have the same dimensions. Thus, all of the weight spaces of a minuscule representation are one-dimensional.

Thus minuscule representations behave quite nicely with respect to the Weyl group action. In fact, in some cases, we can "see" the irreducibility of the minuscule representation by inspecting the cycle structures of the permutations associated with the Weyl group's elements. An invariant subspace of a representation cannot share part of an orbit of weights, so if the cycle structures tell us that there is only one orbit, we must conclude that the representation is irreducible (this assumes that the weight spaces are one-dimensional, which may not be true if the highest weight is not minuscule).

In this worksheet, we will see that cycle structure determines irreducibility for minuscule representation associated with simple Lie algebras of types B2, B3, B5, B7, E6, and E7. The corresponding paper covers the types An, Cn, and Dn (all n). We will also see that cycle structure does not tell us enough in the case of B4 -- even though we are dealing with an irreducible minuscule representation.

Note: Please start with the "A4: Master Demo" which demonstrates how to use each of the procedures defined below.

In this worksheet, we will work in the Euclidean space C^m (m-dimensional complex space). All weights (including simple roots, fundamental weights, etc.) are written down in the standard basis: L_i = [0,...,0,1,0,...,0] (1 in the i-th position) for i=1,...,m. We give C^m the standard bilinear dot product:
( [a_1,a_2,...,a_m] | [b_1,b_2,...,b_m] ) = a_1 b_1 + a_2 b_2 + ... + a_m b_m.

We represent cycle structures by partitions. For example, suppose that some permutation sigma is the product of two 3-cycles, a transposition, and a 1-cycle (all disjoint). Therefore, sigma has cycle structure [3,3,2,1]. However, we will always suppress the 1's in these partitions. Thus, sigma has cycle strucutre [3,3,2].

Throughout this worksheet, V(lambda) will denote the irreducible representation with highest weight lambda.

Remember to Initialize!

Place your mouse next to the "restart" command below and press enter three times (this will add the group package
and define all of the necessary procedures in "Simple Lie Algebra Background Information" and "Weyl Group Action on Weights").

Initialize

> restart; with(group):

Simple Lie Algebra Background Information

SimpleLieTypeCheck -- checks for valid type and rank
CartanMatrix -- returns the Cartan matrix of the specified simple Lie algebra
DynkinDiagram -- plots the Dynkin diagram of the specified simple Lie algebra
SimpleRoots -- returns a base of simple roots for the specified simple Lie algebra
(from Fulton and Harris: pages 324,332,333 & the C-type bases have been rescaled)
FundamentalWeights -- returns the fundamental weights with respect to the base calculated in SimpleRoots

> # SimpleLieTypeCheck checks if the combination of type and rank is valid.
# lie_type should be a capital letter A,B,...,G and lie_rank a positive integer.
# SimpleLieTypeCheck returns true for valid combinations. For invalid combinations
# false is returned along with a warning message.
#
# Note: Warnings are given for types C2 and D3 since they are more properly
# referred to by the names B2 and A3 respectively.
SimpleLieTypeCheck := proc(lie_type, lie_rank)
  if (lie_type = 'A' and (not type(lie_rank,integer) or lie_rank <= 0)) then
     WARNING(cat("Invalid rank: ",lie_rank,". Rank must be a positive integer for type A."));
     false;
  elif (lie_type = 'B' and (not type(lie_rank,integer) or lie_rank <= 1)) then
     WARNING(cat("Invalid rank: ",lie_rank,". Rank must be an integer greater than 1 for type B."));
     false;
  elif (lie_type = 'C' and (not type(lie_rank,integer) or lie_rank <= 1)) then
     WARNING(cat("Invalid rank: ",lie_rank,". Rank must be an integer greater than 1 for type C."));
     false;
  elif (lie_type = 'D' and (not type(lie_rank,integer) or lie_rank <= 2)) then
     WARNING(cat("Invalid rank: ",lie_rank,". Rank must be an integer greater than 2 for type D."));
     false;
  elif (lie_type = 'E' and lie_rank <> 6 and lie_rank <> 7 and lie_rank <> 8) then
     WARNING(cat("Invalid rank: ",lie_rank,". Rank must be 6, 7, or 8 for type E."));
     false;
  elif (lie_type = 'F' and lie_rank <> 4) then
     WARNING(cat("Invalid rank: ",lie_rank,". Rank must be 4 for type F."));
     false;
  elif (lie_type = 'G' and lie_rank <> 2) then
     WARNING(cat("Invalid rank: ",lie_rank,". Rank must be 2 for type G."));
     false;
  elif (not (lie_type in {'A','B','C','D','E','F','G'})) then
     WARNING(cat("Invalid Type: ",lie_type)); # Invalid letter type.
     false;
  elif (lie_type = 'C' and lie_rank = 2) then
     # Looking at Dynkin diagrams it is easy to see that C2=B2.
     WARNING("Type C2 is more commonly known as B2 (they are isomorphic).");
     true;
  elif (lie_type = 'D' and lie_rank = 3) then
     # Looking at Dynkin diagrams it is easy to see that D3=A3.
     WARNING("Type D3 is more commonly known as A3 (they are isomorphic).");
     true;
  else
     true;
  end if;
end:

# CartanMatrix returns the Cartan matrix of the simple Lie algebra of the
# specified type and rank.
#
# Note: These matrices can be found in Humphreys, page 59.
CartanMatrix := proc(lie_type,lie_rank)
  if(SimpleLieTypeCheck(lie_type,lie_rank)) then
     if (lie_type = 'A') then
        # Type A Cartan Matrix
        linalg[matrix](lie_rank, lie_rank, [seq(seq(`if`(abs(i-j)=1,-1,
                       `if`(i=j,2,0)), j=1..lie_rank), i=1..lie_rank)]);
     elif (lie_type = 'B') then
        # Type B Cartan Matrix
        linalg[matrix](lie_rank, lie_rank, [seq(seq(`if`(i=lie_rank-1 and j=lie_rank, -2,
                       `if`(abs(i-j)=1, -1, `if`(i=j,2,0))), j=1..lie_rank), i=1..lie_rank)]);
     elif (lie_type = 'C') then
        # Type C Cartan Matrix
        linalg[matrix](lie_rank, lie_rank, [seq(seq(`if`(i=lie_rank and j=lie_rank-1, -2,
                       `if`(abs(i-j)=1, -1, `if`(i=j,2,0))), j=1..lie_rank), i=1..lie_rank)]);
     elif (lie_type = 'D') then
        # Type D Cartan Matrix
        linalg[matrix](lie_rank, lie_rank, [seq(seq(`if`(i=lie_rank-2 and j=lie_rank, -1,
                       `if`(i=lie_rank-1 and j=lie_rank, 0, `if`(i=lie_rank and j=lie_rank-2, -1,
                       `if`(i=lie_rank and j=lie_rank-1, 0, `if`(abs(i-j)=1, -1,
                       `if`(i=j,2,0)))))), j=1..lie_rank), i=1..lie_rank)]);
     elif (lie_type = 'E') then
        # Type E Cartan Matrix
        linalg[matrix](lie_rank, lie_rank, [seq(seq(`if`(i=1 and j=2, 0, `if`(i=1 and j=3, -1,
                       `if`(i=2 and (j=1 or j=3), 0, `if`(i=2 and j=4, -1, `if`(i=3 and j=2, 0,
                       `if`(i=3 and j=1, -1, `if`(i=4 and j=2, -1, `if`(abs(i-j)=1, -1,
                       `if`(i=j,2,0))))))))), j=1..lie_rank), i=1..lie_rank)]);
     elif (lie_type = 'F') then
        # Type F Cartan Matrix
        linalg[matrix](lie_rank, lie_rank, [2,-1,0,0,-1,2,-2,0,0,-1,2,-1,0,0,-1,2]);
     elif (lie_type = 'G') then
        # Type G Cartan Matrix
        linalg[matrix](lie_rank, lie_rank, [2,-1,-3,2]);
     end if;
  end if;
end:

# DynkinDiagram returns a plot of the Dynkin diagram of the simple Lie algebra
# of the specified type and rank.
#
# Note: These diagrams can be found in Humphreys, page 58.
DynkinDiagram := proc(lie_type, lie_rank)
  local i,nds,lbl,lns,dts,arrow_top,arrow_bottom,ul_corner,lr_corner;

  if(SimpleLieTypeCheck(lie_type, lie_rank)) then
     if (lie_type = 'A') then
        # Type A Dynkin Diagram
        if (lie_rank = 1) then
           ul_corner := plottools[point]([0.5,0.5], color=white):
           lr_corner := plottools[point]([1.5,-0.5], color=white):
           nds[1] := plottools[circle]([1,0], 0.1, color=black):
           lbl[1] := plots[textplot]([1,-0.1,1],align={BELOW,CENTER}):
           plots[display](ul_corner, lr_corner, nds[1], lbl[1], axes=none, scaling=constrained,
                          title = cat("Dynkin Diagram: Type ",lie_type,lie_rank));
        elif (lie_rank > 5) then
           # abbreviated diagram
           for i from 1 to 5 do
              nds[i] := plottools[circle]([i,0], 0.1, color=black):
           od:
           for i from 1 to 3 do
              lbl[i] := plots[textplot]([i,-0.1,i],align={BELOW,CENTER}):
           od:
           lbl[4] := plots[textplot]([4,-0.1,lie_rank-1],align={BELOW,CENTER}):
           lbl[5] := plots[textplot]([5,-0.1,lie_rank],align={BELOW,CENTER}):
           lns[1] := plottools[line]([1.1,0],[1.9,0], color=black):
           lns[2] := plottools[line]([2.1,0],[2.9,0], color=black):
           for i from 1 to 3 do
              dts[i] := plots[textplot]([3.1 + 0.2*i,0.05,"."]):
           od:
           lns[3] := plottools[line]([4.1,0],[4.9,0], color=black):
           lns[4] := plottools[line]([3.1,0],[3.2,0], color=black):
           lns[5] := plottools[line]([3.8,0],[3.9,0], color=black):
           plots[display](seq(nds[i],i=1..5), seq(lbl[i],i=1..5),
                          seq(lns[i],i=1..5), seq(dts[i],i=1..3),
                          axes=none, scaling=constrained,
                          title = cat("Dynkin Diagram: Type ",lie_type,lie_rank));
        else
           # full diagram
           for i from 1 to lie_rank do
              nds[i] := plottools[circle]([i,0], 0.1, color=black):
              lbl[i] := plots[textplot]([i,-0.1,i],align={BELOW,CENTER}):
           od:
           for i from 1 to lie_rank-1 do
              lns[i] := plottools[line]([i+0.1,0],[i+0.9,0], color=black):
           od:
           plots[display](seq(nds[i],i=1..lie_rank), seq(lbl[i],i=1..lie_rank),
                          seq(lns[i],i=1..lie_rank-1), axes=none, scaling=constrained,
                          title = cat("Dynkin Diagram: Type ",lie_type,lie_rank));
        end if;
     elif (lie_type = 'B' or lie_type = 'C') then
        # Type BC Coxeter Diagram
        if (lie_rank > 5) then
           # abbreviated diagram
           for i from 1 to 5 do
              nds[i] := plottools[circle]([i,0], 0.1, color=black):
           od:
           lbl[1] := plots[textplot]([1,-0.1,1],align={BELOW,CENTER}):
           lbl[2] := plots[textplot]([2,-0.1,2],align={BELOW,CENTER}):
           lbl[3] := plots[textplot]([3,-0.1,lie_rank-2],align={BELOW,CENTER}):
           lbl[4] := plots[textplot]([4,-0.1,lie_rank-1],align={BELOW,CENTER}):
           lbl[5] := plots[textplot]([5,-0.1,lie_rank],align={BELOW,CENTER}):
           lns[1] := plottools[line]([1.1,0],[1.9,0], color=black):
           for i from 1 to 3 do
              dts[i] := plots[textplot]([2.1 + 0.2*i,0.05,"."]):
           od:
           lns[2] := plottools[line]([3.1,0],[3.9,0], color=black):
           lns[3] := plottools[line]([4.05,0.1], [4.95,0.1], color=black):
           lns[4] := plottools[line]([4.05,-0.1], [4.95,-0.1], color=black):
           lns[5] := plottools[line]([2.1,0],[2.2,0], color=black):
           lns[6] := plottools[line]([2.8,0],[2.9,0], color=black):
           # The only difference between B & C type Dynkin diagrams is the
           # direction of their arrows.
           if (lie_type = 'B') then
              arrow_top := plottools[line]([4.6,0],[4.35,0.15], color=black):
              arrow_bottom := plottools[line]([4.6,0],[4.35,-0.15], color=black):
           else
              arrow_top := plottools[line]([4.35,0],[4.6,0.15], color=black):
              arrow_bottom := plottools[line]([4.35,0],[4.6,-0.15], color=black):
           end if;
           plots[display](seq(nds[i],i=1..5), seq(lbl[i],i=1..5),
                          seq(lns[i],i=1..6), seq(dts[i],i=1..3),
                          arrow_top, arrow_bottom, axes=none, scaling=constrained,
                          title = cat("Dynkin Diagram: Type ",lie_type,lie_rank)):
        else
           # full diagram
           for i from 1 to lie_rank do
              nds[i] := plottools[circle]([i,0], 0.1, color=black):
              lbl[i] := plots[textplot]([i,-0.1,i],align={BELOW,CENTER}):
           od:
           for i from 1 to lie_rank-2 do
              lns[i] := plottools[line]([i+0.1,0],[i+0.9,0], color=black):
           od:
           lns[lie_rank-1] := plottools[line]([lie_rank-0.95,0.1], [lie_rank-0.05,0.1], color=black):
           lns[lie_rank] := plottools[line]([lie_rank-0.95,-0.1], [lie_rank-0.05,-0.1], color=black):
           # The only difference between B & C type Dynkin diagrams is the
           # direction of their arrows.
           if (lie_type = 'B') then
              arrow_top := plottools[line]([lie_rank-0.4,0],[lie_rank-0.65,0.15], color=black):
              arrow_bottom := plottools[line]([lie_rank-0.4,0],[lie_rank-0.65,-0.15], color=black):
           else
              arrow_top := plottools[line]([lie_rank-0.65,0],[lie_rank-0.4,0.15], color=black):
              arrow_bottom := plottools[line]([lie_rank-0.65,0],[lie_rank-0.4,-0.15], color=black):
           end if;
           plots[display](seq(nds[i],i=1..lie_rank), seq(lbl[i],i=1..lie_rank),
                          seq(lns[i],i=1..lie_rank), arrow_top, arrow_bottom, axes=none,
                          scaling=constrained,
                          title = cat("Dynkin Diagram: Type ",lie_type,lie_rank)):
        end if;
     elif (lie_type = 'D') then
        # Type D Dynkin Diagram
        if (lie_rank > 6) then
           # abbreviated diagram
           for i from 1 to 4 do
              nds[i] := plottools[circle]([i,0], 0.1, color=black):
           od:
           nds[5] := plottools[circle]([4+1/2,sqrt(3)/2], 0.1, color=black):
           nds[6] := plottools[circle]([4+1/2,-sqrt(3)/2], 0.1, color=black):
           lbl[1] := plots[textplot]([1,-0.1,1],align={BELOW,CENTER}):
           lbl[2] := plots[textplot]([2,-0.1,2],align={BELOW,CENTER}):
           lbl[3] := plots[textplot]([3,-0.1,lie_rank-3],align={BELOW,CENTER}):
           lbl[4] := plots[textplot]([4,-0.1,lie_rank-2],align={BELOW,LEFT}):
           lbl[5] := plots[textplot]([4+1/2, sqrt(3)/2+0.1,lie_rank-1],
                                              align={ABOVE,CENTER}):
           lbl[6] := plots[textplot]([4+1/2, -sqrt(3)/2-0.1,lie_rank],
                                              align={BELOW,CENTER}):
           lns[1] := plottools[line]([1.1,0],[1.9,0], color=black):
           lns[2] := plottools[line]([3.1,0],[3.9,0], color=black):
           lns[3] := plottools[line]([4+0.1*(1/2),0.1*(sqrt(3)/2)],
                                     [4+0.9*(1/2),0.9*(sqrt(3)/2)], color=black):
           lns[4] := plottools[line]([4+0.1*(1/2),-0.1*(sqrt(3)/2)],
                                     [4+0.9*(1/2),-0.9*(sqrt(3)/2)], color=black):
           for i from 1 to 3 do
              dts[i] := plots[textplot]([2.1 + 0.2*i,0.05,"."]):
           od:
           lns[5] := plottools[line]([2.1,0],[2.2,0], color=black):
           lns[6] := plottools[line]([2.8,0],[2.9,0], color=black):
           plots[display](seq(nds[i],i=1..6), seq(lbl[i],i=1..6),
                          seq(lns[i],i=1..6), seq(dts[i],i=1..3),
                          axes=none, scaling=constrained,
                          title = cat("Dynkin Diagram: Type ",lie_type,lie_rank)):
        else
           # full diagram
           for i from 1 to lie_rank-2 do
              nds[i] := plottools[circle]([i,0], 0.1, color=black):
              lbl[i] := plots[textplot]([i,-0.1,i],align={BELOW,CENTER}):
           od:
           nds[lie_rank-1] := plottools[circle]([lie_rank-2+1/2,sqrt(3)/2], 0.1, color=black):
           lbl[lie_rank-1] := plots[textplot]([lie_rank-2+1/2, sqrt(3)/2+0.1,lie_rank-1],
                                              align={ABOVE,CENTER}):
           nds[lie_rank] := plottools[circle]([lie_rank-2+1/2,-sqrt(3)/2], 0.1, color=black):
           lbl[lie_rank] := plots[textplot]([lie_rank-2+1/2, -sqrt(3)/2-0.1,lie_rank],
                                              align={BELOW,CENTER}):
           for i from 1 to lie_rank-3 do
              lns[i] := plottools[line]([i+0.1,0],[i+0.9,0], color=black):
           od:
           lns[lie_rank-2] := plottools[line]([lie_rank-2+0.1*(1/2),0.1*(sqrt(3)/2)],
                                              [lie_rank-2+0.9*(1/2),0.9*(sqrt(3)/2)], color=black):
           lns[lie_rank-1] := plottools[line]([lie_rank-2+0.1*(1/2),-0.1*(sqrt(3)/2)],
                                              [lie_rank-2+0.9*(1/2),-0.9*(sqrt(3)/2)], color=black):
           plots[display](seq(nds[i],i=1..lie_rank), seq(lbl[i],i=1..lie_rank),
                          seq(lns[i],i=1..lie_rank-1), axes=none, scaling=constrained,
                          title = cat("Dynkin Diagram: Type ",lie_type,lie_rank)):
        end if;
     elif (lie_type = 'E') then
        # Type E Dynkin Diagram
        for i from 1 to lie_rank-1 do
           nds[i] := plottools[circle]([i,0], 0.1, color=black):
        od:
        nds[lie_rank]   := plottools[circle]([3,1], 0.1, color=black):
        lbl[1] := plots[textplot]([1,-0.1,1],align={BELOW,CENTER}):
        lbl[2] := plots[textplot]([3,1.1,2],align={ABOVE,CENTER}):
        for i from 3 to lie_rank do
           lbl[i] := plots[textplot]([i-1,-0.1,i],align={BELOW,CENTER}):
        od:
        for i from 1 to lie_rank-2 do
           lns[i] := plottools[line]([i+0.1,0],[i+0.9,0], color=black):
        od:
        lns[lie_rank-1] := plottools[line]([3,0.1],[3,0.9], color=black):
        plots[display](seq(nds[i],i=1..lie_rank), seq(lbl[i],i=1..lie_rank),
                       seq(lns[i],i=1..(lie_rank-1)), axes=none, scaling=constrained,
                       title = cat("Dynkin Diagram: Type ",lie_type,lie_rank)):
     elif (lie_type = 'F') then
        # Type F Dynkin Diagram
        for i from 1 to lie_rank do
           nds[i] := plottools[circle]([i,0], 0.1, color=black):
           lbl[i] := plots[textplot]([i,-0.1,i],align={BELOW,CENTER}):
        od:
        lns[1] := plottools[line]([1.1,0],[1.9,0], color=black):
        lns[2] := plottools[line]([3.1,0],[3.9,0], color=black):
        lns[3] := plottools[line]([2,0.1],[3,0.1], color=black):
        lns[4] := plottools[line]([2,-0.1],[3,-0.1], color=black):
        arrow_top := plottools[line]([2.6,0],[2.35,0.15], color=black):
        arrow_bottom := plottools[line]([2.6,0],[2.35,-0.15], color=black):
        plots[display](seq(nds[i],i=1..lie_rank), seq(lbl[i],i=1..lie_rank), seq(lns[i],i=1..lie_rank),
                       arrow_top, arrow_bottom, axes=none, scaling=constrained,
                       title = cat("Dynkin Diagram: Type ",lie_type,lie_rank)):
     elif (lie_type = 'G') then
        # Type G Dynkin Diagram
        nds[1] := plottools[circle]([1,0], 0.1, color=black):
        lbl[1] := plots[textplot]([1,-0.1,1],align={BELOW,CENTER}):
        nds[2] := plottools[circle]([2,0], 0.1, color=black):
        lbl[2] := plots[textplot]([2,-0.1,2],align={BELOW,CENTER}):
        lns[1] := plottools[line]([1,0.1], [2,0.1], color=black):
        lns[2] := plottools[line]([1.1,0], [1.9,0], color=black):
        lns[3] := plottools[line]([1,-0.1], [2,-0.1], color=black):
        arrow_top := plottools[line]([1.4,0],[1.65,0.15], color=black):
        arrow_bottom := plottools[line]([1.4,0],[1.65,-0.15], color=black):
        plots[display](nds[1], nds[2], lns[1], lns[2], lns[3], arrow_top, arrow_bottom,
                       lbl[1], lbl[2], axes=none, scaling=constrained,
                       title = cat("Dynkin Diagram: Type ",lie_type,lie_rank)):
     end if;
  end if;
end:

# SimpleRoots returns an array of simple roots. If alpha = SimpleRoots(lie_type, lie_rank) then
# {alpha[1],alpha[2],...,alpha[lie_rank]} is a base for the root system of lie_type, lie_rank.
# For all bases (except G2) have the properties: 1) Long roots have squared length 2 with
# respect to the standard dot product. 2) Short roots have length 1.
# G2's long root has squared length 3 with respect to the standard dot product and its short
# root has length 1.
#
# Note: These bases can be found in Fulton and Harris, pages 324,332,333.
#       *** I have rescaled bases of type C ***
SimpleRoots := proc(lie_type, lie_rank)
  local alpha,i;

  if (SimpleLieTypeCheck(lie_type, lie_rank)) then
     if (lie_type = 'A') then
        for i from 1 to lie_rank do
           alpha[i] := [seq(`if`(j=i,1,`if`(j=i+1,-1,0)),j=1..lie_rank+1)];
        od:
     elif (lie_type = 'B') then
        for i from 1 to lie_rank-1 do
           alpha[i] := [seq(`if`(j=i,1,`if`(j=i+1,-1,0)),j=1..lie_rank)];
        od:
        alpha[lie_rank] := [seq(`if`(j=lie_rank,1,0),j=1..lie_rank)]:
     elif (lie_type = 'C') then
        for i from 1 to lie_rank-1 do
           alpha[i] := [seq(`if`(j=i,1/sqrt(2),`if`(j=i+1,-1/sqrt(2),0)),j=1..lie_rank)];
        od:
        alpha[lie_rank] := [seq(`if`(j=lie_rank,sqrt(2),0),j=1..lie_rank)]:
     elif (lie_type = 'D') then
        for i from 1 to lie_rank-1 do
           alpha[i] := [seq(`if`(j=i,1,`if`(j=i+1,-1,0)),j=1..lie_rank)];
        od:
        alpha[lie_rank] := [seq(`if`(j=lie_rank or j=lie_rank-1,1,0),j=1..lie_rank)]:
     elif (lie_type = 'E') then
        if (lie_rank=6) then alpha[1] := [1/2,-1/2,-1/2,-1/2,-1/2,sqrt(3)/2];
        elif (lie_rank=7) then alpha[1] := [1/2,-1/2,-1/2,-1/2,-1/2,-1/2,sqrt(2)/2];
        elif (lie_rank=8) then alpha[1] := [1/2,-1/2,-1/2,-1/2,-1/2,-1/2,-1/2,1/2];
        end if:
        alpha[2] := [seq(`if`(j=1 or j=2, 1, 0),j=1..lie_rank)];
        for i from 3 to lie_rank do
           alpha[i] := [seq(`if`(j=i-1,1,`if`(j=i-2,-1,0)),j=1..lie_rank)];
        od:
     elif (lie_type = 'F') then
        alpha[1] := [0,1,-1,0]:
        alpha[2] := [0,0,1,-1]:
        alpha[3] := [0,0,0,1]:
        alpha[4] := [1/2,-1/2,-1/2,-1/2]:
     elif (lie_type = 'G') then
        alpha[1] := [1,0]:
        alpha[2] := [-3/2,sqrt(3)/2]:
     end if;
     alpha;
  end if;
end:

# FundamentalWeights returns an array containing the fundamental weights
# of the simple Lie algebra specified by lie_type and lie_rank.
# That is if lambda := FundamentalWeights(lie_type, lie_rank) then
# {lambda[1],lambda[2],...,lambda[lie_rank]} are the fundamental weights
# for the simple Lie algebra lie_type, lie_rank.
#
# Let u.v be the dot product of u and v. Then if alpha := SimpleRoots(lie_type, lie_rank)
# we have that 2*(lambda[i].alpha[j])/(alpha[j].alpha[j]) = 1 if i=j and 0 otherwise.
FundamentalWeights := proc (lie_type, lie_rank)
  local Inv_CM,i,j,alpha,lambda;

  if (SimpleLieTypeCheck(lie_type,lie_rank)) then
     Inv_CM := linalg[inverse](CartanMatrix(lie_type, lie_rank));
     alpha := SimpleRoots(lie_type, lie_rank);
     for i from 1 to lie_rank do
        lambda[i] := Inv_CM[i,1]*alpha[1];
        for j from 2 to lie_rank do
           lambda[i] := lambda[i] + Inv_CM[i,j]*alpha[j];
        od;
     od:
     lambda;
  end if;
end:

Weyl Group Action on Weights

Reflection -- reflects lambda across the hyperplane orthogonal to alpha
MinusculeWeights -- returns the minuscule weights of the specified simple Lie algebra

WeylOrbit -- computes the orbit (with respect to the Weyl group of the specified simple Lie algebra) of a given weight

WeylGroupAction -- takes an orbit of weights and assigns a labels to each weight. The simple reflections permute these

weights. WeylGroupAction returns the permutations associated with the simple reflections.

CycleStructure -- returns the cycle structures present in the subgroup generated by the given set of permutations

CycleStructureRandom -- Since CycleStructure is too inefficient for larger examples, we provide a random version

which collects cycle structures for N iterations (the default is 10000).

RandElementConj -- Given a cycle structure and a generating set of permutations, RandElementConj tries N times

(the default is 10000) to find an element with that cycle structure.

> # Reflection reflects lambda across the hyperplane which is orthoginal
# to the vector alpha.
#
# If alpha := SimpleRoots(lie_type, lie_rank) then
# {Reflection(alpha[1],__), Reflection(alpha[2],__), ..., Reflection(alpha[lie_rank],__)}
# are the simple reflections of the simple Lie algebra of lie_type,lie_rank.
# These reflections generate the Weyl group.
Reflection := proc(alpha, lambda)
  local tmp;

  if (nops(alpha) = nops(lambda)) then
     tmp := 2*ListTools[DotProduct](lambda,alpha)/ListTools[DotProduct](alpha,alpha);
     tmp := [seq(tmp*alpha[j],j=1..nops(alpha))];
     lambda - tmp;
  else
     WARNING("Cannot reflect: list lengths don't match.");
  end if;
end:

# MinusculeWeights returns the minuscule weights of the simple
# Lie algebra of lie_type,lie_rank.
#
# A list of minuscule weights can be found in Humpreys, page 72 (minimal = minuscule).
MinusculeWeights := proc(lie_type,lie_rank)
  local lambda;
  if (SimpleLieTypeCheck(lie_type,lie_rank)) then
     lambda := FundamentalWeights(lie_type, lie_rank);
     if (lie_type = 'A') then
        {seq(lambda[i],i=1..lie_rank)};
     elif (lie_type = 'B') then
        {lambda[lie_rank]};
     elif (lie_type = 'C') then
        {lambda[1]};
     elif (lie_type = 'D') then
        {lambda[1], lambda[lie_rank-1], lambda[lie_rank]};
     elif (lie_type = 'E') then
        if (lie_rank = 6) then {lambda[1], lambda[6]};
        elif (lie_rank = 7) then {lambda[7]};
        else {};
        end if;
     elif (lie_type = 'F') then
        {};
     elif (lie_type = 'G') then
        {};
     end if;
  end if:
end:

# WeylOrbit returns the set of all weights in the orbit (with respect to the Weyl
# group of the simple Lie algebra lie_type, lie_rank) of the weight wt.
WeylOrbit := proc(wt, lie_type, lie_rank)
  local chi,alpha,i,wt_stack,next_wt,new_wt;

  if (SimpleLieTypeCheck(lie_type, lie_rank)) then
     alpha := SimpleRoots(lie_type, lie_rank);

     if (nops(wt) = nops(alpha[1])) then
        # wt is in its own orbit.
        chi := {wt};
        # wt_stack keeps track of the weights which we need to apply simple reflections.
        wt_stack := stack[new](wt);

        while (not stack[empty](wt_stack)) do
           next_wt := stack[pop](wt_stack);

           for i from 1 to lie_rank do
              new_wt := Reflection(alpha[i],next_wt);
              if (not (new_wt in chi)) then
                 # if new_wt is indeed new, add it to the set of weight and push it on the stack.
                 chi := chi union {new_wt};
                 stack[push](new_wt, wt_stack);
              end if;
           od;
        od;
        chi := simplify(chi);
     else
        WARNING("Cannot reflect: list lengths don't match.");
     end if;
  end if;
end:

# *** This procedure is used to impose a definite order on the weights***
# Without sorting the weights WeylGroupAction returns different permutations
# each time it is run (because the unordered set chi is turned into an ordered
# list chi_list). Without sorting chi_list is ordered "randomly" from the set.
#
# listlex takes in two lists of equal length and returns true or false.
#
# listlex compares two lists a & b and determines if a comes before b
# in "list lexicographic order" (listlex returns true if a=b).
# That is "a" "listlex less than" "b" iff at the first index where a
# and b differ, a's entry is less than b's entry.
listlex := proc(a,b)
  local i;

  # check that the list lengths match.
  if nops(a) <> nops(b) then error "list sizes do not match."; end if;

  if a=b then
     true; # if a=b be then a comes before b in listlex ordering.
  else
     # find the first index where a and b differ (we already know
     # that a is not equal to b).
     i := 1;
     while(a[i]=b[i]) do i:=i+1; od;

     # if a's entry is less than b's entry return true else false.
     if (evalf(a[i]) < evalf(b[i])) then true; else false; end if;
  end if;
end proc:

# WeylGroupAction takes the orbit (chi) of some weight, assigns labels to each
# weight (1,2,...,#(chi)), and represents the action of each simple reflection
# as a permutation of the weights.
WeylGroupAction := proc(chi, lie_type, lie_rank)
  local alpha,chi_list,p,i,j,k,s_perm;

  if (SimpleLieTypeCheck(lie_type, lie_rank)) then
     alpha := SimpleRoots(lie_type, lie_rank);

     # Assign labels -- convert the set of weights into a list of weights.
     # impose the "listlex" ordering so that we get the same permutations
     # even if this procedure is restarted.
     chi_list := sort([op(chi)], listlex);

     if(nops(chi_list[1]) = nops(alpha[1])) then
        # Define functions p(i,_) such that:
        # p(i,j) = k iff Reflection(alpha[i],chi_list[j]) = chi_list[k]
        for j from 1 to nops(chi_list) do
           for i from 1 to lie_rank do
              for k from 1 to nops(chi_list) do
                 if (chi_list[k]=Reflection(alpha[i],chi_list[j])) then p(i,j) := k end if;
              od;
           od;
        od;

        # Convert the p-functions into permutations.
        for i from 1 to lie_rank do
           s_perm[i] := convert([seq(p(i,j),j=1..nops(chi_list))],'disjcyc');
        od;
        s_perm;
     else
        WARNING("Cannot reflect: list lengths don't match.");
     end if;
  end if:
end:

# CycleStructure gives the cycle structures of the elements of the subgroup generated
# by the set "set_gen".
# Note: the 1-cycles are suppressed i.e. [[1,2],[3,4,5],[6],[7]] ==> [3,2].
CycleStructure := proc(set_gen)
  local els,conj_classes,g;
  els := elements(set_gen);
  conj_classes := {};
  for g in els do
     conj_classes := conj_classes union {sort([seq(nops(g[i]),i=1..nops(g))],`>`)};
  od;
  conj_classes;
end:

# CycleStructureRandom gives the cycle structures of some random elements of the subgroup
# generated by the set "set_gen". This procedure is intended for "large" Weyl groups.
# Note: the 1-cycles are suppressed i.e. [[1,2],[3,4,5],[6],[7]] ==> [3,2].
CycleStructureRandom := proc(set_gen)
  local i,j,max,conj_classes,g,G,N;
  N := 10000; # N = the number of random elements to check.

  # find the maximum number occuring the generators.
  max := 1;
  for g in set_gen do
     for i from 1 to nops(g) do
        for j from 1 to nops(g[i]) do
           if max < g[i][j] then max := g[i][j]; end if;
        od;
     od;
  od;

  # set_gen generates a subgroup of the symmetric group S_max.
  G := permgroup(max,set_gen);

  conj_classes := {};
  for i from 1 to N do
     g := RandElement(G);
     conj_classes := conj_classes union {sort([seq(nops(g[i]),i=1..nops(g))],`>`)};
  od;
  conj_classes;
end:

# Given [conj_class,set_gen] = [a conjugacy class,a set of generators],
# RandElementConj tries N random elements from the subgroup G generated
# by set_gen. RandElementConj returns false if no element from the conjugacy
# class conj_class is found. Otherwise such an element is returned.
RandElementConj := proc(inpt)
  local conj_class,set_gen,N,max,G,i,j,g,flag;
  conj_class := inpt[1];
  set_gen := inpt[2];

  N := 10000; # N = the number of random elements to check.

  # find the maximum number occuring the generators.
  max := 1;
  for g in set_gen do
     for i from 1 to nops(g) do
        for j from 1 to nops(g[i]) do
           if max < g[i][j] then max := g[i][j]; end if;
        od;
     od;
  od;

  # set_gen generates a subgroup of the symmetric group S_max.
  G := permgroup(max,set_gen);

  flag := true;
  i := 1;
  while flag and i < N do
     g := RandElement(G);
     if conj_class = sort([seq(nops(g[i]),i=1..nops(g))],`>`) then flag := false; end if;
     i := i+1;
  od;

  if flag then false; else g; end if;
end:

Examples

Type A

A4: Master Demo

Let us take a look at A4 (that is sl(5)). Here we will demonstrate how to use each of the procedures defined above.

To begin, let's print out the Cartan matrix of A4.

> print(CartanMatrix('A',4));

Now A4's Dynkin diagram.

> DynkinDiagram('A',4);

Simple roots for A4 (their order corresponds to the labels of the Dynkin diagram above).

> alpha := SimpleRoots('A',4):
# print them out
seq(alpha[i],i=1..4);

The fundamental weights are weights "dual" to the simple roots. That is, if {alpha_i} are the simple roots

and {lambda_j} are the fundamental weights, then 2*(lambda_j | alpha_i)/(alpha_i | alpha_i) is 1 if i=j and

0 otherwise. One can easily obtain the fundamental weights of a simple Lie algebra by using the inverse

of the Cartan matrix.

Note: (alpha | beta) = inner product (standard dot product) of alpha and beta.

The fundamental weights of A4.

> lambda := FundamentalWeights('A',4):
# print them out
seq(lambda[i],i=1..4);

Let V(lambda) be the irreducible representation with highest weight lambda. "lambda" is called minuscule if every

weight of V(lambda) is conjugate to lambda under the Weyl group action. So the weights of V(lambda) all lie in

one orbit when lambda is minuscule.

If lambda is minuscule, it can be shown that each weight space of V(lambda) is one dimensional. So, for minuscule weights,

we can find all the weights of V(lambda) by acting on lambda with the Weyl group. Moreover, once we've found all of the
weights, we know that the dimension of V(lambda) is the cardinality of the set of weights.

The minuscule weights of A4 (all fundamental weights are minuscule for simple Lie algebras of type A).

> MinusculeWeights('A',4);

The weights in the orbit of lambda[1] (A4's 1st fundamental weight). Since lambda[1] is minuscule, the weights all lie in

one orbit, so this will give us all of the weights of V(lambda[1]).

The Weyl group acts on weights by reflection. If s_1, ..., s_4 are the simple reflections associated with the simple

roots alpha_1, ..., alpha_4, then s_2 acting on lambda[1] is...

> Reflection(alpha[2],lambda[1]);

s_4(s_1(lambda[1]) is...

> Reflection(alpha[4],Reflection(alpha[1],lambda[1]));

Now let's compute the entire orbit of lambda[1].

> chi := WeylOrbit(lambda[1],'A',4):
# print out the *list* of weights (after sorting them).
# [op(chi)] converts the set "chi" into a list.
sort([op(chi)],listlex);

Now we know that the dimension of V(lambda[1]) is...

> # the cardinality of the set chi.
nops(chi);

We know that the Weyl group permutes the weights. So we label each weight with a positive integer, and then see what

kinds of permutations we get.

Note: The labels are assigned using the ordering of the list above (the second weight in the listlex sorted list of weights

gets the label "2").

Since simple reflections generate the Weyl group, WeylGroupAction just returns the simple reflections viewed as permutations

of weights. The Weyl group action viewed as permutations:

> s := WeylGroupAction(chi,'A',4):
# print out the simple reflections s[1], s[2], ...
for i from 1 to 4 do s[i]; od;

So the subgroup of the symmetric group S_4 generated by {s[i], i=1..4} is isomorphic to the Weyl group of A4.

The cycle structures present in this subgroup of S_4:

> CycleStructure({seq(s[i],i=1..4)});

WARNING: These are partitions of 5 (the dimension of V(lambda)), but the 1's are suppressed. For example,

the partition 2+2+1 is shown as [2,2].

Looking at the cycle structures, we notice the partition [5]. This tells us that, given any weight vector, we can generate

the whole representation using that vector and an element of the Weyl group with cycle structure [5]. In other words,

sometimes cycle structures can give us information about irreducibility.

This particular subgroup is fairly small. Let's print out all of its elements.

> elements({seq(s[i],i=1..4)});

Sometimes we wish to examine large subgroups of S_n. In those cases, CycleStructure is too computationally expensive.

But it is still useful to examine a sampling of some of the cycle structures present in the subgroup. To do this, we use the

procedure CycleStructureRandom. This procedure will be particularly useful when dealing with E7.

Note: By default CycleStructureRandom checks 10,000 elements at random. You will notice that in this particular case it is faster

to run CycleStructure.

> CycleStructureRandom({seq(s[i],i=1..4)});

If there is a particular cycle structure we are interested in, we can ask RandElementConj to try to find an element with that

structure for us. Although, if it fails, we can't be sure that there isn't an element with that structure. We might have been unlucky

because the conjugacy class was too small. For example, if we try to find something with cycle structure [] (only the identity

has this structure), we will almost certainly fail if the subgroup is large.

Let us find an element with a 3-cycle and a transposition -- cycle structure [3,2].

> RandElementConj([[3,2],{seq(s[i],i=1..4)}]);

A3 (=D3)

Let us take a look at sl(4) (that is A3) which is isomorphic to so(6) (that is D3).

The Cartan matrix of A3.

> print(CartanMatrix('A',3));

The Cartan matrix of D3.

> print(CartanMatrix('D',3));

Warning, Type D3 is more commonly known as A3 (they are isomorphic).

Their Dynkin diagrams.

> DynkinDiagram('A',3);
DynkinDiagram('D',3);

Warning, Type D3 is more commonly known as A3 (they are isomorphic).

The fundamental weights of A3.

> lambda[1] := FundamentalWeights('A',3):
# print them out
seq(lambda[1][i],i=1..3);

The fundamental weights of D3.

> lambda[2] := FundamentalWeights('D',3):
# print them out
seq(lambda[2][i],i=1..3);

Warning, Type D3 is more commonly known as A3 (they are isomorphic).

The minuscule weights of A3.

> MinusculeWeights('A',3);

The minuscule weights of D3.

> MinusculeWeights('D',3);

Warning, Type D3 is more commonly known as A3 (they are isomorphic).

The weights in the orbit of lambda[1][1] (A3's 1st fundamental weight).

Note: Since lambda[1][1] is minuscule, this gives us all of the weights of the irreducible representation with

highest weight lambda[1][1].

> chi := WeylOrbit(lambda[1][1],'A',3):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The Weyl group action viewed as permutations. (For example: 2 corresponds to the second weight in the above sorted list.)

> s[1] := WeylGroupAction(chi,'A',3):
# print them out
for i from 1 to 3 do
s[1][i];
od;

The weights in the orbit of lambda[2][2] (D3's 2nd fundamental weight).
Note: Looking at the Dynkin diagrams, we see that node 1 in A3 is equivalent to node 2 in D3.

Again, lambda[2][2] is minuscule so we get all the weights of the irrep.

> chi := WeylOrbit(lambda[2][2],'D',3):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

Warning, Type D3 is more commonly known as A3 (they are isomorphic).

The Weyl group action viewed as permutations. (for example: 2 corresponds to the second weight in the above sorted list.)

> s[2] := WeylGroupAction(chi,'D',3):
# print them out
for i from 1 to 3 do
s[2][i];
od;

Warning, Type D3 is more commonly known as A3 (they are isomorphic).

Notice that the actions are identical - as they should be.

The cycle structures present in the subgroup of the symmetric group generated by these permutations.

> CycleStructure({seq(s[1][i],i=1..3)});

We get the cycle structure [4] (a 4-cycle). This cycle structure only allows for invariant subspaces of dimensions 0 & 4.

Thus the cycle structure (in this case) implies irreducibility.

Since this group is fairly small, let's print out all of its elements.

> elements({seq(s[1][i],i=1..3)});

In this example, you can adjust the following parameters as needed to experiment with different A type simple Lie algebras.

This will explore the An representation: V(lambda[k]).
"rank = n" and "highest weight = lambda[k] = the k-th fundamental weight."

> n := 5; k := 1;

The Cartan matrix for An.

> print(CartanMatrix('A',n));

The Dynkin diagram for An.

> DynkinDiagram('A',n);

The fundamental weights for An.

> lambda := FundamentalWeights('A',n):
# print them out
seq(lambda[i],i=1..n);

The minuscule weights for An.

> MinusculeWeights('A',n);

The weights in the orbit of lambda[k].

> chi := WeylOrbit(lambda[k],'A',n);

The orbit of lambda[k] has cardinality...

> # the cardinality of chi
nops(chi);

The Weyl group action (on the orbit of lambda[k]) viewed as permutations.

> s := WeylGroupAction(chi,'A',n):
for i from 1 to n do
s[i];
od;

A sample of the cycle structures.

> CycleStructureRandom({seq(s[i],i=1..n)});

Let's find an element with cycle structure [2,2] (two transpositions) if we can. This may be impossible depending on your choice of n & k.

> RandElementConj([[2,2],{seq(s[i],i=1..n)}]);

Type B

Type B presents some interesting problems. By examining cycle structures, we will "see" the irreducibility of the
minuscule representations associated with types B2, B3, B5, and B7. However, we will also see that the cycle

structures do not tell us enough in the case of B4.

B2 (=C2)

Let us take a look at so(5) (that is B2) which is isomorphic to sp(4) (that is C2).

The Cartan matrix of B2.

> print(CartanMatrix('B',2));

The Cartan matrix of C2.

> print(CartanMatrix('C',2));

Warning, Type C2 is more commonly known as B2 (they are isomorphic).

Their Dynkin diagrams.

> DynkinDiagram('B',2);
DynkinDiagram('C',2);

Warning, Type C2 is more commonly known as B2 (they are isomorphic).

The fundamental weights of B2.

> lambda[1] := FundamentalWeights('B',2):
# print them out
seq(lambda[1][i],i=1..2);

The fundamental weights of C2.

> lambda[2] := FundamentalWeights('C',2):
# print them out
seq(lambda[2][i],i=1..2);

Warning, Type C2 is more commonly known as B2 (they are isomorphic).

The minuscule weights of B2.

> MinusculeWeights('B',2);

The minuscule weights of C2.

> MinusculeWeights('C',2);

Warning, Type C2 is more commonly known as B2 (they are isomorphic).

${[1/2*2^(1/2), 0]}$

The weights in the orbit of lambda[1][2] (B2's 2nd fundamental weight).

Note: Since lambda[1][2] is minuscule, this gives us all of the weights of the irreducible representation with

highest weight lambda[1][2].

> chi := WeylOrbit(lambda[1][2],'B',2):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The Weyl group action viewed as permutations. (5 corresponds to the fifth weight in the above sorted list.)

> s[1] := WeylGroupAction(chi,'B',2):
# print them out
for i from 1 to 2 do
s[1][i];
od;

The weights in the orbit of lambda[2][1] (C2's 1st fundamental weight).

Note: Looking at the Dynkin diagrams, we see that node 2 in B2 is equivalent to node 1 in C2.

Again, lambda[2][1] is minuscule so we get all the weights of the irrep.

> chi := WeylOrbit(lambda[2][1],'C',2):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

Warning, Type C2 is more commonly known as B2 (they are isomorphic).

The Weyl group action viewed as permutations. (For example: 2 corresponds to the second weight in the above sorted list.)

> s[2] := WeylGroupAction(chi,'C',2):
# print them out
for i from 1 to 2 do
s[2][i];
od;

Warning, Type C2 is more commonly known as B2 (they are isomorphic).

Notice that the actions are identical - as they should be.

The cycle structures present in the subgroup of the symmetric group generated by these permutations.

> CycleStructure({seq(s[1][i],i=1..2)});

The cycle structure [4] allows invariant subspaces of dimensions 0 and 4 -- trivial subspaces.

Thus the cycle structure tells us that this representation is irreducible.

Since this group is fairly small, let's print out all of its elements.

> elements({seq(s[1][i],i=1..2)});

The Cartan matrix of B3.

> print(CartanMatrix('B',3));

The Dynkin diagram of B3.

> DynkinDiagram('B',3);

The fundamental weights of B3.

> lambda := FundamentalWeights('B',3):
# print them out
seq(lambda[i],i=1..3);

The minuscule weights of B3.

> MinusculeWeights('B',3);

The weights in the orbit of lambda[3].

Note: Since lambda[3] is minuscule, this gives us all of the weights of the irrep with highest weight lambda[3].

> chi := WeylOrbit(lambda[3],'B',3):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The Weyl group action viewed as permutations. (For example: 2 corresponds to the second weight in the above sorted list.)

> s := WeylGroupAction(chi,'B',3):
# print them out
for i from 1 to 3 do
s[i];
od;

Let's multiply all of the simple reflections together to find the Coxeter element.

> # multiply all of the generators together.
tmp := s[1]:
for i from 2 to 3 do
tmp := mulperms(tmp,s[i]):
od:
print(tmp);

The cycle structures present in the subgroup of the symmetric group generated by these permutations.

> CycleStructure({seq(s[i],i=1..3)});

The cycle structure [4,4] allows for possible invariant subspaces of dimensions 0, 4, 8.

The cycle structure [6,2] allows for possible invariant subspaces of dimensions 0, 2, 6, 8.

Thus, these cycle structures together allow for only 0 and 8 dimensional invariant subspaces (trivial subspaces).

So again, the cycle structure gives us irreducibility.

Let's find an element which is the product of two disjoint 4 cycles (we know there is one by the above list of cycle structures).

> RandElementConj([[4,4],{seq(s[i],i=1..3)}]);

The Cartan matrix of B4.

> print(CartanMatrix('B',4));

The Dynkin diagram of B4.

> DynkinDiagram('B',4);

The fundamental weights of B4.

> lambda := FundamentalWeights('B',4):
# print them out
seq(lambda[i],i=1..4);

The minuscule weights of B4.

> MinusculeWeights('B',4);

The weights in the orbit of lambda[4].

Note: Since lambda[4] is minuscule, this gives us all of the weights of the irrep with highest weight lambda[4].

> chi := WeylOrbit(lambda[4],'B',4):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The Weyl group action viewed as permutations. (For example: 2 corresponds to the second weight in the above sorted list.)

> s := WeylGroupAction(chi,'B',4):
# print them out
for i from 1 to 4 do
s[i];
od;

Let's multiply all of the simple reflections together to find the Coxeter element.

> # multiply all of the generators together.
tmp := s[1]:
for i from 2 to 4 do
tmp := mulperms(tmp,s[i]):
od:
print(tmp);

The cycle structures present in the subgroup of the symmetric group generated by these permutations.

> CycleStructure({seq(s[i],i=1..4)});

We can see that the cycle structure leaves the possibility of an 8-dimensional invariant subspace.

Note: Recall that the partitions returned by CycleStructure and CycleStructureRandom suppress 1's. Thus [3,3,3,3] is the

partition 3+3+3+3+1+1+1+1 (=16). So we have 3+3+1+1=8 (a possible 8-dimensional invariant subspace).

It is known that the representation V(lambda[4]) is irreducible, but unfortunately we cannot get this from cycle structures alone.

The Cartan matrix of B5.

> print(CartanMatrix('B',5));

The Dynkin diagram of B5.

> DynkinDiagram('B',5);

The fundamental weights of B5.

> lambda := FundamentalWeights('B',5):
# print them out
seq(lambda[i],i=1..5);

The minuscule weights of B5.

> MinusculeWeights('B',5);

The weights in the orbit of lambda[5].

Note: Since lambda[5] is minuscule, this gives us all of the weights of the irrep with highest weight lambda[5].

> chi := WeylOrbit(lambda[5],'B',5):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The Weyl group action viewed as permutations. (For example: 2 corresponds to the second weight in the above sorted list.)

> s := WeylGroupAction(chi,'B',5):
# print them out
for i from 1 to 5 do
s[i];
od;

Let's multiply all of the simple reflections together to find the Coxeter element.

> # multiply all of the generators together.
tmp := s[1]:
for i from 2 to 5 do
tmp := mulperms(tmp,s[i]):
od:
print(tmp);

The cycle structures present in the subgroup of the symmetric group generated by these permutations.

> CycleStructure({seq(s[i],i=1..5)});

The cycle structure [10,10,10,2] allows for possible invariant subspaces of dimensions 0, 2, 10, 12, 20, 22, 32.
The cycle structure [8,8,8,8] allows for possible invariant subspaces of dimensions 0, 8, 16, 24, 32.

Thus, these cycle structures together allow for only 0 and 32 dimensional invariant subspaces (trivial subspaces).

Now for the one "higher" rank example and the general case.

The Cartan matrix of B7.

> print(CartanMatrix('B',7));

The Dynkin diagram of B7.

> DynkinDiagram('B',7);

The fundamental weights of B7.

> lambda := FundamentalWeights('B',7):
# print them out
seq(lambda[i],i=1..7);

The minuscule weights of B7.

> MinusculeWeights('B',7);

The weights in the orbit of lambda[7].

Note: Since lambda[7] is minuscule, this gives us all of the weights of the irrep with highest weight lambda[5].

> chi := WeylOrbit(lambda[7],'B',7):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The dimension of V(lambda[7]) is...

> # the cardinality of chi
nops(chi);

The Weyl group action viewed as permutations. (For example: 2 corresponds to the second weight in the above sorted list.)

WARNING: This may take a minute or two.

> s := WeylGroupAction(chi,'B',7):
# print them out
for i from 1 to 6 do
s[i];
od;

Let's multiply all of the simple reflections together to find the Coxeter element.

> # multiply all of the generators together.
tmp := s[1]:
for i from 2 to 7 do
tmp := mulperms(tmp,s[i]):
od:
print(tmp);

At this point, it would be nice to find the cycle structures present in the subgroup, but CycleStructure

takes too long. So instead we can use CycleStructureRandom

WARNING: This may take several minutes.

> CycleStructureRandom({seq(s[i],i=1..7)});

When I executed the above commands, I found the following cycle structures:
[20,20,20,20,20,20,4,4], [14,14,14,14,14,14,14,14,14,2], and [8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8].

The cycle structure [20,20,20,20,20,20,4,4] allows for possible invariant subspaces of dimensions:

0, 4, 8, 20, 24, 28, 40, 44, 48, 60, 64, 68, 80, 84, 88, 100, 104, 108, 120, 124, 128.
The cycle structure [14,14,14,14,14,14,14,14,14,2] allows for possible invariant subspaces of dimensions:

0, 2, 14, 16, 28, 30, 42, 44, 56, 58, 70, 72, 84, 86, 98, 100, 112, 114, 126, 128.

The cycle structure [8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8] allows for possible invariant subspaces of dimensions:

0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128.

Thus, these cycle structures together allow for only 0 and 128 dimensional invariant subspaces (trivial subspaces).

Maybe those partitions didn't appear in your list. You can either take my word, try CycleStructureRandom again, or

try the following commands:

> RandElementConj([[20,20,20,20,20,20,4,4],{seq(s[i],i=1..7)}]);
RandElementConj([[14,14,14,14,14,14,14,14,14,2],{seq(s[i],i=1..7)}]);
RandElementConj([[8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8],{seq(s[i],i=1..7)}]);

Thus (unless you're very unlucky) we get elements with the desired cycle structures.

In this example, you can adjust the following parameters as needed to experiment with different B type simple Lie algebras.

This will explore the Bn representation: V(lambda[k]).
"rank = n" and "highest weight = lambda[k] = the k-th fundamental weight."

> n := 6; k := 6;

The Cartan matrix for Bn.

> print(CartanMatrix('B',n));

The Dynkin diagram for Bn.

> DynkinDiagram('B',n);

The fundamental weights for Bn.

> lambda := FundamentalWeights('B',n):
# print them out
seq(lambda[i],i=1..n);

The minuscule weights for Bn.

> MinusculeWeights('B',n);

The weights in the orbit of lambda[k].

> chi := WeylOrbit(lambda[k],'B',n);

The orbit of lambda[k] has cardinality...

> # the cardinality of chi
nops(chi);

The Weyl group action (on the orbit of lambda[k]) viewed as permutations.

> s := WeylGroupAction(chi,'B',n):
for i from 1 to n do
s[i];
od;

A sample of the cycle structures.

> CycleStructureRandom({seq(s[i],i=1..n)});

Let's find an element with cycle structure [2,2] (two transpositions) if we can. This may be impossible depending on your choice of n & k.

> RandElementConj([[2,2],{seq(s[i],i=1..n)}]);

Type C

In this example, you can adjust the following parameters as needed to experiment with different C type simple Lie algebras.

This will explore the Cn representation: V(lambda[k]).
"rank = n" and "highest weight = lambda[k] = the k-th fundamental weight."

> n := 5; k := 1;

The Cartan matrix for Cn.

> print(CartanMatrix('C',n));

The Dynkin diagram for Cn.

> DynkinDiagram('C',n);

The fundamental weights for Cn.

> lambda := FundamentalWeights('C',n):
# print them out
seq(lambda[i],i=1..n);

The minuscule weights for Cn.

> MinusculeWeights('C',n);

${[1/2*2^(1/2), 0, 0, 0, 0]}$

The weights in the orbit of lambda[k].

> chi := WeylOrbit(lambda[k],'C',n);

$chi := {[1/2*2^(1/2), 0, 0, 0, 0], [0, 0, 0, 0, 1/2*2^(1/2)], [0, 1/2*2^(1/2), 0, 0, 0], [0, 0, 1/2*2^(1/2), 0, 0], [0, 0, 0, 1/2*2^(1/2), 0], [0, 0, 0, 0, -1/2*2^(1/2)], [0, 0, 0, -1/2*2^(1/2), 0], [...$ $chi := {[1/2*2^(1/2), 0, 0, 0, 0], [0, 0, 0, 0, 1/2*2^(1/2)], [0, 1/2*2^(1/2), 0, 0, 0], [0, 0, 1/2*2^(1/2), 0, 0], [0, 0, 0, 1/2*2^(1/2), 0], [0, 0, 0, 0, -1/2*2^(1/2)], [0, 0, 0, -1/2*2^(1/2), 0], [...$

The orbit of lambda[k] has cardinality...

> # the cardinality of chi
nops(chi);

The Weyl group action (on the orbit of lambda[k]) viewed as permutations.

> s := WeylGroupAction(chi,'C',n):
for i from 1 to n do
s[i];
od;

A sample of the cycle structures.

> CycleStructureRandom({seq(s[i],i=1..n)});

Let's find an element with cycle structure [2,2] (two transpositions) if we can. This may be impossible depending on your choice of n & k.

> RandElementConj([[2,2],{seq(s[i],i=1..n)}]);

Type D

In this example, you can adjust the following parameters as needed to experiment with different D type simple Lie algebras.

This will explore the Dn representation: V(lambda[k]).
"rank = n" and "highest weight = lambda[k] = the k-th fundamental weight."

> n := 5; k := 1;

The Cartan matrix for Dn.

> print(CartanMatrix('D',n));

The Dynkin diagram for Dn.

> DynkinDiagram('D',n);

The fundamental weights for Dn.

> lambda := FundamentalWeights('D',n):
# print them out
seq(lambda[i],i=1..n);

The minuscule weights for Dn.

> MinusculeWeights('D',n);

The weights in the orbit of lambda[k].

> chi := WeylOrbit(lambda[k],'D',n);

The orbit of lambda[k] has cardinality...

> # the cardinality of chi
nops(chi);

The Weyl group action (on the orbit of lambda[k]) viewed as permutations.

> s := WeylGroupAction(chi,'D',n):
for i from 1 to n do
s[i];
od;

A sample of the cycle structures.

> CycleStructureRandom({seq(s[i],i=1..n)});

Let's find an element with cycle structure [2,2] (two transpositions) if we can. This may be impossible depending on your choice of n & k.

> RandElementConj([[2,2],{seq(s[i],i=1..n)}]);

Type E

Of the five exceptional algebras, only E6 and E7 have minuscule weights. You can still explore the other

exceptional algebras, but a single orbit of weights will no longer capture the entire representation.

The Cartan matrix of E6.

> print(CartanMatrix('E',6));

The Dynkin diagram of E6.

> DynkinDiagram('E',6);

The fundamental weights of E6.

> lambda := FundamentalWeights('E',6):
# print them out
seq(lambda[i],i=1..6);

The minuscule weights of E6.

> MinusculeWeights('E',6);

${[0, 0, 0, 0, 0, 2/3*3^(1/2)], [0, 0, 0, 0, 1, 1/3*3^(1/2)]}$

Weight lambda[1] is minuscule

The weights in the orbit of lambda[1].

Note: Since lambda[1] is minuscule, this gives us all of the weights of the irrep with highest weight lambda[1].

> chi := WeylOrbit(lambda[1],'E',6):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The dimension of V(lambda[1]) is...

> # the cardnality of chi
nops(chi);

The Weyl group action viewed as permutations. (For example: 2 corresponds to the second weight in the above sorted list.)

> s := WeylGroupAction(chi,'E',6):
# print them out
for i from 1 to 6 do
s[i];
od;

Let's multiply all of the simple reflections together to find the Coxeter element.

> # multiply all of the generators together.
tmp := s[1]:
for i from 2 to 6 do
tmp := mulperms(tmp,s[i]):
od:
print(tmp);

The cycle structures present in the subgroup of the symmetric group generated by these permutations.

WARNING: This may take a minute or two.

> CycleStructure({seq(s[i],i=1..6)});

The cycle structure [12,12,3] allows for possible invariant subspaces of dimensions: 0, 3, 12, 15, 24, 27.
The cycle structure [9,9,9] allows for possible invariant subspaces of dimensions: 0, 9, 18, 27.

Thus, these cycle structures together allow for only 0 and 27 dimensional invariant subspaces (trivial subspaces).

The Coxeter element has two 12-cycles and a 3-cycle. Let's find an element with three 9-cycles.

> RandElementConj([[9,9,9],{seq(s[i],i=1..6)}]);

Weight lambda[6] is minuscule

The weights in the orbit of lambda[6].

Note: Since lambda[6] is minuscule, this gives us all of the weights of the irrep with highest weight lambda[6].

> chi := WeylOrbit(lambda[6],'E',6):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The dimension of V(lambda[6]) is...

> # the cardinality of chi
nops(chi);

The Weyl group action viewed as permutations. (For example: 2 corresponds to the second weight in the above sorted list.)

> s := WeylGroupAction(chi,'E',6):
# print them out
for i from 1 to 6 do
s[i];
od;

Let's multiply all of the simple reflections together to find the Coxeter element.

> # multiply all of the generators together.
tmp := s[1]:
for i from 2 to 6 do
tmp := mulperms(tmp,s[i]):
od:
print(tmp);

The cycle structures present in the subgroup of the symmetric group generated by these permutations.

WARNING: This may take a minute or two.

> CycleStructure({seq(s[i],i=1..6)});

Thus, these cycle structures together allow for only 0 and 27 dimensional invariant subspaces (trivial subspaces).

The Coxeter element has two 12-cycles and a 3-cycle. Let's find an element with three 9-cycles.

> RandElementConj([[9,9,9],{seq(s[i],i=1..6)}]);

The Cartan matrix of E7.

> print(CartanMatrix('E',7));

The Dynkin diagram of E7.

> DynkinDiagram('E',7);

The fundamental weights of E7.

> lambda := FundamentalWeights('E',7):
# print them out
seq(lambda[i],i=1..7);

The minuscule weights of E7.

> MinusculeWeights('E',7);

${[0, 0, 0, 0, 0, 1, 1/2*2^(1/2)]}$

The weights in the orbit of lambda[7].

Note: Since lambda[7] is minuscule, this gives us all of the weights of the irrep with highest weight lambda[7].

> chi := WeylOrbit(lambda[7],'E',7):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The dimension of V(lambda[7]) is...

> # the cardinality of chi
nops(chi);

The Weyl group action viewed as permutations. (For example: 2 corresponds to the second weight in the above sorted list.)

> s := WeylGroupAction(chi,'E',7):
# print them out
for i from 1 to 7 do
s[i];
od;

Let's multiply all of the simple reflections together to find the Coxeter element.

> # multiply all of the generators together.
tmp := s[1]:
for i from 2 to 7 do
tmp := mulperms(tmp,s[i]):
od:
print(tmp);

The Coxeter element has cycle structure [18,18,18,2].

It would take too long (and too much memory) to run CycleStructure. So, we compromise and run

CycleStructureRandom instead. Hopefully, we'll see the cycle structures we need.

WARNING: This may take a few minutes.

> CycleStructureRandom({seq(s[i],i=1..7)});

After running CycleStructureRandom, (hopefully) we see that the cycle structure [14,14,14,14] is present.

Let's find an element with this cycle structure (i.e. four 14-cycles).

> RandElementConj([[14,14,14,14],{seq(s[i],i=1..7)}]);

The cycle structure [18,18,18,2] allows for possible invariant subspaces of dimensions: 0, 18, 20, 36, 38, 54, 56.
The cycle structure [14,14,14,14] allows for possible invariant subspaces of dimensions: 0, 14, 28, 42, 56.

Thus, these cycle structures together allow for only 0 and 56 dimensional invariant subspaces (trivial subspaces).

The Cartan matrix of E8.

> print(CartanMatrix('E',8));

The Dynkin diagram of E8.

> DynkinDiagram('E',8);

Simple roots for E8.

> alpha := SimpleRoots('E',8):
# print them out
seq(alpha[i],i=1..8);

The fundamental weights of E8.

> lambda := FundamentalWeights('E',8):
# print them out
seq(lambda[i],i=1..8);

E8 has no minuscule weights.

> MinusculeWeights('E',8);

The highest long root of E8 is given by Humphreys on page 66.

> 2*alpha[1]+3*alpha[2]+4*alpha[3]+6*alpha[4]+5*alpha[5]+4*alpha[6]+3*alpha[7]+2*alpha[8];

Thus, the highest long root is better known as the last fundamental weight lambda[8]. Thus V(lambda[8]) is the adjoint

representation (irreducible because E8 is simple).

Let's find all of the roots of E8 by reflecting lambda[8].

> chi := WeylOrbit(lambda[8],'E',8):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The dimension of E8 is (# of negative roots) + (rank) + (# of positive roots) = 120 + 8 + 120 = 248.

(see Humphreys page 66: E8 has 120 positive roots).

Since the cardinality of chi is 240, our list of roots is complete.

> # the cardinality of chi
nops(chi);

Note: The weights of V(lambda[8]) are precisely the set chi (the roots) union { [0,0,0,0,0,0,0,0] }.

Type F

The only type F simple Lie algebra is F4.

The Cartan matrix of F4.

> print(CartanMatrix('F',4));

The Dynkin diagram of F4.

> DynkinDiagram('F',4);

Simple roots for F4.

> alpha := SimpleRoots('F',4):
# print them out
seq(alpha[i],i=1..4);

The fundamental weights of F4.

> lambda := FundamentalWeights('F',4):
# print them out
seq(lambda[i],i=1..4);

F4 has no minuscule weights.

> MinusculeWeights('F',4);

Let's find all of the roots of F4. First we compute (and union) the orbits of alpha[1] and alpha[4].

> chi := WeylOrbit(alpha[1],'F',4) union WeylOrbit(alpha[4],'F',4):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The dimension of F4 is (# of negative roots) + (rank) + (# of positive roots) = 24 + 4 + 24 = 52.

(see Humphreys page 66: F4 has 24 positive roots).

> # the cardinality of chi
nops(chi);

Since the cardinality of chi is 48, our list of roots is complete.

Type G

The only type G simple Lie algebra is G2.

The Cartan matrix of G2.

> print(CartanMatrix('G',2));

The Dynkin diagram of G2.

> DynkinDiagram('G',2);

Simple roots for G2.

> alpha := SimpleRoots('G',2):
# print them out
alpha[1],alpha[2];

The fundamental weights of G2.

> lambda := FundamentalWeights('G',2):
# print them out
lambda[1],lambda[2];

G2 has no minuscule weights.

> MinusculeWeights('G',2);

Let's find all of the roots of G2. First we compute (and union) the orbits of alpha[1] and alpha[2].

> chi := WeylOrbit(alpha[1],'G',2) union WeylOrbit(alpha[2],'G',2):
# print out the *list* of weights (after sorting them).
sort([op(chi)],listlex);

The dimension of G2 is (# of negative roots) + (rank) + (# of positive roots) = 6 + 2 + 6 = 14.

(see Humphreys page 66: G2 has 6 positive roots).

> # the cardinality of chi
nops(chi);

Since the cardinality of chi is 12, our list of roots is complete.