# # file: alder.gap # # purpose: By the given structure constants of a 3-dimensional omega-Lie # algebra, computes its (alpha,lambda)-derivations. # This is an accompanying file to the paper "omega-Lie algebras". # # created: Pasha Zusmanovich Nov 21 2008 # # latest revision history: # Dec 14 2009 added function Alder2(); # added function enumerating all 3-dimensional algebras; # added code showing that there are no 4-dimensional algebras with # nondegenerate omega # Dec 23 2009,Jun 23 2011,Oct 25 2015 cosmetics # # this function calculates a nonzero (alpha,lambda)-derivation for an anticommutative # algebra over a field K given by structure constants T, and given vectors alpha and # lambda; returns empty list if no such (alpha,lambda)-derivation exists Alder1 := function (T, alpha, lambda, K) local _add, Mat, b, N, i, j, k, l, s, sol; _add := function (i, j, s, element) local f; f := (i-1)*N+j; Mat[f][s] := Mat[f][s] + element; end; N := Length (alpha); if (N <> Length (lambda)) then Error ("alpha and lambda should be of equal length"); fi; Mat := NullMat (N*N, N*N*(N-1)/2, K); b := NullMat (1, N*N, K)[1]; for i in [1..N] do for j in [(i+1)..N] do for l in [1..N] do s := ((2*N-i)*(i-1)/2 + j-i-1)*N + l; for k in [1..N] do _add (k,l,s, SCTableEntry (T, i,j,k)); _add (i,k,s, - SCTableEntry (T, k,j,l)); _add (j,k,s, SCTableEntry (T, k,i,l)); od; _add (i,l,s, -lambda[j]); _add (j,l,s, lambda[i]); if (i=l) then b[s] := b[s] + alpha[j]; fi; if (j=l) then b[s] := b[s] - alpha[i]; fi; od; od; od; sol := SolutionMatDestructive (Mat, b); if (sol = fail) then return ([]); else return (List (List([1 .. N]), i -> sol{[ (i-1)*N+1 .. i*N ]})); fi; end; # this function calculates all (alpha,lambda)-derivations for an anticommutative algebra # over a field K given by structure constants T, and given vector lambda; # returns list, each element of which represents one (alpha,lambda)-derivation: # first N elements are actions of D on the basis elements, the last one is alpha. Alder2 := function (T, lambda, K) local _add, Mat, N, N2, i, j, k, l, s; _add := function (i, j, s, element) local f; f := (i-1)*N+j; Mat[f][s] := Mat[f][s] + element; end; N := Length (lambda); N2 := N*N; Mat := NullMat (N2+N, N2*(N-1)/2, K); for i in [1..N] do for j in [(i+1)..N] do for l in [1..N] do s := ((2*N-i)*(i-1)/2 + j-i-1)*N + l; for k in [1..N] do _add (k,l,s, SCTableEntry (T, i,j,k)); _add (i,k,s, - SCTableEntry (T, k,j,l)); _add (j,k,s, SCTableEntry (T, k,i,l)); od; _add (i,l,s, -lambda[j]); _add (j,l,s, lambda[i]); if (i=l) then Mat[N2+j][s] := Mat[N2+j][s] - One(K); fi; if (j=l) then Mat[N2+i][s] := Mat[N2+i][s] + One(K); fi; od; od; od; return (List (NullspaceMatDestructive (Mat), v -> List([1 .. N+1], i -> v{[ (i-1)*N+1 .. i*N ]}))); end; # this function returns the 3-dimensional omega-Lie algebra of given type # (as in Nurowski's list) over a given field K # returns 3-elements list: # structure constants of an algebra; # coordinates of a basic element in Ker(omega) (which is 1-dimensional); # lambda (possibly 1-parametric) realizing the multiplicative structure 3DimOmegaLieAlgebra := function (arg) local type, K, a, t, T, keromega, lambda; type := arg[1]; # type of algebra K := arg[2]; # base field if (Length (arg) >= 3) then a := arg[3]; # optional parameter for structure constants fi; if (Length (arg) = 4) then t := arg[4]; # optional parameter for lambda fi; T := EmptySCTable (3, Zero(K), "antisymmetric"); if (type = "4T") then ############## (IV)_T ################################# # [e1,e2] = e2 # [e3,e1] = -e3 # [e2,e3] = e1 # omega(e1,e2) = 0, omega(e3,e1) = 0, omega(e2,e3) = 2 # Ker(omega) = SetEntrySCTable (T, 1, 2, [ 1, 2]); SetEntrySCTable (T, 3, 1, [-1, 3]); SetEntrySCTable (T, 2, 3, [ 1, 1]); keromega := [1, 0, 0]; lambda := [2, 0, 0]; ####################################################### elif (type = "6T") then ############## (VI)_T ################################# # [e1,e2] = e2 # [e3,e1] = -e2 - e3 # [e2,e3] = e1 # omega(e1,e2) = 0, omega(e3,e1) = 0, omega(e2,e3) = 2 # Ker(omega) = SetEntrySCTable (T, 1, 2, [ 1, 2]); SetEntrySCTable (T, 3, 1, [-1, 2, -1, 3]); SetEntrySCTable (T, 2, 3, [ 1, 1]); keromega := [1, 0, 0]; lambda := [2, 0, 0]; ####################################################### elif (type = "6S") then ############## (VI)_S ################################# # [e1,e2] = -e1 # [e3,e1] = -e2 # [e2,e3] = e1 + e3 # omega(e1,e2) = 0, omega(e3,e1) = -2, omega(e2,e3) = 0 # Ker(omega) = SetEntrySCTable (T, 1, 2, [-1, 1]); SetEntrySCTable (T, 3, 1, [-1, 2]); SetEntrySCTable (T, 2, 3, [ 1, 1, 1, 3]); keromega := [0, 1, 0]; lambda := [0, 2, 0]; ####################################################### elif (type = "6N") then ############## (VI)_N ################################# # [e1,e2] = -e1 + e2 # [e3,e1] = -e2 - e3 # [e2,e3] = e1 + e3 # omega(e1,e2) = 0, omega(e3,e1) = -2, omega(e2,e3) = 2 # Ker(omega) = SetEntrySCTable (T, 1, 2, [-1, 1, 1, 2]); SetEntrySCTable (T, 3, 1, [-1, 2, -1, 3]); SetEntrySCTable (T, 2, 3, [ 1, 1, 1, 3]); keromega := [1, -1, 0]; lambda := [t, t, 2*One(K) - t]; ####################################################### elif (type = "7T") then ############## (VII)_T ################################ # [e1,e2] = e2 # [e3,e1] = e2 - e3 # [e2,e3] = e1 # omega(e1,e2) = 0, omega(e3,e1) = 0, omega(e2,e3) = 2 # Ker(omega) = SetEntrySCTable (T, 1, 2, [1, 2]); SetEntrySCTable (T, 3, 1, [1, 2, -1, 3]); SetEntrySCTable (T, 2, 3, [1, 1]); keromega := [1, 0, 0]; lambda := [2, 0, 0]; ####################################################### elif (type = "8a") then # (VIII)_a and (VIII)_{-a} are isomorphic # (VIII)_a and (IX)_a are isomorphic over an algebraically closed field # a is nonzero ############## (VIII)_a for a not i,-i (generic a) #### # [e1,e2] = -e3 # [e3,e1] = ae1 + e2 # [e2,e3] = e1 - ae2 # omega(e1,e2) = -2a, omega(e3,e1) = 0, omega(e2,e3) = 0 # Ker(omega) = SetEntrySCTable (T, 1, 2, [-1, 3]); SetEntrySCTable (T, 3, 1, [ a, 1, 1, 2]); SetEntrySCTable (T, 2, 3, [ 1, 1, -a, 2]); keromega := [0, 0, 1]; if (a*a + One(K) = 0) then lambda := [t, -t*a, 2*a]; else lambda := [0, 0, 2*a]; fi; ####################################################### elif (type = "8Ta") then # (VIII)_Ta and (VIII)_T{-a} are isomorphic # a is nonzero ############## (VIII)_Ta ############################## # [e1,e2] = ae2 - e3 # [e3,e1] = e2 - ae3 # [e2,e3] = e1 # omega(e1,e2) = 0, omega(e3,e1) = 0, omega(e2,e3) = 2a # Ker(omega) = SetEntrySCTable (T, 1, 2, [a, 2, -1, 3]); SetEntrySCTable (T, 3, 1, [1, 2, -a, 3]); SetEntrySCTable (T, 2, 3, [1, 1]); keromega := [1, 0, 0]; if ((a = 1) or (a = -1)) then lambda := [2*a, t, t*a]; else lambda := [2*a, 0, 0]; fi; ####################################################### elif (type = "8Na") then # (VIII)_Na and (VIII)_N{-a} are isomorphic # a is nonzero ############## (VIII)_Na ############################## # [e1,e2] = ae2 - e3 # [e3,e1] = ae1 + e2 - ae3 # [e2,e3] = e1 - ae2 # omega(e1,e2) = -2a, omega(e3,e1) = 0, omega(e2,e3) = 2a # Ker(omega) = SetEntrySCTable (T, 1, 2, [a, 2, -1, 3]); SetEntrySCTable (T, 3, 1, [a, 1, 1, 2, -a, 3]); SetEntrySCTable (T, 2, 3, [1, 1, -a, 2]); keromega := [1, 0, -1]; lambda := [2*a, 0, 2*a]; ####################################################### else Error ("wrong type"); fi; return ([T, keromega, lambda]); end; # for a given omega-Lie algebra, report those basic elements in the space of # (alpha,lambda)-derivations (for a fixed lambda), whose action of alpha on Ker(omega) # is nonzero; # arguments: # 1 - output from 3DimOmegaLieAlegbra() # 2 - ground field find_nondeg := function (l, K) local alder, N; N := 3; # dimension of algebras for alder in Alder2 (l[1], l[3], K) do if (alder[N+1]*l[2] <> 0) then Print (alder, "\n"); fi; od; end; # the following code shows that there are no (alpha,lambda)-derivations of 3-dimensional # omega-Lie algebras leading to 4-dimensional omega-Lie algebra with nondegenerate omega # (there should be no output) K := AlgebraicExtension (Rationals, CyclotomicPolynomial (Rationals, 11)); t := RootOfDefiningPolynomial (K); # parameter for lambda # these types do not require parameter for type in ["4T", "6T", "6S", "6N", "7T"] do # the 3rd argument in 3DimOmegaLieAlgebra() is dummy here find_nondeg (3DimOmegaLieAlgebra (type, K, 0, t), K); od; # these types do require parameter a := RootOfDefiningPolynomial (K); # parameter for structure constants for type in ["8a", "8Ta", "8Na"] do find_nondeg (3DimOmegaLieAlgebra (type, K, a), K); od; # these are special values for some parametric types # types (VIII)_i and (VIII)_{-i} are isomorphic, so it is enough to consider one of them # construct the field Q(t)(i) F := AlgebraicExtension (K, Indeterminate(K)^2+1); t1 := RootOfDefiningPolynomial (K) * One(F); # parameter for structure constants I := RootOfDefiningPolynomial (F); # i^2=-1 find_nondeg (3DimOmegaLieAlgebra ("8a", F, I, t1), F); # types (VIII)_T1 and (VIII)_T{-1} are isomorphic, so it is enough to consider one of them find_nondeg (3DimOmegaLieAlgebra ("8Ta", K, 1, t), K); quit; ##################################################################################### # the variation below of the code above could be used to enumerate all possible # (alpha,lambda)-derivations of all 3-dimensional omega-Lie algebras which are not # Lie algebras; # to get in this way all 4-dimensional omega-Lie algebras one need, additionally, # to do the same for 3-dimensional (ordinary) Lie algebras for type in ["4T", "6T", "6S", "6N", "7T"] do l := 3DimOmegaLieAlgebra (type, K, 0, t); Print (type, ":\n", Alder2 (l[1], l[3], K), "\n\n"); od; for type in ["8a", "8Ta", "8Na"] do l := 3DimOmegaLieAlgebra (type, K, a); Print (type, ":\n", Alder2 (l[1], l[3], K), "\n\n"); od; l := 3DimOmegaLieAlgebra ("8a", F, I, t1); Print ("8i:\n", Alder2 (l[1], l[3], F), "\n\n"); l := 3DimOmegaLieAlgebra ("8Ta", K, 1, t); Print ("8T1:\n", Alder2 (l[1], l[3], K), "\n\n"); ##################################################################################### # end of alder.gap