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;