DOCSLIB.ORG

Parallel Computation and Complexity Classes

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Parallel Computation and Complexity Classes CSCI 1590 Intro to Computational Complexity Parallel Computation and Complexity Classes John Savage Brown University April 13, 2009 John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 1 / 16 Summary 1 Turing Machines and Complexity 2 Parallel Models of Computation 3 PRAM and Complexity Classes 4 Circuits and Complexity Classes John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 2 / 16 Turing Machines At the beginning of this semester we defined the Turing machine. The Church-Turing thesis asserts that any function that can be physically realized (i.e. \computed") can be computed by a Turing Machine. The somewhat controversial Strong-Church Turing thesis states that \any 'reasonable' model of computation can be efficiently simulated on a probabilistic Turing machine." (Bernstein, Vazirani 1997) Here \efficient" means \with polynomial resources". If BPP = P, the Turing machins can be deterministic. John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 3 / 16 Languages and Complexity Classes A Turing machine recognizes a language if it accepts exactly the strings in that language. In the first portion of this class we introduced a number of complexity classes, sets of languages defined by the resources required by a Turing Machine to recognize them. We also related Turing machines to the more practical RAM model. In the second portion of this class we considered a wider range of computational models. These models, which allow for parallelism, force us to consider a wider range of computational resources. Circuits Formulas VLSI Networks PRAM In this lecture we relate these models back to Turing machines. John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 4 / 16 Time Complexity Using Turing machines, we defined a number of time complexity classes P, EXPTIME NP, NEXPTIME p p Σi ,Πi , PH We used reducibility and completeness to characterize these languages. Both deterministic and nondeterministic time hierarchy theorems can be proven through diagonalization. John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 5 / 16 Space Complexity We also used Turing machines to define a number of space complexity classes L, PSPACE NL, NPSPACE Savitch's Theorem shows that PSPACE = NPSPACE, NL ⊆ L2 Diagonalization can be used to establish a space hierarchy theorem. Recall that TQBF is PSPACE-complete. John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 6 / 16 Relationships between classes L ⊆ NL ⊆ L2 ⊂ P ⊆ NP ⊆ PH ⊆ PSPACE ⊆ EXPTIME ⊆ NEXPTIME Few lower bounds are known. Where do the functions computed by circuits, networks, PRAM fit in? John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 7 / 16 Circuits A circuit is a directed acyclic network with a function computed at each non-leaf node. Unlike Turing machines, circuits compute functions on a finite number of inputs. A Turing machine computation of fixed length can be efficiently implemented with a circuit. We used this fact to prove Cook's Theorem. For circuits, instead of considering space and time, we considered size, depth, fanout, and the functions computed at each node. Circuit lower bounds imply lower bounds for Turing machines. (but what about upper bounds?) John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 8 / 16 Embedded Circuits The circuit model of computation allows for arbitrary acyclic graphs. To model VLSI, we embed these graphs in a plane. We allow only a fixed number of edge crossings and a bounded fanout. Circuit size is replaced with area. Space-time tradeoffs become area-time tradeoffs. John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 9 / 16 Networks of Processors In a circuit, gates compute only a few simple functions. If each gate is replaced with a processor, say a RAM, we have a model of parallel computation. Since nodes now have memory we can reasonably consider cyclic graphs. For different network topologies, we ask how efficiently different problems can be parallelized. For practicality, we consider networks with a limited number of edges, as well as networks that can be efficiently embedded on a chip. Moving data between processors is a crucial challenge. John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 10 / 16 PRAM Many parallel computers (e.g. a hypercube) can simulate arbitrary communication with only logarithmic overhead. As a result theorists often focus on whether computations can be efficiently parallelized in a fully connected network of processors. This is known as the PRAM model of computation. The PRAM model can be thought of as a multiheaded Turing machine where the number of heads grows with input length. Heads are each given a unique index, but otherwise they are identical. As with a Turing machine (and a RAM), a bounded length PRAM computation can be efficiently simulated by a circuit. John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 11 / 16 PRAM and Complexity As we did for Turing machines, we can ask what problems can be recognized by a PRAM in polynomial time. If the number of processors is exponential in input length, we can easily solve problems in NP or coNP in polynomial time (or even constant time on a CRCW PRAM). What if we limit the number of processors to be polynomial in input length? Definition NC is the set of languages that can be recognized by a PRAM with a polynomial number of processors in a logarithmic number of steps. John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 12 / 16 NC and Circuit Families Since PRAM can be simulated by circuits, NC can be defined in terms of (uniform) circuits. To relate circuits (which are finite) to Turing machines (which operate on unbounded inputs), we consider families of circuits. A circuit family is a sequence of circuits in which the i th circuit takes inputs of length i. Notice that there exists a family of circuits that computes the halting problem. John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 13 / 16 Uniform Circuit Families Definition A time r(n) (or space r(n)) uniform family of circuits is a circuit family for which there exists a deterministic Turing machine that constructs the i th circuit using time (or space) r(i) given as input the integer i in unary. With the uniformity condition, the halting problem remains unsolvable. The notion of uniformity directly connects Turing machines to circuits. For example, P = NP iff there exists a polynomial time uniform family of circuits that decide some NP-complete language. John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 14 / 16 The Class NC Let NCi be the set of languages recognized by a log-space uniform family of circuits of polynomial-size and depth O(logi (n)) steps. Then S NC = NCi . NC1 ⊆ L ⊆ NL ⊆ NC2 . It is not known if all NCi are distinct. As with PH, NC collapses if NCi = NCi+1 for some i. It is open whether or not P = NC. John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 15 / 16 P/Poly What class of languages is obtained if we drop the uniformity condition but require that the circuits have polynomial size? Definition The complexity class P=poly is the set of languages recognized by families of polynomial sized circuits. Alternatively, P=poly is the set of languages recognized by deterministic Turing machines in polynomial time, where the Turing machine is allowed to receive a polynomial-sized \piece of advice", a(n), that is only a function of input length. (See pg. 383 of Models of Computation.) p If NP 2 P=poly, it is not hard to show that PH = Σ2 (see Arora and Barak, Section 6.2) John Savage (Brown University) CSCI 1590 Intro to Computational Complexity April 13, 2009 16 / 16.
Load more

Recommended publications
  • COMPLEXITY THEORY Review Lecture 13: Space Hierarchy and Gaps
    COMPLEXITY THEORY Review Lecture 13: Space Hierarchy and Gaps Markus Krotzsch¨ Knowledge-Based Systems TU Dresden, 26th Dec 2018 Markus Krötzsch, 26th Dec 2018 Complexity Theory slide 2 of 19 Review: Time Hierarchy Theorems Time Hierarchy Theorem 12.12 If f , g : N N are such that f is time- → constructible, and g log g o(f ), then · ∈ DTime (g) ( DTime (f ) ∗ ∗ Nondeterministic Time Hierarchy Theorem 12.14 If f , g : N N are such that f → is time-constructible, and g(n + 1) o(f (n)), then A Hierarchy for Space ∈ NTime (g) ( NTime (f ) ∗ ∗ In particular, we find that P , ExpTime and NP , NExpTime: , L NL P NP PSpace ExpTime NExpTime ExpSpace ⊆ ⊆ ⊆ ⊆ ⊆ ⊆ ⊆ , Markus Krötzsch, 26th Dec 2018 Complexity Theory slide 3 of 19 Markus Krötzsch, 26th Dec 2018 Complexity Theory slide 4 of 19 Space Hierarchy Proving the Space Hierarchy Theorem (1) Space Hierarchy Theorem 13.1: If f , g : N N are such that f is space- → constructible, and g o(f ), then For space, we can always assume a single working tape: ∈ Tape reduction leads to a constant-factor increase in space • DSpace(g) ( DSpace(f ) Constant factors can be eliminated by space compression • Proof: Again, we construct a diagonalisation machine . We define a multi-tape TM Therefore, DSpacek(f ) = DSpace1(f ). D D for inputs of the form , w (other cases do not matter), assuming that , w = n hM i |hM i| Compute f (n) in unary to mark the available space on the working tape Space turns out to be easier to separate – we get: • Space Hierarchy Theorem 13.1: If f , g : N N are such that f is space- Initialise a separate countdown tape with the largest binary number that can be → • constructible, and g o(f ), then written in f (n) space ∈ Simulate on , w , making sure that only previously marked tape cells are • M hM i DSpace(g) ( DSpace(f ) used Time-bound the simulation using the content of the countdown tape by • Challenge: TMs can run forever even within bounded space.
    [Show full text]
  • 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]
  • CS601 DTIME and DSPACE Lecture 5 Time and Space Functions: T, S
    CS601 DTIME and DSPACE Lecture 5 Time and Space functions: t, s : N → N+ Definition 5.1 A set A ⊆ U is in DTIME[t(n)] iff there exists a deterministic, multi-tape TM, M, and a constant c, such that, 1. A = L(M) ≡ w ∈ U M(w)=1 , and 2. ∀w ∈ U, M(w) halts within c · t(|w|) steps. Definition 5.2 A set A ⊆ U is in DSPACE[s(n)] iff there exists a deterministic, multi-tape TM, M, and a constant c, such that, 1. A = L(M), and 2. ∀w ∈ U, M(w) uses at most c · s(|w|) work-tape cells. (Input tape is “read-only” and not counted as space used.) Example: PALINDROMES ∈ DTIME[n], DSPACE[n]. In fact, PALINDROMES ∈ DSPACE[log n]. [Exercise] 1 CS601 F(DTIME) and F(DSPACE) Lecture 5 Definition 5.3 f : U → U is in F (DTIME[t(n)]) iff there exists a deterministic, multi-tape TM, M, and a constant c, such that, 1. f = M(·); 2. ∀w ∈ U, M(w) halts within c · t(|w|) steps; 3. |f(w)|≤|w|O(1), i.e., f is polynomially bounded. Definition 5.4 f : U → U is in F (DSPACE[s(n)]) iff there exists a deterministic, multi-tape TM, M, and a constant c, such that, 1. f = M(·); 2. ∀w ∈ U, M(w) uses at most c · s(|w|) work-tape cells; 3. |f(w)|≤|w|O(1), i.e., f is polynomially bounded. (Input tape is “read-only”; Output tape is “write-only”.
    [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]
  • Relations and Equivalences Between Circuit Lower Bounds and Karp-Lipton Theorems*
    Electronic Colloquium on Computational Complexity, Report No. 75 (2019) Relations and Equivalences Between Circuit Lower Bounds and Karp-Lipton Theorems* Lijie Chen Dylan M. McKay Cody D. Murray† R. Ryan Williams MIT MIT MIT Abstract A frontier open problem in circuit complexity is to prove PNP 6⊂ SIZE[nk] for all k; this is a neces- NP sary intermediate step towards NP 6⊂ P=poly. Previously, for several classes containing P , including NP NP NP , ZPP , and S2P, such lower bounds have been proved via Karp-Lipton-style Theorems: to prove k C 6⊂ SIZE[n ] for all k, we show that C ⊂ P=poly implies a “collapse” D = C for some larger class D, where we already know D 6⊂ SIZE[nk] for all k. It seems obvious that one could take a different approach to prove circuit lower bounds for PNP that does not require proving any Karp-Lipton-style theorems along the way. We show this intuition is wrong: (weak) Karp-Lipton-style theorems for PNP are equivalent to fixed-polynomial size circuit lower NP NP k NP bounds for P . That is, P 6⊂ SIZE[n ] for all k if and only if (NP ⊂ P=poly implies PH ⊂ i.o.-P=n ). Next, we present new consequences of the assumption NP ⊂ P=poly, towards proving similar re- sults for NP circuit lower bounds. We show that under the assumption, fixed-polynomial circuit lower bounds for NP, nondeterministic polynomial-time derandomizations, and various fixed-polynomial time simulations of NP are all equivalent. Applying this equivalence, we show that circuit lower bounds for NP imply better Karp-Lipton collapses.
    [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]
  • 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 ).
    [Show full text]
  • Multiparty Communication Complexity and Threshold Circuit Size of AC^0
    2009 50th Annual IEEE Symposium on Foundations of Computer Science Multiparty Communication Complexity and Threshold Circuit Size of AC0 Paul Beame∗ Dang-Trinh Huynh-Ngoc∗y Computer Science and Engineering Computer Science and Engineering University of Washington University of Washington Seattle, WA 98195-2350 Seattle, WA 98195-2350 [email protected] [email protected] Abstract— We prove an nΩ(1)=4k lower bound on the random- that the Generalized Inner Product function in ACC0 requires ized k-party communication complexity of depth 4 AC0 functions k-party NOF communication complexity Ω(n=4k) which is in the number-on-forehead (NOF) model for up to Θ(log n) polynomial in n for k up to Θ(log n). players. These are the first non-trivial lower bounds for general 0 NOF multiparty communication complexity for any AC0 function However, for AC functions much less has been known. for !(log log n) players. For non-constant k the bounds are larger For the communication complexity of the set disjointness than all previous lower bounds for any AC0 function even for function with k players (which is in AC0) there are lower simultaneous communication complexity. bounds of the form Ω(n1=(k−1)=(k−1)) in the simultaneous Our lower bounds imply the first superpolynomial lower bounds NOF [24], [5] and nΩ(1=k)=kO(k) in the one-way NOF for the simulation of AC0 by MAJ ◦ SYMM ◦ AND circuits, showing that the well-known quasipolynomial simulations of AC0 model [26]. These are sub-polynomial lower bounds for all by such circuits are qualitatively optimal, even for formulas of non-constant values of k and, at best, polylogarithmic when small constant depth.
    [Show full text]
  • Introduction to Complexity Theory Big O Notation Review Linear Function: R(N)=O(N)
    GS019 - Lecture 1 on Complexity Theory Jarod Alper (jalper) Introduction to Complexity Theory Big O Notation Review Linear function: r(n)=O(n). Polynomial function: r(n)=2O(1) Exponential function: r(n)=2nO(1) Logarithmic function: r(n)=O(log n) Poly-log function: r(n)=logO(1) n Definition 1 (TIME) Let t : . Define the time complexity class, TIME(t(n)) to be ℵ−→ℵ TIME(t(n)) = L DTM M which decides L in time O(t(n)) . { |∃ } Definition 2 (NTIME) Let t : . Define the time complexity class, NTIME(t(n)) to be ℵ−→ℵ NTIME(t(n)) = L NDTM M which decides L in time O(t(n)) . { |∃ } Example 1 Consider the language A = 0k1k k 0 . { | ≥ } Is A TIME(n2)? Is A ∈ TIME(n log n)? Is A ∈ TIME(n)? Could∈ we potentially place A in a smaller complexity class if we consider other computational models? Theorem 1 If t(n) n, then every t(n) time multitape Turing machine has an equivalent O(t2(n)) time single-tape turing≥ machine. Proof: see Theorem 7:8 in Sipser (pg. 232) Theorem 2 If t(n) n, then every t(n) time RAM machine has an equivalent O(t3(n)) time multi-tape turing machine.≥ Proof: optional exercise Conclusion: Linear time is model specific; polynomical time is model indepedent. Definition 3 (The Class P ) k P = [ TIME(n ) k Definition 4 (The Class NP) GS019 - Lecture 1 on Complexity Theory Jarod Alper (jalper) k NP = [ NTIME(n ) k Equivalent Definition of NP NP = L L has a polynomial time verifier .
    [Show full text]
  • Lecture 13: NP-Completeness
    Lecture 13: NP-completeness Valentine Kabanets November 3, 2016 1 Polytime mapping-reductions We say that A is polytime reducible to B if there is a polytime computable function f (a reduction) such that, for every string x, x 2 A iff f(x) 2 B. We use the notation \A ≤p B." (This is the same as a notion of mapping reduction from Computability we saw earlier, with the only change being that the reduction f be polytime computable.) It is easy to see Theorem 1. If A ≤p B and B 2 P, then A 2 P. 2 NP-completeness 2.1 Definitions A language B is NP-complete if 1. B is in NP, and 2. every language A in NP is polytime reducible to B (i.e., A ≤p B). In words, an NP-complete problem is the \hardest" problem in the class NP. It is easy to see the following: Theorem 2. If B is NP-complete and B is in P, then NP = P. It is also possible to show (Exercise!) that Theorem 3. If B is NP-complete and B ≤p C for some C in NP, then C is NP-complete. 2.2 \Trivial" NP-complete problem The following \scaled down version of ANTM " is NP-complete. p t ANTM = fhM; w; 1 i j NTM M accepts w within t stepsg p Theorem 4. The language ANTM defined above is NP-complete. 1 p Proof. First, ANTM is in NP, as we can always simulate a given nondeterministic TM M on a given input w for t steps, so that our simulation takes time poly(jhMij; jwj; t) (polynomial in the input size).
    [Show full text]
  • Lecture 13: Circuit Complexity 1 Binary Addition
    CS 810: Introduction to Complexity Theory 3/4/2003 Lecture 13: Circuit Complexity Instructor: Jin-Yi Cai Scribe: David Koop, Martin Hock For the next few lectures, we will deal with circuit complexity. We will concentrate on small depth circuits. These capture parallel computation. Our main goal will be proving circuit lower bounds. These lower bounds show what cannot be computed by small depth circuits. To gain appreciation for these lower bound results, it is essential to first learn about what can be done by these circuits. In next two lectures, we will exhibit the computational power of these circuits. We start with one of the simplest computations: integer addition. 1 Binary Addition Given two binary numbers, a = a1a2 : : : an−1an and b = b1b2 : : : bn−1bn, we can add the two using the elementary school method { adding each column and carrying to the next. In other words, r = a + b, an an−1 : : : a1 a0 + bn bn−1 : : : b1 b0 rn+1 rn rn−1 : : : r1 r0 can be accomplished by first computing r0 = a0 ⊕ b0 (⊕ is exclusive or) and computing a carry bit, c1 = a0 ^ b0. Now, we can compute r1 = a1 ⊕ b1 ⊕ c1 and c2 = (c1 ^ (a1 _ b1)) _ (a1 ^ b1), and in general we have rk = ak ⊕ bk ⊕ ck ck = (ck−1 ^ (ak _ bk)) _ (ak ^ bk) Certainly, the above operation can be done in polynomial time. The main question is, can we do it in parallel faster? The computation expressed above is sequential. Before computing rk, one needs to compute all the previous output bits.
    [Show full text]