Dear Max,
        Thanks for your response!  I'll further reply below.

>>      I'm trying to get GAP to act on a finite Lie algebra, without much luck.
>> 
>>      I tried the following:
>> gap> L:=SimpleLieAlgebra("A", 1, GF(3));
>> <Lie algebra of dimension 3 over GF(3)>
>> gap> e:=Elements(L)[4];
>> v.2
>> gap> mat:=AdjointMatrix(Basis(L), e);
>> [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3) ], [ Z(3), 0*Z(3), 
>> 0*Z(3) ] ]
>> gap> e*mat;
>> [ [ 0*v.1, 0*v.1, 0*v.1 ], [ 0*v.1, 0*v.1, (Z(3))*v.2 ], [ (Z(3))*v.2, 
>> 0*v.1, 0*v.1 ] ]
>> gap> mat*e;
>> [ [ 0*v.1, 0*v.1, 0*v.1 ], [ 0*v.1, 0*v.1, (Z(3))*v.2 ], [ (Z(3))*v.2, 
>> 0*v.1, 0*v.1 ] ]
>> 
>>      Unless I'm mistaken, e*mat should return the same thing as e*e, which 
>> is to say 0 (=0*v.1).
> 
> I am afraid you are mistaken :-). You asked for a representation matrix of 
> the adjoint action of e on L.
> 
> This matrix acts on GF(3)^3, not on L (which is isomorphic as a vector space, 
> but not equal). 
        I see now that in the documentation, it indicates that matrix-vector 
multiplication is only defined for row vectors.

        Let me make a couple of further suggestions for the documentation, 
which might prevent some confusion from people trying to do similar things:
        OnSubspacesByCanonicalBasis indicates that it operates on the subspaces 
of a vector space.  And indeed, a Lie algebra has a canonical basis.  Perhaps a 
sentence like "This function is currently only implemented for row vector 
spaces" should be added?  Or to simply insert the word "row" before vector 
space.
        It would also be worthwhile to insert the word "row" before vector in 
the documentation for OnPoints and OnRight.

> So, the matrix/vector computation corresponding to e*e actually would be this:
> 
> # convert to coordinates in GF(3)^3
> gap> v:=Coefficients(Basis(L), e);
> [ 0*Z(3), Z(3)^0, 0*Z(3) ]
> 
> # apply the matrix; per manual, "[t]he adjoint map is the left multiplication 
> by x."
> gap> w := mat*v;
> [ 0*Z(3), 0*Z(3), 0*Z(3) ]
> 
> # convert back to L
> gap> LinearCombination(Basis(L), w);
> 0*v.1
> # or shorter:
> gap> Basis(L) * w;
> 0*v.1
        That's helpful.  Perhaps embarrassingly, I was having trouble figuring 
out how to get GAP to convert back and forth.
        Let me explain below the problem I'm looking at, and discuss more there.


>> Perhaps I'm missing something obvious?  Is there some workaround?  I did 
>> look through the "AsObject" methods, and didn't see anything that looked 
>> helpful.
>> 
>>      (I'd ultimately like to find orbits of the action on subspaces, but I 
>> think this is the level at which it is breaking down.)
> 
> What exactly do you mean by "orbit" here? L is not a group action, after all. 
> Perhaps you mean the action of the corresponding finite group of Lie type (so 
> eg. SL_2(F_3) in this example)?
        I noticed that the Lie algebra support for GAP didn't have much support 
for automorphisms, which seems a shame.  And I'm interested in computing the 
inner automorphism group Inn(L) of an arbitrary Lie algebra L.  My underlying 
purpose:  I have some code to display the subalgebra lattice of a finite Lie 
algebra, and would like to group 'conjugate' subalgebras together.

        Apparently, in characteristic 0, the inner automorphism group Inn(L) is 
generated by the exponentials of the adjoints of all the nilpotent elements of 
L.  Here the exponential is the normal matrix exponential series, which 
terminates for nilpotent elements.  Allegedly, in characteristic p, you can do 
the same, except that you need to first convert the matrices to integer 
matrices, then apply the exponential, then convert back to prime 
characteristic.  (The conversion avoids division by p.)  I say 'allegedly' 
because I'm not completely happy with the references I've found for this so 
far, and I'm not an expert on Lie theory.

        In a field of prime order, all these steps are easy to handle with GAP, 
and I have code which computes the exponential map.  So I have Inn(L), at least 
up to the 'allegedly'.  

        Then to figure out which subalgebras are conjugate, I need to apply 
Inn(L) to subalgebras, not just elements.  
        For example, if 
S:=Elements(Subspaces(L))[17];
B:=Basis(L);
        then I guess the following code would work to find mat*S:
Subspace(L, List(Basis(S), x->LinearCombination(B,mat*Coefficients(B,x))));

        But maybe there's something obvious and simpler that I'm missing?
        I guess encoding this as a group action function (inverting the matrix 
to convert a left action to a right action) would at least hide the mess...

        Thanks again!  Best,

                                                        --Russ

> Cheers,
> Max


_______________________________________________
Forum mailing list
Forum@gap-system.org
https://mail.gap-system.org/mailman/listinfo/forum

Reply via email to