Weyl Group Calculations

Initialize and Load the Maple Code 

>	# Clear Memory restart;

 

>	# Import Maple Code read "LieAlgebra.maple";

 

Routine Examples 

These are some examples of how to use the routines imported
from the file "LieAlgebra.maple". 

>	CartanMatrix('A',4);

 

(2.1)

 

>	DynkinDiagram('A',4);

 

The simple roots and fundamental weights are given in terms 

of an appropriate Euclidean space. The dot product computes 

the standard symmetric invariant bilinear form (long roots have 

square length 2). 

>	alpha := SimpleRoots('A',2): seq(alpha[i],i=1..2);

 

(2.2)

 

>	myDot(alpha[1],alpha[1]);

 

(2.3)

 

The fundamental weights are returned in a list of coordinate  

vectors (coordinates with respect to the Euclidean space basis). 

>	lambda := FundamentalWeights('A',2): seq(lambda[i],i=1..2);

 

(2.4)

 

The highest long root is given in coordinates with respect to 

the basis of fundamental weights. 

>	HighestLongRoot('A',2); theta := 1*lambda[1]+1*lambda[2];

 

 

	(2.5)

 

We know that the highest long root for A_2 = sl_3 is 

the sum of the two simple roots. 

>	theta = alpha[1]+alpha[2];

 

(2.6)

 

FindWeights will determine the set of weights for the representation 

with highest weight:  

  lambda = [c_1,c_2,...,c_m] = c_1 lambda_1 + ... c_m lambda_m 

This procedure returns a set of weights given in coordinates with  

respect to the basis of fundamental weights. 

Here are the weights for A_2's adjoint module (whose highest weight 

is 1*lambda_1 + 1*lambda_2). 

>	FindWeights('A',2,[1,1]);

 

(2.7)

 

FundamentalToEuclidean changes from fundamental weight coordinates 

to Euclidean space coordinates. 

>	a*lambda[1]+b*lambda[2] = FundamentalToEuclidean('A',2,[a,b]);

 

(2.8)

 

FindWeightsEuclidean converts the output of FindWeights to the 

coordinates with respect to the Euclidean space basis. 

>	FindWeightsEuclidean('A',2,[1,1]);

 

(2.9)

 

PlotWeights will plot the weights of a highest weight representation 

for simple Lie algebras of ranks 1, 2, and 3. 

Example: Type A_1 = sl_2, the 6 dimensional highest weight module 

             (with highest weight lambda = 5*lambda_1). 

>	PlotWeights('A',1,[5]);

 

PlotWeights has two extra options: showing labels and showing lines connecting 

the weights to the origin. The syntax is:  

[>  PlotWeights(lie_type, lie_rank, show_labels, show_lines); 

Example: Type A_2 = sl_3, the adjoint module. The corresponding labels are 

             the coordinates of the weights with respect to the fundamental weight 

             basis. 

>	PlotWeights('A',2,[1,1],true);

 

Example: Type A_3, highest weight 1*lambda_1+1*lambda_3 

             (no labels, but with lines connecting weights to the origin). 

>	PlotWeights('A',3,[1,0,1],false,true);

 

Let sigma_i be the simple reflection associated with the simple root alpha_i. 

We know that the Weyl group is generated by these simple reflections. 

The WeylReflect, WeylEl, WeylReflectSet, and WeylReflectList functions 

apply Weyl group elements to coordinate vectors (or sets or lists of coordinate 

vectors). All coordinates are with respect to the fundamental weight basis. 

Example: For the algebra A_2, the simple reflection sigma_1 associated  

with alpha_1 reflects 1*lambda_1+1*lambda_2 to -1*lambda_1+2*lambda_2 

>	WeylReflect('A',2,1,[1,1]);

 

(2.10)

 

Example: Again for A_2, w = sigma_2 composed with sigma_1 

is an element of the Weyl group. We will represent this element 

by the list [2, 1]. This Weyl group element applied to the weight 

1*lambda_1+1*lambda_2 is... 

>	w := [2,1]; 'w = sigma[2]*sigma[1]'; mu := [1,1]; 'mu = 1*lambda[1]+1*lambda[2]'; 'w(mu)' = WeylEl('A',2,w,mu);

 

 

 

 

 

	(2.11)

 

Example: Apply the simple reflection sigma_1 to the set or list of weights 

>	WeylReflectSet('A',2,1,{[-1,2],[2,-1],[1,1]});

 

(2.12)

 

>	WeylReflectList('A',2,1,[[-1,2],[2,-1],[1,1]]);

 

(2.13)

 

Determine where the new highest weight is located when we use 

the module action associated with Delta(H^(1),x) and "old" highest
weight 1*lambda[1]+1*lambda[2]. 

>	NewHighestWeight('A',2,[1,1],1);

 

(2.14)

 

If H^(j) is not a minuscule co-weight, our theorem does not apply 

and we are no longer gauranteed to find the "new" highest weight. 

If we try running this routine on the G_2 module with highest weight 

lambda_2, the routine returns a warning that the "new" highest weight 

it found is not unique...thus signaling a problem.  

Note: G_2 has no minuscule co-weights, so our results do not apply here. 

>	NewHighestWeight('G',2,[0,1],1);

 

 

Warning, Answer is not unique!
	(2.15)

 

weylGroup finds all of the elements of the Weyl group where for example: 

[1,2,1] represents sigma_1 sigma_2 sigma_1 and [ ] represents the identity. 

Example: the Weyl group of A_2. 

>	weylGroup('A',2);

 

(2.16)

 

The extra argument "true" makes the function print out status reports 

(which is helpful for very large examples). 

>	weylGroup('A',5,true):

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(2.17)

 

weylGroupSearch (blindly) searches through the Weyl group in order to 

find an element which sends our "old" highest weight to our "new" highest  

weight. This routine helped in conjecturing the general formula for the Weyl 

group element associated with each type and Delta-action. 

This routine returns the goal Weyl group element along with the Weyl group 

(which is computed as a side effect). 

Again, an extra argument of "true", will make the routine print out status reports. 

You may notice that the Weyl group elements found by this routine look "different" 

from the ones in the paper. This is due to the fact that a Weyl group element can 

be represented in many different ways (i.e. identity = sigma_1 sigma_1 so that, for  

example, [] = [1,1] = [1,2,2,1] = [1,2,2,1,2,2]). The representations given in the paper  

were chosen to look "nice", whereas the routine finds a presentation of minimal length. 

Note: This routine works well for ranks < 6. For larger ranks, the Weyl groups 

get quite large and the routine may be unpractical.  

>	weylGroupSearch('A',1,1,true);

 

 

 

 

 

	(2.18)

 

>	weylGroupSearch('A',2,1,true);

 

 

 

 

 

 

 

	(2.19)

 

>	weylGroupSearch('A',3,1)[1];

 

(2.20)

 

>	weylGroupSearch('A',4,1)[1];

 

(2.21)

 

>	weylGroupSearch('A',5,1,true)[1];

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(2.22)

 

DeltaWeylEl returns the Weyl group element "sigma_{lie_type}^{(coweight)}"  

(as defined in the paper). 

>	wSearch := weylGroupSearch('A',4,2)[1];

 

(2.23)

 

>	wPaper := DeltaWeylEl('A',4,2);

 

(2.24)

 

Are these really the same element of the Weyl group? 

Let's check their actions on the fundamental weights. 

>	fundWgts := [seq([seq(0,j=1..(i-1)),1,seq(0,k=(i+1)..4)],i=1..4)]:

 

>	for i from 1 to 4 do

 

>	X:=WeylEl('A',4,wSearch,fundWgts[i]);

 

>	Y:=WeylEl('A',4,wPaper, fundWgts[i]);

 

>	ok := true;

 

>	for j from 1 to 4 do

 

>	if X[j]=Y[j] then

 

>	# ok so far

 

>

else

 

>	ok := false;

 

>

end if:

 

>

end do:

 

>	print(cat("wPaper(lambda_",i,") = ",convert(X,string), " and ",

 

>	"wSearch(lambda_",i,") = ",convert(Y,string), " Match? ", ok));

 

>

end do:

 

>

 

 

 

 

	(2.25)

 

This shows that wPaper and wSearch are actually the same element. 

Verifying Calculations 

We need to verify that the actions of: 

sigma_{E6}^{(1)},  sigma_{E6}^{(6)}, and  sigma_{E7}^{(7)}   

match the actions claimed in the paper. 

In addition, we give verifications for all rank 5 cases and type D6  

cases as well (since type D's behavior is different for even and  

odd ranks).  

A5 

>	# A5 co-weight H^{(1)} verifyCalculations('A',5,1); DeltaWeylElAction('A',5,1);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.1.1)

 

>	# A5 co-weight H^{(2)} verifyCalculations('A',5,2); DeltaWeylElAction('A',5,2);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.1.2)

 

>	# A5 co-weight H^{(3)} verifyCalculations('A',5,3); DeltaWeylElAction('A',5,3);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.1.3)

 

>	# A5 co-weight H^{(4)} verifyCalculations('A',5,4); DeltaWeylElAction('A',5,4);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.1.4)

 

>	# A5 co-weight H^{(5)} verifyCalculations('A',5,5); DeltaWeylElAction('A',5,5);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.1.5)

 

B5 

>	# B5 co-weight H^{(1)} verifyCalculations('B',5,1); DeltaWeylElAction('B',5,1);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.2.1)

 

 

C5 

>	# C5 co-weight H^{(5)} verifyCalculations('C',5,5); DeltaWeylElAction('C',5,5);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.3.1)

 

D5 and D6 

>	# D5 co-weight H^{(1)} verifyCalculations('D',5,1); DeltaWeylElAction('D',5,1);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.4.1)

 

>	# D5 co-weight H^{(4)} verifyCalculations('D',5,4); DeltaWeylElAction('D',5,4);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.4.2)

 

>	# D5 co-weight H^{(5)} verifyCalculations('D',5,5); DeltaWeylElAction('D',5,5);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.4.3)

 

>	# D6 co-weight H^{(1)} verifyCalculations('D',6,1); DeltaWeylElAction('D',6,1);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.4.4)

 

>	# D6 co-weight H^{(5)} verifyCalculations('D',6,5); DeltaWeylElAction('D',6,5);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.4.5)

 

>	# D6 co-weight H^{(6)} verifyCalculations('D',6,6); DeltaWeylElAction('D',6,6);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.4.6)

 

E6 and E7 

 

We need to verify our calculations for type E_6 with co-weights H^(1) and H^(6) 

as well as type E_7 with co-weight H^(7). 

 

Note: E_8, F_2, and G_2 have no minuscule co-weights, so there is nothing to check. 

 

>	# E6 co-weight H^{(1)} verifyCalculations('E',6,1); DeltaWeylElAction('E',6,1);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.5.1)

 

>	# E6 co-weight H^{(6)} verifyCalculations('E',6,6); DeltaWeylElAction('D',6,6);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.5.2)

 

>	# E7 co-weight H^{(7)} # # Warning: Verifying the E_7 case may take several minutes. # verifyCalculations('E',7,7); DeltaWeylElAction('E',7,7);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

	(3.5.3)