Dear Charles and GAP forum,

Thank you for your comment. Indeed what I do now is just to brute force over
the subgroups. Also, what I am more intersted in is the self-normalized
subgroups of the direct product of two groups, more than I am interested in
the case of a wreath product. I would just like to add two comments to what
you said:

(1) The main problem is the memory that ConjugacyClassesSubgroups takes.
Even with a group of relativaly small size for my application (2000
elements), it takes up approximately 200-300mg of memory. Although I am far
from an expert on the internals of GAP, I would think there should be a way
to generate each subgroup at a time, without wasting the memory needed for
holding all of them at once. This would make ConjugacyClassesSubgroups take
lots of time, but at least it would be possible to run for large groups.

(2) Just for the record, a more efficient way of filtering
ConjugacyClassesSubgroups(G) for self-normalized subgroups is:

Filtered(ConjugacyClassesSubgroup(G), HG -> (Size(HG) = Index(G,
Representative(HG)));

\\

-Avital.

----- Original Message -----
From: Charles Wright <wright@math.uoregon.edu>
To: "Multiple recipients of list" <GAP-Forum@dcs.st-and.ac.uk>
Sent: Tuesday, October 08, 2002 4:28 PM
Subject: self-normalizing subgroups

> Dear Forum members --
>
> Finding a good alternative characterization of self-normalizing
> subgroups appears to be a nontrivial problem, as does constructing a
> specialized algorithm to determine them all, even in a solvable group.
> As others have pointed out, some of the obvious hopes fail, and
> inductive approaches run into trouble.
>
> For groups that are not too large, a brute-force search with GAP is at
> least a possibility. In the solvable case, something like
>
> winners := Filtered(SubgroupsSolvableGroup(G), h -> h = Normalizer(G,h));;
>
> does the job, and in general one can start with lat :=
> LatticeSubgroups(G); followed by ccreps :=
List(ConjugacyClassesSubgroups(lat),Representative);;
> and wins := Filtered(ccreps, g -> g = Normalizer(G,g));;
>
> Either of these proposed methods computes far more subgroups than are of
> interest, of course, and only produces a list of representatives of the
> conjugacy classes. Once one has the resulting list of self-normalizing
> subgroups, there still remains the task of figuring out what to make of
> it. For instance, if G :=
> WreathProduct(SymmetricGroup(3),SymmetricGroup(3)), a very small
> example, then there are already 176 classes of subgroups, 15 of which
> are self-normalizing, and the sizes of the various winners are 12, 12,
> 16, 24, 36, 36, 48, 48, 54, 72, 108, 144, 324, 432, and 1296. This
> example and others suggest that there may be some difficulty in finding
> an organizing principle, even when the subgroups in question have been
computed.
>
> C.R.B. Wright
>
>

Miles-Receive-Header: reply