DOCSLIB.ORG

CS5110 Computational Complexity Recap NL Equals Conl

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

CS5110 Computational Complexity Lecturer: Karteek Sreenivasaiah Lecture: 5 Scribe: Udit Maniyar 13th Aug 2019 Recap In the previous lecture, introduced the following language: PATH = fhG; s; ti j G is a directed Graph that has a path from s to tg and showed the following easy theorem: Theorem 1 PATH 2 NL Proof: The nondeterministic log space Turing machine deciding PATH starts at node s and non-deterministically guesses the nodes of a path from s to t. This machine keeps track of only the current node at each step and the length of the path it has covered till now. We cannot store the total path because storing path would exceed logarithmic space. At each step we branch out into all of its neighbours and increase the length of the path by 1. If the length of the path is more than number of nodes in the Graph we reject it. If we have found node t then we accept it. If we really have a path from s to t then we must find a valid sequence of non-deterministic choices and hence must have accepted it. If we don't have a path from s to t then the length exceeds in all branches and hence we reject it. Thus, PATH is in NL. NL equals coNL In this lecture, we show the following surprising theorem by Immerman and Szelepcs´enyi: Theorem 2 NL = coNL Proof: We have seen in the previous class than PATH is NL-Complete. To prove NL = coNL it suffices to prove that PATH is in coNL. The NL algorithm M that we present for PATH must have an accepting computation whenever the input graph G does not contain a path from s to t. Instead of looking at the bigger problem we consider an easier version of the problem. Let c be the number of nodes in G that are reachable from s. We consider c to be given in input of M. We now use c to solve PATH. Later we will show how to compute c. Given G; s; t, and c the machine M operates as follows. 5-1 1. One by one for each Vertex v 2 V guess whether v is reachable from s 2. Maintain a variable count which counts the number of vertices which have been verified to be reachable from s. (a) We already know that PATH is in NL. So we can use the same non deterministic algorithm to check if there is a path from v to s. (b) If the Verification succeeds then increment count (c) If v = t then reject 3. When the branch has covered all of G0s vertices, we check if the number of vertices that it verified to be reachable from s i.e count equals c(the number of nodes that actually are reachable) and rejects if they are not equal. Otherwise, this branch accepts. Space Complexity Analysis: jCountj 2 O(log jV j) PATH 2 O(log jV j). Other than that we just store some constant number of vertices. Hence the machine M 2 O(log jV j) We now have to calculate c, the number of nodes reachable from s. We give a non- deterministic log space algorithm for this problem. At the end of the algorithm we will be left with atleast one accepting branch which contains correct value of c and all other branches will reject. Let Ai be the set of vertices at a distance of at most i steps from s. Let ci = jAij and jV j = m. By definition Ai ⊆ Ai+1. Then A0 = fsg and c0 = 1. Goal : Compute cm If we can compute jci+1j knowing ci then repeated application of this procedure yields the desired value of c = cm. To check if a node v is in Ai+1, we go through all the nodes of G one by one and guess whether each node is in Ai. If we have guessed that a node is in Ai then we try to verify it by checking if there exists a path of length at most i from s to the selected node. If we find that a node u is in Ai, now we check if (u; v) is an edge of G. If it is an edge, this means v is in Ai+1. Along with checking if a node is in Ai or not we also count the number of nodes which we have verified in Ai in count. If we have checked all the vertices in the Graph then we compare count and ci. If count 6= ci this means all vertices in Ai have not been found, so this computation branch rejects. If count = ci and v is not in Ai+1, we go to the next v. Algorithm c_{0} = 1 For i = 0 to m-1 { 5-2 Let c_{i+1} = 1 For v in V\{s} { count = 0 For u in V { Nondeterministically either perform or skip these steps: Nondeterministically Guess a path of length <= i from s to u. Verify the Guess. If Verification fails Reject. If Verification succeeds count++ If (u, v) is an Edge of G c_{i+1}++; Go to next v } If count != c_{i} reject } } At the end we will know c_m. Space Complexity Analysis: This algorithm only stores ci; ci+1; count; u; v; i at any moment and hence it is in log space. Hence Proved PATH 2 coNL =) NL = coNL. Summary of Relationships between complexity classes L ⊆ NL = coNL ⊆ P ⊆ NP ⊆ PSPACE We only know that NL ( PSPACE, but we dont know if coNL ( P or P ( PSPACE holds. Oracles and relativization Oracle machines An oracle is a machine which checks for a membership of a string w in a Language A in single computation step. An oracle Turing machine M A is a modified Turing machine that has access to oracle which decides A. Define PA to be the class of languages which are decidable in polynomial time by a deterministic oracle turing machine that uses oracle A. Similarly define NPA to be the class 5-3 of languages which are decidable in polynomial time by a non-deterministic oracle turing machine that uses oracle A. Limits Of The Diagonalization Method Diagonalization is a simulation of one Turing machine by another. Any Theorem which we can prove by Turing Machine using the Diagonalization should hold even when both the Turing machines are given the same oracle. This means if we could prove P 6= NP using Diagonalization, then the same should hold when these Turing Machine's are given an oracle A, but this is not true because we can find an oracle A using which PA = NPA Similarly we cant prove P = NP because we can find an oracle B s.t PB 6= NPB The Baker-Gill-Solovay Theorem Theorem 3 1. An oracle A exists such that PA = NPA. 2. An oracle B exists such that PB 6= NPB. Proof: Finding an oracle A such that PA = NPA • Let A be oracle for TQBF. We know that TQBF is PSPACE-complete language which means we can decide any language in PSPACE using a single oracle call. =) PSPACE ⊆ PT QBF • A non deterministic polynomial time oracle Turing machine machine can be converted to Non deterministic Polynomial space turing machine because the length of non de- terministic choices is at most a polynomial and we require atmost polynomial space to solve TQBF Oracle queries. =) NPT QBF ⊆ NPSPACE • From Savitchs theorem we have NPSPACE ⊆ PSPACE From the above 3 points we have the series of containments. NPTQBF ⊆ NPSPACE ⊆ PSPACE ⊆ PTQBF . Hence we conclude that PT QBF = NPT QBF B B Now we will create a language(Oracle) B s.t LB ⊆ NP & LB ( P . Let B be any language. We define the language LB as: LB = fw j 9x s.t jxj = jwj&x 2 Bg 5-4 B For any B, the language LB is in NP . This is because given any input w we guess all strings of length jwj and query the oracle B. If anyone of the branches accept then we accept. Else reject. B To show LB 2= P , we do as follows. Let M1;M2;::: be a sequence of all polynomial time i n oracle TM's. We assume Mi runs in time n . Now we will make each machine determine 1 wrongly. Stage i: Choose n to be larger than any string whose status is already determined and n i n such that 2 > n . We run Mi on input 1 and respond to its oracle queries as follows: If Mi queries a string whose status has already been determined, we respond consistently, else i we return NO. We continue the simulation of Mi for n time units. If Mi finds a string of length n in B, it should accept. If Mi determines that all strings of length n are not in B, it should reject. But we don't give Mi enough time to brute force on all the strings of length n. This means when Mi must decide to accept or reject it is not having enough data to give the correct answer since for all the new strings it has asked we have only given false. If the final decision of Mi is accept, then we put all strings of length n to be in B. If we n do this then 1 2= LB, but since the machine accepted the string so we have a contradiction.
Recommended publications
  • Computational Complexity: a Modern Approach

    Computational Complexity: a Modern Approach

    i Computational Complexity: A Modern Approach Draft of a book: Dated January 2007 Comments welcome! Sanjeev Arora and Boaz Barak Princeton University [email protected] Not to be reproduced or distributed without the authors’ permission This is an Internet draft. Some chapters are more finished than others. References and attributions are very preliminary and we apologize in advance for any omissions (but hope you will nevertheless point them out to us). Please send us bugs, typos, missing references or general comments to [email protected] — Thank You!! DRAFT ii DRAFT Chapter 9 Complexity of counting “It is an empirical fact that for many combinatorial problems the detection of the existence of a solution is easy, yet no computationally efficient method is known for counting their number.... for a variety of problems this phenomenon can be explained.” L. Valiant 1979 The class NP captures the difficulty of finding certificates. However, in many contexts, one is interested not just in a single certificate, but actually counting the number of certificates. This chapter studies #P, (pronounced “sharp p”), a complexity class that captures this notion. Counting problems arise in diverse fields, often in situations having to do with estimations of probability. Examples include statistical estimation, statistical physics, network design, and more. Counting problems are also studied in a field of mathematics called enumerative combinatorics, which tries to obtain closed-form mathematical expressions for counting problems. To give an example, in the 19th century Kirchoff showed how to count the number of spanning trees in a graph using a simple determinant computation. Results in this chapter will show that for many natural counting problems, such efficiently computable expressions are unlikely to exist.
  • Sharp Lower Bounds for the Dimension of Linearizations of Matrix Polynomials∗

    Sharp Lower Bounds for the Dimension of Linearizations of Matrix Polynomials∗

    Electronic Journal of Linear Algebra ISSN 1081-3810 A publication of the International Linear Algebra Society Volume 17, pp. 518-531, November 2008 ELA SHARP LOWER BOUNDS FOR THE DIMENSION OF LINEARIZATIONS OF MATRIX POLYNOMIALS∗ FERNANDO DE TERAN´ † AND FROILAN´ M. DOPICO‡ Abstract. A standard way of dealing with matrixpolynomial eigenvalue problems is to use linearizations. Byers, Mehrmann and Xu have recently defined and studied linearizations of dimen- sions smaller than the classical ones. In this paper, lower bounds are provided for the dimensions of linearizations and strong linearizations of a given m × n matrixpolynomial, and particular lineariza- tions are constructed for which these bounds are attained. It is also proven that strong linearizations of an n × n regular matrixpolynomial of degree must have dimension n × n. Key words. Matrixpolynomials, Matrixpencils, Linearizations, Dimension. AMS subject classifications. 15A18, 15A21, 15A22, 65F15. 1. Introduction. We will say that a matrix polynomial of degree ≥ 1 −1 P (λ)=λ A + λ A−1 + ···+ λA1 + A0, (1.1) m×n where A0,A1,...,A ∈ C and A =0,is regular if m = n and det P (λ)isnot identically zero as a polynomial in λ. We will say that P (λ)issingular otherwise. A linearization of P (λ)isamatrix pencil L(λ)=λX + Y such that there exist unimod- ular matrix polynomials, i.e., matrix polynomials with constant nonzero determinant, of appropriate dimensions, E(λ)andF (λ), such that P (λ) 0 E(λ)L(λ)F (λ)= , (1.2) 0 Is where Is denotes the s × s identity matrix. Classically s =( − 1) min{m, n}, but recently linearizations of smaller dimension have been considered [3].
  • Complexity Theory

    Complexity Theory

    Complexity Theory Course Notes Sebastiaan A. Terwijn Radboud University Nijmegen Department of Mathematics P.O. Box 9010 6500 GL Nijmegen the Netherlands [email protected] Copyright c 2010 by Sebastiaan A. Terwijn Version: December 2017 ii Contents 1 Introduction 1 1.1 Complexity theory . .1 1.2 Preliminaries . .1 1.3 Turing machines . .2 1.4 Big O and small o .........................3 1.5 Logic . .3 1.6 Number theory . .4 1.7 Exercises . .5 2 Basics 6 2.1 Time and space bounds . .6 2.2 Inclusions between classes . .7 2.3 Hierarchy theorems . .8 2.4 Central complexity classes . 10 2.5 Problems from logic, algebra, and graph theory . 11 2.6 The Immerman-Szelepcs´enyi Theorem . 12 2.7 Exercises . 14 3 Reductions and completeness 16 3.1 Many-one reductions . 16 3.2 NP-complete problems . 18 3.3 More decision problems from logic . 19 3.4 Completeness of Hamilton path and TSP . 22 3.5 Exercises . 24 4 Relativized computation and the polynomial hierarchy 27 4.1 Relativized computation . 27 4.2 The Polynomial Hierarchy . 28 4.3 Relativization . 31 4.4 Exercises . 32 iii 5 Diagonalization 34 5.1 The Halting Problem . 34 5.2 Intermediate sets . 34 5.3 Oracle separations . 36 5.4 Many-one versus Turing reductions . 38 5.5 Sparse sets . 38 5.6 The Gap Theorem . 40 5.7 The Speed-Up Theorem . 41 5.8 Exercises . 43 6 Randomized computation 45 6.1 Probabilistic classes . 45 6.2 More about BPP . 48 6.3 The classes RP and ZPP .
  • Delegating Computation: Interactive Proofs for Muggles∗

    Delegating Computation: Interactive Proofs for Muggles∗

    Electronic Colloquium on Computational Complexity, Revision 1 of Report No. 108 (2017) Delegating Computation: Interactive Proofs for Muggles∗ Shafi Goldwasser Yael Tauman Kalai Guy N. Rothblum MIT and Weizmann Institute Microsoft Research Weizmann Institute [email protected] [email protected] [email protected] Abstract In this work we study interactive proofs for tractable languages. The (honest) prover should be efficient and run in polynomial time, or in other words a \muggle".1 The verifier should be super-efficient and run in nearly-linear time. These proof systems can be used for delegating computation: a server can run a computation for a client and interactively prove the correctness of the result. The client can verify the result's correctness in nearly-linear time (instead of running the entire computation itself). Previously, related questions were considered in the Holographic Proof setting by Babai, Fortnow, Levin and Szegedy, in the argument setting under computational assumptions by Kilian, and in the random oracle model by Micali. Our focus, however, is on the original inter- active proof model where no assumptions are made on the computational power or adaptiveness of dishonest provers. Our main technical theorem gives a public coin interactive proof for any language computable by a log-space uniform boolean circuit with depth d and input length n. The verifier runs in time n · poly(d; log(n)) and space O(log(n)), the communication complexity is poly(d; log(n)), and the prover runs in time poly(n). In particular, for languages computable by log-space uniform NC (circuits of polylog(n) depth), the prover is efficient, the verifier runs in time n · polylog(n) and space O(log(n)), and the communication complexity is polylog(n).
  • 5.2 Intractable Problems -- NP Problems

    5.2 Intractable Problems -- NP Problems

    Algorithms for Data Processing Lecture VIII: Intractable Problems–NP Problems Alessandro Artale Free University of Bozen-Bolzano [email protected] of Computer Science http://www.inf.unibz.it/˜artale 2019/20 – First Semester MSc in Computational Data Science — UNIBZ Some material (text, figures) displayed in these slides is courtesy of: Alberto Montresor, Werner Nutt, Kevin Wayne, Jon Kleinberg, Eva Tardos. A. Artale Algorithms for Data Processing Definition. P = set of decision problems for which there exists a poly-time algorithm. Problems and Algorithms – Decision Problems The Complexity Theory considers so called Decision Problems. • s Decision• Problem. X Input encoded asX a finite“yes” binary string ; • Decision ProblemA : Is conceived asX a set of strings on whichs the answer to the decision problem is ; yes if s ∈ X Algorithm for a decision problemA s receives an input string , and no if s 6∈ X ( ) = A. Artale Algorithms for Data Processing Problems and Algorithms – Decision Problems The Complexity Theory considers so called Decision Problems. • s Decision• Problem. X Input encoded asX a finite“yes” binary string ; • Decision ProblemA : Is conceived asX a set of strings on whichs the answer to the decision problem is ; yes if s ∈ X Algorithm for a decision problemA s receives an input string , and no if s 6∈ X ( ) = Definition. P = set of decision problems for which there exists a poly-time algorithm. A. Artale Algorithms for Data Processing Towards NP — Efficient Verification • • The issue here is the3-SAT contrast between finding a solution Vs. checking a proposed solution.I ConsiderI for example : We do not know a polynomial-time algorithm to find solutions; but Checking a proposed solution can be easily done in polynomial time (just plug 0/1 and check if it is a solution).
  • Lecture 10: Space Complexity III

    Lecture 10: Space Complexity III

    Space Complexity Classes: NL and L Reductions NL-completeness The Relation between NL and coNL A Relation Among the Complexity Classes Lecture 10: Space Complexity III Arijit Bishnu 27.03.2010 Space Complexity Classes: NL and L Reductions NL-completeness The Relation between NL and coNL A Relation Among the Complexity Classes Outline 1 Space Complexity Classes: NL and L 2 Reductions 3 NL-completeness 4 The Relation between NL and coNL 5 A Relation Among the Complexity Classes Space Complexity Classes: NL and L Reductions NL-completeness The Relation between NL and coNL A Relation Among the Complexity Classes Outline 1 Space Complexity Classes: NL and L 2 Reductions 3 NL-completeness 4 The Relation between NL and coNL 5 A Relation Among the Complexity Classes Definition for Recapitulation S c NPSPACE = c>0 NSPACE(n ). The class NPSPACE is an analog of the class NP. Definition L = SPACE(log n). Definition NL = NSPACE(log n). Space Complexity Classes: NL and L Reductions NL-completeness The Relation between NL and coNL A Relation Among the Complexity Classes Space Complexity Classes Definition for Recapitulation S c PSPACE = c>0 SPACE(n ). The class PSPACE is an analog of the class P. Definition L = SPACE(log n). Definition NL = NSPACE(log n). Space Complexity Classes: NL and L Reductions NL-completeness The Relation between NL and coNL A Relation Among the Complexity Classes Space Complexity Classes Definition for Recapitulation S c PSPACE = c>0 SPACE(n ). The class PSPACE is an analog of the class P. Definition for Recapitulation S c NPSPACE = c>0 NSPACE(n ).
  • Lecture 4: Space Complexity II: NL=Conl, Savitch's Theorem

    Lecture 4: Space Complexity II: NL=Conl, Savitch's Theorem

    COM S 6810 Theory of Computing January 29, 2009 Lecture 4: Space Complexity II Instructor: Rafael Pass Scribe: Shuang Zhao 1 Recall from last lecture Definition 1 (SPACE, NSPACE) SPACE(S(n)) := Languages decidable by some TM using S(n) space; NSPACE(S(n)) := Languages decidable by some NTM using S(n) space. Definition 2 (PSPACE, NPSPACE) [ [ PSPACE := SPACE(nc), NPSPACE := NSPACE(nc). c>1 c>1 Definition 3 (L, NL) L := SPACE(log n), NL := NSPACE(log n). Theorem 1 SPACE(S(n)) ⊆ NSPACE(S(n)) ⊆ DTIME 2 O(S(n)) . This immediately gives that N L ⊆ P. Theorem 2 STCONN is NL-complete. 2 Today’s lecture Theorem 3 N L ⊆ SPACE(log2 n), namely STCONN can be solved in O(log2 n) space. Proof. Recall the STCONN problem: given digraph (V, E) and s, t ∈ V , determine if there exists a path from s to t. 4-1 Define boolean function Reach(u, v, k) with u, v ∈ V and k ∈ Z+ as follows: if there exists a path from u to v with length smaller than or equal to k, then Reach(u, v, k) = 1; otherwise Reach(u, v, k) = 0. It is easy to verify that there exists a path from s to t iff Reach(s, t, |V |) = 1. Next we show that Reach(s, t, |V |) can be recursively computed in O(log2 n) space. For all u, v ∈ V and k ∈ Z+: • k = 1: Reach(u, v, k) = 1 iff (u, v) ∈ E; • k > 1: Reach(u, v, k) = 1 iff there exists w ∈ V such that Reach(u, w, dk/2e) = 1 and Reach(w, v, bk/2c) = 1.
  • Computational Complexity: a Modern Approach

    Computational Complexity: a Modern Approach

    i Computational Complexity: A Modern Approach Draft of a book: Dated January 2007 Comments welcome! Sanjeev Arora and Boaz Barak Princeton University [email protected] Not to be reproduced or distributed without the authors’ permission This is an Internet draft. Some chapters are more finished than others. References and attributions are very preliminary and we apologize in advance for any omissions (but hope you will nevertheless point them out to us). Please send us bugs, typos, missing references or general comments to [email protected] — Thank You!! DRAFT ii DRAFT Chapter 5 The Polynomial Hierarchy and Alternations “..synthesizing circuits is exceedingly difficulty. It is even more difficult to show that a circuit found in this way is the most economical one to realize a function. The difficulty springs from the large number of essentially different networks available.” Claude Shannon 1949 This chapter discusses the polynomial hierarchy, a generalization of P, NP and coNP that tends to crop up in many complexity theoretic investigations (including several chapters of this book). We will provide three equivalent definitions for the polynomial hierarchy, using quantified predicates, alternating Turing machines, and oracle TMs (a fourth definition, using uniform families of circuits, will be given in Chapter 6). We also use the hierarchy to show that solving the SAT problem requires either linear space or super-linear time. p p 5.1 The classes Σ2 and Π2 To understand the need for going beyond nondeterminism, let’s recall an NP problem, INDSET, for which we do have a short certificate of membership: INDSET = {hG, ki : graph G has an independent set of size ≥ k} .
  • 1 the Class Conp

    1 the Class Conp

    80240233: Computational Complexity Lecture 3 ITCS, Tsinghua Univesity, Fall 2007 16 October 2007 Instructor: Andrej Bogdanov Notes by: Jialin Zhang and Pinyan Lu In this lecture, we introduce the complexity class coNP, the Polynomial Hierarchy and the notion of oracle. 1 The class coNP The complexity class NP contains decision problems asking this kind of question: On input x, ∃y : |y| = p(|x|) s.t.V (x, y), where p is a polynomial and V is a relation which can be computed by a polynomial time Turing Machine (TM). Some examples: SAT: given boolean formula φ, does φ have a satisfiable assignment? MATCHING: given a graph G, does it have a perfect matching? Now, consider the opposite problems of SAT and MATCHING. UNSAT: given boolean formula φ, does φ have no satisfiable assignment? UNMATCHING: given a graph G, does it have no perfect matching? This kind of problems are called coNP problems. Formally we have the following definition. Definition 1. For every L ⊆ {0, 1}∗, we say that L ∈ coNP if and only if L ∈ NP, i.e. L ∈ coNP iff there exist a polynomial-time TM A and a polynomial p, such that x ∈ L ⇔ ∀y, |y| = p(|x|) A(x, y) accepts. Then the natural question is how P, NP and coNP relate. First we have the following trivial relationships. Theorem 2. P ⊆ NP, P ⊆ coNP For instance, MATCHING ∈ coNP. And we already know that SAT ∈ NP. Is SAT ∈ coNP? If it is true, then we will have NP = coNP. This is the following theorem. Theorem 3. If SAT ∈ coNP, then NP = coNP.
  • Descriptive Complexity Theories

    Descriptive Complexity Theories

    Descriptive Complexity Theories Joerg FLUM ABSTRACT: In this article we review some of the main results of descriptive complexity theory in order to make the reader familiar with the nature of the investigations in this area. We start by presenting the characterization of automata recognizable languages by monadic second-order logic. Afterwards we explain the characteri- zation of various logics by fixed-point logics. We assume familiarity with logic but try to keep knowledge of complexity theory to a minimum. Keywords: Computational complexity theory, complexity classes, descriptive characterizations, monadic second-order logic, fixed-point logic, Turing machine. Complexity theory or more precisely, computational complexity theory (cf. Papadimitriou 1994), tries to classify problems according to the complexity of algorithms solving them. Of course, we can think of various ways of measuring the complexity of an al- gorithm, but the most important and relevant ones are time and space. That is, we think we have a type of machine capable, in principle, to carry out any algorithm, a so-called general purpose machine (or, general purpose computer), and we measure the com- plexity of an algorithm in terms of the time or the number of steps needed to carry out this algorithm. By space, we mean the amount of memory the algorithm uses. Time bounds yield (time) complexity classes consisting of all problems solvable by an algorithm keeping to the time bound. Similarly, space complexity classes are obtained. It turns out that these definitions are quite robust in the sense that, for reasonable time or space bounds, the corresponding complexity classes do not depend on the special type of machine model chosen.
  • Entanglement in Interactive Proof Systems with Binary Answers

    Entanglement in Interactive Proof Systems with Binary Answers

    Entanglement in Interactive Proof Systems with Binary Answers Stephanie Wehner∗ CWI, Kruislaan 413, 1098 SJ Amsterdam, the Netherlands. [email protected] September 25, 2018 Abstract If two classical provers share an entangled state, the resulting interactive proof system is significantly weakened [6]. We show that for the case where the verifier computes the XOR of two binary answers, the resulting proof system is in fact no more powerful than a system based ∗ ∗ on a single quantum prover: MIP [2] QIP(2). This also implies that MIP [2] EXP which was previously shown using⊕ a different⊆ method [7]. This contrasts with⊕ an interactive⊆ proof system where the two provers do not share entanglement. In that case, MIP[2] = NEXP for certain soundness and completeness parameters [6]. ⊕ 1 Introduction Interactive proof systems have received considerable attention [2, 3, 4, 8, 14, 10] since their in- troduction by Babai [1] and Goldwasser, Micali and Rackoff [11] in 1985. An interactive proof system takes the form of a protocol of one or more rounds between two parties, a verifier and a prover. Whereas the prover is computationally unbounded, the verifier is limited to probabilistic polynomial time. Both the prover and the verifier have access to a common input string x. The goal of the prover is to convince the verifier that x belongs to a pre-specified language L. The verifier’s aim, on the other hand, is to determine whether the prover’s claim is indeed valid. In each round, the verifier sends a polynomial (in x) size query to the prover, who returns a polynomial arXiv:quant-ph/0508201v2 14 Jan 2006 size answer.
  • Descriptive Complexity: a Logicians Approach to Computation

    Descriptive Complexity: a Logicians Approach to Computation

    Descriptive Complexity: A Logician’s Approach to Computation N. Immerman basic issue in computer science is there are exponentially many possibilities, the complexity of problems. If one is but in this case no known algorithm is faster doing a calculation once on a than exponential time. medium-sized input, the simplest al- Computational complexity measures how gorithm may be the best method to much time and/or memory space is needed as Ause, even if it is not the fastest. However, when a function of the input size. Let TIME[t(n)] be the one has a subproblem that will have to be solved set of problems that can be solved by algorithms millions of times, optimization is important. A that perform at most O(t(n)) steps for inputs of fundamental issue in theoretical computer sci- size n. The complexity class polynomial time (P) ence is the computational complexity of prob- is the set of problems that are solvable in time lems. How much time and how much memory at most some polynomial in n. space is needed to solve a particular problem? ∞ Here are a few examples of such problems: P= TIME[nk] 1. Reachability: Given a directed graph and k[=1 two specified points s,t, determine if there Even though the class TIME[t(n)] is sensitive is a path from s to t. A simple, linear-time to the exact machine model used in the com- algorithm marks s and then continues to putations, the class P is quite robust. The prob- mark every vertex at the head of an edge lems Reachability and Min-triangulation are el- whose tail is marked.