[GAP Forum] semsimple algebras and subalgebras

[R.N. Tsai]

Dear Willem and forum,

Thanks for the quick response. The function you created "DecomposeAdRep" is
exactly what I was looking for. Also getting the highest weight of the
adjoint rep works for simple algebras; but I think it has trouble with
direct sum of simple algebras :

# A1+A1 -> A1 (or D2->D1 or O4->O3 ) branching rule for adjoint rep :
gap> r:=LieAlgebraAndSubalgebras("A1 A1");;
gap> L:= r.liealg;;
gap> K:= r.subalgs[1];;
# this gives the correct decomposition : 6->3+1+1+1;
gap> dec:=DecomposeAdRep( L, K );
[ <vector space of dimension 3 over Rationals>, <vector space of dimension 1 over Rationals>, 
  <vector space of dimension 1 over Rationals>, <vector space of dimension 1 over Rationals> ]

# however this has a problem; dim should be 6.
gap> wt:= PositiveRootsAsWeights( RootSystem(L) );;
gap> hw:= wt[ Length(wt) ];
[ 0, 2 ]
gap> dim:=DimensionOfHighestWeightModule(L,hw);
3

Regards,
R.N.



On Monday, February 17, 2014 12:39 AM, Willem de Graaf <degraaf at science.unitn.it> wrote:
 
Dear R.N. Tsai,


You asked:


> I'd like to identify
> the subalgebra irreps with concrete subspaces of the main algebra. Is there
> a (hopefully simple) way to extract this information?

Not directly, however it is not so difficult to write some code for that.
At the bottom of this message please find a GAP function that does that.
It is followed by an example. 

One remark: in your piece of code you use the command

      Dimension(HighestWeightModule(sub,bra[1][k]))


It is much more efficient to use 

      DimensionOfHighestWeughtModule( sub, bra[1][k] );

as this avoids constructing the module.

You also asked:

> is there a general way to get the weight of the adjoint rep for an
> arbitrary semisimple algebra?

If the Lie algebra is denoted L, then you can do

wt:= PositiveRootsAsWeights( RootSystem(L) );;
hw:= wt[ Length(wt) ];

I am glad that the sla package is of use to you.

Best wishes,

Willem de Graaf

# function:

DecomposeAdRep:= function( L, K ) 

        # K is a subalgebra of L, both semisimple in char 0;
        # we return the decomposition of L as K module.

    local cg, e, x, ad, i, spaces, spaces0, h, ww, sp, mat, es, hwv;

    cg:= CanonicalGenerators( RootSystem(K) );
    e:= List( Basis(L), x -> [ ] );
    for x in cg[1] do
        ad:= TransposedMat( AdjointMatrix(Basis(L),x) );
        for i in [1..Length(ad)] do
            Append( e[i], ad[i] );
        od;
    od;
    spaces:= [ List( NullspaceMat(e), u -> u*Basis(L) ) ];

    for h in cg[3] do
        spaces0:= [ ];
        for ww in spaces do 
            sp:= Basis( Subspace(L,ww), ww );
            mat:= List( ww, u-> Coefficients(sp,h*u) );  
            es:= Eigenspaces( LeftActingDomain(L), mat );
            for i in [1..Length(es)] do
                Add( spaces0, List( Basis(es[i]), x -> x*ww ) );
            od;
        od;
        spaces:= spaces0;
    od;

    hwv:= Concatenation( spaces );
    spaces:= [ ];
    for i in [1..Length(hwv)] do
        Add( spaces, MutableBasisOfClosureUnderAction( LeftActingDomain(L),
                 cg[2], "left", [ hwv[i] ], \*, Zero(L), Dimension(L) ) );
    od;
    return List( spaces, u -> Subspace(L,BasisVectors(u)) );

end;


# example:

gap> r:= LieAlgebraAndSubalgebras("G2");;
gap> L:= r.liealg;;
gap> K:= r.subalgs[5];;
gap> DecomposeAdRep( L, K );
[ <vector space over Rationals, with 8 generators>, 
  <vector space over Rationals, with 3 generators>, 
  <vector space over Rationals, with 3 generators> ]