CSE200: Computability and Complexity Fall 2008, Homework 6

Total Page：16

File Type：pdf, Size：1020Kb

CSE200: Computability and Complexity Fall 2008, Homework 6 Instructor: Daniele Micciancio Due Tuesday November 18, 2008 Problem 1: Log-space, Polylog-space (a) Recall the WHILE language we were using in the first homeworks. The input to any WHILE program is encoded as a single list (which has as elements other lists and so on). For instance the string [[][[]][][[[]]]] is a valid input to a WHILE program whereas [][[][]] (two separate lists) and []][ (right parenthesis not preceded by a left one) aren’t. Consider the following set of Valid WHILE Inputs ∗ VWI = {x ∈ {[, ]} x is a Valid WHILE Input} Show that VWI ∈ L. (b) Consider the polylogarithmic space complexity class defined in class as follows [ polyL = SP ACE(logkn) k>0 We say that a language C is polyL-complete if: • C ∈ polyL and • A ≤L C for every A ∈ polyL. (every polylogarithmic space language is log-space (map) reducible to C). (i) Show that NL ⊂ polyL (ii) Show that there exist no polyL-complete problems under the above definition of completeness. (iii) Show that polyL 6= P. (iv) Part (iii) implies that either (a) polyL ⊂ P, or (b) P ⊂ polyL or (c) polyL ⊂ polyL∪P and P ⊂ polyL∪P (none of them is strictly contained in the other). Note that (a), (b), (c) are mutually exclusive. So, part (iii) shows that one and only one of (a), (b) or (c) holds true. Still which of the three cases holds true is not currently known. Justify why deterining which of (a), (b) or (c) holds true might be pretty hard question, by pointing out the implications each of these three relations would have. Note: You can take as given (no need to prove it) that P has complete languages under log-space reductions. Hint 1: Use the Space Hierarchy Theorem. Hint 2: The solution for part (b) is not trivial but is fairly short (for all four subquestions). A solution longer than a page or so, might be an indication that you are on the wrong track. 1 Problem 2: PSPACE, PSPACE-Completeness (a) Consider the following definition for PSPACE-Completeness We say that a language C is P SP ACE-complete if: • C ∈ P SP ACE and • A ≤P SP ACE C for every A ∈ P SP ACE (every PSPACE language is PSPACE (map) reducible to C). Show that under the above definition of completeness every problem in P SP ACE is P SP ACE-Complete. (b) P1 and P2 are playing the following game: they both get as an input a graph G = (V, E), an integer vector 1 ~w = (w1, ..., wn) (with wi > 0) that corresponds to the weights of the nodes and a positive number T. P1 and P2 alternately select nodes with P1 playing first. At each stage of the game, the player that moves can pick a node only if this node doesn’t have any neighbors in the set of previously selected nodes (in other words, at each stage all the previously selected nodes must form an independent set in G). Player P2 wins if at the end of the game (when there are no independent nodes left) the sum of the weights of the nodes he has selected is at least T. Based on the above game, we can define the following language L = {(G, ~w, T )|P2 has a winning strategy no matter how P1 plays } Show that L can be decided in P SP ACE 2. 1 You may assume that the nodes are labeled 1, ..., n and that node i was weight wi. 2It turns out that L is P SP ACE-Complete but here you are not required to prove the P SP ACE-hardness. 2.

Copy Link

Recommended publications

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 deﬁnes commands to typeset (almost) all of the complexity classes you’ll ﬁnd 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]
User's Guide for Complexity: a LATEX Package, Version 0.80
User’s Guide for complexity: a LATEX package, Version 0.80 Chris Bourke April 12, 2007 Contents 1 Introduction 2 1.1 What is complexity? ......................... 2 1.2 Why a complexity package? ..................... 2 2 Installation 2 3 Package Options 3 3.1 Mode Options .............................. 3 3.2 Font Options .............................. 4 3.2.1 The small Option ....................... 4 4 Using the Package 6 4.1 Overridden Commands ......................... 6 4.2 Special Commands ........................... 6 4.3 Function Commands .......................... 6 4.4 Language Commands .......................... 7 4.5 Complete List of Class Commands .................. 8 5 Customization 15 5.1 Class Commands ............................ 15 1 5.2 Language Commands .......................... 16 5.3 Function Commands .......................... 17 6 Extended Example 17 7 Feedback 18 7.1 Acknowledgements ........................... 19 1 Introduction 1.1 What is complexity? complexity is a LATEX package that typesets computational complexity classes such as P (deterministic polynomial time) and NP (nondeterministic polynomial time) as well as sets (languages) such as SAT (satisfiability). In all, over 350 commands are defined for helping you to typeset Computational Complexity con- structs. 1.2 Why a complexity package? A better question is why not? Complexity theory is a more recent, though mature area of Theoretical Computer Science. Each researcher seems to have his or her own preferences as to how to typeset Complexity Classes and has built up their own personal LATEX commands file. This can be frustrating, to say the least, when it comes to collaborations or when one has to go through an entire series of files changing commands for compatibility or to get exactly the look they want (or what may be required).
[Show full text]
Space Complexity
Chapter 3 Space complexity “(our) construction... also suggests that what makes “games” harder than “puzzles” (e.g. NP-complete problems) is the fact that the initiative (“the move”) can shift back and forth between the players.” Shimon Even and Robert Tarjan, 1976 In this chapter we will study the memory requirements of computational tasks. To do this we define space-bounded computation, which has to be per- formed by the TM using a restricted number of tape cells, the number being a function of the input size. We also study nondeterministic space-bounded TMs. As in the chapter on NP, our goal in introducing a complexity class is to “capture” interesting computational phenomena— in other words, iden- tify an interesting set of computational problems that lie in the complexity class and are complete for it. One phenomenon we will “capture” this way (see Section 3.3.2) concerns computation of winning strategies in 2-person games, which seems inherently different from (and possibly more difficult than) solving NP problems such as SAT, as alluded to in the above quote. The formal definition of deterministic and non-deterministic space bounded computation is as follows (see also Figure 3.1): Definition 3.1 (Space-bounded computation.) ∗ Let S : N → N and L ⊆ {0, 1} . We say that L ∈ SPACE(s(n)) (resp. L ∈ NSPACE(s(n))) if there is a constant c and TM (resp. NDTM) M deciding L such that on every input x ∈ {0, 1}∗, the total number of locations that are at some point non-blank during M’s execution on x is at most c·s(|x|).
[Show full text]
PSPACE-Completeness & Savitch's Theorem 1 Recap
CSE 200 Computability and Complexity Wednesday, April 24, 2013 Lecture 8: PSPACE-Completeness & Savitch's Theorem Instructor: Professor Shachar Lovett Scribe: Dongcai Shen 1 Recap: Space Complexity Recall the following definitions on space complexity we learned in the last class: SPACE(S(n))def= \languages computable by a TM where input tape is readonly and work tape size S(n)" LOGSPACEdef= SPACE(O(log n)) def c PSPACE = [c≥1 SPACE(n ) For example, nowadays, people are interested in streaming algorithms, whose space requirements are low. So researching on space complexity can have real-world influence, especially in instructing people the way an algorithm should be designed and directing people away from some impossible attempts. Definition 1 (Nondeterministic Space NSPACE) The nondeterministic space NSPACE(S(n))def= • Input tape, read-only. • Proof tape, read-only & read-once. • Work tape size S(n). So, we can define • NLdef= NSPACE(O(log n)). def c • NPSPACE = [c≥1 NSPACE(n ). def Theorem 2 PATH = f(G; s; t): G directed graph, s; t vertices, there is a path s t in Gg is NL-complete un- der logspace reduction. Corollary 3 If we could find a deterministic algorithm for PATH in SPACE(O(log n)), then NL = L. Remark. Nondeterminism is pretty useless w.r.t. space. We don't know whether NL = L yet. 2 Outline of Today Definition 4 (Quantified Boolean formula) A quantified Boolean formula is 8x19x28x39x4 ··· φ(x1; ··· ; xn) def where φ is a CNF. Let TQBF = fA true QBFg. Theorem 5 TQBF is PSPACE-complete under poly-time reduction (and actually under logspace reductions).
[Show full text]
Algorithms Versus Circuit Lower Bounds
Algorithms versus Circuit Lower Bounds Igor C. Oliveira∗ Department of Computer Science Columbia University [email protected] November 4, 2018 Abstract Different techniques have been used to prove several transference theorems of the form “non- trivial algorithms for a circuit class C yield circuit lower bounds against C”. In this survey we revisit many of these results. We discuss how circuit lower bounds can be obtained from deran- domization, compression, learning, and satisfiability algorithms. We also cover the connection between circuit lower bounds and useful properties, a notion that turns out to be fundamental in the context of these transference theorems. Along the way, we obtain a few new results, simplify several proofs, and show connections involving different frameworks. We hope that our presentation will serve as a self-contained introduction for those interested in pursuing research in this area. arXiv:1309.0249v1 [cs.CC] 1 Sep 2013 ∗ Research supported by NSF grants CCF-1116702 and CCF-1115703. 1 Contents 1 Introduction 3 1.1 Asummaryofsomeknownresults . ...... 4 1.1.1 Satisfiability algorithms and circuit lower bounds . .............. 4 1.1.2 Constructivity and circuit lower bounds . .......... 5 1.1.3 Additional transference theorems . ......... 6 1.2 A guide to the results discussed in this survey . ............. 8 1.2.1 Lower bounds from satisfiability algorithms for low depth circuits . 8 1.2.2 Useful properties and circuit lower bounds . ........... 8 1.2.3 Applications .................................. 10 1.2.4 Anoverviewoftheresults . ..... 11 2 Preliminaries and Notation 11 3 Lower bounds from SAT algorithms for low depth circuits 14 3.1 Aremarkforthealgorithmdesigner . ......... 17 4 Useful properties and circuit lower bounds 17 4.1 Satisfiability algorithms and useful properties .
[Show full text]
Exercise 1 January, 2018
January, 2018 Computational Complexity Exercise 1 1. Show that if any NP-complete language L is in co-NP, then co-NP=NP. 2. Show that if g(n) = o(f(n)), f(n) ≥ log n space constructible, then Nspace(g(n)) 6= Nspace(f(n) log f(n)). (Hint: Let L 2 Nspace(g(n)). Assume that you have two non- deterministic machines M and M, each using O(g(n)) space accepting L and L (why should such machines exist?). Now you can use these machines to do a diagonal argument as in the proof of the deterministic space hierarchy theorem). S i 3. Define polyL as i Dspace(log n). Steve's class SC=fL : 9 constants k; l and a deter- ministic Turing machine M such that M accepts L in O(nk) space and O(logl n) time g Why does it NOT follow from the definition that SC=PolyL or SC = polyL\P? S i 4. We have defined NP as i≥0NTIME(n ). Here is an alternative definition. We define NP to be the class of all languages L ⊆ Σ∗ such that there is a deterministic Turing machine M that runs in time polynomial in the size of its input and an integer k such that if x 2 L then there exists y 2 Σ∗ with jyj ≤ jxjk and M(x; y) = 1 whereas, if x2 = L, for all y 2 Σ∗ M(x; y) = 0. This is the certificate characterization of the class NP (See Korman et.al., Introduction to algorithms for a treatment of NP-completeness using this definition).
[Show full text]
Computational Complexity
Computational complexity lecture 6 Homework: available on the webpage, deadline: 27.11.2017 Determinization Theorem (previous lecture) NTIME(f(n))⊆DSPACE(f(n)) Theorem (now) f(n)+log(n) NSPACE(f(n))⊆cℕDTIME(c ) Determinization Theorem f(n)+log(n) NSPACE(f(n))⊆cℕDTIME(c ) Proof ● We have a nondeterm. machine M working in space g(n)=O(f(n)). W.l.o.g. we assume that M has only one working tape. Determinization Theorem f(n)+log(n) NSPACE(f(n))⊆cℕDTIME(c ) Proof ● We have a nondeterm. machine M working in space g(n)=O(f(n)). W.l.o.g. we assume that M has only one working tape. ● A configuration of M on a fixed input of length n can be represented as: ➔ contents of the working tape, with a marker over the position of the head – (2|G|)g(n) possibilities ➔ a position of the head on the input tape – n+2 possibilities ➔ a state (a constant number of possibilities) ● Altogether, there are dg(n)+log(n) configurations (for some constant d) Determinization Theorem f(n)+log(n) NSPACE(f(n))⊆cℕDTIME(c ) Proof ● We have a nondeterm. machine M working in space g(n)=O(f(n)). W.l.o.g. we assume that M has only one working tape. ● A configuration of M on a fixed input of length n can be represented as: ➔ contents of the working tape, with a marker over the position of the head – (2|G|)g(n) possibilities ➔ a position of the head on the input tape – n+2 possibilities ➔ a state (a constant number of possibilities) ● Altogether, there are dg(n)+log(n) configurations (for some constant d) ● Checking that there is an accepting run amount to checking reachability in the (directed) configuration graph.
[Show full text]
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 4 Space complexity “(our) construction... also suggests that what makes “games” harder than “puzzles” (e.g. NP-complete problems) is the fact that the initiative (“the move”) can shift back and forth between the players.” Shimon Even and Robert Tarjan, 1976 In this chapter we will study the memory requirements of computational tasks. To do this we define space-bounded computation, which has to be performed by the TM using a restricted number of tape cells, the number being a function of the input size. We also study nondeterministic space- bounded TMs. As in the chapter on NP, our goal in introducing a complexity class is to “capture” interesting computational phenomena— in other words, identify an interesting set of computational problems that lie in the complexity class and are complete for it. One phenomenon we will “capture” this way (see Section 4.3.2) concerns computation of winning strategies in 2-person games, which seems inherently different from (and possibly more difficult than) solving NP problems such as SAT, as alluded to in the above quote.
[Show full text]
L4 Complexity Theory I
Introduction to quantum computing and simulability Introduction to computational complexity theory I Daniel J. Brod Leandro Aolita Ernesto Galvão Outline: Computational complexity theory I • Classical computing 101 • Complexity Classes: • P; • NP; • Reductions and NP-completeness; • BPP and BQP; Classical computing • Information encoded in bits (0s and 1s); • Bits manipulated by Turing machines: Head H (contains the program) Read/write device 1 0 1 0 0 1 1 0 1 Classical computing Church-Turing Thesis (physical version) All computational problems solvable by a realistic physical system can be solved by a Turing machine. Classical computing • Information encoded in bits (0s and 1s); • Bits manipulated in Boolean circuits: A B out A 00 1 out B 01 1 10 1 11 0 Classical computing • Information encoded in bits (0s and 1s); • Bits manipulated in Boolean circuits: Classical computing • Physical system is not too important for computability. • Vacuum tubes • Colossus (1943) Replica of Colossus, Bletchley Park Photo: Ian Petticrew Classical computing • Physical system is not too important for computability. • Transistors • Intel® 4004 (1971) - 2.300 transistors. • Intel® Core™ (2010) - 560.000.000 transistors. Photo: Wikipedia (Richard Wheeler) Classical computing • Physical system is not too important for computability. • Billiard balls (Newtonian mechanics) • Fredkin e Toffoli (1982 - proposta teórica) Imagem: Wikipedia Church-Turing Thesis Church-Turing Thesis (Strong version) (Informal statement): all realistic physical systems are computationally equivalent. • What do we mean by “equivalent”? • We are interested in asymptotic behaviour! Polynomial vs exponential • Definition: Efficient computation; • Consider • Some problem P parameterized by “size” n; and • a model of computation M. • M solves P efficiently if there is an algorithm in M to solve P in time that grows as a polynomial (in n).
[Show full text]
CS373T Computational Complexity Exercise 1 August, 2007 Log N
CS373T August, 2007 Computational Complexity Exercise 1 1. Is it true that coNP⊆ PSPACE? Show that NTIME(n) is a proper subset of PSPACE. 2 2. Is it true that NTIME(f(n))⊆ DSPACE(f (n)) for f(n) ≥ log n. 3. Show that 2SAT is in NL. Show that if 3SAT is in NL then P=NP. 2 4. Show that the problem of checking whether a given n bit number is prime is in coNTIME(n ). 5. Show that if P=NP then every language in P except just two languages are NP-complete. Which are those two languages? (Hint: One of the languages is the empty set). i 6. Define polyL as ∪DSP ACE(log n). Steve’s class SC is defined as the class of languages that can i be decided by deterministic machines that run in polynomial time and log n for some i ≥ 0. Why does it NOT follow from Savitch’s theorem that SC=PolyL? Is SC same as polyL∩ P? 7. Recall that in the proof of the hierarchy theorem showing that for any constructable function f(n) ≥ log n, there exists a language L ∈ DSP ACE(f(n)) \ DSP ACE(g(n)) for any g(n) ∈ o(f(n)), we defined the langauge L={x=M0*: M is a TM and rejects M in atmost f(|x|) steps }. What goes wrong with the proof if instead of L, we the langauge L’={ M : M is a TM and M rejects M in atmost f(|M|) steps} is used in the proof? i 8.
[Show full text]
The Complexity of Class Polyl
The complexity of class polyL Frank Vega Joysonic, Belgrade, Serbia [email protected] Abstract. We define the class polyL as the set of languages that can be decided in deterministic polylogarithmic space. We prove every language in NP is in polyL. In this way, we show every language in P is in polyL. Moreover, since every language in polyL is in QP, then every problem in NP can be decided in a quasi-polynomial time. Keywords: Complexity classes · Completeness · Polynomial time · Cir- cuit · Boolean formula. 1 Introduction The P versus NP problem is a major unsolved problem in computer science [1]. This is considered by many to be the most important open problem in the field [1]. It is one of the seven Millennium Prize Problems selected by the Clay Mathematics Institute to carry a US$1,000,000 prize for the first correct solution [1]. It was essentially mentioned in 1955 from a letter written by John Nash to the United States National Security Agency [1]. However, the precise statement of the P = NP problem was introduced in 1971 by Stephen Cook in a seminal paper [1]. In 1936, Turing developed his theoretical computational model [10]. The deterministic and nondeterministic Turing machines have become in two of the most important definitions related to this theoretical model for computation [10]. A deterministic Turing machine has only one next action for each step defined in its program or transition function [10]. A nondeterministic Turing machine could contain more than one action defined for each step of its program, where this one is no longer a function, but a relation [10].
[Show full text]
Assignment I , L ≼Log
Assignment I 1. Suppose NSPACE(f(n))⊆ DTIME(f k(n)) for some constant k > 0 for all constructible f, can we conclude that NP=co-NP or NP6= co-NP? Justify. 2. Show that • If NP6= co-NP, then P6= NP. • If any co-NP complete problem is in NP then NP=co-NP. • If any problem in NP\ co-NP is NP-complete then NP=co-NP. 0 0 log 3. Suppose we deﬁne a language L 2 polyL to be polyL-complete if for all L 2 polyL, L m L. Show that there is no complete problem in the class polyL. c 4. Let L be an NEXP complete problem. Let c be a constant such that L 2 NT ime(2n ). Show that the jxj language L0 = f(x; 12 ): x 2 Lg is in NP. (L0 consists of strings in L suﬃxed by an exponentially large number of 1s). Suppose L0 2 P, show that L is in EXP. From this, conclude that if P=NP, then NEXP=EXP. The technique used in this proof is called padding argument. k 5. Show that for any language L, L 2 Dtime(nk) if and only if the language L0 = f(x; 1jxj ): x 2 Lg is in Dtime(n). (for each string x in L, we add L padded with jxjk 1s to L0). Using this, conclude that P 6= Dspace(n). 6. Show that the problem of determining whether a graph is bipartite is in NL. (You need to use some characterization for bipartite graphs).
[Show full text]