Separation in Quantum and Randomized Query Complexity based on Cheat Sheet model

Transcription

1 Separation in Quantum and Randomized Query Complexity based on Cheat Sheet model Hardik Bansal Advisor : Prof. Rajat Mittal Abstract Recent result by Shalev [1] have shown super-quadratic separation between randomized and quantum query complexity, refuting the long standing conjecture that for any total function R(f) = O(Q(f) 2 ) by giving a function h such that R(h) = Ω(Q(h) 2 ). He converted a partial function, having best known separation between Q(f) and R(f), into a total function using cheat sheet model, defined in the paper, where a set of two functions f and g can be seen as parameter to the model. In this report we studied this model and tried to analyze and improve this separation by fixing the function f and calculate the bounds for some arbitrary function g. 1 Introduction It has always been an interesting question to explore the power and limits of quantum computing but no progress has been made in separating quantum and randomized query complexity of a total boolean function for more than a decade. Although we have better than exponential separation for a partial function, for total functions there is still a lower bound of Q(f) = Ω(R(f) 1/6 ) given by Beals et al. [2]. Till now best known separation for a total function was quadratic, for unstructured search problem [3], whose quantum query complexity Q(f) = θ( N) as compared to its randomized lower bound of R(f) = θ(n). In recent breakthroughs, various improved bounds and separations are proved depicting the power of quantum algorithms over classical ones. One of the results is super-quadratic(better than quadratic) separation between R(f) and Q(f) refuting the long standing conjecture that Q(f) = Ω(R(f) 1/2 ). In this paper, Shalev converted a partial function, introduced by Scott et al. in [4], with best known separation in R(f) and Q(f), into a total function using addressing scheme and cheat sheet technique. In this paper we will explore and analyze these techniques and try to see how we can improve this separation. Recent papers [5] [6] has also shown better separation between R 0 (f) and Q(f), R 0 (f) and D(f) and Q(f), where D(f) is deterministic query complexity and R 0 is query complexity for Las-Vegas algorithm. 1

2 2 Preliminaries 2 3 Boolean Function Boolean functions are one of the most studied functions in computer science. Input to a boolean function can be expressed as a string of bits and output is either 0 or 1. We can define Boolean function over n bits as follow: f : D {0, 1} n {0, 1} Function is total if D = {0, 1} n, i.e. it is defined for all input string over n bits. Similarly, a partial boolean function is a boolean function such that D {0, 1} n. Input for a partial function are said to satisfy a certain promise P. such that x D, iff, x satisfies promise P. 3.1 Deterministic Query Complexity A deterministic query complexity for a Boolean function f is defined by a decision tree T with internal nodes labelled by elements of [n] and every node has outgoing degree 2. Also the leaves are labelled with {0, 1}, which can be seen as the final answer. Answer to an input x is defined by T (x) by following the path from the root to a leaf, where we move from vertex u labelled n u by taking an outgoing edge corresponding to x nu. We do this until we reach a leaf and the label of the leaf is the final answer. We say tree T deterministically computes function f if x : T (x) = f(x). We define deterministic query complexity as follow: where D(T, x) is query required bt decision tree T over input x. 3.2 Randomized Query Complexity D(f) = min max D(T, x) (1) T computes f x Randomized query complexity is defined in a similar manner to Deterministic query complexity but instead of deterministic algorithm we have randomized algorithm with probability error of at most 1/3. This model is equivalent to consider a distribution D over all possible decision tree and success probability can be defined as Pr [T (x) = f(x)] should be greater than equal to 2/3. Since T D there is a distribution over decision we need to look at the concept of expected number of queries for an input x which is defined as E (Q(T, x)). So, in the similar manner as deterministic query T D complexity we can define Randomized query complexity of a function as follow: R(f) = D Pr T D min max [T (x)=f(x)]>=2/3[ x 3.3 Quantum Query Complexity Model [ E T D (Q(T, x))]] (2) Let us define quantum query complexity for a function f : {0, 1} n {0, 1}. In quantum query model, we are given input as an oracle say O x and in order to access some bit of the input we have to give input i b to the oracle and the output of the oracle is i b x i. Now, we can describe any algorithm with t queries to oracle as follow:

3 φ := U t O x U t 1 O x U 1 O x U 0 0 n (3) After this we measure the first qubit of output and the result obtained is the output of function. Query complexity of a function is defined as the minimum query complexity over all the algorithms computing function f Q(f) = min QC(A) (4) A computes f 4 Shalev s Approach 4.1 Forrelation and its importance In his paper [1], he converted a partial function to a total function and it makes sense to use Forrelation as the basis for partial function as it has best known separation for partial function and it might help us extend it to the total function case. Forrelation has Q(f) = O(1), while it has R(f) = Ω( n), giving it a better than exponential separation. It has also been conjectured by Scott in [4] that there exist another promise version of Forrelation that have Q(f) = O(1) and R(f) = O( n). Although he made use of Forrelation, structure of problem in itself is not important to get the separation. Any function with these bounds will be sufficient to get the result. 4.2 OR-AND Another function used in the construction is OR-AND, which is just OR composed with m-instances of AND over m bits. This function is critical to the result as it has certain unique properties. First, it has best possible separation for any total function. Second, its certificate complexity is small. We will see later why certificate complexity of this function is critical for the bound. This is one of the important factor why OR-AND was preferred over unstructured search when both have same separation in query complexity. 4.3 Forandlation Let us define a new function called Forandlation which is Forrelation composed with m OR-AND instances over m m bits each. Quantum query complexity of this function is O(1 m 2 ) = O(m) while the R(f) = Ω( m m 2 ) = Ω(m 2.5 ). Prove is quite straightforward which is just reduction of Forrelation into a Forandlation instance. This function is still partial and we need to make it total. But the main point here is why he used the OR-AND to make Forandlation function. Why not just use Forrelation? While defining cheat sheet we will see why Forandlation makes much more sense than just using Forrelation. 4.4 Cheat Sheet Model and Addressing Schema Here we see how he convert a partial function to a total function. One of the intuitive thing to think is make function output 0 for the cases where promise on the input is not satisfied. But how can we do that? Here, we can make use of a cheat sheet which is given as extra input and is used to check the promise. Suppose we want to make Forandlation a total function what we can do is define a new function in which input is divided in two parts say x = x 1 x 2, where x 1 is input for Forandlation and x 2 are extra m bits. Now these extra bits can be used to denote the output of 3

4 4 m OR-AND instances and check the promise directly by querying them. Also, for this we need to check whether the output of all OR-AND instances actually correspond to these extra m bits or not. But as you can notice, now we can just query m bits out of m 3 bits and make a partial function into total. So, now we can answer the question why not Forrelation. If we would have used the Forrelation function here total input will be O(m) and queries that we need to make to check promise are also O(m), which does not give any advantage over randomized algorithm. So, using Forandlation is makes more sense. But even this construction has problems. Problem is that now a randomized algorithm does not need to compute OR-AND instances and can just look at the second part of the input and directly calculate Forrelation over these m bits. In order overtake this problem we will make use of Addressing scheme as described below: Addressing scheme help us address the above issue by making it hard for a function to jump directly to a cheat sheet. For this we create a large enough array of cheat sheet, so that it is hard for any randomized algorithm to guess the required cheat sheet and solve the function directly. Also the index of required cheat sheet in array is made dependent on the output of Forandlation so that any randomized algorithm, now, have to calculate these instances to get to the required cheat sheet. Below we have given the formal definition of final function h. First, we will define the input of the function h as follow: 1. Input x has two parts x = x 1 x Where x 1 are 10log(m) instances of Forandlation on m 3 bits. 3. x 2 is called array of cheat sheet. This is where we make the function total by checking the promise. A cheat sheet y is made up of three parts y = y 1 y 2 y 3. y 1 can be seen as answers corresponding to all the answers of OR-AND instances(in our case O(m logm)) y 2 can be seen as certificate corresponding to all the answers of OR-AND instances. y 3 is a single bit Now let us define the function. First of all, the function needs to output zero if the promises on any of the instance of Forandlation is not satisfied. Suppose all the promises are satisfied then after solving the 10logm instance of Forandlation, we will get the required index for the cheat sheet array. Corresponding cheat sheet must certify that promises are satisfied for all Forandlation instances as defined earlier and all the answers corresponding to OR-AND written in cheat must also be true. If anything is false, we output 0. Otherwise, we output y Thoughts behind this conversion In the start we had a partial function named Forandlation with Q(f) = O(m). Now, we want to make it false for every input that is not satisfying the promise. For that we can add the answers corresponding to OR-AND instances as extra input but we need to add certificates to make sure these answers are indeed correct. These is exactly what he did but instead he made problem a little bit difficult for randomization by increasing the instances of Forandlation and using address scheme for cheat sheet with index corresponding to answers given by (logm) instances of Forandlation. He could have just added the cheat sheet at the end but he did not because then there is no point in solving the Forandlation.

5 4.5 Quantum Algorithm and Upper Bound First of all let us look at the quantum upper bound of Forandlation function. Since, it is Forrelation composed with m-instances of OR-AND, we can write Q(F A) = O(Q(F OR m ) Q(OA) m 2) = O(m) Quantum algorithm for function is straight forward as described below: Algorithm 1. Compute all Forandlation instances and obtain index for cheat sheet array. 2. Query all the bits in first part y 1 of the corresponding cheat sheet and check whether all the promises are satisfied or not as per the cheat sheet. 3. Verify that cheat sheet is indeed correct by applying grover search all the instances of OR-AND and verifying it via certificate in cheat sheet. Query Complexity Analysis: Quantum Algorithm is straight forward and it just the combination of Grover s search with the classical algorithm. First of all we will calculate the O(logm) instances of Forandlation in O(m logm) queries. After that we will check whether the cheat sheet corresponding to address we get from Forandlation instances is actually certifying the input part x 1 as valid or not. This will take O( log m m) = Õ(m). After that we need to check whether these answers are actually matching corresponding to x 1 we have. We can do it in O( m log m mlog m), where first m log m is correspond to number of OR-AND instances and other m correspond to size of certificate complexity. And this where the point comes of why we cannot use just the AND/OR function instead of OR-AND function. It is because C(f) = max{c 0 (f), C 1 (f)} = n for OR/AND function while it is n for OR-AND function. which in then reduces the check time. 4.6 Randomized Lower Bound for Forandlation We will first prove a lower bound on the Forandlation function using the reduction techniques, one of the major tool in theoretical computer science for proving lower bounds. He converted an instance of Forrelation into a hard Forandlation instance so that, if we can solve these instances in o(n 2.5 ) then Forrelation can be solved in o(n 0.5 ). Reduction: For this we can just take each input bit of Forrelation and convert it into an instance of OR-AND such that its answer is same as the input bit. Since, need to prove that if we can do Forandlation in o(n 2.5 ) then we can do Forrelation in o(n 0.5 ) queries. So, we must make this reduction in such a way so that in order to get answer to the OR-AND instance(which is equivalent to querying corresponding input bit), we need to make at least O(n 2 ) queries. This can be easily achieved by converting a bit into hard input distribution over OR-AND rather than just some fixed input. To do this we will make a n n matrix and for each column select a row at uniformly random and fill 0 in the corresponding entries and fill all the remaining matrix with 1. We now have a matrix with 1 zero in each column. Now, we will randomly select a column and replace the 0 bit in that column with bit b. Cleary, output of OR-AND will be b, as required. Now, he argued that in order to query b any randomized must query ω(n 2 ) other bits. Since, we are worried only about queries to b i we can say, if we can solve Forandlation in o(f(n)) queries then Forrelation can be solved in o(f(n)/n 2 ) queries giving a lower bound of Ω(n 2.5 ) for Forandlation. 5

6 4.7 Randomized Lower bound on Final Function It is intuitive to see that if we cannot solve one instances of Forandlation then it should be hard for us to solve a function which is dependent on O(logn) instances of it. But one thing that we should keep in mind is that addressing scheme might make this function easy for a randomized algorithm, which we need to prove is not true. In order to prove this one can take hard case input for the final function h and argue that if we can solve the function in o(r(f A)). One can say that if the input to all the Forandlation instances satisfies the promise, then, we have to query at least one bit of the corresponding cheat sheet from the array with very high probability if we want the algorithm to succeed. It can be said based on two nearly same input with different outputs. Assuming all the promise to all the instances are satisfied and for one input cheat sheet is just {0} while for other it is all 0 except for the corresponding cheat sheet which is also a correct cheat sheet for the input. Clearly, we can see these two inputs have opposite values and so if any randomized algorithm wants to correct answer with high probability must make at least one query from the corresponding cheat sheet with very high probability. This in then can be used to prove the above lower bound. 5 Our take on this approach Although this algorithm proved a super-quadratic separation between quantum query complexity and randomized query complexity, it does not take into account some important information that we think might me useful in improving this bound. First, and most important of it is the structure of Forrelation function, which can be used to make more concrete statement regarding the randomized lower bound. While proving lower bound Shalev just said that any randomized algorithm must query at least one query from the corresponding entry, which I think can be increased to some better, which might contribute to a better lower bound. For this project, we explored the possibilities over co-function(in his paper OR-AND) that might help in improving the separation. So, we fix the function Forrelation, which if we just ignore the structure is best to consider because of its best separation for any partial function. We explored what are the properties of the co-function that we need to improve the separation and based on it, maybe we could design some function satisfying these properties. 5.1 Upper Bound on Quantum Algorithm Let us denote Forrelation function as f and consider a new function g, which we will use in place of OR-AND function. Now we will follow the same construction as in Shalev s paper and see what we can say about the separation based on arbitrary function g. Consider a new function h : {0, 1} nn {0, 1} as f composed with n instances of g on m input bits each. Finally using the cheat sheet model and addressing scheme, we define a new function F. Quantum Algorithm: We need to look at three steps while calculating its quantum query complexity 1. Calculate all the O(logn) instances of h. 2. See whether all the promises are satisfied or not. 3. To check whether cheat-sheet is correct or not using the certificate structure. 6

7 7 Step 1 will take O(log(n)Q(f)Q(g)). Here we have Q(f) = O(1), therefore, Step 1 can be done in Õ(Q(g)). In step 2, we need to know about the structure of the promise to know how much query will be needed to determine whether promise is satisfied or not but since we are not considering the structure of the function f, we will just ignore it and say that we have to query all the bits. It will take another O(log(n) n ) queries. After that we need to check whether the cheat sheet is indeed correct by looking at the certificate structure in the cheat sheet. There are O(n logn) instances of function g and we need to check all these answers are indeed specified correctly in the cheat sheet. To do that we can do grover search over these instances and each check will take O( C(g)) queries using grover search to find any mismatch from the certificate. So in total O( n C(g)) queries will be needed to check the cheat sheet. All steps combined will give a upper bound of Õ(Q(g) + n + n C(g)) on quantum query complexity of function F. So, we have: 5.2 Randomized Lower Bound Q(F ) = Õ(Q(g) + n + n C(g)) (5) One of the part in proving randomized lower bound for function is to show that R(F ) = Ω(R(h)). This can be proved in the similar manner as in the paper. We can prove that there exist k such that array size is equal to n k such that R(F ) = Ω(R(h)). This will require klogn instances of function h which clearly will not increase the quantum query complexity. One thing that is still need to be proved is lower bound on the randomized query comeplexity of function h. 6 Future Work One of the dimension for the future work is that we can also take an arbitrary function in place of Forrelation and then look at the bounds. for e.g. we can use functions like Simon s problem in place of Forrelation and this will not affect the analysis. Most importantly, we can look at the structure of primary function(here Forrelation), which is not done in the paper [1]. It can be exploited to give a better bounds.

8 References 8 [1] Shalev Ben-David. A super-grover separation between randomized and quantum query complexities. arxiv preprint arxiv: , [2] Robert Beals, Harry Buhrman, Richard Cleve, Michele Mosca, and Ronald De Wolf. Quantum lower bounds by polynomials. Journal of the ACM (JACM), 48(4): , [3] Lov K Grover. A fast quantum mechanical algorithm for database search. In Proceedings of the twenty-eighth annual ACM symposium on Theory of computing, pages ACM, [4] Scott Aaronson and Andris Ambainis. Forrelation: a problem that optimally separates quantum from classical computing. arxiv preprint arxiv: , [5] Andris Ambainis, Kaspars Balodis, Aleksandrs Belovs, Troy Lee, Miklos Santha, and Juris Smotrovs. Separations in query complexity based on pointer functions. arxiv preprint arxiv: , [6] Sagnik Mukhopadhyay and Swagato Sanyal. Towards better separation between deterministic and randomized query complexity. arxiv preprint arxiv: , 2015.