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

[Tim Kohl]

Hi,

I'm loooking at certain G such that |G|=64 where if |HolG| is a (sizable) power
of 2 then computing Normalizer(SymmetricGroup(64),HolG) is problematic.

I'll try your idea with using pc-groups, I've generally been working with
regular subgroups of S_n and their normalizers which are naturally isomorphic
to HolG and then computing the normalizer of the holomorph within the same ambient
S_n.

Thanks.

	-T



On Wed, 20 Aug 2014, Max Horn wrote:

> 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
> 
> 

-- 
Dr. Timothy Kohl | Desktop Services Specialist, Sr.
Boston University| IT Help Center | IS&T
617.353.8203 | tkohl at bu.edu
Listen. Learn. Lead.