# 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;