Graph Isomorphism is in SPP

V. Arvind and Piyush P Kurur Institute of Mathematical Sciences, C.I.T Campus Chennai 600113, India

                      email: {arvind,ppk}@imsc.ernet.in

Abstract

We show that Graph Isomorphism is in the complexity class SPP, and hence it is in ⊕P (in fact, it is in Mod_{k}P for each k ≥ 2). 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.

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 can be defined as:

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

Graph Isomorphism has attracted a lot of research because there is no known polynomial-time algorithm for it and on the other hand there is strong evidence that it is not NP-complete. In [6] 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} [6, 18]. Schöning, who introduced the notion of lowness in complexity theory, pointed out in [18] that GI is low for Σ_{2}^{p}. I.e. GI is powerless as oracle for Σ_{2}^{p}.

Subsequently, it was shown in [13] that GI is also low for the class PP (the language class corresponding to #P). This result is proven using the machinery of GapP functions introduced in the seminal paper of [7]. In [7] the languages classes SPP and LWPP are introduced as generalizations of Valiant’s class UP. It is shown in [7] that UP ⊆ SPP ⊆ LWPP, and LWPP is low for PP.

SPP is perhaps the most important and natural of the counting classes. It is known that SPP is in and low for the classes ⊕P, C_{=}P, PP etc. SPP has a host of other nice properties as well (see [7] 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. In [7] it is also shown that SPP is the smallest reasonable gap-definable class.

Coming back to [13], the result that GI is low for PP is shown in that paper by proving that GI is in LWPP. It is also shown in [13] 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.

1.1 Summary of new results

In this paper, we show that GI is in the class SPP. This was left as an open question in [13] (also see [7]).

As a consequence it follows that GI is in and low for ⊕P (in fact, GI ∈ Mod_{k}P for each k ≥ 2), C_{=}P etc. Previously, only a special case of Graph Isomorphism, namely Tournament Isomorphism, was known to be in ⊕P.^{1}

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 some other algorithmic problems on permutation groups that are not known to have polynomial-time algorithms also 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.

2 Preliminaries and Notation

Let Σ = {0, 1} be the finite alphabet. Let log denote logarithm to base 2. Let FP denote the class of polynomial-time computable functions and NP denotes all languages accepted by polynomial-time nondeterministic Turing machines.

Let ℤ denotes the set of integers. A function f : Σ^{∗} → ℤ is said to be gap-definable if there is an NP 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. Let GapP denote the class of gap-definable functions [7]. For each NP machine M let gap_{M} denote the GapP function defined by it. The language class PP is defined as follows: L is in PP if there is an f ∈ GapP such that x ∈ L if and only if f(x) > 0.

The language classes UP, SPP and LWPP are defined using GapP functions [7]. L is in UP if there is an NP machine M accepting L such that M has at most one accepting path on any input. L is in SPP if there is an NP machine M such that x ∈ L implies that gap_{M}(x) = 1, and x ∉ L implies that gap_{M}(x) = 0. L is in LWPP if there are an NP machine M and h ∈ FP such that x ∈ L implies that gap_{M}(x) = h(0^{|x|}), and x ∉ L implies that gap_{M}(x) = 0. For L ∈ SPP (or in LWPP) we say that the language L is accepted by the machine M. The containments UP ⊆ SPP ⊆ LWPP is shown in [7].

We say that f is in GapP^{A}, for oracle A ⊆ Σ^{∗}, if there is an NP^{A} machine M^{A} such that, for each x ∈ Σ^{∗}, f(x) is the difference between the number of accepting paths and the number of rejecting paths of M^{A} on input x. For any oracle A, we can define the standard relativized classes UP^{A}, SPP^{A}, and LWPP^{A} and we can easily see the containments UP^{A} ⊆ SPP^{A} ⊆ LWPP^{A} for any oracle A.

We say that A ⊆ Σ^{∗} is low for PP if PP^{A} = PP. In [7] it is shown that every language in LWPP is low for PP.

Similarly, we say that A ⊆ Σ^{∗} is low for GapP if GapP^{A} = GapP. Again, it is shown in [7] that A is low for GapP if and only if A ∈ SPP.

Let M be an oracle NP machine, let A ∈ NP be accepted by an NP machine N. We say that M^{A} makes UP-like queries to 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 state a useful variant of a result from [13, 14].

Theorem 2.1 ([13]) 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.

Next, we recall an important property of the class SPP shown in [7].

Theorem 2.2 ([7]) If L is in SPP^{A} for some oracle A ∈ SPP then L ∈ SPP. I.e. SPPSPP = SPP.

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

Lemma 2.3 • Suppose L is in SPP^{A} accepted by the nondeterministic polynomial-time oracle machine M^{A} with oracle

1Tournament Isomorphism in ⊕P follows because any tournament has an odd number of automorphisms. There are special cases of Graph Isomorphism, e.g. Graph Isomorphism for bounded-degree graphs or bounded genus graphs, that have polynomial-time algorithms.

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.1 Permutation group preliminaries

In general, Sym(Ω) denotes the symmetric group on the finite set Ω. A permutation group on Ω is a subgroup of Sym(Ω). For |Ω| = n, in this paper we let Ω = [n] and identify Sym(Ω) with the group S_{n} of all permutations on [n] = {1, 2 …, 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 Ω = {1, 2 …, n}. Subgroups (and in general subsets) of Sym(Ω) will be usually denoted by capital letters A, G, H etc. We use the following notation which is standard in permutation group theory [22, 15]. Given 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 subset A ⊆ S_{n} and x ∈ Ω we use x^{A} to denote the set {x^{g}|g ∈ A}. In particular if A is a subgroup of S_{n}, x^{A} is the orbit of x under the action of A on Ω.

For a subset Δ of [n], let G_{Δ} denote the subgroup of G that fixes each element of Δ. In particular, 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 ⟨A⟩. We assume that subgroups of S_{n} are presented by generator sets. For a generator set A ⊆ S_{n}, each permutation ψ ∈ A is a list of n ordered pairs ⟨i, j⟩ ∈ [n] × [n].

For permutation groups G and H, the expression H ≤ G means that H is a subgroup of G (not necessarily a proper subgroup). 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 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 coset representatives of H in G.

As developed by Sims [20], 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 [20, 9]. 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. 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 (see e.g. [20, 9] for these and other results and [15, 11] for a comprehensive treatment).

Theorem 2.4

1. For each element i ∈ [n] the orbit of i, defined as {i^{g} | g ∈ G}, can be computed in polynomial time.

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

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}. Here, we use the standard lexicographic ordering of permutations in S_{n} given by the ordering of the set [n] = {1, 2, …, n}. This algorithm is a crucial ingredient in the proof of the main theorem in the next section.

Theorem 3.1 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 easy 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 be the tower of subgroups of G where, by Theorem 2.4, 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 do

let x := i + 1;

find the element y in x^{G^{(i)}} such that y^{π_{i}} is minimum;

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

end

Result: π_{n}

Algorithm 1: Lexicographically least in a Right Coset

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 3.2 For all 0 ≤ i < n − 1 the lexicographically least element of G^{(i)}π_{i} is in G^{(i+1)}π_{i+1}.

Proof of Claim. Let x^{H} denote the orbit of any point x ∈ [n] under the action of H ≤ S_{n}. 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}}. Hence π_{n} is the desired lex-least element of Gσ.

We can easily extend the above result to show the following.

Theorem 3.3 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σ.

Remark. The above theorem implies, in particular, that the lexicographically least element of a left coset τG can be computed in polynomial time.

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 [16] (see e.g. [14]) 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 polynomial-time 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:

To each instance ⟨x, 0^{n}⟩ of FIND-GROUP there is associated an unknown subgroup G_{x} ≤ S_{n} for which there is polynomial time membership test. More precisely, a polynomial-time function MEMB(x, g) is given, that takes x and g ∈ S_{n} as input and evaluates to true if and only if g ∈ G_{x}. The FIND-GROUP problem is to compute a strong generator set for G_{x} given ⟨x, 0^{n}⟩ as input.

Notice that AUTO is an example of the generic FIND-GROUP problem, as checking whether g ∈ S_{n} is an automorphism of a graph X on n nodes can be done in time polynomial in n.

Remark. The advantage of solving the generic problem FIND-GROUP is that it allows us to show at one stroke that several group-theoretic problems apart from GI are all in SPP. In particular, as a corollary to Theorem 4.1 we will show in the next section that the hidden subgroup problem (of interest in quantum computing) in the case of permutation groups is also in the class FPSPP.

Theorem 4.1 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. To this end we first define a language:

L = {⟨x, 0^{n}, S, i, j, π⟩ | π is a partial permutation that pointwise fixes 1, …, i − 1 and maps i to j, S ⊆ G_{x}, and ⟨S⟩ pointwise fixes [i], and ∃ g ∈ G_{x}^{(i−1)} such that i^{g} = j, lex−least(⟨S⟩g) and extends π}.

Here, we use lex−least(Hg) for a group H to denote the lexicographically least permutation in the coset Hg.

Partial permutation π is part of instance ⟨x, 0^{n}, S, i, j, π⟩, as we will be using L as oracle to do a prefix search for the lexicographically least g ∈ G^{(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^{(i)};

Guess g ∈ S_{n};

if g ∈ G^{(i−1)} and i^{g} = j and g extends π and g = lex−least(⟨S⟩g) then

ACCEPT ; end else

REJECT ; end

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 3.1 the lexicographically least element of ⟨S⟩g can be computed in polynomial time.

Claim 4.2 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⟩|}.

Proof of Claim. Suppose ⟨x, 0^{n}, S, i, j, π⟩ is in 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 only guessed element g ∈ S_{n} by the machine N that leads to acceptance corresponds to the unique lexicographically least element of ⟨S⟩g.

On the other hand, if ⟨S⟩ is a proper subgroup of G^{(i)} then we can easily see that 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 in a way that it will query L for some ⟨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 2.3 we can convert this algorithm to an FPSPP algorithm.

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 down to 1 do { 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 do π′ := π[i := 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 do

find the element l not in the range of π′ such that ⟨x, 0^{n}, D_{i}, i, j, π′[k := l]⟩ ∈ L; π′ := π′[k := l];

end

{ At this point π′ will be a permutation in S_{n}}

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

end

{ 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} end

Result: D_{0}

Algorithm 2: FP^{L} algorithm CONSTRUCT(⟨x, 0^{n}⟩)

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 4.2, 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 2.3 that FIND-GROUP has an FPSPP algorithm.

Remark. We note that there is alternative way to conceive of an FPSPP algorithm for the FIND-GROUP problem: 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 4.1. Since SPPSPP = SPP and SPP ⊆ Mod_{k}P for each k ≥ 2, the next corollary is an immediate consequence.

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

5 Hidden subgroup problem and other applications

We recall the general definition of the hidden subgroup problem.

Definition 5.1 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 factorization 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 [19], the above problem has efficient quantum algorithms for the case when G is an abelian group (see e.g. [17] 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. [10, 12]). 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 [8] 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 [8] that BQP ⊆ AWPP where AWPP is a language class that generalizes both BPP and LWPP.

Theorem 5.2 [8] BQP ⊆ AWPP and hence BQP is low for PP.

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

Theorem 5.3 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 Sketch. 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 4.1. The result now follows by invoking the algorithm described in the proof of Theorem 4.1. Lowness for PP also follows as SPP is low for PP.

5.1 Other applications

Using the FPSPP algorithm for the FIND-GROUP problem we can show that other algorithmic problems on permutation groups [15] which are not known to have polynomial-time algorithms are also in SPP. Among the different problems mentioned in [15] 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 [15].

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

Proof. We show that NORM is an example of the generic problem FIND-GROUP. The theorem will follow as a direct consequence of Theorem 4.1. 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 2.4.

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 polynomialtime many-one reducible to CONJ-GROUP are also in SPP.

6 Conclusion

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 tournements [3]. 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?

Babai and others, in a series of papers [5, 4, 2], developed a theory of black-box groups to study the complexity of group-theoretic problems in a general setting. The main results in [5, 4, 2] were to put these 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, 21], 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?

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. Bounded round interactive proofs in finite groups. SIAM journal of Discrete Mathematics, 5(1):88–111, February 1992.

[3] 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.

[4] 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.

[5] 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.

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

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

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

[9] 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.

[10] 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.

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

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

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

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

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

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

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

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

[19] 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.

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

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

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