# This is a GAP program for computing the list of dimensions of irreducible # representations of simple Lie algebras/groups. This is done by the # function "dims" below. # # We include "1", because the one-dimensional trivial representation is irreducible. # We ignore the possibility of repetitions -- non-isomorphic representations that # have the same dimension. This does indeed happen, even in nontrivial cases. # For example, the highest weights 10100000 and 10000011 of E_8 (with fundamental # weights numbered as in Bourbaki) both correspond to irreducible representations # of dimension 8,634,368,000. # # Example: # dims("E", 8, 6); # Computes the dimensions of irreps of the Lie algebra E_8 up to the # dimension of the smallest irrep with highest weight of height 6. # # The program is somewhat inefficient. For example, if you compute # the dimensions for irreps with highest weight of height 2 for # SL_4 (by calling dimsh(A3, 3, 2)), the program computes the dimension # of the irrep with highest weight 110 *twice*. In general, if there # are repeated nonzero coordinates, the computation is done too many times. # # However, the Online Encyclopedia of Integer Sequences only demands three text # lines worth of entries, and for that purpose, this program is efficient enough. # My old 1 GHz PowerPC G4 laptop can compute dims("E", 8, 6) in a few minutes. # Turn this to true to give some debugging messages debug := false; # returns the list "lst" with the head deleted tail := function(lst) return(lst{[2..Length(lst)]}); end; # This function is the bottom of the recursion. # It returns the dimension of the irrep of the Lie algebra L with # highest weight w. dims_dim := function(L, w) local rval; rval := DimensionOfHighestWeightModule(L, w); if debug then Print(w, " ", rval, "\n"); fi; return(rval); end; # Returns a set listing the dimensions of irreducible E_8 modules where # the coordinates of the highest weights are as in the list "parts" # # Works recursively. # # For example, if w = [0, 0, ... , 0] and parts = [2, 1, 1, 1], it lists the # dimensions of modules where the highest weight has one 2 and three 1's. # # If w is passed with some nonzero entries, those entries are not overwritten. # dims_h_part := function(L, rank, w, parts) local rval, i, z; rval := Set([]); # the workhorse of the recursion for i in [1..rank] do if w[i] = 0 then # only overwrite 0 coordinates z := ShallowCopy(w); z[i] := parts[1]; if Length(parts) = 1 then # no more recursion: compute the dimension AddSet(rval, dims_dim(L, z)); else # recurse! rval := Union(rval, dims_h_part(L, rank, z, tail(parts))); fi; fi; od; return(rval); end; # this function returns a set listing dimensions of all irreducible representations # of the Lie algebra L such that the sum of the coordinates in the highest weight is "ht" # # "rank" is the rank of L dims_h := function(L, rank, ht) local rval, i, part, parts, w; rval := Set([]); parts := Partitions(ht); for part in parts do # initialize w: it is a vector with all entries 0 w := []; for i in [1..rank] do Add(w, 0); od; if debug then Print("Initialized: ", w, " with partition ", part, "\n"); fi; # pass to dims_h_part, which does all the work rval := Union(rval, dims_h_part(L, rank, w, part)); od; return(rval); end; # this function returns a sorted listing of all dimensions of irreducible # representations of E_8 up to some limit. # # maxlist lists the dimensions of irreps with weights of height "ht" # maxlist[1] is the smallest of these dimensions # Every irrep of height >= ht has dimension >= maxlist[1] # Returns a list consisting of # dimensions of irreps of height <= ht and dimension <= maxlist[1] # maxlist[1] # dims := function(fam, rank, ht) local L, R, filt, rval, i, maxlist; L := SimpleLieAlgebra(fam, rank, Rationals); rval := Set([1]); # don't forget the 1-dimensional trivial rep! for i in [1..(ht-1)] do Print("Computing dimensions for height ", i, "...\n"); rval := Union(rval, dims_h(L, rank, i)); # consider weights of height < ht od; Print("Computing dimensions for height ", ht, "...\n"); maxlist := dims_h(L, rank, ht); filt := Filtered(rval, x -> x < maxlist[1]); AddSet(filt, maxlist[1]); return(filt); end;