> < ^ From:

< ^ Subject:

Dear Chris,

you asked:

I am calculating some group data with GAP 3.3 for groups defined

by (4x4) generators over GF(7). I am interested in particular in

the factors of the derived series of the groups. Would the running

time be shorter if the groups were defined by a smaller set of

generators? (Say 5 instead of 13.)

there are various ways to speed up the calculations depending on the

exact nature of your problem. If you are just interested in the

abelian invariants it would be sensible to compute for each matrix

group an isomorphic permutation group using 'PermGroup' and to work

with this permutation group. Again, depending on our problem, it

might be faster to first convert the factor group to a permutation

group using 'PermGroup' before computing the abelian invariants.

There are other possible speedups. The 'PermGroup' conversion is

quite slow, so you could either

- try the function below which will use boolean list to speed up the

conversion from a matrix group over a finite field to a permutation

group or

- try to construct your matrix groups as subgroups of (one fixed)

$GL(4,7)$, this will avoid the orbit calculation for each group but

your permutation groups will have much larger degrees.

best wishes

Frank

============================================================================= ############################################################################# ## #F MatGroupOps.MakePermGroupP(<G>) . . . make a isomorphic permutation group ## ## The difference between this function and the usual 'PermGroup' is that ## the permutation group constructed for <G> will be a subgroup of the ## corresponding permutation group of <G>'s parent. ## orbitFiniteFieldMatGroup := function ( G, d ) local pow, size, i, int, blt, orb, pnt, gen, img, num;

# set up an enumerator for finite field vectors pow := [1]; size := Size(G.field); for i in [ 1 .. Length(d)-1 ] do pow[i+1] := pow[i]*size; od; int := [ 1 .. size-1 ]; IsVector(int);# construct a bit list

size := size^G.dimension;

blt := BlistList( [1..size], [] );# start the orbit algorithm with vector <d>

orb := [d];

blt[NumberVecFFE(d,pow,int)] := true;for pnt in orb do for gen in G.generators do img := pnt ^ gen; num := NumberVecFFE( img, pow, int ); if not blt[num] then Add( orb, img ); blt[num] := true; fi; od; od;# and return

return orb;

end;

MatGroupOps.MakePermGroupP := function ( G )

local P, domain, p;

# get the parent of <G> P := Parent(G);# if <P> is not finite compute the perm representation in <G>

if IsBound(P.isFinite) and not P.isFinite then

if not IsBound( G.permGroupP ) then

G.permDomain := Union( Orbits( G, G.identity ) );

G.permGroupP := Operation( G, G.permDomain );

fi;# otherwise compute the perm representation for the parent

else

if not IsBound(P.permDomain) then

># if <P> is written over a finite field use blists

>if IsBound(P.field) and IsFinite(P.field) then

> domain := [];

> for p in P.identity do

> UniteSet( domain, orbitFiniteFieldMatGroup( P, p ) );

> od;

> P.permDomain := domain;# otherwise use normal orbit operation else G.permDomain := Union( Orbits( G, G.identity ) ); fi; P.permGroupP := Operation( P, P.permDomain ); fi;# compute the isomorphic permutation group for <G> if not IsBound(G.permGroupP) then G.permDomain := P.permDomain; G.permGroupP := Subgroup( P.permGroupP, Operation( G, P.permDomain ).generators ); fi; fi;

end;

> < [top]