> < ^ Date: Mon, 10 Mar 1997 13:21:23 +0100
> < ^ From: Frank Luebeck <frank.luebeck@math.rwth-aachen.de >
> < ^ Subject: Re: Sylow-3 Subgroups

Dear GAP-Forum, dear Kaustuv,

On Sat, 8 Mar 1997, Kaustuv M. Das wrote:

I am interested in getting hold of
all the Sylow_3 subgroups of Sp_6(5), but whenever I try the GAP command:

gap> SylowSubgroup(G,3);

where G has been defined as :

gap> G:=SymplecticGroup(6,5);

I get an out of memory error (after the machine sits and thinks for about
thirty hours). What am I doing wrong?

I think essentially you are doing the right thing, but GAP seems to do
something which is not very efficient.

GAP's idea is to convert the group to a permutation group and it seems
that it spends a lot of time and memory in doing so.

I append to this mail a short file with some utility functions which I
gave to several people before (who had similar questions than the one
above). An example is given, how to find a Sylow-3-subgroup in Sp_6(5).
It also converts the group to a permutation group and defines functions
for converting elements from matrices to permutations and vice versa.

Maybe it would be useful to many GAP users to have a better interface
between the matrix groups and permutation groups. (Functions like
'NumVec' and 'VecNum' below can also be used to write a much faster
orbit algorithm for vectors under a matrix group, than the default
algorithm in GAP.)

I have tried allocating more memory to the program by changing the
command line in GAP.BAT and that hasn't helped. Also Windows 95
supposedly is better with memory allocation, though I am not sure whether
I believe that or not :) Any suggestions on how I can get hold of all
the Sylow_3 subgroups of Sp_6(5), without having to shift to another
machine would be most welcome.

Give GAP 12MB or more for the shown example. On my Sparc 20 the example
takes less than 3 minutes. It should be faster on your Pentium 133.

By the way: another possibility to find the Sylow-3-Subgroups would be to
look at the much smaller subgroup isomorphic to the unitary group GU_3(5)
(some people call it U_3(25)), whose order is divisible by 3^4.

With best regards,

Frank Luebeck

# an example
# read in the following file:

# define the group
g:=SymplecticGroup(6,5);;

# convert to permutation group
gp:=PermGroupOnVectorspace(g);;
time;

# always a good idea to tell a permutation group its order ("Size"),
# if you know it
gp.size:=Size(g);

# compute Sylow-3-subgroup
sylperm:=SylowSubgroup(gp,3);;
time;

# convert back to matrix group
syl:=Group(List(sylperm.generators,p->MatrixPerm(g,p)),
IdentityMat(6)*Z(5)^0);
Size(syl);

# the following works, too
n:=Normalizer(gp,sylperm);;
Size(n);
# => probably you don't want to write down all the conjugate
# subgroups explicitly

------------  cut here ------------------------------------
########################################################################
##
##  matperm.g                                                Frank Luebeck
##
##  Mathematisches Institut and IWR, Universitaet Heidelberg
##
##  This file contains  some utility functions  to convert between  matrix
##  groups  over finite field and  the corresponding permutations group on
##  all(!) vectors of the vector space.
##

#############################################################################
##
#F  NumVec( <fld>, v ) . . . . . . . . . . . . converts vector <v> over finite
#F  field <fld> to a positive integer number
##
NumVec:=function(f,v)
local fel,p,n,q,i;
if IsBound(f.elements) then
fel:=f.elements;
else
fel:=Elements(f);
fi;
q:=Length(fel);
n:=Length(v);
p:=0;
for i in [1..n] do
p:=p*q+Position(fel,v[i])-1;
od;
return p+1;
end;

#############################################################################
##
#F  VecNum( <fld>, <dim>, <nr> ) . . . . . inverse of 'NumVec', converts number
#F  <nr> to <dim>-dimensional vector over finite field <fld>
##
VecNum:=function(f,n,p)
local fel,q,v,i;
if IsBound(f.elements) then
fel:=f.elements;
else
fel:=Elements(f);
fi;
q:=Length(fel);
v:=[];
p:=p-1;
for i in [1..n] do
v[n-i+1]:=fel[(p mod q)+1];
p:=QuoInt(p,q);
od;
return v;
end;

#############################################################################
##
#F  PermGroupOnVectorspace( <matgrp> )  . . .   . . .  returns permutation
#F  group which describes the matrix group <matgrp> over a finite field as
#F  permutation group on all vectors of the vector space
##
##  Before using this  function think about the number  of vectors in your
##  vector space!
##
PermGroupOnVectorspace:=function(g)
local l, n, f, gen, v, p, i, erg;
l:=Length(g.generators);
n:=g.dimension;
f:=g.field;
g.idPos:=List(g.identity,e->NumVec(f,e));
gen:=List([1..l],i->[]);
for p in [1..Size(f)^n] do
v:=VecNum(f,n,p);
for i in [1..l] do
od;
od;
erg:=Group(List(gen,PermList),());
return erg;
end;

#############################################################################
##
#F  PermMatrix( <matgrp>, <mat> ) . . . . . . converts matrix in <matgrp> to
#F  corresponding permutation in PermGroupOnVectorspace( <matgrp> )
##
PermMatrix:=function(g,M)
local l;
l:=Size(g.field)^g.dimension;
return PermList(List([1..l],i->NumVec(g.field,
VecNum(g.field,g.dimension,i)*M)));
end;

#############################################################################
##
#F  MatrixPerm( <matgrp>, <perm> ) . . . . . . . . . converts permutation  in
#F  PermGroupOnVectorspace( <matgrp> ) to corresponding matrix in <matgrp>
##
MatrixPerm:=function(g,p)
return List(OnTuples(g.idPos,p),i->VecNum(g.field,g.dimension,i));
end;

> < [top]