In this chapter, we develop a nearly linear-time library for constructing certain important subgroups of a given group. All algorithms are of the Monte Carlo type, since they are based on results of Section 4.5. However, if a base and SGS are known for the input group, then all algorithms in this chapter are of Las Vegas type (and in most cases there are even deterministic versions).

A current research project of great theoretical and practical interest is the upgrading of Monte Carlo permutation group algorithms to Las Vegas type. The claim we made in the previous paragraph implies that it is enough to upgrade the SGS constructions; we shall present a result in this direction in Section 8.3. To prove that all algorithms in this chapter are of Las Vegas type or deterministic, we always suppose that the input is an SGS S for some G ≤ Sym(Ω) relative to some base B, S satisfies S = S-1, and transversals corresponding to the point stabilizer chain defined by B are coded in shallow Schreier trees. Throughout this chapter, shallow Schreier tree means a Schreier tree of depth at most 2 log |G|. We remind the reader that, by Lemma 4.4.2, given an arbitrary SGS for G, a new SGS S satisfying S = S-1 and defining a shallow Schreier tree data structure can be computed in nearly linear time by a deterministic algorithm.

The central theme of this book is the design and analysis of nearly linear-time algorithms. Given a permutation group G = 〈S〉 ≤ Sym(Ω), with |Ω| = n, such algorithms run in O(|S|n logc |G|) time for some constant c. If, as happens most of the time in practice, log |G| is bounded from above by a polylogarithmic function of n then these algorithms run in time that is nearly linear as a function of the input length |S|n. In most cases, we did not make an effort to minimize the exponent c of log |G| in the running time since achieving the smallest possible exponent c was not the most pressing problem from either the theoretical or practical point of view. However, in families of groups where log |G| or, equivalently, the minimal base size of G is large, the nearly linear-time algorithms do not run as fast as their name indicates; in fact, for certain tasks, the may not be the asymptotically fastest algorithms at all. Another issue is the memory requirement of the algorithms, which again may be unnecessarily high. The purpose of this chapter is to describe algorithms that may be used in the basic handling of large-base groups. The practical limitation is their memory requirement, which is in most cases a quadratic function of n.

Computational group theory (CGT) is a subfield of symbolic algebra; it deals with the design, analysis, and implementation of algorithms for manipulating groups. It is an interdisciplinary area between mathematics and computer science. The major areas of CGT are the algorithms for finitely presented groups, polycyclic and finite solvable groups, permutation groups, matrix groups, and representation theory.

The topic of this book is the third of these areas. Permutation groups are the oldest type of representations of groups; in fact, the work of Galois on permutation groups, which is generally considered as the start of group theory as a separate branch of mathematics, preceded the abstract definition of groups by about a half a century. Algorithmic questions permeated permutation group theory from its inception. Galois group computations, and the related problem of determining all transitive permutation groups of a given degree, are still active areas of research (see [Hulpke, 1996]). Mathieu's constructions of his simple groups also involved serious computations.

Nowadays, permutation group algorithms are among the best developed parts of CGT, and we can handle groups of degree in the hundreds of thousands. The basic ideas for handling permutation groups appeared in [Sims, 1970, 1971a]; even today, Sims's methods are at the heart of most of the algorithms.

Strong Generators in Solvable Groups

Exploiting special properties of solvable groups, [Sims, 1990] describes a method for constructing a strong generating set. Recall that a finite group G is solvable if and only if it is polycyclic, that is, there exists a sequence of elements (y1, …, yr) such that G = 〈y1, …, yr〉 and for all i ∊ [1, r– 1], yi normalizes

The main idea is that given an SGS for a group H ≤ Sym(Ω) and y ∊ Sym(Ω) such that y normalizes H, an SGS for 〈H, y〉 can be constructed without sifting of Schreier generators. The method is based on the following observation.

Lemma 7.1.1.Suppose that G = 〈H, y〉 ≤ Sym(Ω) and y normalizes H. For a fixed Then

1. m is an integer and there exists h ∊ H such that z := ymh fixes α

2. z normalizes Hα; and

3. Gα, z〉.

Proof. (i) By Lemma 6.1.7, Δ is the disjoint union of G-images of Γ. Moreover, the G-images of Γ are cyclically permuted by y and m is the smallest integer such that Γym = Γ. In particular, αym Ω Γ, so there exists h Ω H with the desired property.

In this chapter, we start the main topic of this book with an overview of permutation group algorithms.

Polynomial-Time Algorithms

In theoretical computer science, a universally accepted measure of efficiency is polynomial-time computation. In the case of permutation group algorithms, groups are input by a list of generators. Given G = 〈S〉 ≤ Sn, the input is of length |S|n and a polynomial-time algorithm should run in O((|S|n)c) for some fixed constant c. In practice, |S| is usually small: Many interesting groups, including all finite simple groups, can be generated by two elements, and it is rare that in a practical computation a permutation group is given by more than ten generators. On the theoretical side, any G ≤ Sn can be generated by at most n/2 permutations (cf. [McIver and Neumann, 1987]). Moreover, any generating set S can be easily reduced to less than n2 generators in O(|S|n2) time by a deterministic algorithm (cf. Exercise 4.1), and in Theorem 10.1.3 we shall describe how to construct at most n – 1 generators for any G ≤ Sn. Hence, we require that the running time of a polynomial-time algorithm is O(nc + |S|n2) for some constant c.

In this book, we promote a slightly different measure of complexity involving n, |S|, and log |G| (cf. Section 3.2), which better reflects the practical performance of permutation group algorithms.

In this chapter, we collect some basic algorithms that serve as building blocks to higher level problems. Frequently, the efficient implementation of these low-level algorithms is the key to the practicality of the more glamorous, high-level problems that use them as subroutines.

Consequences of the Schreier–Sims Method

The major applications of the Schreier–Sims SGS construction are membership testing in groups and finding the order of groups, but an additional benefit of the algorithm is that its methodology can be applied to solve a host of other problems in basic permutation group manipulation. We list the most important applications in this section. The running times depend on which version of the Schreier–Sims algorithm we use; in particular, all tasks listed in this section can be performed by nearly linear-time Monte Carlo algorithms. For use in Chapter 6, we also point out that if we already have a nonredundant base and SGS for the input group then the algorithms presented in Sections 5.1.1–5.1.3 are all Las Vegas. Concerning the closure algorithms in Section 5.1.4, see Exercise 5.1.

Pointwise Stabilizers

Any version of the Schreier–Sims method presented in Chapter 4 can be easily modified to yield the pointwise stabilizer of some subset of the permutation domain. Suppose that G = 〈S〉 ≤ Sym(Ω) and Δ ⊆ Ω are given, and we need generators for G(Δ).