Quantum query complexity of symmetric oracle problems.
Abstract
We study the query complexity of quantum learning problems in which the oracles form a group of unitary matrices. In the simplest case, one wishes to identify the oracle, and we find a description of the optimal success probability of a query quantum algorithm in terms of group characters. As an application, we show that queries are required to identify a random permutation in . More generally, suppose is a fixed subgroup of the group of oracles, and given access to an oracle sampled uniformly from , we want to learn which coset of the oracle belongs to. We call this problem coset identification and it generalizes a number of wellknown quantum algorithms including the BernsteinVazirani problem, the van Dam problem and finite field polynomial interpolation. We provide charactertheoretic formulas for the optimal success probability achieved by a query algorithm for this problem. One application involves the Heisenberg group and provides a family of problems depending on which require queries classically and only query quantumly.
1 Introduction
An oracle problem is a learning task in which a learner tries to determine some information by asking certain questions to a teacher, called an oracle. In our setting the learner is a quantum computer and the oracle is an unknown unitary operator acting on some subsystem of the computer. The computer asks questions by preparing states, subjecting them to the oracle, measuring the results, and finally making a guess about the hidden information. How many queries to the oracle are needed by the computer to guess the correct answer with high probability?
This paper addresses the following oracle problem. Fix a finite group and a subgroup . The elements of are encoded as unitary operators by some unitary representation . Given oracle access to (for some unknown ) the learner must guess which coset of the element lies in. We focus on average case success probability, though an easy averaging argument, given in Section 2, shows that the worst case and average case query complexity are equal.
We call this problem coset identification. This task encompasses many of previously studied qauntum oracle problems, including univariate and multivariate polynomial interpolation over a finite field [CvDHS16, CCH18], the group summation problem [MP14, Zha15, BBC01], and symmetric oracle discrimination [BCMP16]. In addition, the coset identification problem we study generalizes the homomorphism evaluation problem for abelian groups studied by Zhandry in [Zha15], which greatly inspired us. Section 7 gives details of this connection.
In this paper, we analyze the query complexity of the general coset identification problem. We prove that nonadaptive algorithms are optimal for any coset identification problem. We provide tools to reduce the analysis of query complexity to purely character theoretic questions (which are themselves often combinatorial). In particular we derive a formula for the exact quantum query complexity for coset identification in terms of characters. In the case of symmetric oracle discrimination (which itself includes polynomial interpolation as a special case) we find the lower and upper bound for bounded error query complexity.
Another motivation for our work is the study of nonabelian oracles. Much is known about quantum speedups when the oracle is a standard Boolean oracle. Less is known about whether oracle problems with nonabelian symmetries can offer notable speedups. To that end we study the follow scenario: suppose a group acts by permutations on a finite set (we call a set). A learner is given access to a machine which takes an element and returns for some hidden group element . With as few queries as possible the learner should guess the hidden element . The classical query complexity for this problem is a longknown invariant of sets called the base size. For instance, if is the full permutation group of then queries are required classically to determine the hidden permutation. This problem is a special case of symmetric oracle discrimination and we can express the bounded error quantum query complexity of this purely in terms of the character of the set . For instance, we find that when is the full permutation group of then queries are necessary (and sufficient) to determine the hidden element.
This result bears some similarity to other work on learning problems related to the symmetric group. Aaronson and Ambainis [AA14], who prove that at most a polynomial speedup can be achieved in computing functions on inputs which are invariant under the action of the full symmetric group (using a standard evaluation oracle). BenDavid [BD16] proves that at most a polynomial speedup is possible for Boolean functions defined on the full symmetric group. More recently, Dafni, Filmus, Lifshitz, Lindzay and Vinyals [DFL21] have studied the query complexity of Boolean functions defined on the symmetric group, again proving a polynomial relationship between the quantum and classical query complexities (as well as numerous other complexity measures). These results may be compared to the wellknown fact that only polynomial speedups are possible in computing total Boolean functions [BBC01], the idea being that learning problems on the full symmetric group correspond to total functions, while learning problems on a subgroup correspond to partial functions. All of the results mentioned above are not directly comparable to ours, since they use a standard evaluation oracle, while we examine a more symmetric “inplace” oracle model.
The task of oracle identification can be further refined: fix a group , a set , and a function which is constant on left cosets of some subgroup , and distinct on distinct cosets. The (left) coset identification problem is to determine given access to a permutational blackbox hiding through the action on . For instance, when (the symmetric group), its defining representation and the sign homomorphism, it requires classical queries to determine . As a counterpoint to the harsh lower bound above we provide a family of examples for this task parametrized by in which the quantum query complexity is while the classical complexity is . The groups we use are Heisenberg groups acting as small subgroups of the full permutation group. This example is a nonabelian analogue of the fact that good quantum speedups can be found in computing partial Boolean functions [BV97].
The paper is organized as follows. In section 2 we formalize coset identification in the context of quantum learning algorithms and review the notions of adaptive and nonadaptive learning. In section 3 we prove that parallel queries suffice to produce an optimal algorithm for this task. Section 4 applies this theorem to symmetric oracle discrimination and addresses numerous example problems. In section 5 we return to the general coset identification task and we prove the main theorem of this paper, Theorem 5.1, which is a formula for the success probability of an optimal query algorithm in terms of characters. We use this in section 6 to compute the exact and bounded error query complexity of some special examples (including the Heisenberg group example). We conclude in section 7 by explaining how our work reproduces several previously known results involving abelian oracles.
Our paper uses the language of representation theory of finite groups. A suitable reference is the first third of Serre’s textbook [Ser96]. We review some important notations later in Section 5 (in particular, the idea of induced representation is critical for the statement of our results.) Here we mention that a representation of a finite group always refers to a finite dimensional and unitary representation of over the complex numbers. In other words, a representation is a group homomorphism (the unitary group of a f.d. vector space ). We often think of as a left module for the group alegbra , and use the notation for when the map is clear from the context.
2 Quantum learning from oracles
A quantum or classical oracle problem is described by a set of hidden information , a function (the function to learn or compute), and a representation of as operations on inputs of some kind (which determines the oracles). Classically such a representation consists of a set of inputs and an assignment taking each to a permutation of , i.e. a map . A classical oracle problem is specified by a tuple . A classical computer has access to for some unknown by spending one query to input to learn . The goal is to determine with a high degree of certainty with as few queries as possible. More concretely, we measure the efficacy of an algorithm by its average case success probability, namely the probability of correctly outputting supposing the hidden information is sampled uniformly from . For the highly symmetric problems considered in this paper, this is the same as the worstcase success probability, as explained below.
The quantum representation of oracles is described by a Hilbert space and an assignment taking each to a unitary operator of , in other words a map . Thus a quantum oracle problem is specified by a tuple . The quantum computer spends one query to input a state to to acquire the state ; the goal is to produce a state and measurement scheme which outputs the value .
Any classical oracle problem determines a quantum oracle problem via linearization: oracles will act on the Hilbert space (spanned by the orthonormal basis ) by permutation matrices.
We note that there are other oracle models used to encode permutations. One possibility is to require an oracle to act on a bipartite system, with one subsystem specified to be the ‘‘input register” and the other a ‘‘response register”. ^{1}^{1}1More precisely, one usually defines an abelian group structure on (usually cyclic) by defining an operation on . Then the oracle hiding the permutation is defined to act by . Here , so both the input and response registers are copies of .
While we do not specifically consider this model here, we note that many oracle problems, such as polynomial interpolation and group summation, that are normally formulated in this tworegister setup do have an easy reformulation in our setup. Thus, our results and analyses apply to these problems in their original tworegister formulation. See Section 7.
However,
in some cases, the tworegister setup results in a set of oracles that do not form a group, for instance in the work of Ambainis on permutation inversion [Amb02]. In general, it is an interesting question (and to our knowledge, open) whether these oracle models are the same, or if they lead to different query complexities. ^{2}^{2}2As another modification, one may propose that having access to an oracle means an algorithm may choose to access or in any given query. This is a separate model which we do not consider here.
A symmetric oracle problem is an oracle problem in which the hidden information is a group (so we are replacing with ) and the map is a homomorphism in the classical case or in the quantum case. If is a homomorphism, then it is common practice to regard as a (left) module where is the group algebra of (spanned by an orthonormal basis sometimes written without kets as . In module notation we sometimes write (for ) if the representation is understood from context. The quantum oracle arising from a symmetric classical problem is also symmetric.
Of special interest to us is the case when the function to be learned is compatible with the group structure . An instance of the coset identification problem is a symmetric oracle problem where the function is constant on left cosets of a subgroup and distinct on distinct cosets. We also assume is onto. The typical example is when is the set of left cosets of and . An equivalent formulation is to say that is a transitive set and the map is a map of (left) sets (i.e., for all ). Then the subgroup can be recovered as the preimage of .
For our analysis of the coset identification problem, we focus on average case success probability. The symmetry of the problem implies that worst case and average case success probabilites are equal, as the following argument shows: provided an unknown oracle we can select uniformly at random and preprocess our input by applying . Then an optimal averagecase algorithm will return the coset containing with optimal averagecase success probability. The coset which contains can then be retrieved by applying . Hence it suffices to consider the average case success probability of any algorithm for this task (with the unknown oracle sampled uniformly from ).
We examine bounded error and exact measures of query complexity. The exact (or zero error) query complexity of a learning problem is the minimum number of queries needed by an algorithm to compute with zero probability of error. The bounded error query complexity is the minimum number of queries needed by an algorithm to compute with probability . The bounded error query complexity is often studied for a family of problems growing with a parameter and so changing the constant above to any number strictly greater than will only change the query complexity by a constant factor mostly ignored in asymptotic analysis.
Broadly speaking, there are two qualitatively different approaches to solving an oracle problem. The first approach is to ask questions one at a time, carefully changing your questions as you receive more information. This is called using adaptive queries. The other approach is to prepare all your questions and ask them at once in one go (imagining the learner has access to multiple copies of the teacher). This is known as using nonadaptive, or parallel queries.
Classically the adaptive model is at least as strong as the nonadaptive model, since you can convert any nonadaptive algorithm into an adaptive one (by picking your questions in advance but asking them one at a time). This is wellknown to be true also in the quantum setting. In the next section we will prove the converse for coset identification:
Theorem 2.1.
Suppose describes an instance of coset identification. Then there exists a query quantum algorithm to determine with probability if and only if there exists a query nonadaptive query algorithm which does the same.
This theorem is certainly not true for arbitrary learning problems: Grover’s algorithm provides an example in which any optimal algorithm must use adaptive queries [Zal99]. To prove the theorem we must precisely state what adaptive and nonadaptive algorithms are.
2.1 Adaptive vs. nonadaptive: definitions
Recall that a quantum learning problem is described by a tuple where indexes the set of hidden information, is a finite dimensional Hilbert space, a representation of the unknown information by unitary operators, and is the function to learn.
The standard model for an adaptive algorithm is as follows (see e.g. [BBC01, Section 3.2]):
A query adaptive quantum algorithm for the quantum oracle problem consists of a tuple where

is the dimension of the auxiliary workspace used in the computation

is a unit vector in

is a set of unitary operators acting on

is a POVM with measurement outcomes indexed by .
The algorithm uses queries to the oracle (with sampled uniformly from ) to produce the output state
upon which the algorithm executes the measurement described by . Here and elsewhere denotes the identity operator (in this case acting on the space ).
In quantum circuit notation the preparation of the state reads:
By contrast, an algorithm is nonadaptive if at any point during the algorithm, the input for some query does not depend on the results to any of the previous queries. Essentially this means that all the inputs are completely determined before the algorithm begins. Classically, nonadaptive queries are identical to simultaneous queries to copies of an oracle. This motivates the following definition (cf [Mon10, Section 2]):
A query nonadaptive quantum algorithm for the oracle problem is a tuple where

is the dimension of the auxiliary register.

is the input state, a unit vector of .

is a POVM indexed by .
The algorithm operates on the input state to produce
which is then measured using the POVM . The next fact is very useful and follows immediately from definitions.
Lemma 2.2.
A query nonadaptive algorithm for the problem is the same as a singlequery nonadaptive algorithm for the oracle problem .
The quantum circuit notation for the nonadaptive preparation of the state is drawn as follows.
In either model, the algorithm uses copies of the unitary to produce a state . Using the POVM results in a measurement value with probability
Since we assume the oracle is sampled uniformly from , the probability that executes successfully is
2.2 Symmetric oracle problems
Suppose we have a symmetric oracle problem . As mentioned in the introduction, since we are focusing on query complexity and not on issues of implementation, analysis of this problem depends only on the character of , as we prove in the lemma below. In fact, a little more is true. Let denote the set of irreducible characters of . Given a representation define the set
Here we are using to denote the usual inner product of characters. If and we say that appears in the representation .
Lemma 2.3.
The optimal success probability of a query algorithm to solve a symmetric oracle problem depends only on and .
Proof.
First, note that if is a Hilbert space isomorphism then we can define a new oracle problem where the oracles now act on . Any query algorithm to solve the original problem can be “conjugated” by (e.g. the input state becomes and the nonoracle unitaries and POVM are conjugated by ) to produce a query algorithm for the new problem which succeeds with the same probability. Conversely any algorithm to solve the new problem can be conjugated by to solve the old problem with the same probability. Therefore oracle problems with isomorphic unitary representations of will have the same query optimal success probability. In other words, only the character is relevant.
Second, we claim that the multiplicities of irreducible characters in are not important; only whether they appear in or not. Indeed, adding a dimensional workspace to a computer’s original system produces a new representation of with character . Since we allow our algorithm to introduce any such workspace, we are in effect allowing it to increase the multiplicity of each character by a factor of . Note that this process will never produce irreps which did not appear in to begin with. Hence the optimal success probability depends only on which irreps appear in , i.e. the set . ∎
It makes sense that if an algorithm is granted access to more representations to work with, its success probability cannot decrease. To be more precise, fix , and let denote the optimal success probability of a query algorithm for the symmetric oracle problem .
Lemma 2.4.
Suppose , are representations of on the spaces and , with . Then
Proof.
The basic idea is any query algorithm to solve can be extended to produce a query algorithm for . Suppose an algorithm for uses an dimensional ancilla space, i.e. operates on . Since , there exists some so that contains a subrepresentation isomorphic to . Hence we can write where as modules. Now we claim the initial state, intermediate unitaries, and POVM for the algorithm can be extended to an algorithm acting on . The initial state for is the vector in corresponding to the initial state for in . The intermediate unitaries for act on according to the unitaries for the algorithm and are extended arbitrarily to . The measurement operators for all agree with the measurement operators for on and all but one of the operators act as on the subspace . To satisfy the completeness relation on , exactly one of the POVMs should act as the identity on (this modification is unimportant since “takes place” entirely within ). The success probability of is equal to that of . ∎
3 Parallel queries suffice
Here we prove Theorem 2.1, namely that the optimal success probability for coset identification can be attained by a parallel (nonadaptive) algorithm. We prove this by showing that any query adaptive algorithm can be converted to a query nonadaptive algorithm without affecting the success probability. Another way to say this is that every query adaptive algorithm can be simulated by a query nonadaptive one. This technique is greatly inspired by the work of Zhandry [Zha15] who proves this result when is abelian, and also bears resemblance to the lower bound technique of Childs, van Dam, Hung and Shparlinski [CvDHS16], where the special case of polynomial interpolation is addressed.
Let be a unitary representation of . Let denote the group algebra of . Each acts on by left multiplication, an operator we denote . We will use the controlled multiplication operator ([DBCW02]) defined on by
This defines a unitary operator and is a generalization of the standard CNOT gate (take and ). As such we draw it using circuit diagrams as in fig. 1.
There are two actions on we use, one given by and the other . Our first observation is that intertwines these actions.
Lemma 3.1.
The controlled multiplication operator satisfies
The proof follows by applying both sides to a vector and using the definition of . The representation obtained by letting each act by the identity on is a direct sum of many copies of the trivial reprseentation, so we denote it . The lemma allows us to interpret as a module isomorphism . In pictures the lemma reads:
The next property is crucial for our parallelization argument. Recall that if is a module then denotes the set of irreducible characters of which appear in .
Lemma 3.2.
Suppose is a subrepresentation of . Then there is a subrepresentation of such that the image of under is contained in and satisfies .
Proof.
By Lemma 3.1 is a module isomorphism where and have the same underlying vector space. Let denote the image of under . Then restricts to a module isomorphism . Next let be the submodule of which contains each irreducible of with maximal multiplicity (so if appears in then appears with multiplicity ). Now as modules so in particular . Hence also .
It remains to prove . Indeed, in the module the subspace is the maximal subrepresentation containing only irreducibles in . As noted contains only irreducibles in so therefore , which is the same vector space as . ∎
Now suppose is an instance of coset identification and is a query adaptive algorithm to evaluate the homomorphism . First, by replacing with if necessary, we may assume that the algorithm does not use a workspace, that is . We will describe a new adaptive algorithm which is a modification of as follows. We introduce a new workspace which is a copy of . The new intermediate unitaries are . The input state is where is the equal superposition state in . When the oracle is hiding the unitary this produces the following state:
Next measurement is performed: first the second register is measured in the standard basis of . Then the original POVM is applied to the first register. The result of these two measurements will be a pair ; the final output of the algorithm is . ^{3}^{3}3Formally the algorithm is given by
Lemma 3.3.
The algorithm succeeds with the same success probability as .
Lemma 3.4.
The algorithm can be simulated by a query parallel query algorithm.
Proof of Theorem 2.1 from Lemmas 3.3 and 3.4.
By the two lemmas, given any query adaptive algorithm which solves coset identification with probability , there exists a query parallel query algorithm which succeeds with the same probability. ∎
Proof of Lemma 3.3.
Consider the premeasurement state for given that the hidden group element is . It can be written
If the first measurement reads then the state collapses to . If the second measurement is now performed, the result will read with the same probability that the algorithm would read this result given that the oracle was hiding . The algorithm then classically converts the result to which is equal to since is a left set map. So the following conditional probabilities are equal:
Denote these probabilities by and respectively. Since the probability that the first measurement of reads is for all and is sampled independently of , we compute the average case success probability by
∎
Proof of Lemma 3.4.
We rewrite the premeasurement state of expressed by Figure 3 using Lemma 3.1. Denote the state that results when the hidden element is by . We apply Lemma 3.1 diagrammatically from left to right:
In the last step, in addition to applying Lemma 3.1 at the right of the diagram, we used the fact that . In formulas we have
Therefore we have converted this algorithm to a singlequery algorithm using the oracle with initial state where .
Claim. The image of under is contained in where is a submodule satisfying .
This is readily proved by induction and Lemma 3.2. For instance, by Lemma 3.2 the image of under is contained in where is a submodule with . The next part of is which sends to itself. Now another is applied and by Lemma 3.2 this sends to where .
Therefore the inital state belongs to the subspace , which means that the algorithm may be simulated by a single query algorithm to the oracle acting on the subspace . Note that the irreducibles appearing in this subspace are . Hence Lemma 2.3 implies there exists a singlequery algorithm using the representation which achieves the same success probability as . As noted in Lemma 2.2 this is the same as a query parallel algorithm using the representation . This concludes the proof of Lemma 3.4. ∎
Corollary 3.5.
The optimal query success probability for an algorithm solving an instance of coset identification is equal to the optimal singlequery success probability achievable solving the instance . ∎
4 Application to symmetric oracle identification
Symmetric oracle discrimination is the following task: given oracle access to a symmetric oracle hiding a group element , determine exactly. This is the special case of coset identification in which . Thus an instance of this problem is determined by a finite group and a (finitedim) unitary representation . The following theorem computes the success probability of a singlequery algorithm and is proved by Bucicovschi, Copeland, Meyer and Pommersheim:
Theorem 4.1.
([BCMP16], Theorem 1) Suppose is a finite group and a unitary representation of . Then an optimal singlequery algorithm to solve symmetric oracle discrimination succeeds with probability
where
The result of the previous section tells us that parallel algorithms are optimal for symmetric oracle discrimination.
Theorem 4.2.
Suppose is a finite group and a unitary representation of . Then an optimal query algorithm to solve symmetric oracle discrimination succeeds with probability
where
Proof.
To express the exact and bounded error query complexity of symmetric oracle discrimination we’re compelled to make the following definitions.
Let denote a module. The quantum base size, denoted , is the minimum for which every irrep of appears in . If no such exists then . The bounded error quantum base size, denoted is the minimum for which
If is a case of symmetric oracle discrimination then by Theorem 4.2 the number of queries needed to produce a probability algorithm is . That is, the exact quantum query complexity of the problem is equal to the quantum base size of . Similarly the bounded error query complexity is .
It may happen that one of these quantities is infinite. However when is a faithful representation then a classical result attributed to Brauer and Burnside ([Isa76], Theorem 4.3) guarantees that every irrep of appears in one of the tensor powers where is the number of distinct values of the character of . If contains a copy of the trivial representation, then we can say that every irrep of is contained in some tensor power for some . Hence in this case (with faithful and containing a copy of the trivial irrep) both and are finite.
In particular, this occurs whenever we “quantize” a classical symmetric oracle discrimination problem. This is the learning problem specified by a finite set and a homomorphism . A query to an oracle hiding consists of inputting and receiving . The learner must determine the hidden group element (or permutation) . The quantized learning problem uses the homomorphism sending elements of to permutation matrices. (Such a representation is called a permutation representation.) Then the quantized learning problem is faithful if the original problem is faithful and the module contains a copy of the trivial representation, namely .
This is precisely the situation we would like to study because we can compare the classical and quantum query complexity. Classically the exact and bounded error query complexities are equal, since if a classical algorithm does not use enough queries to identify the hidden permutation with certainty then it must make a guess between at least equally likely permutations which behave the same on all the queries that were used, resulting in a success rate of at most .

Suppose hosts the defining permutation representation of . Then queries are required to determine a hidden permutation .

If we take the same action but restrict the group to then we need queries to determine a hidden element .

Consider the action of the dihedral group on the set of vertices of an gon. Then queries are required to determine a hidden group element.
In general the classical query complexity is a wellknown invariant of a permutation group denoted called the minimal base size or just base size of [LS:02]. It may be defined to be the length of the smallest tuple with the property that if and only if . From the definition it is clear that the base size agrees with the nonadaptive classical query complexity of the problem. In fact, it is also equal to the adaptive query complexity, since if a sequence of adaptive guesses suffices to identify a particular hidden , then the same sequence of guesses works for every element of the group. This means any optimal algorithm may be implemented nonadaptively. Thus the classical query complexity of symmetric oracle discrimination of is the base size of and the quantum exact (bounded error) query complexity is the (bounded error) quantum base size. We are naturally led to a broad group theoretic problem:
Question. What are the relationships between and ?
We are not aware of any direct comparison of these quantities in the group theory literature. Here we only compute the various quantities for some special cases. We saw earlier that . We will prove
Theorem 4.3.
Let denote the quantum base sizes for acting on . Then

queries are necessary and sufficient for exact learning.

queries are necessary and sufficient to succeed with probability .

In fact, for any , queries are necessary and sufficient to succeed with probability .
Proof.
Recall that the irreducible characters of are parametrized by partitions of which can be written either as a sequnce or as a Young diagram with total boxes and boxes in the th row. Let denote the module corresponding to the defining permutation representation of . Then decomposes as a sum of two irreducibles:
We note that is the trivial representation. A wellknown rule says that if is a simple representation corresponding to the Young diagram then the irreps appearing in
where is the set of Young diagrams obtained from by adding then removing a box from lambda. In particular, this shows by induction that
We see that queries are required until every irreducible is contained in (in particular, the sign representation corresponding to the partition is not included in unless ). This proves part (1) of the theorem.
To prove part (2) we must examine more closely the set consisting of all partitions with at least columns (i.e. . We are interested in the sum
It is well known that if is an irrep corresponding to the Young diagram then is equal to the number of standard tableaux of shape ([Sag01], Theorem 2.5.2). Hence is equal to the number of pairs of standard tableaux of shape . Now by the RobinsonSchensted correspondence, the sum above is equal to the number of sequences of the numbers whose longest increasing subsequence is at least (see e.g. [Sag01], Theorem 3.3.2). Next, a deep result of Baik, Deift and Johannson [BDJ99] identifies the distribution of the , the length of the longest increasing subsequence of a random permutation of elements, as the TracyWidom distribution (which also governs the largest eigenvalue of a random Hermitian matrix) of mean and standard deviation . In particular, Theorem 1.1 of [BDJ99] asserts that if is the cumulative distribution function for the TracyWidom distribution, then
Let be any real number. If we use queries, then our success probability will be
Thus for any , if we wish to succeed with probability , it will be necessary and sufficient to use queries, where (for sufficiently large). ∎
Here is the analogous result for identifying an element of the alternating group.
Theorem 4.4.
Consider the standard action of acting on . Then the quantum base sizes are given as follows.

are necessary for exact learning.

are necessary and sufficient to succeed with probability . In fact, for any , are necessary and sufficient to succeed with probability .
Proof.
Recall the following facts about the representation theory of . The conjugate of a partition is the partition obtained by swapping the rows and columns of ; in other words where the number of boxes in the th column of . For each partition of that is not selfconjugate, i.e. , the restriction of to is an irreducible representation of . Also, . For self conjugate , the representation breaks up into two distinct irreducible representations and of equal dimension.
Recall from the previous proof that after queries, we get copies of all the such that . Observe that for any partition , we must have either or . (If both fail, the partition fits into a square of side length , which contains fewer than boxes.) It follows that after queries, for any , we have picked up a copy of or . Hence we have every irreducible representation of . Therefore, queries suffice for exact learning. Showing that that fewer queries cannot suffice is similar. Here we make the observation that there exists a partition such that and , since boxes can be packed into a square of side length . It follows that queries do not pick up the or for such . Thus, we do not get every irrep of .
We now examine the bounded error case. For a positive integer , let be the success probability of the optimal query algorithm for identifying a permutation of and let be the corresponding probability for .
Let denote the fold tensor power of the defining representation of . We can decompose as a direct sum of irreps of and if we know which appear we can determine which irreps of appear in . In particular, each time we have a nonselfconjugate such that appears in , we will have appearing in . Let’s consider the contribution of this appearance to the success probability and , which is the square of the dimension divided by the order of the group. Since the dimension of equals the dimension of , while the order of is twice the order of , the contribution to is twice the contribution to .
Now if is selfconjugate then decomposes into two irreps of of equal dimensions. The sum of the squares of these two irreps is thus onehalf the square of the dimension of . Once we’ve divided by the sizes of the groups, we see that the contribution to is equal to the contribution to .
We have thus seen that for any the contribution to is either 2 or 1 times the contribution to . It follows that
Thus for we must have , which as we showed in Theorem 4.3 requires queries. On the other hand, if we are given queries, we achieve , which forces . ∎
The two theorems above show that there is very little speedup possible when trying to identify a permutation from the symmetric group or the alternating group. For the alternating group, one can at least get by with fewer queries for exact quantum learning. Here there is an analogy to Van Dam’s problem of exactly learning the value of an long bitstring using queries to its bits [van98]. Exact learning requires queries. However, if we are guaranteed in advance that the parity of the string is even, then only queries are required for exact learning. To see this using the techniques of the current paper, we argue as follows. Let be the subgroup consisting of all strings of even parity. If we are allowed queries, then we can access those representations of corresponding to strings of Hamming weight less than or equal to (see also the remarks in Section 7.3). If is the bitwise complement of , then and take the same values on . Now, for any string , one of and will have Hamming weight less than or equal to . Hence every representation of can be accessed by queries to the oracle, and we will succeed with probability 1.
5 Query complexity of coset identification
In this section we derive a formula for the optimal success probability of a query algorithm to solve coset identification. In light of our previous result on parallelizability (Corollary 3.5), this boils down to finding a formula in the singlequery case. This will directly generalize the singlequery results of [BCMP16] used in Section 4.
To state the result we fix some notation. Suppose is an instance of coset identification with the preimage of . Given an representation let denote the induced representation of (which is a representation of ; see Section 5.1.1 below for more details.) Likewise if is a module then we denote by the module obtained by restriction to . Recall that if is a module then denotes the set of all irreducible characters of appearing in . We sometimes use the notation to emphasize which group we are considering. Finally, given two representations and we let
Thus denotes the sum of all the isotypical components of which correspond to an irreducible isotype appearing in . We will be interested in the quantities
which can be understood as the fraction of which is shared with .
Theorem 5.1.
An optimal singlequery algorithm to solve the instance of coset identification succeeds with probability
In words: to find the optimal success probability, you look at an irrep of which appears in . Then you examine the fraction of which is shared with . Finally take the maximum over all irreps appearing in .
From this theorem we can quickly deduce Theorem 4.2, the singlequery result for symmetric oracle identification. This is the special case when is the trivial group. Then has only one irrep, namely the trivial representation , and is isomorphic to . Hence the formula we get from Theorem 5.1 is
which is the formula of Theorem 4.2.
The next two sections are devoted to the proof of Theorem 5.1. First we prove the lower bound (i.e. existence of a state and measurement achieving the desired success probability) and then we prove the upper bound (optimality of that success probability).
5.1 The lower bound
First we collect some facts concerning induced representations and averaging operators needed for the proof of Theorem 5.1. A fine treatment of the subject is contained in Serre’s book [Ser96].
5.1.1 Induced Representations
Suppose is a subgroup of a finite group and let denote a representation of . Note that admits a right action. The representation of induced from is
When and are understood we simply write . Similarly if is a representation of then it is also a representation of , called the restriction of to . We denote it by or simply .
From the definition of induced representations, we can write
where ranges over a set of coset representatives for . Conversely, if a representation of contains an invariant subspace such that
where again ranges over a set of coset representatives for , then is isomorphic to as representations.
In our situation all representations are unitary. In particular if is a unitary representation of then is equipped with the inner product determined by requiring the subspaces to be pairwise orthogonal, and translating the inner product of to each subspace . With this inner product is a unitary representation of . We will often denote the orthogonal projection onto by . Then the orthogonal projection onto is , and we have .
5.1.2 Averaging operators
Given a module we can define the averaging operator, which turns an arbitrary linear map into a invariant one:
Note that commutes with every so that indeed is invariant, i.e. . If is a invariant operator then . The map is tracepreserving, so in particular if is a projection then is nonzero, since it has nonzero trace. If contains only a single isotype of irrep, i.e. for some irrep then is closely related to the partial trace with respect to the subspace :
(1) 
5.1.3 Proof of the lower bound
Before giving the proof of the lower bound in Theorem 5.1 we prove a preliminary proposition.
If is a algebra over , an module and a linear subspace, we let denote the submodule of generated by (i.e. the smallest submodule containing the subspace ). Similarly for we let denote the subspace .
Proposition 5.2.
Suppose is an irreducible unitary representation of (a subgroup of ). Also suppose is a subrepresentation of . Let denote orthogonal projection onto . Then there exists a unit vector such that
Remark. In Proposition 5.7 we will prove this is an upper bound for over all unit vectors .
Proof.
Let denote the invariant orthogonal projection onto . Since is irreducible, is a minimal idempotent in . Therefore, since also belongs to , we know is a scalar times . In turn this implies is a scalar multiple of an orthogonal projection, since it is selfadjoint and
The image of is an invariant subspace of which is either or isomorphic to . Let this subspace be , so we have
(2) 
for some nonzero scalar . We will also use the fact that
(3) 
which results from Eq. (2) by multiplying the equation by on the left and right. Next, we claim that is not zero (so it is in fact isomorphic to as an module). Indeed, we have
where the sum is over a set of coset representatives of . This shows that is nonzero. In particular we have . We can now compute the scalar via