Academia.eduAcademia.edu

Outline

Title
Abstract
Figures
Introduction and Summary of Results
Ambainis' Lower Bound Method Revisited
The Zero Error Case
References
All Topics
Computer Science
Quantum Computing

Quantum query complexity and semi-definite programming

Profile image of Mario SzegedyMario Szegedy

2003, 18th IEEE Annual Conference on Computational Complexity, 2003. Proceedings.

https://doi.org/10.1109/CCC.2003.1214419
visibility

…

description

15 pages

link

1 file

Abstract

We reformulate quantum query complexity in terms of inequalities and equations for a set of positive semidefinite matrices. Using the new formulation we: 1. show that the workspace of a quantum computer can be limited to at most n + k qubits (where n and k are the number of input and output bits respectively) without reducing the computational power of the model. 2. give an algorithm that on input the truth table of a partial boolean function and an integer t runs in time polynomial in the size of the truth table and estimates, to any desired accuracy, the minimum probability of error that can be attained by a quantum query algorithm attempts to evaluate f in t queries. 3. use semidefinite programming duality to formulate a dual SDPP (f, t, ) that is feasible if and only if f can not be evaluated within error by a tstep quantum query algorithm Using this SDP we derive a general lower bound for quantum query complexity that encompasses a lower bound method of Ambainis and its generalizations. 4. Give an interpretation of a generalized form of branching in quantum computation.

Figures (9)
We now verify conditions (9), (10) and (11). Even though the matrices (M“) : 0 < j < t—1) are not explicitly part of P(f,t,¢) we continue to write M0) = ya o MY ) for 0 < j <t—1. We have that M = E since it is the Gram matrix of an indexed set of vectors all of whose members are the same unit vector; thus (9) holds. It follows from (5), (6) and (7) that for 1 < 7 < ft, wl ) = yG ow! “), Therefore, Proposition | implies that cw? :a2 € S) and (ow!) : x € S) have the same Gram matrix. The Gram matrix of the former is 14%) while that of the latter has entries: Constraint (13) follows immediately from condition (4) that the algorithm computes f within e. To show (12), we use the properties of systems of orthogonal projectors to write:
We now verify conditions (9), (10) and (11). Even though the matrices (M“) : 0 < j < t—1) are not explicitly part of P(f,t,¢) we continue to write M0) = ya o MY ) for 0 < j <t—1. We have that M = E since it is the Gram matrix of an indexed set of vectors all of whose members are the same unit vector; thus (9) holds. It follows from (5), (6) and (7) that for 1 < 7 < ft, wl ) = yG ow! “), Therefore, Proposition | implies that cw? :a2 € S) and (ow!) : x € S) have the same Gram matrix. The Gram matrix of the former is 14%) while that of the latter has entries: Constraint (13) follows immediately from condition (4) that the algorithm computes f within e. To show (12), we use the properties of systems of orthogonal projectors to write:
This completes the proof that the existence of a t-step QQA that computes f within error € gives a feasible so- lution for P(f,t,¢). We now turn to the converse. We assume that we have a feasible solution to P(f,t,¢) and construct from it a t-step QQA for f within error ¢, whose working memory has value set [r] = {0,...,7 — 1} (as re- quired by the final part of the theorem). We define Hy to be the the free Hilbert space of dimension r spanned by [r]. The query register has value set {0,...,} which spans the n + 1 dimensionsal space Hg and so the accessible space Hf, = Hg ® Hy has dimension nr.
This completes the proof that the existence of a t-step QQA that computes f within error € gives a feasible so- lution for P(f,t,¢). We now turn to the converse. We assume that we have a feasible solution to P(f,t,¢) and construct from it a t-step QQA for f within error ¢, whose working memory has value set [r] = {0,...,7 — 1} (as re- quired by the final part of the theorem). We define Hy to be the the free Hilbert space of dimension r spanned by [r]. The query register has value set {0,...,} which spans the n + 1 dimensionsal space Hg and so the accessible space Hf, = Hg ® Hy has dimension nr.
It is easy to see that for any realizable Gram matrix M, the feasibility of O(M, f,¢) implies A(M, F,«). Suppose ([, : z € T) isa feasible solution to O(M, f,«), and let x,y € S with f(x) A fly). Letl’ = M—T pay. As M has 1’s on the diagonal and T’, and I’ are each positive semidefinite symmetric, where the next to last inequality follows from the Cauchy- Schwartz inequality and the final inequality comes from (13) which implies [./z.z] > 1—eandT’Jy.y] > 1—-—e.
It is easy to see that for any realizable Gram matrix M, the feasibility of O(M, f,¢) implies A(M, F,«). Suppose ([, : z € T) isa feasible solution to O(M, f,«), and let x,y € S with f(x) A fly). Letl’ = M—T pay. As M has 1’s on the diagonal and T’, and I’ are each positive semidefinite symmetric, where the next to last inequality follows from the Cauchy- Schwartz inequality and the final inequality comes from (13) which implies [./z.z] > 1—eandT’Jy.y] > 1—-—e.
It is routine (if tedious) to check that with these defini- tions II(A, B) is (the modified form of) P(f,t,<). Figure 8 provides a visual aid for the verification. We now form II(A, B) to form the dual P(f,t,¢) to P(f,t,<). We re- name the dual variable matrices (Y; : 7 € {0,...,t}) as (—LY) : j © {0,...,t}) and the dual variables (Y, : z € T)as(Az:2z€T). Now we define the index sets J and J and the systems of matrices A and B corresponding to this modified form of P(f,t,e). We take J = {0,...,t} UT and and J = {0,...,6-—1} x {0,...,n} UT x {1,-1}. We specify the matrices A, g and By as follows (using the notation for matrices introduced prior to the definition of P(f,t,¢) in section 3).
It is routine (if tedious) to check that with these defini- tions II(A, B) is (the modified form of) P(f,t,<). Figure 8 provides a visual aid for the verification. We now form II(A, B) to form the dual P(f,t,¢) to P(f,t,<). We re- name the dual variable matrices (Y; : 7 € {0,...,t}) as (—LY) : j © {0,...,t}) and the dual variables (Y, : z € T)as(Az:2z€T). Now we define the index sets J and J and the systems of matrices A and B corresponding to this modified form of P(f,t,e). We take J = {0,...,t} UT and and J = {0,...,6-—1} x {0,...,n} UT x {1,-1}. We specify the matrices A, g and By as follows (using the notation for matrices introduced prior to the definition of P(f,t,¢) in section 3).
Combining Theorems | and Lemma 2 we have: Semidefinite program P(f,t,<). Find S x S' real symmet- ric matrices (L; :0 <i <t) and (A, : z € T) satisfying: Theorem 2 For any partial boolean function f, natural number t and € € (0,1/2) the following are equivalent:
Combining Theorems | and Lemma 2 we have: Semidefinite program P(f,t,<). Find S x S' real symmet- ric matrices (L; :0 <i <t) and (A, : z € T) satisfying: Theorem 2 For any partial boolean function f, natural number t and € € (0,1/2) the following are equivalent:
Figure 1. Each entry in the table represents a S x S matrix. The columns of the table correspond to the set / and are labeled by the dual variable matrices. The rows of the table correspond to the set J and are labeled by the primal variable matrices. Each column gives a constraint of (the modified version of) P(/,¢,«) and each row gives a constraint of P(f, t,€). (This is the transpose of the standard picture, which we use for typographical convenience.) The final row of the table gives B, for a € I followed by B~, for a’ < J. The entries of the upper main part of the table give the matrices A’. a and of the lower part give A), ,.
Figure 1. Each entry in the table represents a S x S matrix. The columns of the table correspond to the set / and are labeled by the dual variable matrices. The rows of the table correspond to the set J and are labeled by the primal variable matrices. Each column gives a constraint of (the modified version of) P(/,¢,«) and each row gives a constraint of P(f, t,€). (This is the transpose of the standard picture, which we use for typographical convenience.) The final row of the table gives B, for a € I followed by B~, for a’ < J. The entries of the upper main part of the table give the matrices A’. a and of the lower part give A), ,.
Here the rows and columns of the matrices correspond to inputs 00, 01, 10, 11 in this order. Example: Consider f = x1 A x2. We show that the (zero- error) quantum decision tree complexity of this function is greater than | (Le. it is 2) by giving Lio) and L(,) that satisfy the conditions of P4(f, t, 0):
Here the rows and columns of the matrices correspond to inputs 00, 01, 10, 11 in this order. Example: Consider f = x1 A x2. We show that the (zero- error) quantum decision tree complexity of this function is greater than | (Le. it is 2) by giving Lio) and L(,) that satisfy the conditions of P4(f, t, 0):

Related papers

Improved Quantum Query Complexity Bounds for Some Graph Problems
Prafulla Dhariwal

2014

We prove improved quantum query complexity bounds for some graph problem. Our results are based on a new quantum algorithm in [1] that could be used to improve query complexity upper bounds. We prove a lower bound of Ω ( kn ) queries to an adjacency matrix for the k-source shortest paths problem for unweighted graphs, which matches the upper bound proved in [1]. We also prove an upper bound of O(n) queries for finding the minimum vertex cover in a bipartite graph G if we are given the maximum matching in G. In [1], Lin and Lin proved that the latter could be found in O(n) queries, which gives us an O(n) upper bound for the minimum vertex cover problem for bipartite graphs. We also discuss the implications of their results on the query complexity of other related graph problems.

View PDFchevron_right
Quantum Query Complexity of Some Graph Problems
mehdi mhalla

SIAM Journal on Computing, 2006

Quantum algorithms for graph problems are considered, both in the adjacency matrix model and in an adjacency list-like array model. We give almost tight lower and upper bounds for the bounded error quantum query complexity of Connectivity, Strong Connectivity, Minimum Spanning Tree, and Single Source Shortest Paths. For example we show that the query complexity of Minimum Spanning Tree is in Θ(n 3/2 ) in the matrix model and in Θ( √ nm) in the array model, while the complexity of Connectivity is also in Θ(n 3/2 ) in the matrix model, but in Θ(n) in the array model. The upper bounds utilize search procedures for finding minima of functions under various conditions. Keywords: graph theory, quantum algorithm, lower bound, connectivity, minimum spanning tree, single source shortest paths * This paper subsumes the three manuscripts "A quantum algorithm for finding the minimum" (quant-ph/960714), "Quantum algorithms for lowest weight paths and spanning trees in complete graphs" (quant-ph/0303131), and "Quantum query complexity of graph connectivity" (quant-ph/0303169), and includes several other previously unpublished results. We are grateful to Yaohui Lei for his permission to include results presented in quant-ph/0303169 in this paper.

View PDFchevron_right
On Complexity of Quantum Branching Programs Computing Equality-like Boolean Functions
Farid Ablayev

2008

We consider the Hidden Subgroup, and Equality-related problems in the context of quantum Ordered Binary Decision Diagrams. For the decision versions of considered problems we show polynomial upper bounds in terms of quantum OBDD width. We apply a new modification of the fingerprinting technique and present the algorithms in circuit notation. Our algorithms require at most logarithmic number of qubits.

View PDFchevron_right
A strong direct product theorem for quantum query complexity
Jérémie Roland

computational complexity, 2013

We show that quantum query complexity satisfies a strong direct product theorem. This means that computing k copies of a function with less than k times the number of quantum queries needed to compute one copy of the function implies that the overall success probability will be exponentially small in k. We do this by showing that the multiplicative adversary method, which inherently satisfies a strong direct product theorem, is always at least as large as the additive adversary method, which is known to characterize quantum query complexity.

View PDFchevron_right
Complexity of Computing Functions by Quantum Branching Programs
Farid Ablayev

2007

We consider the problems of computing certain types of boolean functions which we call Equality, Semi-Simon and Periodicity functions. For all these problems, we prove linear lower complexity bounds on oblivious Ordered Read-Once Quantum Branching Programs (quantum Ordered Binary Decision Diagrams). We present also two different approaches to prove existence of efficient quantum branching programs for those boolean functions matching the lower complexity bounds.

View PDFchevron_right
Bounds for Error Reduction with Few Quantum Queries
Sourav Chakraborty

Lecture Notes in Computer Science, 2005

We consider the quantum database search problem, where we are given a function f : [N ] → {0, 1}, and are required to return an x ∈ [N ] (a target address) such that f (x) = 1. Recently, Grover [G05] showed that there is an algorithm that after making one quantum query to the database, returns an X ∈ [N ] (a random variable) such that Pr[f (X) = 0] = 3 , where = |f −1 (0)|/N. Using the same idea, Grover derived a t-query quantum algorithm (for infinitely many t) that errs with probability only 2t+1. Subsequently, Tulsi, Grover and Patel [TGP05] showed, using a different algorithm, that such a reduction can be achieved for all t. This method can be placed in a more general framework, where given any algorithm that produces a target state for some database f with probability of error , one can obtain another that makes t queries to f , and errs with probability 2t+1. For this method to work, we do not require prior knowledge of. Note that no classical randomized algorithm can reduce the error probability to significantly below t+1 , even if is known. In this paper, we obtain lower bounds that show that the amplification achieved by these quantum algorithms is essentially optimal. We also present simple alternative algorithms that achieve the same bound as those in Grover [G05], and have some other desirable properties. We then study the best reduction in error that can be achieved by a t-query quantum algorithm, when the initial error is known to lie in an interval of the form [ , u]. We generalize our basic algorithms and lower bounds, and obtain nearly tight bounds in this setting.

View PDFchevron_right
On computational power of quantum read-once branching programs
Farid Ablayev

2011

In this paper we review our current results concerning the computational power of quantum read-once branching programs. First of all, based on the circuit presentation of quantum branching programs and our variant of quantum fingerprinting technique, we show that any Boolean function with linear polynomial presentation can be computed by a quantum read-once branching program using a relatively small (usually logarithmic in the size of input) number of qubits. Then we show that the described class of Boolean functions is closed under the polynomial projections.

View PDFchevron_right
On New Quantum Search Algorithms and Complexity of NP-Complete Problems
Dhananjay Mehendale

viXra, 2016

We develop three new quantum algorithms for searching the desired target state in the unstructured database of size N. The first algorithm requires Log N iterative steps. It constructs two quantum bags of equal size in terms of two quantum states, out of which exactly one quantum state will have nonzero overlap with the target state. This determination of overlap is done by taking the inner product, in Log N time [2], of the implicitly known target state with any one of these two quantum states. The second algorithm requires just one single step which uses a new suitable operator and the choice of this operator is problem dependent, i.e. it depends upon the number of qubits required to be used to represent an element in the index set. The third algorithm again requires only a single step and this algorithm makes use of a fixed (same) operator. It is known that algorithm for unstructured database search can be easily adaptable for solving NP-Complete problems. However, the computatio...

View PDFchevron_right
Decrease in query complexity for quantum computers with superposition of circuits
Mateus Araújo

2014

View PDFchevron_right
Boolean Functions with a Low Polynomial Degree and Quantum Query Algorithms
Daina Taimiņa, Lelde Lace

Lecture Notes in Computer Science, 2005

The complexity of quantum query algorithms computing Boolean functions is strongly related to the degree of the algebraic polynomial representing this Boolean function. There are two related difficult open problems. First, Boolean functions are sought for which the complexity of exact quantum query algorithms is essentially less than the complexity of deterministic query algorithms for the same function. Second, Boolean functions are sought for which the degree of the representing polynomial is essentially less than the complexity of deterministic query algorithms. We present in this paper new techniques to solve the second problem.

View PDFchevron_right

References (20)

  1. S. Aaronson, "Algorithms for Boolean function query properties," to appear in SIAM Journal on Computing.
  2. F. Alizadeh, "Interior point methods in semidefinite programming with applications to combinatorial opti- mization," SIAM J. Optimization, 5 (1995), pp. 13-51.
  3. A. Ambainis, "Quantum lower bounds by quantum ar- guments," Proceedings of the 32nd Annual ACM Sym- posium on the Theory of Computing (STOC), pp. 636- 643, 2000.
  4. A. Ambainis, "Quantum lower bounds by quantum ar- guments," Journal of Computer and System Sciences, 64(2002), pp. 750-767.
  5. H. Barnum, M. E. Saks "A lower bound on the quantum query complexity of read-once functions," Electronic Colloquium on Computational Complexity (ECCC)(002): (2002)
  6. R. Beals, H. Buhrman, R. Cleve, M. Mosca, and R. de Wolf, "Quantum lower bounds by polynomi- als," Proc. 39th IEEE Symp. on Foundations of Comp. Sci.(FOCS), 1998, pp. 352-361.
  7. C. H. Bennett, G. Brassard, E. Bernstein, and U. Vazi- rani, "Strengths and weaknesses of quantum comput- ing," SIAM Journal on Computing, 26 (1997), pp. 1510-1523.
  8. M. Grötschel, L. Lovász and A. Schrijver, Geomet- ric Algorithms and Combinatorial Optimization Algo- rithms and Combinatorics 2, Springer-Verlag, Berlin, 1988.
  9. Lov Grover, "A fast quantum mechanical algorithm for database search," Proc. 28th ACM Symp. on Theory of Computing (STOC), 1998, pp. 212-219.
  10. L. Grover, "Quantum mechanics helps in searching for a needle in a haystack," Physical Review Letters, 79(1997) pp. 325-328.
  11. P. Hoyer, J. Neerbek, and Y.Shi, "Quantum bounds for ordered searching and sorting," Proc. 28th Int. Coll. on Automata Lang. and Prog. (ICALP), 2001, Lecture Notes in Computer Science, vol. 2076, Springer-Verlag, New York, pp. 346-357.
  12. P. Hoyer, J. Neerbek, Y. Shi, "Quantum Complexities of Ordered Searching, Sorting, and Element Distinct- ness" Algorithmica 34 (2002) pp. 429-448.
  13. A. Kitaev "Any quantum coin tossing protocol is sub- ject to same-sided bias", 2002, unpublished.
  14. H. Minc, Nonnegative Matrices, Wiley-Interscience, New York, 1988.
  15. A. Nayak, personal communication.
  16. M.A. Nielsen and I.L. Chuang, Quantum Computa- tion and Quantum Information Cambridge University Press, Cambridge, 2000.
  17. A. Peres, Quantum Theory: Concepts and Methods, Kluwer Academic, Dordrecht, 1993.
  18. R.T. Rockafeller, Convex Analysis, Princeton Univer- sity Press, Princeton, NJ, 1970.
  19. P. W. Shor, "Algorithms for quantum computation: discrete logarithms and factoring," Proc. 37th Ann. Symp. on the Foundations of Comp. Sci. (FOCS), 1994, pp. 56-65.
  20. P. W. Shor, "Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer," SIAM J. Comp. 26 (1997) pp. 1484-1509.

Related papers

Quantum bounded query complexity
Wim van dam

1999

We combine the classical notions and techniques for bounded query classes with those developed in quantum computing. We give strong evidence that quantum queries to an oracle in the class NP does indeed reduce the query complexity of decision problems. Under traditional complexity assumptions, we obtain an exponential speedup between the quantum and the classical query complexity of function classes. For decision problems and function classes we obtain the following results: • P NP[2k] || ⊆ EQP NP[k] || • P NP[2 k+1 −2] || ⊆ EQP NP[k] • FP NP[2 k+1 −2] || ⊆ FEQP NP[2k] • FP NP || ⊆ FEQP NP[O(log n)] For sets A that are many-one complete for PSPACE or EXP we show that FP A ⊆ FEQP A[1]. Sets A that are many-one complete for PP have the property that FP A || ⊆ FEQP A[1]. In general we prove that for any set A there is a set X such that FP A ⊆ FEQP X[1] , establishing that no set is superterse in the quantum setting.

View PDFchevron_right
EXPLICIT RELATION BETWEEN ALL LOWER BOUND TECHNIQUES FOR QUANTUM QUERY COMPLEXITY
Jérémie Roland

International Journal of Quantum Information, 2013

The polynomial method and the adversary method are the two main techniques to prove lower bounds on quantum query complexity, and they have so far been considered as unrelated approaches. Here, we show an explicit reduction from the polynomial method to the multiplicative adversary method. The proof goes by extending the polynomial method from Boolean functions to quantum state generation problems. In the process, the bound is even strengthened. We then show that this extended polynomial method is a special case of the multiplicative adversary method with an adversary matrix that is independent of the function. This new result therefore provides insight on the reason why in some cases the adversary method is stronger than the polynomial method. It also reveals a clear picture of the relation between the different lower bound techniques, as it implies that all known techniques reduce to the multiplicative adversary method.

View PDFchevron_right
Unbounded-error quantum query complexity
Rudy Raymond

Theoretical Computer Science, 2011

This work studies the quantum query complexity of Boolean functions in a scenario where it is only required that the query algorithm succeeds with a probability strictly greater than 1/2. We show that, just as in the communication complexity model, the unbounded error quantum query complexity is exactly half of its classical counterpart for any (partial or total) Boolean function. Moreover, we show that the "black-box" approach to convert quantum query algorithms into communication protocols by Buhrman-Cleve-Wigderson [STOC'98] is optimal even in the unbounded error setting. We also study a setting related to the unbounded error model, called the weakly unbounded error setting, where the cost of a query algorithm is given by q + log(1/2(p -1/2)), where q is the number of queries made and p > 1/2 is the success probability of the algorithm. In contrast to the case of communication complexity, we show a tight Θ(log n) separation between quantum and classical query complexity in the weakly unbounded error setting for a partial Boolean function. We also show the asymptotic equivalence between them for some well-studied total Boolean functions. * Some previous work does not have the factor of 2 in the denominator; see Section 2 for a discussion.

View PDFchevron_right
Quantum Query Complexity of State Conversion
Mario Szegedy, Robert Špalek

2011 IEEE 52nd Annual Symposium on Foundations of Computer Science, 2011

The general adversary bound is a semi-definite program that lower-bounds the number of input queries needed by a quantum algorithm to evaluate a function. It is known to be tight up to constant factors for functions (total or partial) with boolean output and binary input alphabet. We show that the general adversary bound is tight for any function whatsoever, with potentially non-boolean input or output alphabets. We also show that quantum query complexity exhibits a remarkable composition property: Q f (g(x 1 ), . . . , g(x n )) = O Q(f )Q(g) for any compatible functions f, g. This was previously known only in the boolean case.

View PDFchevron_right
Lower Bounds on Quantum Query and Learning Graph Complexities
Ansis Rosmanis

2014

In this thesis we study the power of quantum query algorithms and learning graphs; the latter essentially being very specialized quantum query algorithms themselves. We almost exclusively focus on proving lower bounds for these computational models. First, we study lower bounds on learning graph complexity. We consider two types of learning graphs: adaptive and, more restricted, non-adaptive learning graphs. We express both adaptive and non-adaptive learning graph complexities of Boolean-valued functions (i.e., decision problems) as semidefinite minimization problems, and derive their dual problems. For various functions, we construct feasible solutions to these dual problems, thereby obtaining lower bounds on the learning graph complexity of the functions. Most notably, we prove an almost optimal Ω(n9/7/ √ log n) lower bound on the non-adaptive learning graph complexity of the Triangle problem. We also prove an Ω(n1−2 /(2−1)) lower bound on the adaptive learning graph complexity of...

View PDFchevron_right

Related topics

  • Quantum Computer
  • Boolean function

    • Cited by

    Quantum Identification of Boolean Oracles
    Raymond Putra

    2004

    The oracle identification problem (OIP) is, given a set S of M Boolean oracles out of 2N ones, to determine which oracle in S is the current black-box oracle. We can exploit the information that candidates of the current oracle is restricted to S. The OIP contains several concrete problems such as the original Grover search and the Bernstein-Vazirani problem. Our interest is in the quantum query complexity, for which we present several upper bounds. They are quite general and mostly optimal: (i) The query complexity of OIP is $O(\sqrt{N {\rm log} M {\rm log} N}{\rm log log} M)$ for anyS such that M = |S| > N, which is better than the obvious bound N if M $< 2^{N/log^3 N}$ . (ii) It is $O(\sqrt{N})$ for anyS if |S| = N, which includes the upper bound for the Grover search as a special case. (iii) For a wide range of oracles (|S| = N) such as random oracles and balanced oracles, the query complexity is $O(\sqrt{N/K})$ , where K is a simple parameter determined by S.

    View PDFchevron_right
    Product Rules in Semidefinite Programming
    Mario Szegedy

    Lecture Notes in Computer Science, 2007

    In recent years we have witnessed the proliferation of semidefinite programming bounds in combinatorial optimization , quantum computing and even in complexity theory . Examples to such bounds include the semidefinite relaxation for the maximal cut problem , and the quantum value of multi-prover interactive games . The first semidefinite programming bound, which gained fame, arose in the late seventies and was due to László Lovász , who used his theta number to compute the Shannon capacity of the five cycle graph. As in Lovász's upper bound proof for the Shannon capacity and in other situations the key observation is often the fact that the new parameter in question is multiplicative with respect to the product of the problem instances. In some recent results authors show the parallel repetition theorem for quantum interactive games using product properties of semidefinite relaxation . Our goal is to classify those semidefinite programming instances for which the optimum is multiplicative under a naturally defined product operation. The product operation we define generalizes the ones used in [11] and [4,16]. We find conditions under which the product rule always holds and give examples for cases when the product rule does not hold. These conditions are lated extended to cover the remaining cases too .

    View PDFchevron_right
    Quantum Identification of Boolean Oracles
    Rudy Raymond

    Lecture Notes in Computer Science, 2004

    The oracle identification problem (OIP) is, given a set S of M Boolean oracles out of 2 N ones, to determine which oracle in S is the current black-box oracle. We can exploit the information that candidates of the current oracle is restricted to S. The OIP contains several concrete problems such as the original Grover search and the Bernstein-Vazirani problem. Our interest is in the quantum query complexity, for which we present several upper and lower bounds. They are quite general and mostly optimal: (i) The query complexity of OIP is O( √ N log M log N log log M ) for any S such that M = |S| > N , which is better than the obvious bound for any S if |S| = N , which includes the upper bound for the Grover search as a special case. (iii) For a wide range of oracles (|S| = N ) such as random oracles and balanced oracles, the query complexity is Θ( N/K), where K is a simple parameter determined by S.

    View PDFchevron_right
    580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved