#
# file:    tori.gap
#
# purpose: routines related to tori in a Lie algebra
# 
#          Routines defined here:
#
#          AbelianSubalgebrasMaxDim
#          CheckTori
#          Decomp
#          Rootspace
#          ToralElements
#
# created: Pasha Zusmanovich <pasha.zusmanovich@gmail.com> Mar 18 2021
#


# L: Lie p-algebra
#
# find toral elements in L, by brute-force method
ToralElements := function (L)
	local basis, i, N, t, e;

	if (not IsRestrictedLieAlgebra (L)) then
		Error ("the argument is not a restricted Lie algebra");
	fi;

	basis := CanonicalBasis (L);
	t := [];

	N := Size(L); 	# number of elements in the algebra
	i := 0;
	for e in L do
		if ((PthPowerImage (basis, e) = e) and (e <> Zero(L))) then
			Add (t, e);
		fi;

		i := i+1;
		if (i mod 10000 = 0) then
			Print ("processed ", i, " elements out of ", N, 
                   ", found " , Length (t), " toral elements\n"); 
		fi;
	od;
	return (t);
end;




# A: (nonassociatve) algebra in which x^2 = 0
# list: list of elements of A
# verbose: true or false, whether to print some messages
#
# find all subalgebras of A with trivial multiplication of the maximal 
# dimension spanned by elements of the list, by brute-force search
AbelianSubalgebrasMaxDim := function (A, list, verbose)
	local abelian, dim, e, e_new, e_list, e_list_new, i, j, n,
		  subalgs, subalgs_next_dim;

	n := Length (list);
	dim := 1;   # current dimension

	# abelian subalgebras of current dimension, in the form of an ordered list 
	# of length dim of indices in the 'list';
	# start with 1-dimensional subspaces
	subalgs := List ([1..n], x -> [x]);

	while (true) do
		if (verbose) then
			Print ("checking for abelian subalgebras of dimension ", dim+1, 
            	   "...\n");
		fi;
		subalgs_next_dim := [];
		for e in subalgs do
			e_list := List (e, x -> list[x]);

			# as the algebra is anticommutative and x^2 = 0, we are starting
			# from the next index
			for i in [e[dim]+1 .. n] do
				abelian := true;
				for j in e do
					if (list[j] * list[i] <> Zero(A)) then
						abelian := false;
						break;
					fi;
				od;
				if (abelian) then
					e_list_new := ShallowCopy (e_list);					
					Add (e_list_new, list[i]);
					if (Dimension (Subspace (A, e_list_new)) = dim+1) then
						e_new := ShallowCopy (e);
						Add (e_new, i);
						Add (subalgs_next_dim, e_new);
 					fi;
				fi;
			od;
		od;

		if (verbose) then
			Print ("got ", Length (subalgs_next_dim), " subalgebras\n");
		fi;
		if (IsEmpty (subalgs_next_dim)) then
			break;
		else
			dim := dim + 1;
			subalgs := subalgs_next_dim;
		fi;
	od;

	return (subalgs);
end;


# find rootspace in a Lie algebra L with respect to a toral element h in its 
# p-envelope L2 corresponding to eigenvalue i
Rootspace := function (L, Lp, h, i)
	local bas;
	bas := CanonicalBasis (Lp);
	return (
			Intersection (L, 
							Subspace (Lp, 
						  				 List (
				  							   NullspaceMat (
						TransposedMat (AdjointMatrix (bas, h)) - 
                    	i*IdentityMat (Dimension(Lp), LeftActingDomain (Lp))
					                                        ),
			      							   x -> LinearCombination (x, bas)
				                              )
                                     )
                         )
           );
end;



# with respect to a given torus, computes its root spaces corresponding to
# GF(2)^n
# T: list of toral elemes
Decomp := function (L, Lp, T)
	local n, r, rootspaces;
	n := Length (T);

	# list of 2-element lists [root (n-tuple of elements of GF(2)), space]
	rootspaces := [];

	for r in Tuples ([0,1], n) do
		Add (rootspaces, 
         	[r, Intersection (
				List ([1 .. n], x -> Rootspace (L, Lp, T[x], r[x]))
                             )]);
	od;
	return (rootspaces);
end;




# L:  Lie algebra
# L2: p-envelope of L
# toral_elem: list of toral elements in L2
# tori: list of tori of equal dimension in L2, in the form of lists of indices 
#       in toral_elem
#
# for each tori, check whether it is a Cartan subalgebra of L2, 
# whether the root space decompositions of L with respect to it is thin
#
CheckTori := function (L, Lp, toral_elem, tori)
	local i, list, N, n, thin, rootspaces, s, T, zerotuple;

	N := Length (tori);

	# dimension of tori (should be the same for each torus)
	n := Length (tori[1]);
	zerotuple := List ([1..n], x -> 0);

	for i in [1 .. N] do
		if (i mod 10 = 0) then
			Print ("processed ", i, " out of ", N, " tori\n"); 
		fi;

		list := List ([1..n], x -> toral_elem[tori[i][x]]);

		T := Subalgebra (Lp, list, "basis");
		if (LieNormalizer (Lp, T) <> T) then
			Print (tori[i], " is not a Cartan subalgebra\n");
		fi;

		rootspaces := Decomp (L, Lp, list);
		thin := true;
		for s in rootspaces do
			if (s[1] = zerotuple) then
				if (Dimension (s[2]) > 0) then
					thin := false;
				fi;
			elif (Dimension (s[2]) <> 1) then
				thin := false;
			fi;
		od;
		if (not thin) then
			Print (tori[i], " does not provide thin decomposition\n");
		fi;
	od;
end;



# eof