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:
Read("matperm.g");

# 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
      Add(gen[i],NumVec(f,v*g.generators[i]));
    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;