Closure Algorithms 1. Orbit Computations

A frequently occurring situation is that a black-box groupGacts on a permu-tation domainand we have to compute the orbitα^G:= {α^g|g∈G}of some α∈. Naturally, the primary example is when the black-box groupGis actually

apermutation groupG≤Sym(). Two other examples are whenG=and we have to compute the conjugacy class of some element ofG, or when consists of all subgroups ofG(specified by sets of generators) and we need the conjugacy class of a subgroup. These latter examples explain why we consider orbit computations here rather than among the permutation group algorithms.

When working with permutation groups, we always assume that the generators of G are input as permutations of , while here we may have permutation domainsthat are too large to be listed explicitly and yet the orbitα^Gis small enough to be handled. Therefore, all we assume here is that givenβ∈and g∈G, we can compute the imageβ^gand that we can compare elements of. Note that the latter task may be nontrivial: In the case when we compute the con-jugacy class of a subgroup, comparing elements ofamounts to the problem of deciding whether two lists of generators define the same subgroup ofG.

Suppose thatG= S. The orbitα^G is the smallest subset of contain-ing α and closed under the action of the generators of G. Hence, α^G can be obtained by a standard algorithm for computing connected components in graphs. We may define a directed graph D(,E) with vertex set and edge setE= {−−−→

(β, γ)|β, γ∈∧(∃g∈S)(β^g=γ)}(i.e., the ordered pair (β, γ) is a n edge if and only if one of the generators ofGcarriesβtoγ). Note that ifβ^g=γ thenγ^gk=βfor asuitable powerg^k ofg(because in this book we deal only with finite groups), so the connected components ofDare strongly connected.

The Basic Orbit Algorithm

The orbitα^G is the vertex set of abreadth-first-search treerooted atαin the directed graphD. LetL₀ := {α}and, recursively, define

Li := {γ∈|(∃β∈Li−1)(−−−→(β, γ)∈ E)}

j<i

Lj.

In human language,Liconsists of those vertices that are endpoints of directed edges starting inLi−1but do not already occur in the previously defined setsLj. TheLiare called thelevelsof the breadth-first-search tree. The algorithm stops whenLm= ∅for somem. ThenO:= _j<mLjis the connected component ofD(,E) containingα. Note that sinceO^s =Ofor all generatorss∈S, we also haveO^g =Ofor allg∈Gsince anyg∈Gcan be written as a product of elements ofS. Hence indeedO=α^G.

As an example, let=[1,5]= {1,2,3,4,5},G= S = s1,s2 ≤Sym() with s₁=(1,2)(4,5) and s₂=(1,4,5), and let α=4. The orbit algorithm starts with setting L0:= {4}. Then we compute the set L₀^S= {4^s1,4^s2} = {5}

andL₁:= {5}\L₀= {5}. Next, we computeL^S₁= {5^s1,5^s2} = {1,4}andL₂ := {1,4}\(L0∪L1)= {1}. In the next step, L₂^S = {1^s1,1^s2} = {2,4}andL3 :=

{2,4}\(L0∪L1∪L2)= {2}are computed. Finally,L₃^S = {2^s1,2^s2} = {1,2}and L₄:= {1,2}\(L₀∪L₁∪L₂∪L₃)= ∅are computed. SinceL₄= ∅, the algo-rithm terminates and outputs the orbit 4^G=L0∪L1∪L2∪L3= {1,2,4,5}.

In implementations, we collect the elements of the setsLi in alistU. We defineU[1] :=αand, successively for each elementβ∈U, computeβ^gfor all g∈S. Ifβ^gis not already inUthen we addβ^gtoU. The algorithm terminates when all elements ofU are processed.

The timing of the algorithm depends on|α^G|. We have to compute the image of eachβ∈α^Gunder eachg∈S, and so the total number of image computations is|α^G||S|. The cost of an image computation depends heavily on the actual representation of G. If the black-box groupG is apermutation group then computingβ^g for some β∈ andg∈G is the basic operation whose time requirement is the unit in running time estimates; in the other two examples mentioned earlier, an image computation amounts to performing some group operations to compute a conjugate of a group element or the conjugates of a list of generators.

Also, we have to decide whether an imageβ^gjust computed already occurs in the listU. As with image computations, the cost of this operation varies ac-cording to the actual representation of the black-box group and. We consider three possible situations. In the first one, a supersetof manageable size is known forα^Gand the position of elements ofα^Gincan be determined easily.

This occurs, for example, whenGis a permutation group acting on: We ma y simply choose:=. In the second situation, no such supersetis available.

The third situation is a special case of the second: There is no supersetat our disposal, but a linear ordering ofis defined and we can compare any two elements ofin this ordering. This latter situation occurs, for example, when =G and we have to compute the conjugacy class of someα∈G, and the elements of the black-box groupGhave unique representations as strings. In this case, we may simply consider the lexicographic ordering of strings as a linear ordering of.

Theorem 2.1.1. Suppose that a group G= Sacts on a set. Then the orbit of someα∈can be computed using O(|α^G||S|)image computations. More-over,

(i) if a superset⊇ α^Gis known in advance and it is possible to allocate

||units of memory then the image computations dominate the running time;

(ii) if no such set is available, the additional cost is the comparison of O(|α^G|²|S|)pairs in;

(iii) if comparison of elements also recognizes which comes first in a lin-ear ordering on, then the additional cost drops to the comparison of O(|α^G|log²|α^G||S|)pairs.

Proof. (i) We define an auxiliary list L of size||. Each time an element is added toU, we also mark the corresponding position inL. Thus, when we have to decide whether some newly computed imageγ =β^gis already inU, it is enough to look up whether the position ofγinLis already marked.

(ii) If no such supersetis available, we may compare a newly computed imageβ^g to the already defined elements ofU. This results in an algorithm withO(|α^G|²|S|) comparisons of elements of.

(iii) Suppose that there is a linear ordering on. If, besides the listU, we maintain a listV containing a linear ordering ofUthen it is possible to decide whether someγ∈already occurs inU by a binary search ofV, which is fast; however, if γ ∈U then the insertion of γ into the list V is potentially very expensive, because we have to shift by one position all elements of the list that are greater thanγ. Therefore, instead of a long list V containing a linear ordering ofU, we maintain shorter lists V₁,V₂,. . .that contain linear orderings of certain segments ofU. Namely, if the binary expansion of|U|is

|U| =2ⁱ¹+2ⁱ²+ · · · +2^ik withi₁>i₂>· · ·>ik, thenVjcontains the linear ordering of the 2^ijelements ofUin positionsU[l+1],U[l+2], . . . ,U[l+2^ij], forl=2ⁱ¹+ · · · +2^ij−1. Deciding whether someγ∈already occurs inUcan be done by binary searches of allVj, requiringO(i₁+ · · · +ik)=O(log²|U|) comparisons.

If someγ∈is added toU, the linear orderingsVj can be updated in the following way. We create a new setVk+1:= {γ}and, starting with j:=kand proceeding recursively through decreasing values of j, we merge the linear orders Vj and Vj+1 if |Vj| = |Vj+1|. We stop when we encounter the first j such that|Vj|>|Vj+1|. For example, if|U| =55 then adding an element to Utriggers three merges, since 55=32+16+4+2+1 and 55+1=32+ 16+4+2+(1+1) = 32+16+4+(2+2) = 32+16+(4+4) = 32+16+8.

We made a total ofO(|α^G|log²|α^G||S|) comparisons while deciding whether we should add some elements oftoU. In addition, we must make compar-isons when we merge some setsVj andVj+1. We claim that during the en-tire orbit computation, the total number of comparisons at updating theVj is O(|α^G|log|α^G|). This claim follows from the observation that for each fixed β∈U, if the setVj containingβ is merged then the new set containingβ is twice the size of the original. Hence,β is processed log|α^G|times. Because

|α^G|log|α^G| ∈O(|α^G|log²|α^G||S|), we are done.

Remark 2.1.2. Another possibility for searching the listUis to usehash func-tions. A hash function is a functionh :→Kfor some setK; in particular,h computes a value associated to each element ofU, and accordingly the elements ofU can be stored in|K|sets. When we have to decide whether a newω∈ is already inU, it is enough to compareωwith previous elements that have the same hash valueh(ω).

The efficiency of the method depends on finding a hash function that is easily computable, and relatively few elements ofU will get the same hash value.

Among elements with the same hash value, one of the methods described in Theorem 2.1.1 may be applied, but hopefully on an input of much smaller size.

Finding good hash functions is the subject of extensive research (see [Knuth, 1973, Chap. 6]). Here we only mention that if the orbitU is expected to be a

“random” subset ofthen choosing a few random bits works well in practice.

For example, ifGis amatrix group of dimensiond over GF(2), =GF(2)^d, and we need the orbit of some vectorα∈then we may try the hash function that retrieves, for example, the middle ten coordinates of vectors.

Remark 2.1.3. Using more sophisticated data structures (e.g., 2–3 trees; cf.

[Sedgewick, 1988, Chap. 15]), the number of comparisons in Theorem 2.1.1(iii) can be decreased toO(|α^G|log|α^G||S|).

Often the information that someγ∈occurs inα^Gis not enough; we also need an elementh∈Gsuch thatα^h=γ. Such elements can be obtained during the orbit computation. For this purpose, besidesU, we maintain a listW of group elements such that for alli ≤ |U|, α^W[i] =U[i]. When anew imageβ^g is added toUfor someβ=U[i] a ndg∈S, we defineW[|U| +1] :=W[i]g.

The additional cost is that of|α^G| group multiplications and, often more restrictively, the storage of|α^G|group elements. Hence, in practice, ifβ^g is added toUthen we store inW[|U| +1] only (apointer to)g∈S. This method saves storage, and we do not even have to perform group multiplications during the orbit computation. We pay the price when an elementh∈Gwithα^h =γ is actually needed. UsingW, we have to trace back the preimages ofγ until we reachαand compute the product of generators encountered at the tracing.

Note that in the version mentioned in Theorem 2.1.1(i), the array of length||

can be used to store pointers to generators, instead of our having to define an additional arrayW.

The orbit algorithms can also be used to find the permutation action of the generators ofGonα^G. For allγ∈α^G ands∈S, we have computedγ^s and identified it with an element ofα^G. Keeping track of these identifications, we obtain the desired permutation actions.

Finally, we remark that for anyA⊆, the orbit algorithm can be used to com-puteA^G := {α^g|α∈A,g∈G}. The only modification needed is to initialize U:= A.

2.1.2. Closure of Algebraic Structures

An important variant of orbit computations is the situation when the set on which the groupG acts has an algebraic structure. Given A⊆, we ha ve to determineA^G, the smallest subset ofcontaining A that is closed for the G-action and for the operation(s) of the algebraic structure on . The most important example occurring in this book is when=Gand we have to compute the normal closure of someA ≤Gor, slightly more generally, when Gacts on a groupand we need theG-closure of some subgroupA ≤.

As customary when the output of an algorithm is closed for some algebraic operations, we seek onlygeneratorsforA^G. This enables us to handle objects that are too large to have all their elements listed.

In this section, we present a version that supposes that we are able totest membershipin the already constructed substructures ofA^G. Versions without this assumption (using randomized algorithms) will be given in Sections 2.3 and 2.4.

The Closure Algorithm

GivenG= SandA⊆, generators for theG-closureA^Gcan be obtained by a slight modification of the orbit algorithm. We collect the generators for A^Gin alistU. We defineU:= Aand, successively for each elementh∈U, computeh^gfor allg∈S. Ifh^gis not in the algebraic structureUthen we add h^g toU. The algorithm terminates when all elements ofU are processed. At that moment,UcontainsAand is closed for the action ofGon. Also, each element ofUis of the formx^yfor somex∈Aandy∈G; thereforeU = A^G. Note that each time an element was added toU, the algebraic structureU increased. Hence, ifhas at least a group structure (which will be the case in all applications) then Lagrange’s theorem implies that|U|increased by an integer factor and so the number of generators added to the generator listUfor A^Gis at most log|A^G|. The time-critical part of the algorithm is usually the computation that allows us to test membership inU.

Algorithms Based on Normal Closure

As a consequence, we obtain algorithms for tasks that are based on normal clo-sure computations. In particular, we can compute the derived series and lower

central series in a group and test solvability and nilpotence. Also, it can be deter-mined whether agivenH≤Gis subnormal inG. Recall thatHis subnormal inGif and only if the series of subgroups defined byG0:=G,Gi+1:= H^Gi fori ≥0 reachesH. Note, however, the difference in difficulty for these tasks when no membership test is available. Because normal closure can be computed by randomized algorithms, in each case we can construct generators for the re-quired series of subgroups. However, at testing solvability and nilpotence we have to decide only whether a group in the subgroup chain is trivial, whereas at testing subnormality we have to check whether some subgroup we constructed is contained inH. The latter task does not seem possible without membership testing.