DOCSLIB.ORG

Computational Complexity; Slides 8, HT 2021 PSPACE-Completeness and Quantified Boolean Formulae

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Computational Complexity; Slides 8, HT 2021 PSPACE-Completeness and Quantified Boolean Formulae Computational Complexity; slides 8, HT 2021 PSPACE-completeness and Quantified Boolean Formulae Prof. Paul W. Goldberg (Dept. of Computer Science, University of Oxford) HT 2021 Paul Goldberg PSPACE-completeness and QBFs 1 / 15 Easy theorem: P1 ≤p P2. To reduce P1 to P2, p(jwj) (hM; wi; p) 7! hM; w i where denotes the blank symbol. That is, we can \pad" the original input to give ourselves more space. From polynomial space to linear space recall PSPACE... Generic PSPACE-complete problem P1 Input: hM; wi, a polynomial p Question: Does M accept w in space O(p(jwj))? Linear space version P2: Input: hM; wi Question: Does M accept w in space O(jwj)? Paul Goldberg PSPACE-completeness and QBFs 2 / 15 From polynomial space to linear space recall PSPACE... Generic PSPACE-complete problem P1 Input: hM; wi, a polynomial p Question: Does M accept w in space O(p(jwj))? Linear space version P2: Input: hM; wi Question: Does M accept w in space O(jwj)? Easy theorem: P1 ≤p P2. To reduce P1 to P2, p(jwj) (hM; wi; p) 7! hM; w i where denotes the blank symbol. That is, we can \pad" the original input to give ourselves more space. Paul Goldberg PSPACE-completeness and QBFs 2 / 15 Savitch's Theorem: PSPACE=NPSPACE Let M be an NPSPACE TM of interest; want to know whether M can accept w within 2p(n) steps. Proof idea: predicate reachable(C; C 0; i), satisfied by configurations C; C 0 and integer i, provided C 0 is reachable from C within2 i transitions (w.r.t M). Note: reachable(C; C 0; i) is satisfied provided there exists C 00 such that reachable(C; C 00; i − 1) and reachable(C 00; C 0; i − 1) 00 To check reachable(Cinit ; Caccept ; p(n)), try for all configs C : 00 00 reachable(Cinit ; C ; p(n) − 1) and reachable(C ; Caccept ; p(n) − 1) Which themselves are checked recursively. Depth of recursion is p(n), need to remember at most p(n) configs at any time. We may assume Caccept is unique. Paul Goldberg PSPACE-completeness and QBFs 3 / 15 Savitch's Theorem More generally: Theorem. (Savitch 1970) For all (space-constructible) S : N ! N such that S(n) ≥ log n, NSPACE(S(n)) ⊆ DSPACE(S(n)2). In particular: PSPACE = NPSPACE EXPSPACE = NEXPSPACE Paul Goldberg PSPACE-completeness and QBFs 4 / 15 A PSPACE-complete problem: QBF c.f. Cook's theorem. A more general kind of logic problem characterises PSPACE https://en.wikipedia.org/wiki/True_quantified_Boolean_formula A Quantified Boolean Formula is a formula of the form Q1X1 ::: QnXn'(X1;:::; Xn) where the Qi are quantifiers 9 or 8 ' is a CNF formula in the variables X1;:::; Xn and atoms0 and1 Example 9X18X29X38X48X5 (X1 _ 0 _:X5) ^ (:X2 _ 1 _:X5) ^ (X2 _ X3 _ X4) Paul Goldberg PSPACE-completeness and QBFs 5 / 15 Quantified Boolean Formulae Consider the following problem: QBF Input: A QBF formula '. Question: Is ' true? Observation: For any propositional formula ': ' is satisfiable if, and only if, 9X1 ::: 9Xn' is true. X1;:::; Xn: Variables occurring in ' Consequence: QBF is NP-hard. Similarly, QBF is also co-NP-hard. Paul Goldberg PSPACE-completeness and QBFs 6 / 15 Space complexity: Algorithm uses O(nm) tape cells. (At depth d of recursion tree, remember d simplified versions of '; can be improved to O(n + m) by remembering ' and d bits...) Theorem: QBF is in PSPACE Proof: Given ' := Q1X1 ::: QnXn , letting m := j j Eval-QBF(') if n = 0 Accept if evaluates to true. Reject otherwise. if ' := 9X 0 0 construct '1 := [X 7! 1] if Eval-QBF('1) evaluates to true, accept. 0 else construct '0 := [X 7! 0] (reuse space in Eval-QBF('1)) return Eval-QBF('0) if ' := 8X 0 0 construct '1 := [X 7! 1] if Eval-QBF('1) evaluates to false, reject. 0 else construct '0 := [X 7! 0] (reuse space in Eval-QBF('1)) return Eval-QBF('0) Paul Goldberg PSPACE-completeness and QBFs 7 / 15 Theorem: QBF is in PSPACE Proof: Given ' := Q1X1 ::: QnXn , letting m := j j Eval-QBF(') if n = 0 Accept if evaluates to true. Reject otherwise. if ' := 9X 0 0 construct '1 := [X 7! 1] if Eval-QBF('1) evaluates to true, accept. 0 else construct '0 := [X 7! 0] (reuse space in Eval-QBF('1)) return Eval-QBF('0) if ' := 8X 0 0 construct '1 := [X 7! 1] if Eval-QBF('1) evaluates to false, reject. 0 else construct '0 := [X 7! 0] (reuse space in Eval-QBF('1)) return Eval-QBF('0) Space complexity: Algorithm uses O(nm) tape cells. (At depth d of recursion tree, remember d simplified versions of '; can be improved to O(n + m) by remembering ' and d bits...) Paul Goldberg PSPACE-completeness and QBFs 7 / 15 Describe configuration( q; p; a1 ::: ap(n)) by a set V := fXq; Yi ; Za;i : q 2 Q; a 2 Γ; 0 ≤ i < p(n)g of variables and the truth assignment β defined as n1 s = q n1 s = p n1 a = ai β(Xs ) := β(Ys ) := β(Za;i ) := 0 s 6= q 0 s 6= p 0 a 6= ai Theorem: QBF is NPSPACE-hard Let L 2 NPSPACE. We show L ≤p QBF. Let M := (Q; Σ; Γ; q0; ∆; Fa; Fr ) be a TM deciding L such that M never uses more than p(n) cells. ∗ For each input w 2 Σ , jwj = n, we construct a formula 'M;w such that M accepts w if, and only if, 'M;w is true. Paul Goldberg PSPACE-completeness and QBFs 8 / 15 Theorem: QBF is NPSPACE-hard Let L 2 NPSPACE. We show L ≤p QBF. Let M := (Q; Σ; Γ; q0; ∆; Fa; Fr ) be a TM deciding L such that M never uses more than p(n) cells. ∗ For each input w 2 Σ , jwj = n, we construct a formula 'M;w such that M accepts w if, and only if, 'M;w is true. Describe configuration( q; p; a1 ::: ap(n)) by a set V := fXq; Yi ; Za;i : q 2 Q; a 2 Γ; 0 ≤ i < p(n)g of variables and the truth assignment β defined as n1 s = q n1 s = p n1 a = ai β(Xs ) := β(Ys ) := β(Za;i ) := 0 s 6= q 0 s 6= p 0 a 6= ai Paul Goldberg PSPACE-completeness and QBFs 8 / 15 NPSPACE-Hardness of QBF Consider the following formula Conf(V) with free variables V := Xq; Yi ; Za;i : q 2 Q; a 2 Γ; 0 ≤ i < p(n) _ ^ _ ^ Conf(V) := Xq ^ :Xq0 ^ Yp ^ :Yp0 ^ q2Q q06=q p≤p(n) p06=p ^ _ ^ Za;i ^ :Zb;i 1≤i≤p(n) a2Γ b6=a2Γ Definition. For any truth assignment β of V define config(V; β) as (q; p; w1 ::: wp(n)): β(Xq) = β(Yp) = β(Zwi ;i ) = 1; 8i ≤ p(n) Lemma If β satisfies Conf(V) then jconfig(V; β)j = 1. Paul Goldberg PSPACE-completeness and QBFs 9 / 15 NPSPACE-hardness of QBF Definition. For an assignment β of V we defined config(V; β) as (q; p; w1 ::: wp(n)): β(Xq) = β(Yp) = β(Zwi ;i ) = 1; 8i ≤ p(n) Lemma If β satisfies Conf(V) then jconfig(V; β)j = 1. Remark. β may be defined on other variables than those in V. config(V; β) is a potential configuration of M, but it might not be reachable from the start configuration of M on input w. Conversely: Every configuration( q; p; w1 ::: wp(n)) induces a satisfying assignment. Paul Goldberg PSPACE-completeness and QBFs 10 / 15 NPSPACE-Hardness of QBF Consider the following formula Next(V; V0) defined as Conf(V) ^ Conf(V0) ^ Nochange(V; V0) ^ Change(V; V0). ^ ^ 0 Nochange := Yp ) (Za;i $ Za;i ) 1≤p≤p(n) i6=p a2Γ ^ Change := (Yp ^ Xq ^ Za;p) ) 1≤p≤p(n) _ 0 0 0 (Xq0 ^ Zb;p ^ Y\p + m") (q;a;q0;b;m)2∆ Lemma For any assignment β defined on V; V0: 0 0 β satisfies Next(V; V ) () config(V; β) `M config(V ; β) Paul Goldberg PSPACE-completeness and QBFs 11 / 15 For i ! i + 1: h i Idea: Pathi+1(V1; V2) := 9V Conf(V) ^ Pathi (V1; V) ^ Pathi (V; V2) i Problem: jPathi j = O(2 ) (Reduction would use exp. time/space) New Idea: Pathi+1(V1; V2) := 9V Conf(V) ^ (Z1 = V1 ^ Z2 = V) 8Z18Z2 _ ! Pathi (Z1; Z2) (Z1 = V ^ Z2 = V2) Lemma For any assignment β defined on V1; V2: If β satisfies Pathi (V1; V2), then i config(V2; β) is reachable from config(V1; β) in ≤ 2 steps. NPSPACE-hardness of QBF Define Pathi (V1; V2): i M starting on config(V1; β) can reach config(V2; β) in ≤ 2 steps. For i = 0: Path0 := V1 = V2 _ Next(V1; V2) Paul Goldberg PSPACE-completeness and QBFs 12 / 15 i Problem: jPathi j = O(2 ) (Reduction would use exp. time/space) New Idea: Pathi+1(V1; V2) := 9V Conf(V) ^ (Z1 = V1 ^ Z2 = V) 8Z18Z2 _ ! Pathi (Z1; Z2) (Z1 = V ^ Z2 = V2) Lemma For any assignment β defined on V1; V2: If β satisfies Pathi (V1; V2), then i config(V2; β) is reachable from config(V1; β) in ≤ 2 steps. NPSPACE-hardness of QBF Define Pathi (V1; V2): i M starting on config(V1; β) can reach config(V2; β) in ≤ 2 steps. For i = 0: Path0 := V1 = V2 _ Next(V1; V2) For i ! i + 1: h i Idea: Pathi+1(V1; V2) := 9V Conf(V) ^ Pathi (V1; V) ^ Pathi (V; V2) Paul Goldberg PSPACE-completeness and QBFs 12 / 15 New Idea: Pathi+1(V1; V2) := 9V Conf(V) ^ (Z1 = V1 ^ Z2 = V) 8Z18Z2 _ ! Pathi (Z1; Z2) (Z1 = V ^ Z2 = V2) Lemma For any assignment β defined on V1; V2: If β satisfies Pathi (V1; V2), then i config(V2; β) is reachable from config(V1; β) in ≤ 2 steps.
Load more

Recommended publications
  • Database Theory
    DATABASE THEORY Lecture 4: Complexity of FO Query Answering Markus Krotzsch¨ TU Dresden, 21 April 2016 Overview 1. Introduction | Relational data model 2. First-order queries 3. Complexity of query answering 4. Complexity of FO query answering 5. Conjunctive queries 6. Tree-like conjunctive queries 7. Query optimisation 8. Conjunctive Query Optimisation / First-Order Expressiveness 9. First-Order Expressiveness / Introduction to Datalog 10. Expressive Power and Complexity of Datalog 11. Optimisation and Evaluation of Datalog 12. Evaluation of Datalog (2) 13. Graph Databases and Path Queries 14. Outlook: database theory in practice See course homepage [) link] for more information and materials Markus Krötzsch, 21 April 2016 Database Theory slide 2 of 41 How to Measure Query Answering Complexity Query answering as decision problem { consider Boolean queries Various notions of complexity: • Combined complexity (complexity w.r.t. size of query and database instance) • Data complexity (worst case complexity for any fixed query) • Query complexity (worst case complexity for any fixed database instance) Various common complexity classes: L ⊆ NL ⊆ P ⊆ NP ⊆ PSpace ⊆ ExpTime Markus Krötzsch, 21 April 2016 Database Theory slide 3 of 41 An Algorithm for Evaluating FO Queries function Eval(', I) 01 switch (') f I 02 case p(c1, ::: , cn): return hc1, ::: , cni 2 p 03 case : : return :Eval( , I) 04 case 1 ^ 2 : return Eval( 1, I) ^ Eval( 2, I) 05 case 9x. : 06 for c 2 ∆I f 07 if Eval( [x 7! c], I) then return true 08 g 09 return false 10 g Markus Krötzsch, 21 April 2016 Database Theory slide 4 of 41 FO Algorithm Worst-Case Runtime Let m be the size of ', and let n = jIj (total table sizes) • How many recursive calls of Eval are there? { one per subexpression: at most m • Maximum depth of recursion? { bounded by total number of calls: at most m • Maximum number of iterations of for loop? { j∆Ij ≤ n per recursion level { at most nm iterations I • Checking hc1, ::: , cni 2 p can be done in linear time w.r.t.
    [Show full text]
  • Interactive Proof Systems and Alternating Time-Space Complexity
    Theoretical Computer Science 113 (1993) 55-73 55 Elsevier Interactive proof systems and alternating time-space complexity Lance Fortnow” and Carsten Lund** Department of Computer Science, Unicersity of Chicago. 1100 E. 58th Street, Chicago, IL 40637, USA Abstract Fortnow, L. and C. Lund, Interactive proof systems and alternating time-space complexity, Theoretical Computer Science 113 (1993) 55-73. We show a rough equivalence between alternating time-space complexity and a public-coin interactive proof system with the verifier having a polynomial-related time-space complexity. Special cases include the following: . All of NC has interactive proofs, with a log-space polynomial-time public-coin verifier vastly improving the best previous lower bound of LOGCFL for this model (Fortnow and Sipser, 1988). All languages in P have interactive proofs with a polynomial-time public-coin verifier using o(log’ n) space. l All exponential-time languages have interactive proof systems with public-coin polynomial-space exponential-time verifiers. To achieve better bounds, we show how to reduce a k-tape alternating Turing machine to a l-tape alternating Turing machine with only a constant factor increase in time and space. 1. Introduction In 1981, Chandra et al. [4] introduced alternating Turing machines, an extension of nondeterministic computation where the Turing machine can make both existential and universal moves. In 1985, Goldwasser et al. [lo] and Babai [l] introduced interactive proof systems, an extension of nondeterministic computation consisting of two players, an infinitely powerful prover and a probabilistic polynomial-time verifier. The prover will try to convince the verifier of the validity of some statement.
    [Show full text]
  • On the Randomness Complexity of Interactive Proofs and Statistical Zero-Knowledge Proofs*
    On the Randomness Complexity of Interactive Proofs and Statistical Zero-Knowledge Proofs* Benny Applebaum† Eyal Golombek* Abstract We study the randomness complexity of interactive proofs and zero-knowledge proofs. In particular, we ask whether it is possible to reduce the randomness complexity, R, of the verifier to be comparable with the number of bits, CV , that the verifier sends during the interaction. We show that such randomness sparsification is possible in several settings. Specifically, unconditional sparsification can be obtained in the non-uniform setting (where the verifier is modelled as a circuit), and in the uniform setting where the parties have access to a (reusable) common-random-string (CRS). We further show that constant-round uniform protocols can be sparsified without a CRS under a plausible worst-case complexity-theoretic assumption that was used previously in the context of derandomization. All the above sparsification results preserve statistical-zero knowledge provided that this property holds against a cheating verifier. We further show that randomness sparsification can be applied to honest-verifier statistical zero-knowledge (HVSZK) proofs at the expense of increasing the communica- tion from the prover by R−F bits, or, in the case of honest-verifier perfect zero-knowledge (HVPZK) by slowing down the simulation by a factor of 2R−F . Here F is a new measure of accessible bit complexity of an HVZK proof system that ranges from 0 to R, where a maximal grade of R is achieved when zero- knowledge holds against a “semi-malicious” verifier that maliciously selects its random tape and then plays honestly.
    [Show full text]
  • On the NP-Completeness of the Minimum Circuit Size Problem
    On the NP-Completeness of the Minimum Circuit Size Problem John M. Hitchcock∗ A. Pavany Department of Computer Science Department of Computer Science University of Wyoming Iowa State University Abstract We study the Minimum Circuit Size Problem (MCSP): given the truth-table of a Boolean function f and a number k, does there exist a Boolean circuit of size at most k computing f? This is a fundamental NP problem that is not known to be NP-complete. Previous work has studied consequences of the NP-completeness of MCSP. We extend this work and consider whether MCSP may be complete for NP under more powerful reductions. We also show that NP-completeness of MCSP allows for amplification of circuit complexity. We show the following results. • If MCSP is NP-complete via many-one reductions, the following circuit complexity amplifi- Ω(1) cation result holds: If NP\co-NP requires 2n -size circuits, then ENP requires 2Ω(n)-size circuits. • If MCSP is NP-complete under truth-table reductions, then EXP 6= NP \ SIZE(2n ) for some > 0 and EXP 6= ZPP. This result extends to polylog Turing reductions. 1 Introduction Many natural NP problems are known to be NP-complete. Ladner's theorem [14] tells us that if P is different from NP, then there are NP-intermediate problems: problems that are in NP, not in P, but also not NP-complete. The examples arising out of Ladner's theorem come from diagonalization and are not natural. A canonical candidate example of a natural NP-intermediate problem is the Graph Isomorphism (GI) problem.
    [Show full text]
  • Week 1: an Overview of Circuit Complexity 1 Welcome 2
    Topics in Circuit Complexity (CS354, Fall’11) Week 1: An Overview of Circuit Complexity Lecture Notes for 9/27 and 9/29 Ryan Williams 1 Welcome The area of circuit complexity has a long history, starting in the 1940’s. It is full of open problems and frontiers that seem insurmountable, yet the literature on circuit complexity is fairly large. There is much that we do know, although it is scattered across several textbooks and academic papers. I think now is a good time to look again at circuit complexity with fresh eyes, and try to see what can be done. 2 Preliminaries An n-bit Boolean function has domain f0; 1gn and co-domain f0; 1g. At a high level, the basic question asked in circuit complexity is: given a collection of “simple functions” and a target Boolean function f, how efficiently can f be computed (on all inputs) using the simple functions? Of course, efficiency can be measured in many ways. The most natural measure is that of the “size” of computation: how many copies of these simple functions are necessary to compute f? Let B be a set of Boolean functions, which we call a basis set. The fan-in of a function g 2 B is the number of inputs that g takes. (Typical choices are fan-in 2, or unbounded fan-in, meaning that g can take any number of inputs.) We define a circuit C with n inputs and size s over a basis B, as follows. C consists of a directed acyclic graph (DAG) of s + n + 2 nodes, with n sources and one sink (the sth node in some fixed topological order on the nodes).
    [Show full text]
  • The Complexity Zoo
    The Complexity Zoo Scott Aaronson www.ScottAaronson.com LATEX Translation by Chris Bourke [email protected] 417 classes and counting 1 Contents 1 About This Document 3 2 Introductory Essay 4 2.1 Recommended Further Reading ......................... 4 2.2 Other Theory Compendia ............................ 5 2.3 Errors? ....................................... 5 3 Pronunciation Guide 6 4 Complexity Classes 10 5 Special Zoo Exhibit: Classes of Quantum States and Probability Distribu- tions 110 6 Acknowledgements 116 7 Bibliography 117 2 1 About This Document What is this? Well its a PDF version of the website www.ComplexityZoo.com typeset in LATEX using the complexity package. Well, what’s that? The original Complexity Zoo is a website created by Scott Aaronson which contains a (more or less) comprehensive list of Complexity Classes studied in the area of theoretical computer science known as Computa- tional Complexity. I took on the (mostly painless, thank god for regular expressions) task of translating the Zoo’s HTML code to LATEX for two reasons. First, as a regular Zoo patron, I thought, “what better way to honor such an endeavor than to spruce up the cages a bit and typeset them all in beautiful LATEX.” Second, I thought it would be a perfect project to develop complexity, a LATEX pack- age I’ve created that defines commands to typeset (almost) all of the complexity classes you’ll find here (along with some handy options that allow you to conveniently change the fonts with a single option parameters). To get the package, visit my own home page at http://www.cse.unl.edu/~cbourke/.
    [Show full text]
  • University Microfilms International 300 North Zeeb Road Ann Arbor, Michigan 48106 USA St John's Road
    INFORMATION TO USERS This material was produced from a microfilm copy of the original document. While the most advanced technological means to photograph and reproduce this document have been used, the quality is heavily dependant upon the quality of the original submitted. The following explanation of techniques is provided to help you understand markings or patterns which may appear on this reproduction. 1. The sign or "target" for pages apparently lacking from the document photographed is "Missing Page(s)". If it was possible to obtain the missing page(s) or section, they are spliced into the film along with adjacent pages. This may have necessitated cutting thru an image and duplicating adjacent pages to insure you complete continuity. 2. When an image on the film is obliterated with a large round black mark, it is an indication that the photographer suspected that the copy may have moved during exposure and thus cause a blurred image. You w ill find a good image of the page in the adjacent frame. 3. When a map, drawing or chart, etc., was part of the material being photographed the photographer followed a definite method in "sectioning" the material. It is customary to begin photoing at the upper left hand corner of a large sheet and to continue photoing from left to right in equal sections with a small overlap. If necessary, sectioning is continued again — beginning below the first row and continuing on until complete. 4. The majority of users indicate that the textual content is of greatest value, however, a somewhat higher quality reproduction could be made from "photographs" if essential to the understanding of the dissertation.
    [Show full text]
  • The Correlation Among Software Complexity Metrics with Case Study
    International Journal of Advanced Computer Research (ISSN (print): 2249-7277 ISSN (online): 2277-7970) Volume-4 Number-2 Issue-15 June-2014 The Correlation among Software Complexity Metrics with Case Study Yahya Tashtoush1, Mohammed Al-Maolegi2, Bassam Arkok3 Abstract software product attributes such as functionality, quality, complexity, efficiency, reliability or People demand for software quality is growing maintainability. For example, a higher number of increasingly, thus different scales for the software code lines will lead to greater software complexity are growing fast to handle the quality of software. and so on. The software complexity metric is one of the measurements that use some of the internal The complexity of software effects on maintenance attributes or characteristics of software to know how activities like software testability, reusability, they effect on the software quality. In this paper, we understandability and modifiability. Software cover some of more efficient software complexity complexity is defined as ―the degree to which a metrics such as Cyclomatic complexity, line of code system or component has a design or implementation and Hallstead complexity metric. This paper that is difficult to understand and verify‖ [1]. All the presents their impacts on the software quality. It factors that make program difficult to understand are also discusses and analyzes the correlation between responsible for complexity. So it is necessary to find them. It finally reveals their relation with the measurements for software to reduce the impacts of number of errors using a real dataset as a case the complexity and guarantee the quality at the same study. time as much as possible.
    [Show full text]
  • Interactive Proofs for Quantum Computations
    Innovations in Computer Science 2010 Interactive Proofs For Quantum Computations Dorit Aharonov Michael Ben-Or Elad Eban School of Computer Science, The Hebrew University of Jerusalem, Israel [email protected] [email protected] [email protected] Abstract: The widely held belief that BQP strictly contains BPP raises fundamental questions: Upcoming generations of quantum computers might already be too large to be simulated classically. Is it possible to experimentally test that these systems perform as they should, if we cannot efficiently compute predictions for their behavior? Vazirani has asked [21]: If computing predictions for Quantum Mechanics requires exponential resources, is Quantum Mechanics a falsifiable theory? In cryptographic settings, an untrusted future company wants to sell a quantum computer or perform a delegated quantum computation. Can the customer be convinced of correctness without the ability to compare results to predictions? To provide answers to these questions, we define Quantum Prover Interactive Proofs (QPIP). Whereas in standard Interactive Proofs [13] the prover is computationally unbounded, here our prover is in BQP, representing a quantum computer. The verifier models our current computational capabilities: it is a BPP machine, with access to few qubits. Our main theorem can be roughly stated as: ”Any language in BQP has a QPIP, and moreover, a fault tolerant one” (providing a partial answer to a challenge posted in [1]). We provide two proofs. The simpler one uses a new (possibly of independent interest) quantum authentication scheme (QAS) based on random Clifford elements. This QPIP however, is not fault tolerant. Our second protocol uses polynomial codes QAS due to Ben-Or, Cr´epeau, Gottesman, Hassidim, and Smith [8], combined with quantum fault tolerance and secure multiparty quantum computation techniques.
    [Show full text]
  • Lecture 11 1 Non-Uniform Complexity
    Notes on Complexity Theory Last updated: October, 2011 Lecture 11 Jonathan Katz 1 Non-Uniform Complexity 1.1 Circuit Lower Bounds for a Language in §2 \ ¦2 We have seen that there exist \very hard" languages (i.e., languages that require circuits of size (1 ¡ ")2n=n). If we can show that there exists a language in NP that is even \moderately hard" (i.e., requires circuits of super-polynomial size) then we will have proved P 6= NP. (In some sense, it would be even nicer to show some concrete language in NP that requires circuits of super-polynomial size. But mere existence of such a language is enough.) c Here we show that for every c there is a language in §2 \ ¦2 that is not in size(n ). Note that this does not prove §2 \ ¦2 6⊆ P=poly since, for every c, the language we obtain is di®erent. (Indeed, using the time hierarchy theorem, we have that for every c there is a language in P that is not in time(nc).) What is particularly interesting here is that (1) we prove a non-uniform lower bound and (2) the proof is, in some sense, rather simple. c Theorem 1 For every c, there is a language in §4 \ ¦4 that is not in size(n ). Proof Fix some c. For each n, let Cn be the lexicographically ¯rst circuit on n inputs such c that (the function computed by) Cn cannot be computed by any circuit of size at most n . By the c+1 non-uniform hierarchy theorem (see [1]), there exists such a Cn of size at most n (for n large c enough).
    [Show full text]
  • Simple Doubly-Efficient Interactive Proof Systems for Locally
    Electronic Colloquium on Computational Complexity, Revision 3 of Report No. 18 (2017) Simple doubly-efficient interactive proof systems for locally-characterizable sets Oded Goldreich∗ Guy N. Rothblumy September 8, 2017 Abstract A proof system is called doubly-efficient if the prescribed prover strategy can be implemented in polynomial-time and the verifier’s strategy can be implemented in almost-linear-time. We present direct constructions of doubly-efficient interactive proof systems for problems in P that are believed to have relatively high complexity. Specifically, such constructions are presented for t-CLIQUE and t-SUM. In addition, we present a generic construction of such proof systems for a natural class that contains both problems and is in NC (and also in SC). The proof systems presented by us are significantly simpler than the proof systems presented by Goldwasser, Kalai and Rothblum (JACM, 2015), let alone those presented by Reingold, Roth- blum, and Rothblum (STOC, 2016), and can be implemented using a smaller number of rounds. Contents 1 Introduction 1 1.1 The current work . 1 1.2 Relation to prior work . 3 1.3 Organization and conventions . 4 2 Preliminaries: The sum-check protocol 5 3 The case of t-CLIQUE 5 4 The general result 7 4.1 A natural class: locally-characterizable sets . 7 4.2 Proof of Theorem 1 . 8 4.3 Generalization: round versus computation trade-off . 9 4.4 Extension to a wider class . 10 5 The case of t-SUM 13 References 15 Appendix: An MA proof system for locally-chracterizable sets 18 ∗Department of Computer Science, Weizmann Institute of Science, Rehovot, Israel.
    [Show full text]
  • On the Computational Complexity of Maintaining GPS Clock in Packet Scheduling
    On the Computational Complexity of Maintaining GPS Clock in Packet Scheduling Qi (George) Zhao Jun (Jim) Xu College of Computing Georgia Institute of Technology qzhao, jx ¡ @cc.gatech.edu Abstract— Packet scheduling is an important mechanism to selects the one with the lowest GPS virtual finish time provide QoS guarantees in data networks. A scheduling algorithm among the packets currently in queue to serve next. generally consists of two functions: one estimates how the GPS We study an open problem concerning the complexity lower (General Processor Sharing) clock progresses with respect to the real time; the other decides the order of serving packets based bound for computing the GPS virtual finish times of the ' on an estimation of their GPS start/finish times. In this work, we packets. This complexity has long been believed to be 01%2 answer important open questions concerning the computational per packe [11], [12], [3], [9], where 2 is the number of complexity of performing the first function. We systematically sessions. For this reason, many scheduling algorithms such study the complexity of computing the GPS virtual start/finish 89,/. ,4,/. 8!:1,/. as +-,435.76 [2], [7], [11], and [6] times of the packets, which has long been believed to be ¢¤£¦¥¨§ per packet but has never been either proved or refuted. We only approximate the GPS clock (with certain error), trading also answer several other related questions such as “whether accuracy for lower complexity. However, it has never been the complexity can be lower if the only thing that needs to be carefully studied whether the complexity lower bound of computed is the relative order of the GPS finish times of the ' tracking GPS clock perfectly is indeed 01;2 per packet.
    [Show full text]