A Quantum Algorithm Detecting Concentrated Maps

We consider an arbitrary mapping f: {0, …, N − 1} → {0, …, N − 1} for N = 2n, n some number of quantum bits. Using N calls to a classical oracle evaluating f(x) and an N-bit memory, it is possible to determine whether f(x) is one-to-one. For some radian angle 0 ≤ θ ≤ π/2, we say f(x) is θ − concentrated if and only if e2πif(x)/N⊂ei[ψ0−θ,ψ0+θ] for some given ψ0 and any 0 ≤ x ≤ N − 1. We present a quantum algorithm that distinguishes a θ-concentrated f(x) from a one-to-one f(x) in O(1) calls to a quantum oracle function Uf with high probability. For 0 < θ < 0.3301 rad, the quantum algorithm outperforms random (classical) evaluation of the function testing for dispersed values (on average). Maximal outperformance occurs at θ=12sin−11π≈0.1620 rad.


Introduction
In recent years, much progress has been made in the study of quantum computation [1,2]. The first algorithm arguing for computational speed-up due to quantum mechanics was discovered in 1985 [3]. Deutsch considered a mapping with two inputs and two outputs. An oracle, which one might think of as a classical black-box, evaluates functions of a bit by inputting b ∈ {0, 1} and outputting f(b) ∈ {0, 1}. Two calls to such an oracle are required to learn whether f is one-toone. The calls compute f(0) and f (1), and then the oneto-one property holds when the values are distinct. Since quantum mechanics is linear, a quantum function evaluator (quantum oracle) must act on superpositions of states. (1) A single call to this quantum oracle allows one to determine whether f(0) and f (1) are distinct [2, pg.36]. Several years later, Deutsch and Jozsa generalized the algorithm to allow for multiple inputs and two outputs [4]. Specifically, they describe a multi-argument function as balanced if its image holds two elements and the preimage of each is the same size. Deutsch and Jozsa's algorithm then distinguishes between a constant and balanced function using a single quantum oracle call. Further generalizations [5] distinguish between functions which are constant or else map onto an evenly spaced subset of the unit circle {|z| = 1}.
We present a variant of such algorithms. Specifically, suppose that we have a function f : {0, 1, 2, ..., N -1} , n some number of quantum bits. Using N calls to a classical oracle evaluating f(x) and an N-bit memory, it is possible to determine whether f(x) is one-to-one. For some radian angle 0 ≤ θ ≤ π/2, we say f(x) is θ -concentrated if and only if e 2πif(x)/N ⊂ e i[ψ 0 -θ,ψ 0 +θ] for some given ψ 0 and any 0 ≤ x ≤ N -1. We present a quantum algorithm that distinguishes a θ-concentrated f(x) from a one-to-one f(x) in O(1) calls to a quantum oracle function U f with high probability. For 0 < θ < 0.3301 rad, the quantum algorithm outperforms random (classical) evaluation of the function testing for dispersed values (on average). Maximal outperformance occurs at θ = sin .., N -1}, where N = 2 n for n some (integer) number of qubits, so that the n-qubit state space is N dimensional [2]. Let ω = e 2π/N be the (2 n )th root of unity, and choose ψ 0 ∈ [0, 2π). We say such an f(x) is θ -concentrated about ψ 0 if and only if (2) We say f(x) is θ-concentrated if and only if there exists a ψ 0 so that (2) holds. Using N -1 bits and N evaluations of the function (classical oracle calls), we may determine with certainty whether f(x) is one-to-one. Suppose instead one has a quantum oracle U f encoding an f(x) which is known to be either constant or concentrated. We here present an algorithm which uses O (1) calls to U f to distinguish between these cases, with arbitrarily high probability.
To describe U f , we briefly review quantum data spaces [2,6]. The state of a string of quantum bits is encoded as a vector in a complex Hilbert space, say |ψ〉 ∈ H. For qubit-states, the usual convention is that the one-qubit state space is H 1 = span C {|0〉, |1〉}, where this basis is Hermitian orthonormal. The n-qubit state space is then the N = 2 n tensor (Kronecker) product The abbreviation |b 1 b 2 ...b n 〉 for |b 1 〉 ⊗ |b 2 〉 ⊗···⊗ |b n 〉 is typical, and the Hermitian inner product is that induced by the tensor structure. At times, we further abbreviate the bit-string b 1 b 2 ...b n within the ket by the associated integer, i.e., the binary expansion. Explicit description of the oracle also makes it simpler to take 2n to be our number of quantum bits. We then refer to a first register and a second register, according to the tensor decomposition H 2n = H n ⊗ H n .
Given this, the conventions for the quantum oracle box are as following. The oracle U f effects a unitary transformation of H 2n which linearly extends (4) where y ⊕ f(x) denotes y + f(x) mod N and the tensor symbols have been suppressed. Our quantum algorithm then requires O(1) calls to U f and O(n 2 ) two-qubit gates otherwise to distinguish with probability arbitrarily close to one between the cases Hence the quantum algorithm in this sense outperforms a classical device using O(N) classical oracle calls to determine whether f(x) is one-to-one with certainty. However, consider instead a probabilistic classical computer, capable of evaluating f(x) on a given random x, 0 ≤ x ≤ N -1. With a single oracle call, such a classical probabilistic computer is likely to detect f(x) is not θ-concentrated with probability 1 -. Hence f(x) is one-to-one, by hypothesis. Making use of a single quantum oracle call, our quantum algorithm identifies any one-to-one function with certainty, and it correctly identifies a θ-concentrated f(x) with probability cos 2 θ. Taking f(x) one-to-one or θ-concentrated, each with probability , further demonstrates that the quantum algorithm outperforms the classical probabilistic algorithm on average for 0 < θ < 0.3301 rad, with maximal quantum outperformance at θ = sin -1 ≈ 0.1620 rad.
To determine whether f(x) is one-to-one, proceed as follows. We suppose a classical oracle capable of evaluating f(x) and a memory block of size N bits.
Initialize each memory bit to 0 for (j=0; j<= N-1; ++j) Moreover, note that there can not exist any oraclebased algorithm which determines whether f(x) is oneto-one while only using N -1 or fewer calls to the classical oracle which evaluates f(x).
Since the quantum algorithm will only decide between the one-to-one and θ-concentrated cases with probability very close to one, we also consider competitive probabilistic classical algorithms. For simplicity, suppose now f(x) is either one-to-one or θ-concentrated about 0, i.e., ψ 0 = 0 in (2). Given a random number generator, the following algorithm is immediate: The probabilistic algorithm fails if and only if f(x) is one-to-one and yet ω f(x) ∈ exp(i[-θ, θ]), roughly with probability 1 -for n large.

A Quantum Variant of Deutsch-Jozsa
The following algorithm exploits a quantum oracle U f per Eq. (4). It requires two quantum registers, each n bits long.
2. Let ω = e 2πi/N , for N = 2 n . As is well-known [2], there is a quantum circuit, polynomial in size in n, which implements the quantum Fourier transform map: F : H n → H n linearly extending |y〉 ω yz |z〉. Apply F to the second register, for |Φ〉 2 = F|N -1〉 = ω -z |z〉.
3. Recall the one-qubit Hadamard gate given by H = (-1) jk | j〉 〈k|. Then apply H ⊗n to the first register, with the result that (5) Thus the first register now holds an equal superposition of all states. As preparation for the next step, we also note the full data state: 4. We next apply the quantum oracle U f . The result is (7) Note that a single call to U f implicitly uses every value of f(x) for a state in full superposition, such as |Φ 1 〉.

5.
We reindex a sum in the last equation as follows. For fixed x = x 0 , label z = y -f(x 0 ). Then ω -y |y ⊕ f(x 0 )〉 = ω z+f (x 0 ) |z〉. As this is true for all x 0 , we have The next step is to disregard the known data |Φ 2 〉 in the second register.
We briefly comment on the quantum computational resources consumed. Besides the 2n-qubits, O(n) local computations and two n-qubit Fourier transforms are required. The latter require O(n 2 ) gates [1].

Comparison of Quantum to Classical
We finally compare the probabilistic classical algorithm with the quantum algorithm above, allowing each a single oracle call. For simplicity we suppose ψ 0 = 0 in (2); this hypothesis favors the classical algorithm. Also for simplicity, we suppose f(x) is equally likely to be either concentrated or one-to-one.
Thus f(x) is either one-to-one (event O) or θ-concentrated (event C) with probability . Suppose the classical probabilistic algorithm makes one oracle call and then guesses f(x) is concentrated if ω f (x) lies within the sector exp(i[-θ, θ]) and one-to-one else. If f(x) is θconcentrated, then the classical algorithm makes a correct guess (event G C ). In the one-to-one case, the probability of a correct guess is approximately 1 -. So If multiple oracle calls are allowed, it will help to recall x from previous trials and force the oracle to evaluate new values. However, as N = 2 n is expected to be large, this is a minor consideration, and 1 -is approximately the probability of making a correct guess after l-trials.
In contrast, consider the quantum algorithm. It guesses f(x) is concentrated if |00 ··· 0〉 is observed and guesses one-to-one else. Thus, in contrast to the classical algorithm, the quantum algorithm never fails if f(x) is one-to-one. If f(x) is concentrated, then the quantum guess is correct with probability of at least cos 2 θ. Thus Thus the appropriate comparison of the probabilistic and quantum algorithms might be quantified by the difference Prob(G Q )-Prob(G C ), i.e., the quantum approach is preferable for those θ with cos 2 θ ≥ 1 -, i.e., sin 2 θ ≥ . The maximum difference occurs at θ = 0.1620 rad, while applying Newton's method to sin 2 θshows that the quantum approach is preferable given 0 < θ < 0.3301 rad. The right boundary of the interval is approximate.