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 <[email protected]> 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 | [email protected]
Listen. Learn. Lead.
_______________________________________________
Forum mailing list
[email protected]
http://mail.gap-system.org/mailman/listinfo/forum
