[GAP Forum] normalizers of normalizers of groups of order 64

[Max Horn]

Dear Tim,

On 20.08.2014, at 16:05, Tim Kohl <tkohl at math.bu.edu> wrote:

> 
> 
> Hi,
> 
> I have computed (in GAP) regular representations of the 267 groups of order 64 and also computed
> the normalizers (holomorphs) of these groups in S_64. 
> 
> What I'm after now are the normalizers of *these* holomorphs, but there are 37 of
> them that I can't get my hands on. When I run these in the background, the Linux box
> reports a General Protection Fault in gap. However the process seems to be running, and
> has not grown larger than the amount of memory I allocated. 
> 
> The sizes of 36 of these 37 holomorphs I'm trying to compute the normalizer of are pure powers of 2
> which probably only adds to their complexity, but I was able to get the other 230 without too
> much difficulty.

I am not sure whether I understand you correctly: Are you saying that the difficulties arise in the case where the holomorph of a holomorph is a 2-group? In that case, the following might help:


For those groups which are pure powers of 2, working with pc groups instead of permutation groups is much more efficient. We can exploit that the holomorph is just the semi-direct product of G with Aut(G):

 Holomorph := G -> SemidirectProduct(AutomorphismGroup(G), G);


Now if G is a p-group, then the "autpgrp" package can compute its automorphism group quite effectively, as done in the following:


# Get the groups of order 64
gs:=AllSmallGroups(64);;

# Trick: force GAP to notice these are p-groups, so that the
# efficient autpgrp methods are used.
ForAll(gs,IsPGroup);

# Compute the holomorphs. Takes about 30 seconds on my laptop.
hs := List(gs, Holomorph);;

# Now again force GAP to detect p-groups among the holomorphs
Number(hs, IsPGroup); # 211 are p-groups, leaving 56 which are not

# You want to compute the holomorphs of the groups in hs. 
# Whenever G is a p-group and Aut(G) is solvable, we can compute
# the holomorph relatively efficiently:

# Let's restrict to the p-groups.
hsp:=Filtered(hs,IsPGroup);;

# Compute their automorphism groups -- about 8 minutes on my laptop
# Note that GAP stores these, so the following holomorph
# computations can reuse them. I only do it separately to be able
# to see which part of the computation takes what time.
List(hsp, AutomorphismGroup);;

# Compute the holomorphs for all G where Aut(G) is a solvable group
ksp := [];
for i in [1..Length(hsp)] do
  if IsBound(ksp[i]) then continue; fi;
  Print(i,": ");
  if not IsSolvableGroup(AutomorphismGroup(hsp[i])) then
    Print("Aut(G) is not solvable skipping\n");
    continue;
  fi;
  ksp[i]:=Holomorph(hsp[i]);
  Print("|Hol(G)| = ", Size(ksp[i]), "\n");
od;

This skipped just two groups and took another 8 minutes.
Note that some of these groups we computed are not 2-groups.  The reason I
skipped over groups with non-solvable automorphism groups is that for these
groups, GAP is forced to represent the result as a large degree permutation
group, instead of a more efficient pc presentation; thus this is slow and
uses tons of memory, so I didn't want to bother with it, esp. since (as I
understand it) you are mainly interested in the groups where the end result
is a 2-group.


Hope that helps,
Max