Fault-ignorant Quantum Search

We investigate the problem of quantum searching on a noisy quantum computer. Taking a 'fault-ignorant' approach, we analyze quantum algorithms that solve the task for various different noise strengths, which are possibly unknown beforehand. We prove lower bounds on the runtime of such algorithms and thereby find that the quadratic speedup is necessarily lost (in our noise models). However, for low but constant noise levels the algorithms we provide (based on Grover's algorithm) still outperform the best noiseless classical search algorithm.


I. INTRODUCTION
Since the inception of quantum computing [1], a large effort has been devoted to making quantum computers function in a noisy environment and securing them against imperfections in the physical setup itself. The theoretical literature offers several ways to cope with such errors. The leading idea is to encode quantum states into a larger system [2,3] such that noise hits can be recognized and subsequently corrected. A quantum computation can then be performed in a fault-tolerant way directly on these encoding systems [4,5], and nested levels of error-correction can make the computation errorfree. The last statement assumes that the initial error rate is not too high and that the error hits are not too correlated, e.g. occur locally. Beyond these assumptions, quantum error-correction schemes require significant resources in terms of circuit size and experimental control [6]. Other approaches use decoherence-free subspaces, employing for the quantum computation those parts of a system's Hilbert space which are relatively unaffected by the noise [7,8]. The latter approach works only in more limited circumstances and requires detailed knowledge of the noise.
Here, we follow a different idea which tries to avoid the disadvantages just mentioned. Rather than devoting large efforts to eliminating the errors at all costs, we accept them in the computation and try to design algorithms that eventually still find the desired result. The spatial size of the quantum circuit should however not be enlarged much beyond the noiseless version of the algorithm.
Furthermore, the algorithms should find the desired result under any level of background noisethis level may actually be unknown to the algorithm, hence the term fault-ignorant computation. The algorithm is, however, allowed to take more time the larger the actual noise gets. In this sense, we are trading spatial resources (circuit size) for temporal resources (runtime). Still, when the actual noise level is low (but constant in the problem size), we want our algorithms to produce the desired result faster than any classical algorithm even in a noiseless environment -this indeed will be the case for the explicit algorithms we present.
While under noise the resulting algorithms may not give the full quantum speedup for large problem sizes, they may still be useful for initial realizations of quantum computers that we may possess (small sizes, non-scalable).
In this paper, we analyze the above fault-ignorant idea for the example of quantum search on a noisy quantum computer. The unstructured search problem, i.e. the search for a marked item in an unordered list with oracle access, can be solved on a noiseless quantum computer by Grover's algorithm quadratically faster than by any classical algorithm [1,9]. This quantum speedup is optimal [10][11][12].
Good algorithms or optimality issues for the noisy case are however much less clear. Many studies in this direction investigate how (different models of) background noise or a faulty oracle affect specifically Grover's algorithm (e.g. [13][14][15][16][17][18]), and it is often found that the quadratic speedup persists as long as the noise stays below a certain threshold depending on the database size. Only the paper [19] by Regev and Schiff gives, for a specific model of a faulty oracle, a general lower bound on the number of oracle invocations necessary to find the marked item by any quantum algorithm. A concrete algorithm that functions under a faulty oracle is briefly suggested in [18], advocating the avoidance of active error correction as well, as we do.
In this paper, we address the strengths and weaknesses of general oracular search algorithms under noise in more detail, in particular giving explicit constants in the runtimes. On the one hand we give fault-ignorant algorithms, on the other we investigate their optimality. More detailed comparisons to the works [18,19] are made in Section III C. The Hilbert space in our setup consists of a search space, possibly supplemented by an ancillary system, both suffering from noise (our constructive algorithms will actually not use such an ancillary system, which we however allow in the proofs of our lower bounds and which makes them stronger). Additionally, the algorithms may have access to a noiseless classical memory, which is a technologically realistic assumption. The noise itself is modelled as discrete hits of some noise channel that is to be applied between any two oracle invocations.
The problem is then as follows: Devise a quantum algorithm that, except for some specified maximal failure probability ε, returns the marked item under any decoherence rate p, using as few oracle calls as possible. The fastest (noiseless) classical algorithm needs (1 − ε)N table lookups for this task, examining the database entries one by one. We exhibit quantum algorithms which, under low but constant depolarizing level p, require fewer oracle calls than this classical algorithm.
The paper is organized as follows. In Sec. II we introduce quantum search in the presence of decoherence, and bit by bit develop a fault-ignorant algorithm (Algorithm 1) that consists of "quantum building blocks" and uses the noiseless classical memory merely to store the marked item in case of a previous successful round. A matching lower bound on the runtime of such algorithms is given by Theorem 2. We expand this analysis in Sec. III and allow for a noiseless classical memory that can store all previously falsified items, which enhances search efficiency (Algorithm 2). In Appendix A we give a possible mathematical and general formalization of fault-ignorant algorithms, which encompasses the search algorithms from the main part of the paper and allows to formulate other problems in this setting as well. In Appendix B we discuss in more detail the noise models for which our results from the main text apply.

A. Setup: Noiseless and noisy quantum search
The quantum search problem [1,10] asks for an algorithm of short runtime to identify (up to some small error probability ε) one out of N oracles, i.e. to return the index x of the "black box" implementing the unitary transformation where x ∈ {1, . . . , N } and ⊕ denotes addition modulo 2. Here, we assume the oracle x to have been chosen uniformly at random (often referred to as unstructured database). It is customary to take the input of the oracle O x at each step to be |ϕ ⊗ 1 √ 2 (|0 − |1 ) so that the output is also of this form with the sign of the coefficient of |x flipped in the first tensor factor. In this case one can neglect the second subsystem and concentrate on the effective unitary transformation As usual, we measure the runtime of an algorithm by counting the number of queries (oracle uses), which are viewed as the expensive or time-consuming operations, and disregard all the other quantum channels which are independent of the oracle. Grover [9] found a solution to this problem which makes use of the equal superposition state |ψ ≡ 1 √ N N x=1 |x -this state reflects the initial lack of knowledge about the oracle and will be used frequently in the following. At the beginning of the algorithm the state |ψ is prepared and then the oracle black box O x and the unitary I − 2|ψ ψ| are applied alternately. (In this description, and in our whole paper, we disregard any subsystem structure of C N ; if, for example, C N = (C 2 ) ⊗n , then the "inversion about the mean" I − 2|ψ ψ| can be implemented efficiently in the number n of qubits [1,9]). After k applications of both operators, a von Neumann measurement is performed in the standard basis. The outcome of this measurement will give the correct index x of the oracle with probability [1] independently of which oracle x ∈ {1, . . . , N } was implemented by the black box. In particular, if we choose k = π 4 √ N , the success probability is 1 − O(N −1/2 ). Alternatively, if we fix some small maximal error probability ε ∼ > N −1/2 , with which the algorithm may return an incorrect oracle index, then we may stop after k = 1 4 √ N arccos(2ε − 1) iterations. In fact, it can be shown, for any 0 ≤ k < π 4 √ N , that Grover's algorithm yields the highest probability of success which can be achieved by any quantum algorithm using the oracle k times [12].
The above analysis is valid when the unitaries and measurements etc. can be implemented perfectly and the quantum computer is not subject to noise. In more realistic settings, however, these idealizations have to be lifted, and some such extensions have been considered in the literature before, cf. Section I. In this work, we consider the specific case where the quantum computer is continually affected by noise, e.g. coming from the environment.
Our aim is not to approach this problem by implementing quantum error correction, which may be expensive in terms of the required control and size of the quantum computer. Rather, we aim to find (optimal) algorithms which succeed even under the influence of -known, or ideally even unknownnoise, in such a way that their runtime may depend on the noise level.
Throughout this paper the term "noise" will mean the application of a certain quantum channel to the state of the quantum register in discrete time steps. This is supposed to model, within the discrete-time setting of oracle algorithms, that the quantum computer is continually affected by noise. More precisely, we will impose that the noise channel has to act once between any two invocations of the oracle.
Our paradigmatic example of noise will be the family of partial depolarizing channels acting on states on a d-dimensional Hilbert space. We can interpret these channels as acting on the system with D p=1 iff a biased coin toss yields head (with probability p ∈ [0, 1]), and otherwise leaving the quantum computer unaltered. Intuitively speaking, the partially depolarizing noise (4) discards the whole quantum register with probability p between any two oracle invocations. In particular, quantum error correction cannot be applied to this noise model (cf. Appendix B). Even more so, it will serve to illustrate our idea of faultignorant computing, one of whose rationals actually is to avoid costly error correction procedures.
In Appendix B we will further introduce partially dephasing noise (B2), which can also be regarded as modelling the transitioning from quantum to classical algorithms, and relate the different noise models. For now, we shall use partial depolarizing (4) to derive lower bounds on the number of oracle calls needed in different scenarios. On the other hand, to prove the functioning of our algorithms, it will even suffice to assume a noise channel of the form D p ( ) := pT ( ) + (1 − p) where T is an arbitrary quantum channel.

B. Building block for noisy search algorithms
Let us see how the probability of a successful measurement, i.e. returning the correct oracle index x, looks when we include an application of the noise channel after each query. As a preparation, we first consider Grover's algorithm under noise. Introducing the channel G † , the final state can be written as (D p G x ) k (|ψ ψ|), so that the success probability is then where we took an average over the N possible oracles, since the search is unstructured and we assume equal a priori probabilities. In this paper, we choose to consider the average success probability of algorithms, i.e. averaged over all possible oracles with equal weight (see e.g. [12]), as opposed to the minimal success probability, i.e. minimized over all oracles (e.g. [1,11]). Both figures of merit agree for "symmetric algorithms", e.g. for Grover's algorithm [12] and for the constructive algorithms we propose in this paper. But our choice makes the lower bounds derived below on the required number of oracle invocations stronger. Now, for the above noise models D p = pD 1 + (1 − p) id, the evolution (D p G x ) k can be written as a sum of 2 k histories. Since each term gives a positive contribution to the sum, we can find a lower bound by keeping only the noise-free term (1 − p) id in each factor: which is quite sharp unless kp 1, cf. Appendix B; compare this also to noiseless case, Eq. (3). (The convention 0 0 = 1 is understood throughout this paper.) We are now interested in how well this simple algorithm, and other algorithms that we shall consider below (i.e. not necessarily consisting of Grover steps), perform. That is, we would now like to derive upper bounds on the success probability p s depending on N , k, and p. As the starting point we use the implicit bound on p s derived by Zalka [12] for the average success probability p s after k oracle calls: This bound has been established in [12] for the following situation: We start from any pure state |φ ∈ C K ; the oracle O x (1 ≤ x ≤ N ) inverts the coefficients of the basis states within a subset S x ⊆ {1, . . . , K} where S x ∩ S y = ∅ for x = y; we let arbitrary unitaries U 1 , . . . , U k ∈ C K×K act after each oracle use; in the end we perform a von Neumann measurement in some basis, and our guess for x is an arbitrary function of the measurement outcome. The same bound (7) holds thus when we start from any mixed state over C N ⊗ C M (M ≥ 1), apply arbitrary channels between the oracle uses, and our guess for x comes from measuring a POVM (E x ) N x=1 . This holds because mixed states, quantum channels and POVM measurements can be dilated to pure states, unitary evolutions and von Neumann measurements on a larger system [1], and the oracles (2) tensored by the identity on all other subsystems still invert coefficients of disjoint sets of basis states.
Even for the more general algorithms described above, we can thus use Lemma 1 (see Appendix D) and inequality (7), to prove the following explicit upper bound on the average success probability p s of any quantum algorithm using k oracle calls (with or without noise): Now we are ready to prove a result on the limitations of algorithms using a noisy quantum register C N ⊗ C M for computation, with the oracle acting on the first subsystem. Here D p stands for the partial depolarizing channel (4) with noise parameter p ∈ [0, 1], acting on the combined system: Theorem 1 (Bound on success probability of building block). Let 0 ∈ B(C N ⊗C M ) be the initial state of the algorithm, O x : B(C N ⊗C M ) → B(C N ⊗C M ) defined by O x (|y y |⊗σ) = (−1) δxy+δ xy |y y |⊗σ be the quantum channels implementing the oracles on the first subsystem, and D p the partially depolarizing noise that is to be applied between any two oracle calls (p ∈ [0, 1]). Let T 1 , T 1 , T 2 , T 2 , . . . , T k , T k : B(C N ⊗C M ) → B(C N ⊗ C M ) denote steps in the algorithm, such that the state after k uses of the oracle O x is and let the final measurement be given by the POVM (E y ) N y=1 . Then the average success probability of this algorithm is upper bounded as follows: and FIG. 1: Algorithm 0, performing k steps of quantum search. Noise is acting between any two oracle invocations Ox (see Eq. (2)), before and after which one may however apply arbitrary channels Ti, T i . The computation uses a quantum register of dimension N , on which the oracle acts, and an ancillary (quantum) register C M , both noisy. A measurement, described by some POVM (Ey), is applied to the final state x k to guess the marked element x.
Proof. For partially depolarizing noise D p ( ) = pτ Tr( ) + (1 − p) towards some state τ , e.g. τ = I N ⊗ I M /N M , introduce the following states: and hence As the "computation" of σ x i involved i oracle calls, from (8) we have x Tr[σ x i E x ] ≤ (2i + 1) 2 , and thus which trivially leads to (10). Furthermore, we can use (1 − p) k ≥ 1 − kp by the Bernoulli inequality to obtain (11): In the following text we shall address a sequence of operations as in (9) acting on an initial state 0 as Algorithm 0 (or Alg 0 ), which is also depicted in Fig. 1.
It is worthwhile to mention two ways of using these results: (i) one can consider the noise level p to be fixed and examine the scaling behaviour with respect to the number N of search items, or (ii) one can consider p to scale in some way with N .
Point (ii) provides a way to compare the results with other works (e.g. [18]) where this kind of scaling was analyzed. Our results, however, apply to any values of N and p (and later, of ε) in the stated ranges, but we are implicitly often imagining the case N → ∞, p = const (and ε = const), which is a sensible limit as explained in Appendix B. Theorem 1 has two important implications. The first is that, for any fixed p > 0, the growth of the success probability is at most linear in the number k of queries, as opposed to the quadratic growth in the noiseless case (cf. (3) for k π 4 √ N ). This may come as a surprise as one might have guessed that the quadratic speedup of Grover's algorithm may persist for small enough noise levels p > 0 (i.e. fixed p and N → ∞). In other words, Theorem 1 says that there exists no algorithm with success probability p s ∼ k 2 whenever partial depolarizing acts. The lower bound (11) in particular implies that quantum error correction cannot be done for partially depolarizing noise D p .
The second implication is that the success probability is bounded by 1 N + 8 N p 2 independently of k, cf. (10). For growing N → ∞, this goes to 0 unless p = O(N −1/2 ); in general we cannot reach a prescribed success probabilty 1 − ε with an algorithm as described in Theorem 1. The straightforward solution to this problem is that we repeat the algorithm (including the final measurement) until the probability of failure in all the repetitions combined drops below ε. This strategy is detailed in the following subsection and shows the basic structure for all further algorithms. C. Search algorithm by repeating the basic building block -known noise level p Now we consider algorithms that consist of a number of repetitions (rounds) of the basic building block described in the previous subsection: repeatedly preparing states like (9), using the oracle O x a number of times, and trying to infer the oracle index x by a measurement. In our concrete constructions we shall, as in Grover's algorithm [1,9], specify the channels T i in (9) to perform unitary inversions (I − 2|ψ ψ|) about the mean, and T i to equal the identity channel (whereas for our lower bounds T i , T i remain arbitrary).
Note that these repetitions require a noiseless classical memory in order to reliably store the correct result x after one of the rounds has been successful (any noisy classical register may be part of the subsystem C M in Theorem 1 and is subject to noise D p ). Furthermore, in order to test whether the measurement after any one of the repetitions has returned the correct index x and in order not to overwrite the correct result in subsequent rounds, one needs to perform a verification of the measurement outcome -using one oracle call or classical table look-up -immediately after each measurement.
In this subsection we will first develop and analyze an algorithm that finds, except for some specified failure probability ε > 0, the marked element x among N elements, on a noisy quantum computer. Secondly, we will prove (Theorem 2) that, up to a constant, the runtime of this algorithm is optimal among a certain class of algorithms, when the noise level p is known in advance.
Our algorithm will consist of m rounds of the procedure described in Theorem 1, each time checking whether the concluding measurement gave the correct x and, if so, storing the result in a noiseless classical register. Specifically, in each round we perform Grover's algorithm for some number k (to be determined) of steps -this has been described at the beginning of Subsection II B. We now first give a motivating "derivation" of the algorithm.
Clearly, the events "the noise did not hit and the measurement was unsuccessful in the ith round" and "the noise did not hit and the measurement was unsuccessful in the jth round" are independent for i = j when we use Grover iterations, and similarly for more than two rounds, since Grover's algorithm is symmetric with respect to permutation of the oracles (the probability for the complement of each such event is given by (6), which we will substitute below for 1 − p s ). This means that if we perform m rounds with k Grover iterations in each round, then the probability of failure and the total number of queries will be (1 − p s (N, k, p)) m and (k + 1)m, respectively (including the verification step after each of the m measurements). If we are to reach the target error bound ε in the least number of steps, we need to minimize (k + 1)m subject to the condition (1 − p s (N, k, p)) m ≤ ε. The latter gives a lower bound on m depending on N , k and p, namely This means that for given values of N and p one needs to minimize i.e. the number of queries per decrease of error probability by a factor of e, where the factor N −1 is included for normalization. Let the optimal k be denoted by k opt (N, p). Note that minimizing the rate function R from (18) originates from minimizing the number of oracle calls from independent rounds to get the failure probability below ε. This is different than optimizing the expected number of oracle calls, cf. [11,12] for a comparison.
Then our new algorithm consists of m = (log ε) /log (1 − p s (N, k opt (N, p), p)) repetitions of rounds with k opt (N, p) Grover steps each, measurement in the standard basis plus verification step and storing the result in the classical output register when successful. The discussion in the following example will motivate an easy-to-compute quantity to be used instead of k opt (N, p).
Example 1 (Asymptotically optimal number of Grover iterations). If we are interested in large databases, we can simplify by taking N → ∞, yielding, with (6) instead of (B5) (giving virtually identical results): To find the optimal k = k opt (∞, p), we compare (k ≥ 1): This is a decreasing function of p, so R(∞, k − 1, p) and R(∞, k, p) intersect at which is appropriate for large k, and we have k(∞, p) = k whenever p k+1 (∞) < p ≤ p k (∞) with the convention p 0 (∞) := 1. By inverting the series expansion around k = ∞ one can get an explicit approximate expression for k opt (∞, p): the inverse is 1 p + O(p), and thus k opt (∞, p) ≈ 1 p is a good approximation especially for small p. Intuitively, this behaviour can be understood by saying that the quantum register remains undisturbed for time ∼ 1/p on average, so that ∼ 1/p Grover steps provide an advantage (see also, e.g., [18]). Plugging k = 1 and considering small noise level p 1, we see so R(∞, k opt (∞, p), p) vanishes linearly in p around p = 0. The fact that this is non-zero and finite for p > 0, means that the normalization by 1/N in (18) was the "correct" one. This suggests that the number of steps m(k + 1) necessary is proportional to N p log(1/ε), i.e. linear in N for any fixed p > 0 and ε ∈ (0, 1), meaning that the quadratic speedup is lost under depolarizing noise (4); see also Theorem 2.
Example 1 motivates a more rigorous analysis of the case of finite N < ∞. In this finite case, one has to be careful for small values of p, since it is clearly not a good idea to do more than π 4 √ N Grover iterations in one round. Let us first assume that p > 4 π 1 √ N , and suppose we perform m = cN p 2 log ε −1 rounds with k = 1 p Grover steps in each round, for some c > 0 (this ansatz is motivated by Example 4, and will below turn out to be good). Then the probability of failing in all rounds can be bounded as (see 6) for some 0 < δ ≤ 1 − 4/π 2 depending on N and p.
As we want to guarantee a failing probability of at most ε, we need to choose c such that the exponent in the final expression (23) is at least 1 -independently of p for the following statements to be valid. However, for large values of p the exponent goes to 0, which is a consequence of vanishing (6) for large p and k = 1 p ≥ 1 Grover steps; this can be avoided by introducing a cutoff p * ∈ (0, 1) into the specification of the algorithm, such that for p ≥ p * we use k = 0 iterations in each round, i.e. only perform verification steps on randomly chosen elements. The failure probability in this range is Numerically one finds that viable values for c and p * in the specification of a concrete algorithm, i.e. such that both (23) and (24) do not exceed ε, are, for example, c = 5 and p * = 1/2 (even when setting δ = 1 − 4/π 2 ). We have not optimized these constants, as our main interest is in the scaling for large N , small ε, and all noise levels p. The number of oracle invocations during such an algorithm is upper bounded by where we used p > 4 N Grover iterations in each of the m rounds, i.e. before each measurement, which gives a success probability of at least roughly e −βπ/4 by the lower bound (6); therefore, m = e βπ/4 log 1 ε ≤ e log 1 ε rounds are sufficient to get the failure probability below ε, putting an upper bound on the number of oracle calls similar to (25) with a term proportional to ∼ √ N log(1/ε) instead of the term ∼ N p log(1/ε). Summing up, our algorithm finds the marked element x, except with probability ε ∈ (0, 1], on a quantum computer with noise level p ∈ [0, 1] using the oracle at most times, e.g. for (non-optimal) constants c 1 = 2, c 2 = 10. We omit here a formal statement of the algorithm, which should have become resonably clear from the description above, but will remedy this in Subsection II D for the more general case of unknown noise level. We would like to point out that there are at least two different interpretations of these complexity results. Firstly, one can run the algorithm indefinitely long (i.e. without any a priori bound on the number of rounds) until the marked element is found. Then we can guarantee that the algorithm gives the correct result with probability 1, and the number of oracle calls required is at most ∼ √ N +(N p+ √ N ) log 1 ε except with probability ε. Alternatively, one can decide in advance to use the oracle times before terminating the above algorithm, and after any successful measurement store the result in a classical memory; then, in the end, the marked element will have been found with probability at least 1 − ε.
With the runtime bound (26), one can look at the case where p is fixed and independent of N (allowing for asymptotic scaling N → ∞). Then we see that, unless p = 0, the leading term is ∼ N p log(1/ε), proportional to N . On the other hand, if we suppose p scales with N , the other terms may dominate. In Next we show that our algorithm presented above is essentially optimal within a certain class of algorithms (a wider class of algorithms will be considered in Section III). Namely, we assume that the algorithms employ a quantum register C N ⊗ C M (as above in Theorem 1), consist of several "rounds" where in each round we prepare some state, apply arbitrary channels and use the oracle an arbitrary number of times (possibly different for each round, but applying the noise channel between any two consecutive queries), do any measurement yielding an element of {1, . . . , N }, and verify the result with one oracle use, writing it into a (noiseless) classical register reserved for storing the output if correct. Crucially, we assume that the events of success in each round are independent of each other. This assumption is valid in particular if the noise is symmetric (under permutations of the basis vectors |x of C N , which partial depolarizing (4) satisfies) and the steps between measurements are Grover iterations (as for example in our algorithm above).
Theorem 2 (Lower runtime bound on memoryless algorithms). Consider a sequence of algorithms, one for each size of the search space N = 1, 2, 3, . . ., satisfying these assumptions. If the success probabilities are 1 − ε N , then, asymptotically, the number of queries q N in the N th algorithm is lower bounded by the level p ∈ [0, 1] of depolarizing noise: Proof. Suppose that the N th algorithm consists of m N rounds with k 1 N , . . . , k m N queries in each round (abbreviating m ≡ m N ), with failure probability ε i N in the ith round. Then q N = (k 1 N +1)+. . .+(k m N +1), and by the independence condition which is a weighted average of expressions of type k+1 N log(1/ε(N,k,p)) . Lower-bounding this expression thus automatically lower-bounds (28), and therefore it is enough to consider the m = 1 case only.
Since, by (10) Theorem 2 shows that, under any nonzero noise p > 0 (and ε ∈ (0, 1)), our algorithm from above has asymptotically optimal runtime, up to a constant factor: In our algorithm, ε N ≡ ε was chosen independent of N and (26) shows that asymptotically q N ∼ < 10N p log(1/ε), which matches (27) up to a factor of 80. In the noiseless case p = 0, our algorithm reduces to repeated Grover searches, whose optimality for p = 0 was shown in [10][11][12].
One other implication is noteworthy: On one hand, Theorem 2 says that, at positive noise p > 0 and asymptotically for N → ∞, the number of oracle queries ∼ > N p log(1/ε) has to grow at least linearly in N , so that the quadratic speed of noiseless Grover search is lost (at least for the class of algorithms considered above, and for the depolarizing noise model). On the other hand, however, the prefactor in this linear growth is O(p), and this is actually achieved by the algorithm above, cf. (26); thus, for small enough noise p, the number of oracle calls to solve the search task by a quantum algorithm is much less than the minimal number ∼ N (1 − ε) of oracle calls required by any classical algorithm, even in a noiseless environment.
In the following subsection, we will extend the algorithm so that it works in a noisy environment even when its noise level p is not known beforehand (Algorithm 1 and Theorem 3).

D. Fault-ignorant search composed from basic building blocks
We are now ready to turn to the "fault-ignorant" setting -the algorithm should be ignorant of the actual noise level under which the quantum computer operates. More precisely, the goal is to find an algorithm for which not the ability to give the correct result depends on the level of noise, but rather only its runtime may depend on the actual noise level. Actually, the algorithm described in the previous subsection has this property for any fixed number k of oracle calls per round; however, the runtime can then become large unless k ≈ k opt (N, p). For example, if we choose k ≈ π 4 √ N in order to get a quadratic speedup for p = 0, then for p ≈ 1 the number of oracle calls grows as fast as N 3/2 , which is clearly unsatisfactory.
In order to overcome this problem we allow the number of queries to change from round to round. Thus, for each N and ε, we need to find a sequence k 1 (N, ε), k 2 (N, ε), . . ., where k i (N, ε) denotes the number of Grover iterations performed in the ith round. Again, for our constructive algorithm, we employ the usual Grover iterations; and again, Theorem 2 will later show that this algorithm is nearly optimal.
One idea can be as follows. In the first round, we do a Grover search with k 1 (N, ε) := k opt (N, 0) ≈ π 4 √ N oracle calls (for the definition of k opt see below (18)). For N ∼ > ε −2 this is enough to get the error Grover steps plus one verification step each. Each round starts by preparing the equal superposition state ψ, which is follwed by Grover steps (a special case of Algorithm 0, see Fig. 1), and a measurement in the computational basis; finally, the output is checked against the oracle (possibly by list look-up) and, in case of success, stored (by Vx) in a noiseless classical register with N states, so that the result is ready for readout by an external agent (the algorithm may however continue). No ancillary system C M is used by the algorithm (M = 1).
probability below ε as long as p = 0; the set p ∈ [0, 1] p s (N, k opt (N, 0), p) > 1 − ε is open and therefore exists and is larger than 0 (if the set is empty, e.g. when ε N −1/2 , we set the infimum to p 2 := 0). Suppose that the measurement after the first round fails to find the marked element x. There are now two possibilities: either the actual noise level was below p 2 , in which case the probability of this failure was at most ε (i.e. as required); or the actual noise level exceeded p 2 , in which case the function k opt gives an upper bound on the optimal number of Grover iterations to perform in the next round, so we set k 2 (N, ε) := k opt (N, p 2 ). We then proceed similarly by iteratively setting (N, k j , p)) ≥ ε and k i := k opt (N, p i ), giving the number of Grover iterations to be performed in the ith round.
The sequences {k i } i obtained this way are difficult to analyze, but by examining the results of numerical simulations for various values of N and ε one can get an idea about their behaviour. This turns out to be enough to get an approximation which still achieves the asymptotically optimal performance, up to a multiplicative factor in the runtime (see below). Specifically, we arrive at the following algorithm (see also (31) Repeat the following steps for g = 0, 1, 2, . . .: 1. prepare the equal superposition state |ψ = 1 √ N N x=1 |x on a quantum register C N , 3. measure in the standard basis, verify the result using one oracle invocation; if correct then store in classical output register.
The following theorem proves that Algorithm 1 is fault-ignorant, i.e. finds the marked element independently of the actual noise level (in particular, the algorithm does not need p as an input), and gives a bound on its runtime which, however, depends on the actual noise level.
Theorem 3 (Fault-ignorance of Algorithm 1). Let p ∈ [0, 1] be the actual noise level (of partial depolarizing or dephasing) acting on the quantum register when executing Algorithm 1, and let N ≥ 100 and ε ∈ (0, 1/2]. Then Algorithm 1, with c = 10, finds the marked element after at most oracle queries except with probability at most ε. If one wants Algorithm 1 to be fault-ignorant only for noise levels p ∈ [0, 0.1], and if one presupposes reasonable values N ≥ 1000 and ε ∈ (0, 0.1], then one can guarantee the constant prefactor to be 20 instead of 100 as in (32), when using c = 4.5; cf. Appendix C.
As the proof of Theorem 3 is rather technical, we present here only a sketch; for details, see Appendix C.
Sketch of the proof. As the noise acts symmetrically with respect to the different oracles and since the Grover steps of Algorithm 1 are symmetric as well, the success events for different rounds g are independent, so that we will be able to upper bound the failure probability after round g * : When the sum g * g=0 in the last expression is greater than log(1/ε) then we can guarantee the failure probability to be at most ε, as desired. To get the statement about the number of oracle calls, we upper bound it by The proof of Theorem 3 now consists in showing that there exists a number g * (of rounds) such that the failure probability (33) is at most ε, while the number of oracle calls (34) is at most (32). Similar to our analysis leading up to (26), this argument will be split into three different cases: for p ≤ π/(4 √ N ) the first few rounds (g = 0, 1, 2, . . .) are the important ones; for p ≥ 0.3 we take into account only the rounds with k g = 0 (i.e. large g); and for π/(4 √ N ) ≤ p ≤ 0.3 our proof relies on an intermediate regime of g. Details are given in Appendix C.
Theorem 2 actually shows that the runtime of Algorithm 1 (which we just proved to be at most Eq. (32)) is optimal up to a constant: To see this, note that Algorithm 1 is contained in the class of algorithms to which the bound from Theorem 2 on the number of oracle queries q N ∼ > 1 8 N p log 1 ε applies. For any fixed noise level p > 0 and up to a constant factor, this equals the upper bound (32) on the number of queries needed by Algorithm 1. In particular, even if one does not know the actual noise level in advance, one only loses a constant factor in the number of queries, compared to the case of known p.
We re-emphasize here the last point from Subsection II C, that for small enough noise levels p, the quantum Algorithm 1 needs fewer oracle calls than even the best classical algorithm in a noiseless environment.
As the runtime depends on an unknown parameter, it is necessary to have the ability to stop the algorithm as soon as the result is found. Theorem 3 then states a "probabilistic bound" on the number of oracle uses up to the point when the element is found; this bound is probabilistic in the sense that in a fraction of at most ε of all runs of Algorithm 1, the actual runtime may exceed this bound.
When considering more general algorithms, namely for which the events of failure in different rounds are not independent, the derivation of the lower bound on the necessary number of queries from Theorem 2 is no longer valid. This dependency can arise either from asymmetric noise or from an asymmetry in the algorithm itself. Indeed, it is useful to consider such "asymmetric algorithms": already classically one can find the marked element using N (1 − ε) queries, except with error probability ε, by simply testing a subset of N (1 − ε) elements using one oracle call each. This feature of not considering previously falsified items again is absent from Algorithm 1 whose runtime may therefore exceed that of classical search, through the factor log(1/ε) in Theorem 2.
The algorithms considered in Section III will make use of this asymmetry, which can also be conceived of as conditioning the actions in future rounds on previous measurement outcomes that are being stored in a classical memory. This will be done by incorporating a noiseless classical memory which we will allow the algorithms to use in a limited way, namely by excluding oracle indices that have been falsified in previous rounds.

A. Search with exclusion
Classical search can find the marked element with maximal failure probability ε in at most N (1 − ε) steps by excluding falsified oracle indices. Here we aim to achieve an upper bound of N on the runtime -independently of ε and of p -for our quantum algorithms as well, whereas in Section II we have only presented algorithms whose runtime may exceed N parametrically due to the factor log(1/ε), e.g. in (32).
On a quantum computer a random choice may be implemented by preparing the equal superposition state |ψ over a subset of basis states followed by a measurement in that basis. This in turn can be viewed as a Grover search with zero iterations (cf. Subsection II A). This leads to the idea of replacing the uniform random choices by proper Grover searches (each including several steps plus a concluding measurement) over decreasing subsets, i.e. {1, . . . , N }\{i 1 , . . . , i m } after round m . For this, the classical noiseless memory that previously stored only the search outcome, will be exanded by a register of 2 N states (N bits) to mark the previously excluded items.
We shall now develop and sketch a search algorithm based on this idea of excluding previously tested elements; the following procedure is applicable if the noise level p is known beforehand. If one fixes the number N of database entries, the noise parameter p and the target error bound ε, then the question is how to choose the number of iterations in each round in order to consume the least number of queries. Suppose that in the ith round we perform k i queries and we do m rounds in total. Then the number of queries is m i=1 (k i + 1), while the probability of not finding the marked element is m i=1 (1 − p s (N − i + 1, k i , p)); so the minimal number of queries for which one can guarantee success (up to failure probability ε) in the general noise model is In following subsection we simplify the above algorithm, based on typical behaviour of the sequences {k i } i found in numerical experiments.

B. Fault-ignorant quantum search with exclusion
In this subsection we present a more explicit algorithm to solve the search problem in the fault-ignorant setting, i.e. an algorithm which can be specified and works even for unknown noise level p, using the exclusion to obtain faster runtime (cf. also (36) Repeat the following steps for g = 0, 1, 2, . . .: 1. prepare the equal superposition state ψ g over the set S g , 2. perform k g Grover iterations (with I − 2|ψ g ψ g | as reflection), where 3. measure in the standard basis, verify the result r g using one oracle invocation, store if correct, Similarly as Theorem 3 for Algorithm 1, the following theorem proves fault-ignorance of Algorithm 2 and provides a bound on its runtime: Theorem 4 (Fault-ignorance of Algorithm 2). Let p ∈ [0, 1] be the actual noise level (of partial depolarizing or dephasing) acting on the quantum register when executing Algorithm 2, and let N ≥ 100 and ε ∈ (0, 1/2]. Then Algorithm 2, with c = 10, finds the marked element after at most oracle queries except with probability at most ε. Proof. The success probability in each round of Algorithm 2 is at least as large as in Algorithm 1 because we are excluding elements; thus, the runtime of Algorithm 1 puts an upper bound on the runtime by (32). Before that, however, Algorithm 3 may switch to testing (and excluding) elements in random order (the second selector in (37)); this switch happens after at most (1 − ε)N + (π/4) √ N + 1 oracle calls, and after the switch Algorithm 2 needs at most (1 − ε)N + 1 additional calls to find the marked element except with probability ε.
The constant 100 in (38) can be improved to 20 for a restricted range of parameters, following the remark below Theorem 3.
Again, similar to Theorem 2, we can show that, despite restricting to Grover's specific steps, Algorithm 2 is essentially optimal within a wider class of algorithms. Namely, we extend the class of algorithms considered in and before Theorem 2 in such a way that, instead of requiring independence of the failure probabilites in different rounds, we assume that after each unsuccesful round we exclude the tested element and thereby reduce the search space as well as the state space of the computation. We also need to ensure that failure probabilities are multiplicative, which is the case e.g. if both the noise and the algorithm treat the search elements uniformly (this in particular applies to Grover iterations and partial depolarizing noise).
A priori, this wider class of algorithms is qualitatively different from the algorithms considered in Theorem 2, as it now contains algorithms succeeding with (1 − ε)N ≤ N oracle calls, independently of p, for example the classical verification-and-exclusion algorithm described above. This is reflected in the fact that the lower bound in the following theorem never exceeds N , unlike the bounds on q N in the memoryless setting from Theorem 2.
Theorem 5 (Lower runtime bound on exclusion algorithms). For any quantum search algorithm (that may or may not have the noise level p as an input) satisfying the above constraints and whose quantum register is subject to depolarizing noise with fixed strength p ∈ (0, 1), the number q N of queries to find the marked element up to fixed failure probability ε ∈ (0, 1) is lower bounded as for some sequence C N = C N (ε, p) with lim N →∞ C N = 1.
Proof. We can assume that lim sup N →∞ q N /N ≤ 1 − ε, because there does exist an algorithm with this limit being 1 − ε (see above). For now, fix N , and by letting N → ∞ later, we will make sure that all following expressions are well-defined (e.g. no logarithms of negative arguments occur, etc.). Let the number of queries in round g (0 ≤ g ≤ r) be k g + 1 (i.e. including the verification-exclusion step), so r < q N = r g=0 (k g + 1). For the success probabilty in round g we have by (10) and (11) where the latter inequality implies that h(p, k) is bounded independently of k (and of N ), since p is given. Thus we can lower bound the failure probability (using log where we used g ≤ r ≤ q N from above and defined C N : , which converges to 1 as N → ∞. Inverting (41) to get an explicit bound on q N finally gives (39).
In summary, Algorithm 2, which uses the exclusion strategy and Grover iterations, is fault-ignorant and Theorem 4 provides an upper bound on its runtime. Conversely, Theorem 5 provides a lower bound on the number of oracles calls for any symmetric fault-ignorant algorithm using the exclusion strategy. And the inequalities from Lemma 2 (see Appendix D) show that Algorithm 2 is basically optimal within this class of algorithms, in the sense that for any p, ε ∈ (0, 1) its runtime is at most a constant factor (independent of p and ε) above the lower bound from Theorem 5.
And even stronger, the lower bound on the runtime in Theorem 5 is proven for algorithms that may "know" the noise level p as one of their inputs (such as the algorithm resulting from (35)), whereas our Algorithm 2 basically saturates this lower bound without actually being dependent on the actual noise level p; the latter feature is the characteristic of fault-ignorant algorithms. Thus, not knowing the noise level inflicting upon the quantum computation extends the runtime at most by a constant factor, which was observed in the memoryless setting following Theorem 3 as well.
C. Our search algorithms, and comparision to other work [18,19] In Section II we did not allow for a classical memory (except to store the correct output), whereas in Section III we allowed a noiseless classical register in order to exclude falsified items from future search rounds. This is obviously not the most general class of algorithms. One may for example perform nonprojective measurements which could result in a non-uniform distribution over oracles (cf. [20]) after the measurement. Or one may abandon the division into "rounds" altogether, and rather use the noisy quantum register and noiseless classical memory in a more general way (cf. Appendix A). While these possibilities are rather vague, at least in the noiseless case (p = 0) Grover's algorithm is exactly optimal [12]. A similar general proof eludes us in the noisy case considered in this paper; Theorems 2 and 5 give such a bound under more restrictive qualifications.
Nevertheless, the results obtained here may suggest that any nonzero noise level p > 0 (in our noise models, cf. Appendix B) prolongs the runtime beyond the noiseless lower bound (in [12]), necessitating it to be proportional to the number of search items as N → ∞. However, for small but constant noise level p > 0, the runtime bound ∼ < N p log(1/ε) on our algorithms (cf. Theorems 3 and 4) can be far below the N (1 − ε) oracle calls required by the best noiseless classical algorithm. In this regard, see [21] for a treatment of locally acting noise and questions about optimality in this case.
Similar in spirit to our Theorems 1, 2 and 5, a lower bound of ∼ > N p/(1 − p) on the runtime of general noisy quantum search algorithms was obtained in [19], whose faulty oracle model is somewhat similar to our partial depolarizing noise (4) (with roughly the same noise parameter p; they fixed ε 1/10). One difference is that, in Theorems 2 and 5, we allow error-free (e.g. classical) verification steps, whereas every oracle use in [19] is potentially faulty, leading to a diverging bound as p → 1. Also, [19] does not include a noiseless classical memory. Due to these extensions, our lower bounds are restricted to "symmetric" algorithms consisting of "rounds", whereas [19] applies to all algorithms within their memoryless setting. No concrete algorithm is given in [19].
The work [18] specifically investigated Grover's algorithm under phase noise, again somewhat analogous to our noise model (4). It was observed that Grover's algorithm gives an advantage only if it runs for k ∼ < 1/p steps, and it was hinted that at this time one may perform a measurement and start a new Grover round. In Sections II B and II C, we give more rigorous arguments (and prefactors) for the scaling k ∼ 1/p, also for algorithms not necessarily consisting of Grover steps. Our Algorithms 1 and 2 do indeed use the division into Grover rounds, but they even function fault-ignorantly. The avoidance of active error correction [6] is advocated by [18] as well.
A more technical difference of our work to most of the literature is that we consider the average success probability of an algorithm, i.e. averaged over all N oracles with equal weight, whereas the literature most often only investigates the minimum success probability of any of the N oracles. This makes our lower bounds stronger than the ones obtained in the literature. (As our constructive algorithms are symmetric, the minimum and average success probabilities coincide for those.)

IV. CONCLUSION
In this paper we investigated the idea of fault-ignorant quantum algorithms. Such algorithms should output the correct result even in the presence of noise of potentially unknown strength, in such a way that the actual noise level may affect the runtime it takes to arrive at the correct answer (up to some specified failure probability ε), but should not affect that fact that the correct answer is found eventually. This approach allows to reduce the required spatial circuit sizes, at the expense of increased runtime.
Following this general idea, we have provided fault-ignorant algorithms for quantum searching that function under depolarizing or dephasing noise of unknown strength p. We find the "quadratic speedup" to be achievable only for low decoherence rates p ∼ < 1/ √ N . Otherwise, our best algorithm's runtime scales asymptotically as min{N p log 1/ε, N (1 − ε)} as N → ∞. This is linear in N , but for low enough noise levels p it outperforms the optimal classical search algorithm. Our algorithms may thus be useful for initial uses of quantum computing, when unlimited scalability will not yet be achievable due to technical limitations.
We moreover proved that, up to a constant factor, our algorithms runtimes are optimal within wide classes of noisy quantum search algorithms. For the searching task, it turned out that ignorance of the actual noise level will extend the runtime by only a constant factor compared to the case of known p.
Due to the novelty of the approach, our algorithms and lower bounds leave questions for further research. On the side of concrete algorithms, one may ask for them to be independent not only of the noise level p but also of the desired accuracy ε; then one could continue running the algorithm for longer time to increase the success probability or accuracy.
Concerning lower bounds on the complexity of noisy quantum search, it would be worthwhile to establish an analogue of Theorem 1 for the case of partial dephasing or general partial entanglement-breaking noise. This would immediately extend the validity of our lower bound in Theorem 5 to the class of quantum algorithms that use a noiseless classical register in an arbitrary way and need not be divided into "rounds".
Finally, we hope that, beyond unstructured search, the fault-ignorant idea will be fruitfully applied to algorithmic tasks, such as sampling algorithms. , specified to solve a noisy quantum computational task (Definition 1): An input state i is affected in turn by devised operations Tj (which may include an oracle indexed by x, or other coherent operations, or measurement/verification procedures that store information in noiseless classical registers) and noise Dp acting on the quantum register. After some number of steps the probability distribution of the output should approximate the desired distribution fxi.

Appendix A: Fault ignorance -a mathematical framework
The aim of this appendix is to provide a mathematical definition of fault-ignorant computing, a term so far used only informally. We would like to do this in a way which enables to include a fairly broad class of algorithmic problems into this framework in a unified manner, while keeping the definition reasonably simple. The definitions are supposed formalize algorithms that do not need to know the actual noise level in order to accomplish their task -they should be ignorant of the noise. A fault-ignorant algorithm is robust enough to provide the answer (up to some specified failure probability) under noise, the latter affecting only its runtime.
In our formalization, we want to allow the desired and the actual output of the algorithm to be probabilistic, and to depend on an input (as is usual for computational problems) and on an oracle (as for example in search problems). Given the discrete-time nature of the computation as well as of our noise models (cf. Appendix B), it is necessary to explicitly refer to an allowed class of quantum operations. This can be done most conveniently if one also specifies the (spatial) resources available for performing the computation, i.e. the size of the quantum computer available or of any accompanying classical memory. Further, we consider only the quantum register to be noisy, whereas noiseless classical memory is available.
In light of this, we propose the following definitions, which we explain and supplement by examples afterwards. • f ∈ R X×I×O is a stochastic matrix, i.e. has nonnegative entries and for any x ∈ X and i ∈ I we have o∈O f xio = 1, • H is a Hilbert space, • s ∈ N, We interpret X as the set labelling the different oracles, I and O as the sets of possible inputs and outputs, respectively (see also Fig. 4). For a task which does not make use of an oracle, we let X be any singleton set, and similarly, if the computation does not need an input, we let |I| = 1. The stochastic matrix f describes the desired distribution on the output set depending on the input and the oracle. The computation is performed using the Hilbert space H and a classical memory of s states, with the output being written into an additional classical register with |O| states, corresponding to the possible output states in O. The additional classical bit C 2 is to have value 1 iff the algorithm wants to signal that the result is available in the register C O . The reason for this is that in the fault-ignorant setting the runtime depends on an unknown parameter (namely p, see below), and therefore the algorithm needs a way to tell whether the computation is already done without destroying the quantum state.
The map · : I → B(H) plays the role of input encoding in the sense that the physical initial state i on the register B(H) represents the abstract input value i ∈ I. The quantum register H is subject to noise modeled by the quantum channels D p depending on a parameter p ∈ [0, 1], which we think of as a strength parameter.
Finally, the set S ⊆ CPT(B(H) ⊗ C s ⊗ C O ⊗ C 2 ) X represents the set of allowed elementary steps. An element in this subset is understood as a quantum channel depending on the oracle, whereby the quantum channel acts on the quantum register B(H) as well as on the classical (diagonal) registers C s , C O and C 2 described above. This gives a way to impose conditions on how "complicated" the elementary operations are, e.g. in terms of oracle use or locality requirements, and at the same time it maps the abstract oracle x ∈ X to actual physical transformations it may perform.
Definition 2 (Fault-ignorant algorithm). A fault-ignorant algorithm solving the noisy quantum computational task (X, I, O, f, H, , D, s, S) is a family ((T ε n ) n ) ε∈(0,1) of finite or infinite sequences with T ε n ∈ S such that for all ε ∈ (0, 1) and for all p ∈ [0, 1] the value m ε (p) := min m 0 ∈ N ∀m > m 0 : ∀x, i : Thus, the sequence of operations in (A2) models a m-step noisy quantum computation, in the sense that between any two elementary operations from S a noise channel D p is to be applied on the quantum register B(H) (Fig. 4). The sequence (T ε n ) n itself describes the algorithmic operations, which may depend on the required accuracy ε, i.e. on the maximally tolerable distance from the desired output distribution f xi , cf. (A1). Note that, by performing a computation in the noiseless classical register C s alone, every classical algorithm is fault-ignorant.
The requirement for m ε (p) to be finite for any p, even though the algorithm ((T ε n ) n ) ε∈(0,1) does not depend on p, justifies the term fault-ignorant algorithm. The condition "∀m > m 0 " in (A1) requires the result to be available in the classical memory at any later time when the outside agent, ignorant of the noise level and thus of the necessary computation time, may check the C 2 flag to see whether the computation has already finished and want to read out the result. Note that Definition 2 does not put any requirements on the efficiency of the algorithm, which however in some circumstances may be quantified by m ε (p), i.e. the minimal number of invocations of T ε k (x) (e.g. oracle calls).
We now illustrate the definitions above by two examples.
Example 2 (Quantum search). As an example we now show how the noisy quantum search problem considered in Sections II and III fits into this framework. In this case we have a set of N oracles X = {1, . . . , N }, and the algorithm is required to identify the oracle, so O = X. Since no input is needed, we set I = {0}. Now the function to be computed is deterministic, so f will be a 0-1 matrix, more specifically f xio = δ xo . The Hilbert space we used is H = C N ⊗ C M ⊗ C 2 for some M setting the size of ancillary quantum system and C 2 standing for ancillary system of the oracle, cf. (1). The noise acting on it is for example partial depolarizing, . Since there is no input, 0 is just any fixed initial state, e.g. we may take 0 = I 2N M 2N M . In the version without classical memory we set s = 1 (Section II), while if we are to exclude previously tested elements, we may set s = 2 N (Section III).
The set of allowed elementary operations is where O x first prepares the pure state 1 √ 2 (|0 − |1 ) on the C 2 -subsystem of H, and then acts as |x , b → |x , b + δ x,x on H (cf. Eqs. (1) and (2)) and as the identity on the classical registers. This choice of S means that an elementary step consists of a single use of the oracle, possibly applying an arbitrary (but oracle-independent!) channel before and afterwards.
Finally, half of the trace-distance in (A1) gives, when the ready-flag C 2 has been set to 1, exactly the probability of not outputting the correct oracle index in the classical output register, and it is this failure probability which we wanted to be smaller than ε in Sections II and III.
Example 3 (Binary addition). This example illustrates the possibility to introduce some kind of "locality structure". The task is the addition of two n-bit numbers given their binary representation using local gates on a 2n-bit quantum register with local dephasing noise. Such a task is given by X = {0}, Hilbert space is H = C 2 ⊗2n , (i1,i2) = |i 1 , i 2 (with i 1 , i 2 considered as a 2n-bit string), D p = d ⊗2n p with d p : B(C 2 ) → B(C 2 ) the partial dephasing with strength p, s = 1, and S ⊆ CPT(B(C 2 ⊗2n ) ⊗ C O ⊗ C 2 ) consisting of 1-and 2-(qu)bit gates, i.e. channels which act as the identity on all but at most two bits (quantum or classical), remembering the subsystem structure of C O C 2 ⊗n+1 .
An algorithm that works only for known noise level p is not fault-ignorant; such algorithms may be formalized by assuming a p-dependence (T ε,p n ) n in the family of sequences in Definition 2. On the other hand, if these sequences do not depend on the desired accuracy ε, i.e. (T ε n ) n ≡ (T n ) n , then the algorithm does have another feature: the level of accuracy ε need not be specified before starting the algorithm; when higher accuracy is desired, one only needs to continue running the algorithm.
Returning to efficiency questions, one may call a fault-ignorant algorithm (or rather, a family of faultignorant algorithms, parametrized by some "problem size" N ) efficient if, for any p, any ε and any N , its runtime is within a constant factor times the runtime of the best algorithm that may depend on ε and on p. In this sense, our Theorems 2 and 5 can be seen as statements that Algorithms 1 and 2 are efficient (within restricted classes of algorithms).
It should be clear that there is nothing special about the set [0, 1] parametrizing the noise channels apart from the possibility to interpret it as "strength" or to use it directly as a coefficient in a convex combination. One could instead consider a family (D p ) p∈P of noise channels indexed by an arbitrary set P parametrizing wider classes of noise, and so allowing for "more" ignorance about the faults. Another obvious extension of Definition 1 would be to allow for time-dependent noise. a suitably prepared quantum register can accomplish this check and write the result into the (noiseless) classical memory. This fact is important, as it allows the verification/falsification step at the conclusion of each round. Alternatively, such a noiseless check may be implemented by a classical table lookup.
The above noise models are formulated in discrete time, but our prescription for the noise D p to act between any two oracle calls is supposed to model the continuous action of noise in a real-world situation. For example, since in (B1) the probability to "lose" the quantum computer between any two consecutive oracle calls is p, its lifetime is roughly 1/p (measured in the time between two oracle calls); and indeed, the time scale k ∼ 1/p appeared often in the analysis in Subsection II C.
Note that quantum error correction [1,4,5] does not work for partial depolarizing (B1) or dephasing (B2), as these noises affect the whole quantum computer "collectively". This means that the whole quantum computer is subjected to a "flash" of noise, such as drifting lasers or an external hit by a magnetic field. These may be reasonable noise models for not-too-large quantum computers.
Discussing the noise models more quantitatively, we first notice that the lower bound (6) on the success probability after k steps of Grover's algorithm under noise applies to all three noise models (B1)-(B3). For partial depolarizing (B1) one can compute the success probability in (6) exactly: the 2 k − 1 omitted terms are of the form where m is the number of noise hits. These terms correspond to events when the maximally mixed state is prepared at some point due to noise acting and since both D p and G x (see before Eq. (5)) are unital.
As the coefficients of these terms sum up to (1 − (1 − p) k ), the exact success probability for this model is Using this exact success probability for partial depolarizing improves the runtime bounds for this specific noise model (e.g. Theorem 3 for large noise level p), but the lower bound (6) is quite tight unless kp 1. An exact computation of the success probability can also be done for partial dephasing (B2), but is much more involved. Furthermore, one can prove that the success probability for partial dephasing is not smaller than for depolarizing at the same noise level: p ϕ s (N, k, p) ≥ p pol s (N, k, p). This inequality is, however, not immediate, as for identical noise parameters p ∈ (0, 1), partial depolarizing D pol p cannot be obtained by post-processing D ϕ p , i.e. D pol p = P • D ϕ p for all quantum channels P . Our proofs of the lower bounds on the number of oracle calls (Theorems 2 and 5) require partial depolarizing (B1), as Theorem 1 was proved only for this model.
Finally, we argue that it makes sense in Sections II and III to perform efficiency analyses by keeping the noise parameter p fixed while the size of the quantum register N (or N M ) varies, possibly even tending to infinity. Phrased another way, we ask whether, for example, the strength of partial depolarizing (B1) with parameter p on an d-dimensional quantum system is comparable to the strength of partial depolarizing with the same parameter p in d dimensions, even if d and d are widely different.
First, both partial depolarizing (B1) and partial dephasing (B2) (the latter with respect to a tensor product of bases) are compatible under tracing out subsystems when the same parameter p is used on the tensor product system and on the subsystem: With this parametrization of the noise, it does therefore not help for algorithm performance to introduce larger and larger ancillary systems or "innocent bystanders": the noise on the "Grover part" of the algorithm cannot be made small in this way, which is a reasonable requirement. Secondly, both for partial depolarizing and dephasing, one can obtain the noise in d − 1 dimensions by post-processing the noise on a d-dimensional system: where P = id for dephasing noise (and the additional dimension |d has to correspond to one of the basis vectors in (B2)), and P (X) := (I − |d d|)X(I − |d d|) + (I − |d d|) d| X |d /(d − 1) for depolarizing. This compatibility under restrictions of the Hilbert space to subspaces is important and sensible in the context of exclusion algorithms (Algorithm 2, and proof of Theorem 4), where the effective dimension of the quantum register is reduced by 1 in each round.
Proof. As we assume the noise to act symmetrically with respect to the different oracles (which both partial depolarizing and dephasing do) and since the Grover steps of Algorithm 1 are symmetric as well, the success events in different rounds g are independent. Thus, with (6), we can upper bound the failure probability after round g * by (1 − p s (N, k g , p)) = exp    g * g=0 log (1 − p s (N, k g , p)) (1 − p) kg sin 2 (2k g + 1) arcsin To show that the failure probability is at most ε, as desired, below we will lower bound the sum g * g=0 and adjust parameters such that it is at least log(1/ε). The sum can be further bounded by assuming it to start at some g = g * with 0 ≤ g * ≤ g * : The number of oracle calls can be upper bounded as follows: The proof of the theorem now consists in showing that there exists a number g * (of rounds) such that the failure probability (C1) is at most ε, while the number of oracle calls (C3) does not exceed the value given in (32). This argument will be split into three cases, as sketched in the main text. We make abundant use of the fact that c log(1/ε) ≥ 1, since ε ≤ ε 0 := 1/2 and c = 10. We also define N 0 := 100 and assume N ≥ N 0 throughout, in accord with the statement of Theorem 3.
So far we have proved that the algorithm is fault-tolerant with runtime at most √ N + 86(N p + √ N ) log(1/ε). Due to ε ≤ ε 0 = 1/2, (32) is an upper bound on the runtime.