Graph Isomorphism is in SPP ⋆

V. Arvind ∗ and Piyush P Kurur^{1}

Institute of Mathematical Sciences, Chennai 600113, India

Abstract

We show that Graph Isomorphism is in the complexity class SPP, and hence it is in ⊕P (in fact, in Mod_{k}P for each k ≥ 2). These inclusions for Graph Isomorphism were not known prior to membership in SPP. We derive this result as a corollary of a more general result: we show that a generic problem FIND-GROUP has an FPSPP algorithm. This general result has other consequences: for example, it follows that the hidden subgroup problem for permutation groups, studied in the context of quantum algorithms, has an FPSPP algorithm. Also, some other algorithmic problems over permutation groups known to be at least as hard as Graph Isomorphism (e.g. coset intersection) are in SPP, and thus in Mod_{k}P for each k ≥ 2.

Key words: Graph Isomorphism, Counting Classes, SPP, Lowness.

1 Introduction

The Graph Isomorphism problem —of testing if two graphs are isomorphic— is a well-studied algorithmic problem in the class NP. Formally, the decision problem GI (for Graph Isomorphism) is defined as:

GI = {⟨X_{1}, X_{2}⟩ | X_{1} and X_{2} are isomorphic graphs}.

⋆ A preliminary version of the results in this paper were presented at the IEEE FOCS 2002 conference.

∗ Corresponding author.

  Email addresses: arvind@imsc.res.in (V. Arvind), ppk@imsc.res.in (Piyush

P Kurur). 1 Present Address: Department of Computer Science and Engineering, I.I.T, Kanpur, Kanpur 208016, India.

Preprint submitted to Elsevier

It is an outstanding open problem in computational complexity whether Graph Isomorphism has a polynomial-time algorithm. This problem has stimulated a great deal of research in algorithms and complexity over the years. There is strong evidence that Graph Isomorphism is not NP-complete. In [2] (also see [5]) it was shown that Graph Nonisomorphism is in AM implying that GI is in NP ∩ coAM. It follows that GI cannot be NP-complete unless the polynomial hierarchy collapses to Σ_{2}^{p} [10,29]. Schöning, who introduced the notion of lowness in complexity theory, pointed out in [29] that GI is low for Σ_{2}^{p}. I.e. GI is powerless as oracle for Σ_{2}^{p}.

Subsequently, it was shown in [22] that GI is also low for the counting complexity class PP (PP is the language class corresponding to #P). This result is proven using the machinery of GapP functions introduced in the seminal paper by Fenner, Fortnow, and Kurtz [13] on gap-definable counting classes. The study of counting complexity classes is an area of research in structural complexity theory motivated by Valiant’s class #P (see e.g. [13]). Intuitively, counting complexity classes are defined by suitable restrictions on the number of accepting and rejecting paths in nondeterministic Turing machines. In [13] the languages classes SPP and LWPP are introduced as generalizations of Valiant’s class UP. It is shown in [13] that UP ⊆ SPP ⊆ LWPP, and LWPP is low for PP.

After Shor’s breakthrough quantum polynomial-time algorithms for integer factoring and discrete log [31] a natural question is whether Graph Isomorphism is in BQP (the class of problems solvable in quantum polynomial time). The hidden subgroup problem was formulated to generalize Shor’s algorithmic technique. In particular, Graph Isomorphism can be seen as an instance of the hidden subgroup problem.

How does the class BQP relate to standard complexity classes defined using classical Turing machines? Fortnow and Rogers [15] show that BQP is contained in the counting complexity class AWPP (definitions follow). Thus, in a sense, we can also think of BQP as a counting class.

1.1 Summary of new results

In this paper, we show that Graph Isomorphism is in the class SPP. This was left as an open question in [22] (also see [13]). As a consequence it follows that GI is in and low for Mod_{k}P for each k ≥ 2. Previously, only a special case of Graph Isomorphism, namely Tournament Isomorphism, was known to be in ⊕P.^{2}

2 Tournament Isomorphism in ⊕P follows because any tournament has an odd number of automorphisms. There are special cases of Graph Isomorphism, e.g.

What we prove is a more general result: we show that a generic problem FIND-GROUP is in FPSPP as a consequence of which GI and several other algorithmic problems on permutation groups that are not known to have polynomial-time algorithms turn out to be in SPP. In particular, as another corollary, we show that the hidden subgroup problem (HSP) over permutation groups is in FPSPP. The hidden subgroup problem is of interest in the area of quantum algorithms.

Outline of the FPSPP algorithm

To indicate how the proof of our main theorem will proceed, we give a broad outline of the FPSPP algorithm for the specific problem of computing a generator set for the automorphism group G = Aut(X) of a graph X on n vertices (this problem is polynomial-time equivalent to GI). Since G is a subgroup of S_{n}, it has the following tower of subgroups

1 = G^{(n−1)} ≤ G^{(n−2)} ≤ … ≤ G^{(1)} ≤ G^{(0)} = G,

where G^{(i)} is the subgroup of G that fixes the points 1, 2, …, i.

Our algorithm will compute a generator set for G by computing the coset representatives of G^{(i)} in G^{(i−1)} for each i. Starting with G^{(n−1)}, the algorithm will compute what is known as a strong generator set for G^{(i)} in decreasing order of i until finally it computes a strong generator set for G^{(0)} = G.

If G were given by its generator set as input, then it is well-known that a strong generator set for G can be computed in polynomial time. These ideas were developed in [32,16] to design a polynomial-time membership test for permutation groups. These ideas play an important role in the design of our algorithm. For our problem notice that we do not have access to a generator set for G = Aut(X). Indeed, a generator set for Aut(X) is what the algorithm has to compute. Our algorithm will use an NP oracle to access elements of G from different subgroups in the above tower. An important aspect that yields the FPSPP bound is that the queries made by the algorithm to the NP oracle are carefully chosen. A key procedure we use here is a polynomial-time algorithm for finding the lexicographically least element in a coset Hg of a permutation group H ≤ S_{n} and g ∈ S_{n}.

The plan of the paper is as follows: in the next section we explain notation and give preliminary definitions and results, particularly concerning SPP and

Graph Isomorphism for bounded-degree graphs or bounded genus graphs, that have polynomial-time algorithms.

related counting complexity classes. In Sections 3 and 4 we develop the ingredients leading to the proof of our main result that there is an FPSPP algorithm for the FIND-GROUP problem, and derive as corollary that GI is in SPP. In Sections 5 and 6 we give further applications of the main result. Finally, we state some open problems.

2 Preliminaries

Following standard notation, we use Σ to denote the alphabet {0, 1} and Σ^{∗} denotes the set of all finite strings over Σ. The length of a string x ∈ Σ^{∗} is denoted by |x|. Let ℤ denote the set of integers.

As usual, the class of languages computable in polynomial time is denoted by P, and the class of polynomial-time computable functions is denoted by FP. The class of languages computable in nondeterministic polynomial time is denoted by NP. Other basic notions from complexity theory that we require in this paper can be found in standard textbooks such as Balcázar et al’s texts [7,8]. We now focus on definitions of counting complexity classes, with particular emphasis on gap-definable classes, and give a brief description of some of their properties relevant to the present article. Details can be found in [13–15,12].

2.1 SPP and other Counting Complexity Classes

Fenner, Fortnow and Kurtz defined gap-definable functions [13] using which they examined several counting complexity classes like PP, C_{=}P, Mod_{k}P, and SPP.

Definition 1 A function f : Σ^{∗} → ℤ is said to be gap-definable if there is a nondeterministic polynomial time Turing machine M such that, for each x ∈ Σ^{∗}, f(x) is the difference between the number of accepting paths and the number of rejecting paths of M on input x. More precisely, if acc_{M}(x) denotes the number of accepting paths and rej_{M}(x) the number of rejecting paths of M on input x, then

f(x) = acc_{M}(x) − rej_{M}(x).

Let GapP denote the class of gap-definable functions [13]. For each nondeterministic polynomial time Turing machine M let gap_{M} denote the GapP function defined by it.

Recall that a language L is in UP if there is a nondeterministic polynomialtime Turing machine M accepting L such that M has at most one accepting path on any input. The class UP was defined by Valiant in [33] and it captures the complexity of 1-way functions.

The complexity class SPP introduced in [13] is the GapP analogue of UP. The class LWPP, also introduced in [13], contains SPP. We recall their definitions.

Definition 2

(1) A language L is in SPP if there is a nondeterministic polynomial-time Turing machine M such that

x ∈ L implies gap_{M}(x) = 1,
x ∉ L implies gap_{M}(x) = 0.

(2) A language L is in LWPP if there are a nondeterministic polynomial-time Turing machine M and an FP function g such that

x ∈ L implies gap_{M}(x) = g(1^{|x|}),
x ∉ L implies gap_{M}(x) = 0.

In either case we say that L is accepted by the machine M.

We note that UP ⊆ SPP ⊆ LWPP. The standard counting complexity classes PP and Mod_{k}P can also be defined using gap-definable functions.

Definition 3 [13]

(1) A language L is in PP if there is a nondeterministic polynomial-time Turing machine M such that

x ∈ L ⟺ gap_{M}(x) > 0.

(2) A language L is in Mod_{k}P (for k ≥ 2) if there is a nondeterministic polynomial-time Turing machine M such that

x ∈ L ⟺ gap_{M}(x) ≠ 0 (mod k).

Indeed, the above definitions are examples of a general notion of gap-definable complexity classes introduced and studied in [13]. It is shown in [13] that SPP is the minimal gap-definable class in a certain sense.

By relativizing the nondeterministic polynomial-time Turing machines we can define the relativized class GapP^{A}, for oracle A ∈ Σ^{∗}. Thus, we can define the relativized complexity classes SPP^{A}, PP^{A}, and Mod_{k}P^{A}.

The notion of lowness was first introduced in complexity theory by Schöning in [28]. We recall the definition.

Definition 4 Let C be a relativizable complexity class. We say that a language A ∈ Σ^{∗} is low for C if C^{A} = C.

In particular we are interested in languages that are low for the class PP. We summarize as a theorem some properties of SPP from [13] related to lowness.

Theorem 5 [13]

(1) Every language in SPP (indeed, even in the larger class LWPP) is low for PP. More precisely, PPLWPP = PP.

(2) SPP ⊆ Mod_{k}P for all k ≥ 2. Moreover, SPPSPP = SPP.

We note here that Graph Isomorphism was shown to be low for PP in [22] by proving that it is in LWPP. It is also shown in [22] that GA (testing if a given graph has a nontrivial graph automorphism) is in SPP. It is known that GA is polynomial-time reducible to GI, but the converse is open.

Recall that BPP denotes the class of languages with polynomial-time randomized algorithms with error probability bounded by, say, 1/3. The class BPP is also known to be low for PP [21].

The complexity class AWPP was introduced in [14]. More recently, Fenner [12] has shown a sort of gap amplification property for AWPP which yields the following neat definition for this class.

Definition 6 A language L is in the class AWPP if there is a nondeterministic polynomial-time Turing machine M and a polynomial p such that for all x ∈ Σ^{∗}

x ∈ L implies 2/3 ≤ \frac{gap_{M}(x)}{2^{p(|x|)}} ≤ 1,
x ∉ L implies 0 ≤ \frac{gap_{M}(x)}{2^{p(|x|)}} ≤ 1/3.

The class AWPP generalizes both BPP and SPP, and it is shown in [14] that every language in AWPP is low for PP.

Let BQP denote the class of languages that have quantum polynomial-time algorithms with bounded error probability (say 1/3). To complete the picture relating these classes, Fortnow and Rogers in [15] have shown that BQP is contained in AWPP and hence BQP is also low for PP.

It is interesting to note that NP ∩ co-NP is not known to be low for PP. Here is a diagram that shows the containments between the complexity classes discussed here.

[figure: AWPP; LWPP; BQP; SPP; BPP; UP; RP; P].

Although no containment is known between BQP and SPP, it is interesting to compare these classes in terms of natural problems they contain. In the present paper we show that Graph Isomorphism and the hidden subgroup problem for permutation groups are in SPP. These problems have resisted efficient deterministic or randomized algorithms, but they are still considered as problems likely to have polynomial-time quantum algorithms. On the other hand, FPSPP contains Integer Factoring and Discrete Log that have polynomialtime quantum algorithms. In fact, these problems are even in FPUP. Also, as PSPP = SPP, notice that the class FPSPP is essentially SPP: for f ∈ FPSPP and input x, the bits of f(x) can be computed in SPP. A similar closure property holds for BQP.

As mentioned before, SPP is contained in and is low for the complexity classes Mod_{k}P, C_{=}P, and PP. Also, SPP has other nice properties (see [13] for details). For instance, SPP is characterized exactly as the class of languages low for GapP. In summary, SPP can be seen as the GapP analogue of UP and is a robust complexity class.

Let M be a nondeterministic polynomial-time oracle Turing machine. Suppose A is a language in NP accepted by some NP machine N. We say that M^{A} makes UP-like queries to the oracle A if on all inputs x, M^{A}(x) makes only such queries y for which N(y) has at most one accepting path. Effectively, it is like M having access to a UP oracle. We now state a useful variant of a result from [22,23].

Theorem 7 ([22]) Let M be a nondeterministic polynomial-time oracle machine with oracle A ∈ NP such that M^{A} makes UP-like queries to A then the function h(x) = gap_{M^{A}}(x) is in GapP.

The following lemma, which is a straightforward consequence of Theorem 7 and of Theorem 5, is in a form useful for this paper.

Lemma 8

• Suppose L is in SPP^{A} accepted by the nondeterministic polynomial-time oracle machine M^{A} with oracle A ∈ NP (i.e. x ∈ L implies that gap_{M^{A}}(x) = 1, and x ∉ L implies that gap_{M^{A}}(x) = 0), such that the machine M^{A} makes UP-like queries to A, then L is in SPP.

• Suppose a function f : Σ^{∗} → Σ^{∗} is in FP^{A} (i.e. f is computed by a polynomial-time oracle transducer M^{A}) where A ∈ NP, such that the machine M^{A} makes UP-like queries to A, then f is in FPSPP.

2.2 Permutation group preliminaries

The set of all permutations on the set [n] = {1, 2 …, n} is a group under composition of permutations. This group is the symmetric group of degree n and is denoted by S_{n}. A permutation group on the set [n] is a subgroup of S_{n}.

We use letters g, h, …, σ, τ, π, … with subscripts and superscripts to denote elements of S_{n} and i, j and k for the elements of the set [n]. Subsets and subgroups of S_{n} are denoted by capital letters A, G, H etc. For two groups G and H, we write H ≤ G to denote that H is a subgroup of G (not necessarily a proper subgroup).

We use the following standard notation in permutation group theory [35,25]. For g ∈ S_{n} and i ∈ [n], we denote by i^{g} the image of i under permutation g. The composition g_{1}g_{2} of permutations g_{1}, g_{2} ∈ S_{n} is defined left to right: i.e. applying g_{1} first and then g_{2}. More precisely, i^{g_{1}g_{2}} = (i^{g_{1}})^{g_{2}} for all i ∈ [n]. For A ⊆ S_{n} and i ∈ [n] we denote the set {i^{g}|g ∈ A} by i^{A}. In particular, if A ≤ S_{n} then i^{A} is the orbit of i under the action of A on [n].

If G ≤ S_{n} then for each i ∈ [n], we let G^{(i)} denote the subgroup {g ∈ G | j^{g} = j for each j ∈ [i]}. G^{(i)} is called the pointwise stabilizer of [i] in G.

The identity permutation is denoted by 1 (we use 1 to denote the identity of all groups) and the subgroup consisting of only 1 is denoted 1. The permutation group generated by a subset A of S_{n} is the smallest subgroup of S_{n} containing A and is denoted by ⟨A⟩.

For the algorithmic problems considered in this paper, we assume that a permutation π in S_{n} is presented as the ordered sequence (1^{π}, 2^{π}, …, n^{π}). Further, we assume that subgroups of S_{n} are presented by generator sets.

Let G be a group and H be a subgroup of G. For φ ∈ G the subset Hφ = {πφ : π ∈ H} of G is a right coset of H in G. Two right cosets of H in G are either disjoint or identical. Thus, the right cosets of H in G form a partition of G. When G is finite this partition is finite and can be written as G = Hφ_{1} ∪ Hφ_{2} ∪ … ∪ Hφ_{k}. Each right coset of H has cardinality equal to |H| and the set {φ_{1}, φ_{2}, …, φ_{k}} is a set of distinct coset representatives of H in G.

As developed by Sims [32], pointwise stabilizers are fundamental in the design of algorithms for permutation group problems. The structure used is the chain of stabilizers subgroups in G given by: 1 = G^{(n)} ≤ G^{(n−1)} ≤ … ≤ G^{(1)} ≤ G^{(0)} = G. Let C_{i} be a complete set of right coset representatives of G^{(i)} in G^{(i−1)}, 1 ≤ i ≤ n. Then ⋃_{i=1}^{n−1} C_{i} forms a generator set for G. Such a generator set is called a strong generator set for G [32,16]. Any g ∈ G has a unique factorization g = g_{1}g_{2} … g_{n}, with g_{i} ∈ C_{i}.

We now recall two basic algorithmic results concerning permutation groups that are essential ingredients in the proof of our main result in Section 4. These algorithms are originally due to Sims [32], and the polynomial-time analysis is from [16]. Further details can be found in the survey article by Luks [25] and the monograph by Hoffman [18].

Theorem 9 Given as input the generator set S for a permutation group G ≤ S_{n}, the following two basic algorithmic tasks can be implemented in time polynomial in n

(1) For each element i ∈ [n], its orbit i^{G} = {i^{g} | g ∈ G}, can be computed in polynomial time. Furthermore, for each j in the orbit i^{G} we can compute in polynomial time an element g ∈ G such that i^{g} = j.

(2) The tower of subgroups 1 = G^{(n)} ≤ G^{(n−1)} ≤ … ≤ G^{(1)} ≤ G can be computed in time polynomial in n. (I.e. the right coset representative sets C_{i} for the groups G^{(i)} in G^{(i−1)}, 1 ≤ i ≤ n can be computed in polynomial time giving a strong generator set for each G^{(i)} including G).

3 Computing the least element of a right coset

We define the lexicographic ordering ≺ of permutations in S_{n} induced by the natural order of [n] as follows: For two permutations π ≠ τ ∈ S_{n} we say that π ≺ τ if for some i ∈ [n] we have

i^{π} < i^{τ} and j^{π} = j^{τ} for 1 ≤ j ≤ i − 1.

Clearly, this is a total order on S_{n}. Writing a permutation π as the ordered sequence (1^{π}, 2^{π}, …, n^{π}) this is clearly the natural lexicographic ordering on these sequences with the sequence (1, 2, …, n) as the least element of S_{n} and the sequence (n, n − 1, …, 1) as the last element of S_{n}.

In this section we describe a simple polynomial-time algorithm that takes as input a permutation group ⟨A⟩ = G ≤ S_{n} and a permutation σ ∈ S_{n} and computes the lexicographically least element of the right coset Gσ of G in S_{n}. This algorithm is a crucial ingredient in the proof of the main theorem in the next section.

Theorem 10 There is a polynomial-time algorithm that takes as input a permutation group ⟨A⟩ = G ≤ S_{n} and a permutation σ ∈ S_{n} and computes the lexicographically least element of the right coset Gσ.

PROOF.

We describe the algorithm and then argue its correctness.

Input: G ≤ S_{n}, σ ∈ S_{n}; Output: Lexicographically least element in Gσ ; Let G^{(n)} ≤ G^{(n−1)} ≤ … ≤ G^{(1)} ≤ G^{(0)} = G be the tower of subgroups of G where, by Theorem 9, the generator set for each G^{(i)} and the strong generator set for G can be computed in polynomial time; π_{0} = σ;

for i := 0 to n − 1 find the element y in (i + 1)^{G^{(i)}} such that y^{π_{i}} is minimum; (* This can be done in polynomial time as the entire orbit (i + 1)^{G^{(i)}} of i + 1 in G^{(i)}, which is a set of size at most n − i, can be computed in polynomial time by applying Theorem 9, and finding the minimum in the orbit takes linear time. *); Let g_{i} ∈ G^{(i)} be such that (i + 1)^{g_{i}} = y; (* By Theorem 9, g_{i} can be computed in polynomial time *); π_{i+1} := g_{i}π_{i};

endfor; Output π_{n};

Since π_{0} = σ and G^{(n−1)} = {1}, it suffices to prove the following claim in order to show that the algorithm computes the lexicographically least element of Gσ.

Claim 11 For all 0 ≤ i < n − 1 the lexicographically least element of G^{(i)}π_{i} is in G^{(i+1)}π_{i+1}.

Proof of Claim. By definition, π_{i+1} = g_{i}π_{i}, where g_{i} is in G^{(i)} such that g_{i} maps i + 1 to y ∈ (i + 1)^{G^{(i)}} and such that y^{π_{i}} = x is the minimum element in {z^{π_{i}} | z ∈ (i + 1)^{G^{(i)}}}. Since G^{(i)} fixes each element in the set [i] and since g_{i} ∈ G^{(i)}, we can see that for every 1 ≤ k ≤ i , for each g ∈ G^{(i)} and h ∈ G^{(i+1)}, we have k^{hπ_{i+1}} = k^{π_{i+1}} = k^{g_{i}π_{i}} = k^{π_{i}} = k^{gπ_{i}}. In particular if ρ is the lex-least element of G^{(i)}π_{i}, every element in G^{(i+1)}π_{i+1} agrees with ρ on the first i elements.

Furthermore, for each g ∈ G^{(i+1)} notice that (i + 1)^{gπ_{i+1}} = (i + 1)^{π_{i+1}} = (i + 1)^{g_{i}π_{i}} = x, where x is defined above. It is clear that G^{(i+1)}π_{i+1} is precisely the subset of G^{(i)}π_{i} each of whose elements maps i + 1 to x. Together with the fact that (i + 1)^{ρ} = x (by the lex-least property of ρ), we get the desired conclusion.

By induction and the above claim it follows that the lex-least element of Gσ = G^{(0)}π_{0} is in G^{(n)}π_{n} = {π_{n}}. Thus, π_{n} is the desired lexicographically least element of Gσ. □

The polynomial-time algorithm of Theorem 10 can be generalised to compute the lexicographically least element of τGσ.

Corollary 12 There is a polynomial-time algorithm that takes as input a permutation group ⟨A⟩ = G ≤ S_{n} and two permutations τ, σ ∈ S_{n}, and computes the lexicographically least element of τGσ. In particular, the lexicographically least element of a left coset τG can also be computed in polynomial time.

PROOF. Notice that τGσ = τGτ^{−1}τσ and τGτ^{−1} is a subgroup of S_{n} with generating set {τgτ^{−1} | g ∈ A}. The result follows directly from Theorem 10 applied to the group τGτ^{−1} and the permutation τσ. □

4 Graph Isomorphism in SPP

We are ready to prove the main theorem of the paper. Recall that the Graph Isomorphism problem is the following decision problem: GI = {(X_{1}, X_{2}) | X_{1} and X_{2} are isomorphic}. A related problem is AUTO which is a functional problem: given a graph X as input the problem is to output a strong generator set for Aut(X). It is well-known from the result of Mathon [26] (see e.g. [23]) that GI and AUTO are polynomial-time Turing equivalent.

Thus, in order to show that GI ∈ SPP it suffices to show that AUTO ∈ FPSPP.

In other words, it suffices to show that there is a deterministic polynomialtime Turing machine M with oracle A ∈ SPP that takes a graph X as input and outputs a strong generator set for Aut(X).

We observe here that the problem AUTO itself is one among a class of problems, each of which we will show is in FPSPP by giving such an algorithm for the following generic problem FIND-GROUP which we formally describe below:

Let G_{n} denote the set of all subgroups of S_{n}, for each n. Let G denote the union ⋃ G_{n}. The FIND-GROUP problem is defined by a function

f : Σ^{∗} × 0^{∗} ⟶ G,

where to each pair ⟨x, 0^{n}⟩ in the domain, the image f(⟨x, 0^{n}⟩) is a subgroup of S_{n}. When the function f is fixed and n is given, it is more convenient notation to denote f(⟨x, 0^{n}⟩) by G_{x}.

Furthermore, for each subgroup f(⟨x, 0^{n}⟩) we assume that we have an efficient membership test. More precisely, we assume that we have access to a procedure MEMB(x, g), that takes x and g ∈ S_{n} as input, and evaluates to true if and only if g ∈ G_{x} in time polynomial in n and |x|. The FIND-GROUP problem is to compute a strong generator set for G_{x} given ⟨x, 0^{n}⟩ as input.

The problem FIND-GROUP is generic in the sense that for different functions f we get different problems. For instance, in the case of AUTO, for each n vertex graph X, encoded as x ∈ Σ^{∗}, we can define f(⟨X, 0^{n}⟩) = Aut(X) and for m ≠ n we can define f(⟨X, 0^{m}⟩) as the trivial subgroup 1 of S_{m}. The function MEMB(x, g) is polynomial-time computable as checking whether g ∈ S_{n} is in Aut(X) can be done in time polynomial in n.

Remark. An FPSPP algorithm for FIND-GROUP allows us to show at one stroke that, apart from GI, several other permutation group problems are in SPP. In particular, we show in the next section that the hidden subgroup problem for permutation groups has an FPSPP algorithm.

Theorem 13 There is an FPSPP algorithm for the FIND-GROUP problem.

PROOF. Let ⟨x, 0^{n}⟩ be an input instance of FIND-GROUP. The goal is to compute a strong generator set for G_{x} ≤ S_{n} using MEMB as subroutine. As we have fixed the input, we will sometimes drop the subscript and write G instead of the group G_{x}.

Our goal is to design an FPSPP algorithm for finding the coset representatives of G^{(i)} in G^{(i−1)} for each i in the tower of subgroups 1 = G^{(n−1)} ≤ G^{(n−2)} ≤ … ≤ G^{(1)} ≤ G^{(0)} = G. Starting with G^{(n−1)}, which is trivial, the algorithm will build a strong generator set for G^{(i)} in decreasing order of i until finally it computes a strong generator set for G^{(0)} = G. Thus, it suffices to describe how the algorithm will compute the coset representatives of G^{(i)} in G^{(i−1)} assuming that a strong generator set for G^{(i)} is already computed.

We first introduce a definition and notation. A partial permutation on the set [n] is an injective function π : I ⟶ [n], where the domain I of π is a subset of [n]. Thus, π is any function that can be extended to a permutation in S_{n}. We say that a partial permutation φ extends π if the domain of φ contains I and i^{φ} = i^{π} for all i ∈ I. Let π : I ⟶ [n] be a partial permutation and let i ∈ [n]\I. We denote by π[i ↦ j] the unique partial permutation that extends π to the domain I ∪ {i} by mapping i to j.

For a subgroup H ≤ S_{n} and g ∈ S_{n} let lex−least(Hg) denote the lexicographically least permutation in the coset Hg. We next define a language in NP to which our main algorithm will make UP-like queries:

L = {⟨x, 0^{n}, S, i, j, π⟩ | S ⊆ G_{x}^{(i)}, π is a partial permutation that fixes

each of 1, …, i − 1 and i^{π} = j, and there is a g ∈ G_{x}^{(i−1)} such that g extends π and g = lex−least(⟨S⟩g)}.

Partial permutation π is part of instance ⟨x, 0^{n}, S, i, j, π⟩, as we will use L as an oracle to do a prefix search for the lexicographically least g ∈ G_{x}^{(i−1)} such that i^{g} = j. We now describe an NP machine N that accepts L.

Description of Machine N ; Input: ⟨x, 0^{n}, S, i, j, π⟩; Verify using MEMB that S ⊆ G_{x}^{(i)};

Guess g ∈ S_{n}; if g ∈ G_{x}^{(i−1)} and i^{g} = j and g extends π and g = lex−least(⟨S⟩g) then ACCEPT else REJECT;

Clearly, N is an NP machine that accepts L. The crucial point is that if i^{g} = j then for every element h ∈ ⟨S⟩g, i^{h} = j. Also, using the algorithm in Theorem 10 the lexicographically least element of ⟨S⟩g can be computed in polynomial time.

Claim 14 If ⟨S⟩ = G^{(i)} then the number of accepting paths of N on input ⟨x, 0^{n}, S, i, j, π⟩ is either 0 or 1. In general, on input ⟨x, 0^{n}, S, i, j, π⟩, N has either 0 or \frac{|G^{(i)}|}{|⟨S⟩|} accepting paths.

Proof of Claim. Suppose ⟨x, 0^{n}, S, i, j, π⟩ ∈ L and ⟨S⟩ = G^{(i)}. Notice that if for some g ∈ G^{(i−1)} we have i^{g} = j (for j > i), then ⟨S⟩g consists of all elements in G^{(i−1)} that map i to j. Thus the unique guess in S_{n} made by N that leads to acceptance is the lexicographically least element of ⟨S⟩g. On the other hand, if ⟨S⟩ is a proper subgroup of G^{(i)} then G^{(i)}g can be written as a disjoint union of |G^{(i)}|/|⟨S⟩| many right cosets of ⟨S⟩. Thus, in general N would have |G^{(i)}|/|⟨S⟩| many accepting paths if ⟨x, 0^{n}, S, i, j, π⟩ is in L.

We are now ready to describe an FP^{L} algorithm for FIND-GROUP. The algorithm is designed so it queries L for a ⟨x, 0^{n}, S, i, j, π⟩ only if ⟨S⟩ = G^{(i)}, thereby ensuring that it makes only UP-like queries to L. Finally, by Lemma 8 we can convert this algorithm to an FPSPP algorithm.

(* FP^{L} algorithm CONSTRUCT(⟨x, 0^{n}⟩ *); C_{i} := ∅ for every 0 ≤ i ≤ n − 2; (* C_{i} will finally be a complete set of coset representatives of G^{(i+1)} in G^{(i)} *). D_{i} := ∅ for every 0 ≤ i ≤ n − 2; D_{n−1} = 1; (* D_{i} will finally be a strong generator set for G^{(i)} for each i. *)

for i := n − 1 downto 1 (* D_{i} is already computed at the beginning of the i^{th} iteration and at the end of the i^{th} iteration we have D_{i−1} *) Let π : [i − 1] → [n] be the partial permutation that fixes all elements from 1 to i − 1; (* in case i = 1 this is the everywhere undefined partial permutation *)

for j := i + 1 to n π′ := π[i ↦ j]; (* π′ extends π to [i] by mapping i to j *) if ⟨x, 0^{n}, D_{i}, i, j, π′⟩ ∈ L then (* There is an element in G^{(i−1)} that maps i to j. We will find it by a prefix search that extends the partial permutation π′ *) for k := i + 1 to n

find the element ℓ not in the range of π′ such that ⟨x, 0^{n}, D_{i}, i, j, π′[k ↦ ℓ]⟩ ∈ L; π′ := π′[k ↦ ℓ]; (* At this point π′ will be a permutation in S_{n} *)

endfor

C_{i−1} := C_{i−1} ∪ {π′};

endif endfor (* At this point C_{i−1} is a complete set of coset representatives of G^{(i)} in G^{(i−1)} *)

D_{i−1} = D_{i} ∪ C_{i−1}; Output D_{0} We claim that a call to the FP^{L} algorithm CONSTRUCT(⟨x, 0^{n}⟩) outputs a strong generator set D_{0} for the group G = G_{x}. We show this by induction. Initially, D_{n−1} = 1 clearly generates G^{(n−1)} = 1. Suppose at the beginning of the i^{th} iteration it holds that D_{i} is a strong generator set for G^{(i)}. It suffices to show that at the end of the i^{th} iteration D_{i−1} = D_{i} ∪C_{i−1} is a strong generator set for G^{(i−1)}. For each j : i+1 ≤ j ≤ n, the query ⟨x, 0^{n}, D_{i}, i, j, π′⟩ ∈ L checks if there is an element in G^{(i−1)} that maps i to j. The subsequent prefix search with queries to L computes the lexicographically least element in G^{(i−1)} that maps i to j. Furthermore, by Claim 14, as D_{i} generates G^{(i)}, all queries made to L are UP-like. Thus, at the end of the i^{th} iteration C_{i−1} is a complete set of coset representatives for G^{(i)} in G^{(i−1)} and hence D_{i−1} is a strong generator set for G^{(i−1)}. Thus at the end D_{0} is a a strong generator set for G. Therefore, we have an FP^{L} algorithm problem for FIND-GROUP.

Finally, since the FP^{L} algorithm makes only UP-like queries to the NP oracle L, it follows from Lemma 8 that FIND-GROUP has an FPSPP algorithm. □

Remark. Let UPSV denote the class of functions f : Σ^{∗} ⟶ Σ^{∗} for which there is a nondeterministic polynomial-time transducer M that on each input x has a unique accepting path on which it outputs f(x). We note that using UPSV there is alternative description of our FPSPP algorithm for FIND-GROUP: we can first design an UPSVSPP algorithm, where the prefix search that we do in CONSTRUCT(⟨x, 0^{n}⟩) is replaced by directly guessing a permutation in the right coset (consisting of elements that fix 1 to i − 1 and map i to j) and rejecting along all paths on which we do not guess the lexicographically least element of the coset. Then, by a general prefix search argument we can see that FPSPP and UPSVSPP are the same and hence conclude that FIND-GROUP is in FPSPP.

As we already noted, GI and AUTO are polynomial-time equivalent and AUTO, being an instance of FIND-GROUP has an FPSPP algorithm by Theorem 13. Since SPPSPP = SPP and SPP ⊆ Mod_{k}P for each k ≥ 2, the next corollary is an immediate consequence.

Corollary 15 Graph Isomorphism is in SPP and hence in Mod_{k}P for every k ≥ 2.

5 Hidden subgroup problem

We recall the general definition of the hidden subgroup problem.

Definition 16 The hidden subgroup problem HSP has an input instance a finite group G (presented by a finite generator set) and we are given (in the form of an oracle) a function f from G to some finite set X such that f is constant and distinct on different right cosets of a hidden subgroup H of G. The problem is to determine a generator set for H.

Many natural problems like Graph Isomorphism, Integer Factoring etc, can be cast as a special case of HSP. An efficient quantum algorithm for the general problem will result in efficient quantum algorithm for all these. Based on suitable generalizations of Shor’s technique [31], the above problem has efficient quantum algorithms for the case when G is an abelian group (see e.g. [27] for an exposition). However, the status of HSP is open for general nonabelian groups, except for some special cases where it is settled (see, e.g. [17,19]). In particular, even when we restrict attention to G being the permutation group S_{n}, it is not known if HSP has quantum polynomial time algorithms except in special cases.

Independently, it is shown by Fortnow and Rogers [15] that the class BQP of languages that have polynomial-time quantum algorithms is closely connected with language classes that are low for PP. In particular, it is shown in [15] that BQP ⊆ AWPP where AWPP is a language class that generalizes both BPP and LWPP.

Theorem 17 [15] BQP ⊆ AWPP and hence BQP is low for PP.

In this section we show as a corollary to Theorem 13 that there is an FPSPP algorithm for the HSP problem over permutation groups.

Theorem 18 There is an FPSPP algorithm for the HSP problem over permutation groups, and hence HSP over permutation groups is low for PP, GapP, ⊕P, C_{=}P etc.

PROOF. We are given (in the form of an oracle) a function f from S_{n} to a finite set X such that f is constant and distinct on different right cosets of a hidden subgroup H of S_{n}. The FPSPP will first compute f(1) with one query to f. Now, notice that f gives a membership test for the unknown subgroup H, because a permutation g ∈ S_{n} is in H if and only if f(g) = f(1). Thus we essentially have a membership test as required for the FIND-GROUP problem of Theorem 13. The result now follows by invoking the algorithm described in the proof of Theorem 13. Lowness for PP also follows as SPP is low for PP. □

Using the FPSPP algorithm for the FIND-GROUP problem we can show that other algorithmic problems on permutation groups [25] which are not known to have polynomial-time algorithms are also in SPP. Among the different problems mentioned in [25] we pick the following two examples as most other problems are known to be polynomial time reducible to these.

The input instance to the CONJ-GROUP problem consists of three subgroups ⟨S⟩ = G, ⟨S_{1}⟩ = H_{1}, and ⟨S_{2}⟩ = H_{2} of S_{n}, and the problem is to determine if there is a g ∈ G such that gH_{1}g^{−1} = H_{2} (i.e. H_{1} and H_{2} are G-conjugate).

A closely related problem NORM has input instance two subgroups G and H of S_{n}, and the problem is to determine a generator set for the normalizer subgroup N_{G}(H) = {g ∈ G | gHg^{−1} = H}. Just as GI and AUTO are polynomial-time equivalent, it turns out that CONJ-GROUP and NORM are also polynomial-time equivalent [25].

Theorem 19 The problem NORM is in FPSPP and CONJ-GROUP is in SPP.

PROOF. We show that NORM is an instance of FIND-GROUP. The theorem will follow as a direct consequence of Theorem 13. It suffices to observe that given subgroups ⟨S⟩ = G and ⟨T ⟩ = H of S_{n}, testing if g ∈ N_{G}(H) (i.e. gHg^{−1} = H) can be carried out in polynomial time. More precisely, it is clear that gHg^{−1} = H if and only if gtg^{−1} ∈ H for every t ∈ T, which can be checked in polynomial time by Theorem 9. □

As already mentioned, a consequence of the above theorem is that several other decision problems in permutation groups (e.g. coset intersection, double coset equality, set transporter) which are polynomial-time many-one reducible to CONJ-GROUP are also in SPP.

6 Parallel queries to NP

In this section we discuss an application of our main theorem Theorem 13 to a different problem concerning Graph Isomorphism.

We first recall the definitions of two important function classes. Let FPNP_{||} denote the class of functions computable in polynomial time with parallel queries to an NP oracle. Likewise, let FPNP[log] denote the class of functions computable in polynomial time with logarithmically many adaptive queries to an NP oracle. In contrast to the decision problem setting where PNP_{||} =

PNP[log], it is believed to be unlikely that FPNP_{||} = FPNP[log]. Indeed, it is shown in [11,30,9] that FPNP_{||} = FPNP[log] implies NP = RP. It is useful to recall the proof of this result. Let SAT denote the set of satisfiable Boolean formulas. The key idea in the proof is that given a boolean formula F with a unique satisfying assignment, the satisfying assignment can be computed in FPNP_{||}. Thus, if FPNP_{||} = FPNP[log], we can find a satisfying assignment of F in polynomial time by enumerating the polynomially many candidates (given by all possible answers to the logarithmically many queries) and testing. Since SAT is randomly many-one reducible to USAT (the set of boolean formulas with unique satisfying assignment), the collapse result FPNP_{||} = FPNP[log] implies NP = RP follows.

A question that has remained open is whether we can derive the collapse NP = P from the same assumption. The paper by Jenner and Torán [20] contains a detailed investigation of this question.

In general, we could ask which problems in NP are in P as a consequence of the assumption FPNP_{||} = FPNP[log]. Consider a language L ∈ NP defined by a set A in P and a polynomial bound p as follows:

x ∈ L ⟺ ∃y ∈ Σ^{∗} : |y| ≤ p(|x|) and ⟨x, y⟩ ∈ A.

Given an x ∈ L the problem of computing a witness y ∈ Σ^{∗} such that |y| ≤ p(|x|) and ⟨x, y⟩ ∈ A is the search problem corresponding to L. Of course, the search problem depends on the set A. Suppose L has the property that this search problem can be solved in FPNP_{||}. Then, analogous to the discussion

above regarding SAT, it is easy to see that FPNP_{||} = FPNP[log] implies that

L is in P. Using the FPNP[log] machine for the search problem, in polynomial time we can simply enumerate the entire set of polynomially many candidate witnesses and check if there is a y among them such that ⟨x, y⟩ ∈ A. Thus we have the following.

Proposition 20 Suppose L ∈ NP has a corresponding search problem that can be solved in FPNP_{||}. Then FPNP_{||} = FPNP[log] implies that L is in P.

A natural example for such a language L is the Graph Automorphism problem GA as shown in [24]. Thus, FPNP_{||} = FPNP[log] implies GA is in P [24].

For Graph Isomorphism, however, it is open if the search problem can be solved in FPNP_{||}. Thus the above proposition is not applicable. Nevertheless,

we will show that if FPNP_{||} = FPNP[log] then GI is in P as a consequence of Theorem 13 and another general proposition similar to Proposition 20.

We recall the definition of promise problems.

Definition 21 [11] A promise problem is a pair of sets (Q,R). A set L is called a solution of the promise problem (Q,R) if for all x ∈ Q, x ∈ L ⇔ x ∈ R.

A promise problem of particular interest is (1SAT, SAT), where 1SAT contains precisely those Boolean formulas which have at most one satisfying assignment. Observe that any solution of the promise problem (1SAT, SAT) has to agree with SAT in the formulas having a unique satisfying assignment as well as in the unsatisfiable formulas. By the results of Selman [30,11] we know that FPNP_{||} = FPNP[log] implies that every solution to the promise problem (1SAT, SAT) is in P.

Proposition 22 Suppose L ∈ NP is accepted by a deterministic polynomialtime oracle machine M with access an NP oracle A such that M makes only UP-like queries to A. Then FPNP_{||} = FPNP[log] implies that L is in P.

PROOF. Recall that an oracle query q to A is UP-like if the NP machine for A has at most one accepting path on input q. Since all oracle queries made by the machine M to NP oracle A are UP-like, we can replace the oracle with any solution to the promise problem (1SAT, SAT): let f denote the standard parsimonious reduction from A to SAT. Then, each query q to A is transformed to a SAT query f(q) which will be correctly answered by any solution to (1SAT, SAT). But the promise problem (1SAT, SAT) is in P by the assumption FPNP_{||} = FPNP[log]. Thus, it follows that L is also in P. □

We can now easily derive our claimed result for Graph Isomorphism, and HSP for permutation groups.

Theorem 23 FPNP_{||} = FPNP[log] implies that the FIND-GROUP problem for permutation groups can be solved in polynomial time. Hence, it follows that FPNP_{||} = FPNP[log] implies Graph Isomorphism is in P and it implies that the hidden subgroup problem for permutation groups is in P.

PROOF. As a consequence of Theorem 13 it follows that FIND-GROUP has a polynomial-time oracle algorithm that makes only UP-like queries to an NP oracle A. Thus, by Proposition 22 it follows that FPNP_{||} = FPNP[log] implies FIND-GROUP can be solved in polynomial time. Consequently, Graph Isomorphism and the hidden subgroup problem for permutation groups are in P under the assumption FPNP_{||} = FPNP[log]. □

7 Concluding remarks

In this paper we have shown that Graph Isomorphism is in SPP. We have also shown that several other problems on permutation groups are in SPP. All these results are byproducts of the FPSPP algorithm for the problem FIND-GROUP. We would like to know if better upper bounds can be shown for the complexity of special cases of graph isomorphism especially tournament isomorphism. Specifically, is tournament isomorphism in UP? It is known that the automorphisms of a tournaments forms a solvable group and has odd order. Can this additional property be somehow exploited?

A related problem is Graph Canonization. Let f be a function from the family of finite graphs, G, to itself. We say that f is a canonization if for every X ∈ G, f(X) ≅ X and for every X_{1}, X_{2} ∈ G, f(X_{1}) = f(X_{2}) iff X_{1} ≅ X_{2}. There is an O(n^{logn}) algorithm for Tournament Isomorphism by giving a canonization procedure for tournaments [4]. The complexity of Graph Canonization is intriguing. The only known upper bound for the problem is FPNP. It is known that Graph Isomorphism is polynomial-time reducible to Graph Canonization. Is the converse true, at least for tournaments? Is Graph Canonization for tournaments low for PP?

In order to study the complexity of group-theoretic problems in a general setting, Babai and others in [6,5,3], have developed a theory of black-box groups. The main results in [6,5,3] were to put several natural problems in NP∩coAM or AM ∩ coAM. However, lowness for PP has been addressed only for the case of solvable black-box groups in [1,34], where many of these problems are shown to be in SPP. It is interesting to ask if our approach of showing membership in SPP via finding the lexicographically least element in a coset can be generalized to black-box groups. More precisely, what is the complexity of finding a canonical element in the right coset of a black-box group?

Acknowledgment. We are grateful to the referees for useful remarks and suggestions that have helped improve the presentation.

References

[1] V. Arvind and N. V. Vinodchandran. Solvable black-box group problems are low for PP. Theoretical Computer Science, 180(1–2):17–45, 1997.

[2] L. Babai. Trading group theory for randomness. In 17th Annual Symposium on Foundations of Computer Science, pages 421–429. ACM, 1985.

[3] L. Babai. Bounded round interactive proofs in finite groups. SIAM journal of Discrete Mathematics, 5(1):88–111, February 1992.

[4] L. Babai and E. M. Luks. Canonical labeling of graphs. In Proceedings of the Fifteenth Annual ACM Symposium on Theory of Computing, pages 171–183, 1983.

[5] L. Babai and S. Moran. Arthur-Merlin games: a randomized proof system, and a hierarchy of complexity classes. Journal of Computer and System Sciences, 36:254–276, 1988.

[6] L. Babai and E. Szemeredi. On the complexity of matrix group problems I. In Proceedings of the 24^{th} IEEE Foundations of Computer Science, pages 229–240, 1984.

[7] J. L. Balcázar, J. Díaz, and J. Gabarró. Structural Complexity I, volume 11 of ETACS monographs on theoretical computer science. Springer-Verlag, Berlin, 1988.

[8] J. L. Balcázar, J. Díaz, and J. Gabarró. Structural Complexity II, volume 22 of ETACS monographs on theoretical computer science. Springer-Verlag, Berlin, 1990.

[9] R. Beigel. NP-hard sets are P-superterse unless R = NP, January 04 1995.

[10] R. Boppana, J. Hastad, and S. Zachos. Does co-NP have short interactive proofs. Information Processing Letters, 25:127–132, May 1987.

[11] S. Even, A. L. Selman, and Y. Yacobi. The complexity of promise problems with applications to public-key cryptography. Information and Control, 61(2):159– 173, May 1984.

[12] S. A. Fenner. PP-lowness and a simple definition of AWPP. Theory of Computing Systems, 36(2):199–212, 2003.

[13] S. A. Fenner, L. J. Fortnow, and S. A. Kurtz. Gap-definable counting classes. In Structure in Complexity Theory Conference, pages 30–42, 1991.

[14] S.A. Fenner, L.J. Fortnow, S. A. Kurtz, and L. Li. An oracle builder’s toolkit. In SCT: Annual Conference on Structure in Complexity Theory, pages 120–131, 1993.

[15] L. J. Fortnow and J. D. Rogers. Complexity limitations on quantum computation. In IEEE Conference on Computational Complexity, pages 202– 209, 1998.

[16] M. L. Furst, J. E. Hopcroft, and E. M. Luks. Polynomial-time algorithms for permutation groups. In IEEE Symposium on Foundations of Computer Science, pages 36–41, 1980.

[17] S. Hallgren, A. Russel, and A. Ta-Shma. Normal subgroup reconstruction and quantum computing using group representation. In Proceedings of the 32^{nd} ACM Symposium on Theory of Computing, pages 627–635, Portland, Oregon, 21-23 May 2000.

[18] C. M. Hoffmann. Group-Theoretic Algorithms and Graph Isomorphism. Springer, Berlin, Heidelberg, 1982.

[19] G. Ivanyos, F. Magniez, and M. Santha. Efficient quantum algorithms for some instances of the non-abelian hidden subgroup problem. In 13^{th} ACM Symposium on Parallel Algorithms and Architectures, pages 263–270, 2001.

[20] B. Jenner and J. Torán. Computing functions with parallel queries to NP. Theoretical Computer Science, 141(1–2):175–193, 1995.

[21] J. Köbler, U. Schöning, S. Toda, and J. Torán. Turing machines with few accepting computations and low sets for PP. Journal of Computer and System Sciences, 44(2):272–286, 1992.

[22] J. Köbler, U. Schöning, and J. Torán. Graph isomorphism is low for PP. Computational Complexity, 2(4):301–330, 1992.

[23] J. Köbler, U. Schöning, and J. Torán. The Graph Isomorphism Problem: Its Structural Complexity. Birkhauser, 1993.

[24] A. Lozano and J. Torán. On the Non-Uniform Complexity of the Graph Isomorphism Problem. Cambridge University Press, 1992.

[25] E. M. Luks. Permutation groups and polynomial time computations. DIMACS Series in Discrete Mathematics and Theoretical Computer Science, 11:139–175, 1993.

[26] R. Mathon. A note on graph isomorphism counting problem. Information Processing Letters, 8(3):131–132, 15 March 1979.

[27] M Mosca. Quantum Computer algorithms. PhD thesis, Oxford University, 1999.

[28] U. Schöning. A low and a high hierarchy within NP. Journal of Computer and System Sciences, 27:14–28, 1983.

[29] U. Schöning. Graph isomorphism is in the low hierarchy. In Symposium on Theoretical Aspects of Computer Science, pages 114–124, 1987.

[30] A. L. Selman. A taxonomy of complexity classes of functions. Journal of Computer and System Sciences, 48(2):357–381, 1994.

[31] P. W. Shor. Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer. SIAM Journal on Computing, 26(5):1484– 1509, 1997.

[32] C. C. Sims. Computational methods in the study of permutation groups. Computational problems in Abstract Algebra, pages 169–183, 1970.

[33] L. G. Valiant. The complexity of computing the permanent. Theoretical Computer Science, 8:189–201, 1979.

[34] N. V. Vinodchandran. Counting complexity of solvable black-box group problems. SIAM Journal of Computing, 33(4):852–869, 2004.

[35] H. Wielandt. Finite Permutation Groups. Academic Press, New York, 1964.