Homework 8 Solutions Problem 1. Draw a diagram showing the various classes of languages that we have discussed and alluded to in terms of which class.

Slides:



Advertisements
Similar presentations
Lecture 24 MAS 714 Hartmut Klauck
Advertisements

Foundations of Cryptography Lecture 10 Lecturer: Moni Naor.
3.2 Pumping Lemma for Regular Languages Given a language L, how do we know whether it is regular or not? If we can construct an FA to accept the language.
NP-Completeness Lecture for CS 302. Traveling Salesperson Problem You have to visit n cities You want to make the shortest trip How could you do this?
Complexity class NP Is the class of languages that can be verified by a polynomial-time algorithm. L = { x in {0,1}* | there exists a certificate y with.
CSCI 4325 / 6339 Theory of Computation Zhixiang Chen.
Complexity 12-1 Complexity Andrei Bulatov Non-Deterministic Space.
Complexity 15-1 Complexity Andrei Bulatov Hierarchy Theorem.
Computability and Complexity 22-1 Computability and Complexity Andrei Bulatov Hierarchy Theorem.
Complexity 13-1 Complexity Andrei Bulatov Hierarchy Theorem.
1 L is in NP means: There is a language L’ in P and a polynomial p so that L 1 · L 2 means: For some polynomial time computable map r : 8 x: x 2 L 1 iff.
P and NP Sipser (pages ). CS 311 Fall Polynomial time P = ∪ k TIME(n k ) … P = ∪ k TIME(n k ) … TIME(n 3 ) TIME(n 2 ) TIME(n)
Computability and Complexity 19-1 Computability and Complexity Andrei Bulatov Non-Deterministic Space.
CS151 Complexity Theory Lecture 5 April 13, 2004.
Complexity ©D.Moshkovits 1 Space Complexity Complexity ©D.Moshkovits 2 Motivation Complexity classes correspond to bounds on resources One such resource.
FORMAL LANGUAGES, AUTOMATA AND COMPUTABILITY
CS151 Complexity Theory Lecture 12 May 6, CS151 Lecture 122 Outline The Polynomial-Time Hierarachy (PH) Complete problems for classes in PH, PSPACE.
Computability and Complexity 32-1 Computability and Complexity Andrei Bulatov Boolean Circuits.
1 Polynomial Time Reductions Polynomial Computable function : For any computes in polynomial time.
Computability and Complexity 20-1 Computability and Complexity Andrei Bulatov Class NL.
RELATIVIZATION CSE860 Vaishali Athale. Overview Introduction Idea behind “Relativization” Concept of “Oracle” Review of Diagonalization Proof Limits of.
1 Single Final State for NFAs and DFAs. 2 Observation Any Finite Automaton (NFA or DFA) can be converted to an equivalent NFA with a single final state.
Automata & Formal Languages, Feodor F. Dragan, Kent State University 1 CHAPTER 5 Reducibility Contents Undecidable Problems from Language Theory.
CS Master – Introduction to the Theory of Computation Jan Maluszynski - HT Lecture NP-Completeness Jan Maluszynski, IDA, 2007
Chapter 11: Limitations of Algorithmic Power
Complexity ©D. Moshkovitz 1 And Randomized Computations The Polynomial Hierarchy.
The Polynomial Hierarchy By Moti Meir And Yitzhak Sapir Based on notes from lectures by Oded Goldreich taken by Ronen Mizrahi, and lectures by Ely Porat.
Fall 2004COMP 3351 Regular Expressions. Fall 2004COMP 3352 Regular Expressions Regular expressions describe regular languages Example: describes the language.
Final Exam Review Cummulative Chapters 0, 1, 2, 3, 4, 5 and 7.
INHERENT LIMITATIONS OF COMPUTER PROGRAMS CSci 4011.
PSPACE-Completeness Section 8.3 Giorgi Japaridze Theory of Computability.
Definition: Let M be a deterministic Turing Machine that halts on all inputs. Space Complexity of M is the function f:N  N, where f(n) is the maximum.
February 18, 2015CS21 Lecture 181 CS21 Decidability and Tractability Lecture 18 February 18, 2015.
Theory of Computing Lecture 17 MAS 714 Hartmut Klauck.
Space Complexity. Reminder: P, NP classes P NP is the class of problems for which: –Guessing phase: A polynomial time algorithm generates a plausible.
CSCI 2670 Introduction to Theory of Computing November 29, 2005.
CSCI 2670 Introduction to Theory of Computing December 1, 2004.
Week 10Complexity of Algorithms1 Hard Computational Problems Some computational problems are hard Despite a numerous attempts we do not know any efficient.
1 Lower Bounds Lower bound: an estimate on a minimum amount of work needed to solve a given problem Examples: b number of comparisons needed to find the.
Theory of Computing Lecture 21 MAS 714 Hartmut Klauck.
Umans Complexity Theory Lectures Lecture 1a: Problems and Languages.
Decidable languages Section 4.1 CSC 4170 Theory of Computation.
INHERENT LIMITATIONS OF COMPUTER PROGAMS CSci 4011.
CS 203: Introduction to Formal Languages and Automata
Hierarchy theorems Section 9.1 Giorgi Japaridze Theory of Computability.
Donghyun (David) Kim Department of Mathematics and Computer Science North Carolina Central University 1 Chapter 7 Time Complexity Some slides are in courtesy.
Umans Complexity Theory Lectures Lecture 1c: Robust Time & Space Classes.
Alternation Section 10.3 Giorgi Japaridze Theory of Computability.
Fall 2013 CMU CS Computational Complexity Lecture 2 Diagonalization, 9/12/2013.
Complexity 24-1 Complexity Andrei Bulatov Interactive Proofs.
NP-complete Languages
Space Complexity. Reminder: P, NP classes P is the class of problems that can be solved with algorithms that runs in polynomial time NP is the class of.
CSCI 2670 Introduction to Theory of Computing December 2, 2004.
CSCI 4325 / 6339 Theory of Computation Zhixiang Chen.
Theory of Computational Complexity Yuji Ishikawa Avis lab. M1.
Computability Examples. Reducibility. NP completeness. Homework: Find other examples of NP complete problems.
The NP class. NP-completeness Lecture2. The NP-class The NP class is a class that contains all the problems that can be decided by a Non-Deterministic.
Complexity 27-1 Complexity Andrei Bulatov Interactive Proofs (continued)
 2005 SDU Lecture14 Mapping Reducibility, Complexity.
NP-Completeness A problem is NP-complete if: It is in NP
Umans Complexity Theory Lectures
Theory of Computability
HIERARCHY THEOREMS Hu Rui Prof. Takahashi laboratory
Part II Theory of Nondeterministic Computation
CS21 Decidability and Tractability
CSE 589 Applied Algorithms Spring 1999
CS151 Complexity Theory Lecture 5 April 16, 2019.
CS151 Complexity Theory Lecture 4 April 12, 2019.
Intro to Theory of Computation
CS151 Complexity Theory Lecture 4 April 8, 2004.
Presentation transcript:

Homework 8 Solutions Problem 1. Draw a diagram showing the various classes of languages that we have discussed and alluded to in terms of which class contains which other classes. Indicate (by words if necessary) which containments are not known to be strict. Note: this is an open-ended question, but at a minimum include the Kleene hierarchy, the polynomial-time hierarchy, PSPACE, NP-complete languages, and regular languages 1

P NP co-NP logspace NL Regular Languages PSPACE

NP = 1p 2p co-NP P = 0p = 0p = 1p 2p #P Non-Collapse PSPACE SAT Clique co-SAT co-VC #SAT #P Non-Collapse has not been proved TQBF PSPACE complete

Decidable=0 = 0 1 1 PSPACE 2 2 EXPTIME

Problem 2: State the time hierarchy theorem (consult Sipser) Problem 2: State the time hierarchy theorem (consult Sipser). Show the error in the following argument that NP = P: Proof by contradiction. Assume NP = P. Then SAT is in P. Therefore there exists a value k such that SAT is in TIME(nk). Because every language in NP is polynomial-time reducible to SAT, we know that P is a subset of TIME(nk). Yet the time hierarchy theorem tells us that TIME(nk+1) contains a language that is not in TIME(nk). Therefore our assumption that NP = P must be false.

Because every language in NP is polynomial-time reducible to SAT, we know that P is a subset of TIME(nk). Time hierarchy Theorem: If f is a time-constructable function and f(n)>n, then TIME(f(n)) properly contains TIME(f(n)/log(f(n))) This is incorrect because a reduction from L to SAT may transform inputs of size n to a larger size (e.g. nb). So the running time of an algorithm that employs the reduction will be O(nbk) not O(nk)

Problem 4: Define “trapdoor function” (consult Sipser). Problem 3: Define “uniform family of circuits” and NC (consult Sipser). A uniform family of circuits {Ci}i=1 is a set of circuits that are can be output by a logspace machine NC = Ui=1 NC(i) where NC(i) is all languages L decidable by some uniform family of polynomial size depth logi(n) circuits. Problem 4: Define “trapdoor function” (consult Sipser). A trapdoor function, primarily used in cryptography, is a function f such that it is efficient to compute f(x) for any x but, given random y, it is not possible to find any value x such that f(x) = y in polynomial time without knowledge of a key k. With knowledge of key k, it is possible to find x efficiently. 8 8

 NSpace(nk)   DSpace(n2k)   DSpace(nj) Problem 5: Prove that NPSPACE = PSPACE Savitch’s theorem implies that  k, NSpace(nk)  DSpace(n2k) Therefore, NPSpace =  NSpace(nk)   DSpace(n2k)   DSpace(nj) = PSpace Because we already know that PSpace  NPSpace, this implies PSpace = NPSpace    k k j

Problem 6. Prove that TQBF restricted to formulas where the part following the quantifiers is in conjunctive normal form is still PSPACE-complete (Sipser 8.13) The idea is simple: in the proof that TQBF is PSPACE-complete, the boolean expression following the quantifiers can always be put in conjunctive normal form. This expression says that “machine M can more from configuration X to configuration Y in one step.”

Problem 7. Let EQREX = {(R,S): R an S are equivalent regular expressions}. Show that EQREX  PSPACE (Sipser 8.16) A PSPACE algorithm that decides can be written in 2 steps: 1. Convert (R,S) to (Rnfa, Snfa) where (Rnfa, Snfa) are NFAs that accept R and S respectively. This done by using the 3 proof tricks that show regular languages are closed under concatenation, union, and Kleene star, building the NFAs directly from the regular expressions. This is a polynomial time (and hence obviously PSPACE) operation 2. Decide whether Rnfa and Snfa accept the same languages. The idea here is that it is sufficient to determine whether there are any strings w of length less than n -- the max of the 2 NFAs’ pumping lengths -- such that w is accepted by one NFA but not the other. To do this, one can run through all strings of length less than n. This requires exponential time, but polynomial space.