[GAP Forum] Elementary abelian p-subgroups

[Alexander Hulpke]

Dear Forum, Dear Jared Warner,

[From a private email I happen to know that the groups are typically certain classical groups].

> I'm interested in studying the Quillen Complex of a finite group G, which
> is the lattice of elementary abelian p-subgroups of G.  Magma has a command
> ElementaryAbelianSubgroups which does exactly what I want, but I'd like to
> do this with GAP (to avoid paying for Magma).

There are a couple of remarks here. Yes, GAP does not have this specific function, but [I have no access to the Magma Source code to check] I suspect that the magma code simply does the same calculation as a full lattice, just discarding subgroups in the process if they can never lead to elementary abelian subgroups.

GAP has some hooks for this kind of discarding, however the interface is somewhat awkward, in part since it is difficult to decide which kinds of subgroups would turn out to be the popular ones to be used.
Furthermore (as we do provide the full source code) it would be possible to simply copy the appropriate function and to insert test that will do the same kind of discarding. However doing so likely will require at least some basic knowledge of the algorithms involved.

To get some further reduction it seems to be worth to me (assuming there are comparatively few such subgroups -- I'm sure anyone sufficiently malicious could construct examples in which this strategy turns out bad) to work [As Mathieu suggested] in Sylow subgroups first and fuse the found elementary abelian subgroups first under the normalizer (as this is cheaper) and then under conjugation by the whole group. Then the groups in question are solvable and the underlying algorithm for subgroups of a solvable group allows for a hook for discarding.
(This algorithm is different than the cyclic extension which Steve mentioned explicitly, and Mathieu mentioned implicitly, in that it descends, not ascends. My reason for doing so is that I fear that an ascending building process will get choked in subgroup conjugacy tests in the case of larger elementary abelian normal subgroups.)

Also at the moment it is beneficial in GAP to work in an isomorphic permutation group instead of a matrix group.

I have coded this strategy rather naively in GAP in the following function (taking the group and a prime, and returning a list of conjugacy classes of elementary abelian subgroups). Clearly there are many places for optimization, but maybe it is of help. (Also you are likely to run this only finitely many times, depending on how finite this might be good enough for the job at hand.) I also would be curious to hear of examples you wanted to run this on in which it still performs substandard.

Best,

  Alexander Hulpke

#filter function
NonelabUnconsider:=function(c,a,n,b,m)
  return HasElementaryAbelianFactorGroup(a,n) and
    # a may not act on b (as n does not act, otherwise the group obtained
    # will not be abelian)
    (ForAll(GeneratorsOfGroup(a),x->ForAll(GeneratorsOfGroup(b),y->IsOne(Comm(x,y))))
    or IsAbelian(n));
end;

Elabsub:=function(G,p)
local n,s,u,c,i,hom,pc;
  if IsMatrixGroup(G) then
    hom:=IsomorphismPermGroup(G);
    G:=Image(hom,G);
  else
    hom:=fail;
  fi;
  s:=SylowSubgroup(G,p);
  s:=Omega(s,p,1); # elements of order p
  n:=Normalizer(G,s);
  if not IsSolvableGroup(n) then
    # TODO: Better larger solvable subgroup
    pc:=NaturalHomomorphismByNormalSubgroupNC(n,s);
    n:=PreImage(pc,RadicalGroup(Image(pc)));
  fi;
  pc:=IsomorphismSpecialPcGroup(n);
  s:=Image(pc,s);
  u:=SubgroupsSolvableGroup(Image(pc),rec(groups:=[s],
                                          consider:=NonelabUnconsider));
  u:=Filtered(u,x->IsElementaryAbelian(x) and IsSubset(s,x));
  u:=List(u,x->PreImage(pc,x));
  Info(InfoLattice,1,Length(u)," subgroup classes in normalizer, fuse!");
  u:=SubgroupsOrbitsAndNormalizers(G,u,false);
  c:=[];
  for i in u do
    s:=ConjugacyClassSubgroups(G,i.representative);
    SetStabilizerOfExternalSet(s,i.normalizer);
    Add(c,s);
  od;
  if hom<>fail then
    u:=[];
    for i in c do
      s:=ConjugacyClassSubgroups(Source(hom),PreImage(hom,Representative(i)));
      # transfer normalizer data
      SetStabilizerOfExternalSet(s,PreImage(hom,StabilizerOfExternalSet(i)));
      SetSize(s,Size(i));
      Add(u,s);
    od;
    c:=u;
  fi;
  return c;
end;