4

Let $G$ be a finite group, given as either a permutation group as a finite set or a subgroup of a matrix group over a finite field. There are a number of impressively implemented algorithms for finding conjugacy classes of subgroups of $G$, some are discussed in papers mentioned in this answer:

https://math.stackexchange.com/a/2775758/1038520

My question is:

Are the best algorithms for subgroup enumeration inherently probabilistic?

Looking at Cannon-Cox-Holt, there is at least one point where one step in the algorithm (discussed in section 3) calls for making random choices of elements of conjugacy classes, but I have not tried to precisely follow through to see either how this is done or whether it can be done deterministically (let alone other steps of the process).

The background motivation for my question is as follows. I use some of these enumeration algorithms in $\texttt{magma}$. However, it can (and does) happen that if you run the same code twice on the same group $G$, the output may differ. That is, the precise ordering of the subgroups (up to conjugation) may differ, and the output may even permute two (non-conjugate) subgroups $H$ and $H'$ of $G$ which are isomorphic. (For example, $G=S_6$ and $H \simeq H' \simeq S_5$). This is a little frustrating as a user (for writing code that can be replicated), but I would feel much better if I knew there was a fundamentally good reason it had to be this way. So this question is really just about making me feel better.

Note that in practice in $\texttt{magma}$ I can always $\texttt{SetSeed(1);}$ to avoid this particular issue.

user297024
  • 1,180
  • Note that in your example $G = S_6$, you can easily distinguish between the two subgroups isomorphic to $S_5$; one is transitive and the other one is intransitive. I cannot answer the question about the details of the algorithm, but probabilistic algorithms are used because they are practical and fast. In general I would personally avoid assuming consistent output for certain functions, even with a fixed seed. It is better/safer to find different ways to assure consistency, e.g. in your example take $H$ to be the subgroup for which IsTransitive returns true; and $H'$ the other one. – testaccount Nov 27 '23 at 02:53
  • In terms of complexity it is still an open problem whether probabilistic algorithms are essentially better than non-probabilistic. However many people believe to be false. – freakish Nov 27 '23 at 08:11
  • @testaccount, you misunderstood my example on two levels. First, I was simply giving a familiar example of non-conjugate isomorphic subgroups. Second, your comment assumes that $S_6$ is given as a permutation group on $6$ points but maybe it is given as a transitive permutation group on $10$ points. In that case, the non-conjugate subgroups of $S_5$ in $S_6$ will be conjugate inside $S_{10}$ so they cannot be distinguished by their actions alone. The examples that are relevant to me are similar in spirit (but more complicated) than this; I didn't include details since they weren't relevant. – user297024 Nov 28 '23 at 01:45

1 Answers1

3

Many of the most effective algorithms in group theory involve choosing random elements in the group. For example, it has long been the case that finding representatives of the conjugacy classes of elements of finite simple groups involves choosing random elements until you have found most classes, and then possibly using cleverer methods to find the few remaining small classes. (This situation may be changing because it is becoming increasingly possible to find representatives of the classes of classical groups using theoretical results rather than random elements, and for sporadic groups it can be done by database lookup.)

As you have observed, this has the possibly unfortunate consequence that many functions in Magma (and probably also in GAP) (including the subgroup algorithms with which I have been involved in the implementation) do not return identical results when re-run on the same input. It would be possible in principle to force them to return consistent results by hard-wiring SetSeed commands into the package code, but the Magma administrators have told us not to do that for various good reasons. So I am afraid that if you want consistent results then you will need to use SetSeed yourself, but even that does not always work, because computations in a group may be affected by what Magma already knows about that group from earlier computations.

Personally I believe that in practice probabilistic methods are faster and more effective than deterministic in many areas of methematics, but I cannot justify that theoretically. Another example is the so-called Meataxe algorithm for testing modules over finite group algebras for irreducibility which involves choosing random elements of the group algebra.

Derek Holt
  • 90,008
  • Thanks; this is more or less what I expected was the case. Your comment about SetSeed, however, is something I didn't anticipate. If the first line of the code is SetSeed(1); the second line is the definition of G and the third line is ZG:=Subgroups(G); does that definitively get around this problem? Perhaps it's best practice in any case to be careful about this. – user297024 Nov 28 '23 at 01:56
  • 1
    Yes, if you do that, you should get consistent results. But if you define G first and perhaps compute its order, and then call SetSeed, that could change things. – Derek Holt Nov 28 '23 at 21:08