DOCSLIB.ORG

IIT Kharagpur 1 Space Complexity

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
IIT Kharagpur 1 Space Complexity Computer Science & Engineering Department IIT Kharagpur Theory of Computation: CS41001 Lecture VIII Instructor: Goutam Biswas Autumn Semester 2014-2015 1 Space Complexity In this lecture we shall consider workspace-bounded computation of Turing machines. In such a Turing machine the restriction is put on the number of work-tape cells used by the machine. 1.1 PSPACE, NPSPACE, L and NL We already know that a language L ⊆ {0, 1}∗ is in DSP ACE(s(n)), if there is a function s : N0 → N0 so that there is a Turing machine M, that decides L, using at most s(n) cells of the work tape for all but finite many input x ∈ {0, 1}∗, where n = |x|. In fact a language is in DSP ACE(s(n)) even if it is in DSP ACE(cs(n)) or DSP ACE(O(s(n))), where c > 0 is a constant. NSPACE(s(n)) is defined similarly if there is a nondeterministic Turing machine that decides L (in the usual way), using at most s(n) cells of the work tape. The bound on space has nothing to do with the read-only input tape. So, it makes sense to talk about the sub-linear amount of workspace (s(n) < n). But s(n) should be greater than log n as it may be necessary to remember the position of the input symbols. We know the following relation among the time and space complexity classes. Proposition 1. For any space-constructible function s : N0 → N0, DTIME(s(n)) ⊆ DSPACE(s(n)) ⊆ NSPACE(s(n)) ⊆ DTIME(2O(s(n))). We conclude the following from the previous proposition. Proposition 2. NP ⊆ PSPACE Proof: Let L ∈ NP, so there is a polynomial time Turing machine verifier V and a polynomial p so that for every x ∈ L there is a certificate w ∈ {0, 1}p(|x|) such that V accepts <x,w >. We design a Turing machine as follows: N: input x ∈ {0, 1}∗ 1. Systematically generates string w ∈ {0, 1}p(|x|) (bounded by polynomial space) and performs the following steps. 2. Runs V on <x,w > (polynomial time, so bounded by polynomial space), 3. If V accepts, then accept, else continue. 4. If no witness found, reject. 1 QED. Consider the following language in L and NL. Example 1. We already know that a regular language is in L. As it is not necessary to use any space. Example 2. n n L1 = {0 1 : n ∈ N0}. We have a Turing machine M with read-only input tape and read-write work tape. It works as follows: M: input x 1. Scan the input to see that there is no 0 after 1. If there is, reject. 2. Count the number of 0’s as a binary numeral. 3. Decrement the counter with the number of 1’s. 4. If the count is non-zero and all 1’s are counted, or the count is zero but a few more 1’s are left, then reject, otherwise accept. The counter will take O(log n) work space, so L1 ∈ L. Similarly the context-sensitive language n n n L2 = {0 1 2 : n ∈ N} is also in L. Example 3. MULT = {< a, b, ab >: a, b ∈ N0}. The algorithm depends on the fact that the ith bit of the result depends on j=min(i,n−1) (c + ajbi−j) mod 2, j=maxX(0,i−n) where c is the carry from the previous stage. The value i = 0, · · · , 2n − 1, where both a and b are n bit numbers. The next stage carry is generated as j=min(i,n−1) ⌊(c + ajbi−j)/2⌋. j=maxX(0,i−n) The maximum size of the result to store is O(log n). So MULT ∈ L Example 4. PATH = {< G,s,d >: G is a directed graph with a path from s to d}. Let |V (G)| = n. So the nodes can be numbered with ⌈log2 n⌉ bits. If there is a path from s to t, then there is a nondeterministic choice for the next node. The workspace requirement is O(log n) - the bits of the current node and the bits (partially completed) next node obtained through non-deterministic choice. So a path can be computed in O(log n) work space by a nondeterministic Turing machine in O(log n) work space i.e. PATH ∈ NL . Note that the size of the whole path is O(n log n). We may assume tape to be “write only once” from left to right. Or at any point we can compute the jth bit of the ith node using O(log n) workspace. Whether PATH ∈ L is unknown. But we shall prove that PATH is NL complete. 2 1.2 PSPACE It is not known whether P = PSPACE. But people believe that they are not equal. If P = PSPACE, then P = NP as NP ⊆ PSPACE and P ⊆ NP. Definition 1: A language L is PSPACE-hard if for every L′ ∈ PSPACE, L′ is polynomial ′ time Karp reducible to L, L ≤P L. A language L is PSPACE-complete if it is PSPACE- hard and also belongs to PSPACE. The following language is PSPACE-complete. SP ACE − T MSAT = {< M,x, 1n >: M accepts x in space n} Any language L ∈ P SP ACE is Karp reducible to SP ACE − T MSAT . Let M be a deter- ministic Turing machine decides L in polynomial space p(n), where n is the length of the input. The reduction function maps x →< M,x, 1p(|x|) >, ∀x ∈ {0, 1}∗. Compare it with a similar r.e.-complete language L∈ = {<M,x>: Turing machine M accepts x}, and an NP-complete language T MSAT = {< M,x, 1n, 1t >: ∃w ∈ {0, 1}n such that the TM M accepts <x,w > in t steps}. For every r.e. language L accepted by a Turing machine M, L ≤m L∈. The mapping is ∀x ∈ {0, 1}∗, x →<M,x>. Similarly, for every language L in NP with a p(n) (polynomial) time bounded verifier V and a q(n) (polynomial) length witness, L ≤p T MSAT . The mapping is ∀x ∈ {0, 1}∗,x →< V,x, 1p(|x|), 1q(|x|) >. We are now going to look for a more useful language known to be PSPACE-complete. Definition 2: A quantified Boolean formula (QBF) is defined inductively as follows: 1. Boolean constants true (1) and false (0) are QBFs. 2. Any Boolean variable xi is a QBF. There are denumerable Boolean variables. 3. If f1 and f2 are Boolean formulas and xi is a Boolean variables, then (f1 ∨ f2), (f1 ∧ f2), ¬f1, ∃xif1 and ∀xif1 are QBFs. We shall use appropriate associativity and precedence conventions to avoid most of the paren- thesis. The scope of a quantifier is as usual. In general a QBF looks as follows: Q1x1 · · · Qnxnφ(x1, · · · ,xn), n ≥ 0, where Qi is either an existential (∃) or a universal (∀) quantifier. xi’s are Boolean variables that take values over { true, false}. A QBF is called closed if all variables are quantified. A closed QBF can be evaluated to true (1) or false (0). A variable is said to be free if it is not quantified. An open QBF with k free variables is a map from {0, 1}k → {0, 1}. Example 5. The closed QBF ∃x1∀x2(x1 ∨ x2) is true as x1 = 1 makes the formula always true. But the closed formula ∃x1∀x2(x1 ∧ x2) is false. The open formula ∀x2(x1 ∨ x2), where x1 is the free variable, is a map from {0, 1} → {0, 1}. The Boolean argument goes to x1, ∀x2(0 ∨ x2) → 0, ∀x2(1 ∨ x2) → 1. 3 A QBF is not restricted to prenex normal form. Quantifiers may appear within the body of the formula. But such formula can be convert to prenex normal form using the following equivalences: ∀xφ(x) ≡ ¬¬∀xφ(x) ≡ ¬∃x¬φ(x), ψ ∨∃xφ(x) ≡ ∃x(ψ ∨ φ(x)), ψ ∧∀xφ(x) ≡ ∀x(ψ ∧ φ(x)), where ψ does not have any free x. If ψ has a free variable x, then we can rename the bound variable in ∀xφ(x). Example 6. The question of satisfiability of φ(x1, · · · ,xn) is equivalent to the question of truth value of the QBF ∃x1 ···∃φ(x1, · · · ,xn). The formula φ(x1, · · · ,xn) is SAT if and only if ∃x1 ···∃φ(x1, · · · ,xn) is true. Similarly the question of validity of φ(x1, · · · ,xn) is equivalent to the truth value of ∀x1 ···∀xnφ(x1, · · · ,xn). The formula φ(x1, · · · ,xn) is a tautology (in TAUT) if and only if ∀x1 ···∀xnφ(x1, · · · ,xn) is true. The language TQBF is defined as follows: TQBF = {ψ : ψ is a closed and true QBF}. Theorem 3. The language TQBF is PSPACE-complete. Proof: First we prove that TQBF is in PSPACE. Let the size of the formula ψ be m and there are n variables. If (n = 0), the formula contains Boolean constants, and it can be evaluated in O(m) time and space. Let s(n,m) be the space required to evaluate a formula of n variables and of length m. If we initialise the first variable x1 with 0, we get a new formula ψ[x1 ← 0] of n − 1 variables. Similarly, if we initialise x1 with 1, we get another formula ψ[x1 ← 1] of n − 1 variables. So we have the following recursive procedure to evaluate the truth value of a QBF. eval(Qixi · · · Qnxnφ(v1, · · · , vi−1,xi, · · · ,xn), i) if i = n evaluate the constant Boolean expression.
Load more

Recommended publications
  • 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]
  • EXPSPACE-Hardness of Behavioural Equivalences of Succinct One
    EXPSPACE-hardness of behavioural equivalences of succinct one-counter nets Petr Janˇcar1 Petr Osiˇcka1 Zdenˇek Sawa2 1Dept of Comp. Sci., Faculty of Science, Palack´yUniv. Olomouc, Czech Rep. [email protected], [email protected] 2Dept of Comp. Sci., FEI, Techn. Univ. Ostrava, Czech Rep. [email protected] Abstract We note that the remarkable EXPSPACE-hardness result in [G¨oller, Haase, Ouaknine, Worrell, ICALP 2010] ([GHOW10] for short) allows us to answer an open complexity ques- tion for simulation preorder of succinct one counter nets (i.e., one counter automata with no zero tests where counter increments and decrements are integers written in binary). This problem, as well as bisimulation equivalence, turn out to be EXPSPACE-complete. The technique of [GHOW10] was referred to by Hunter [RP 2015] for deriving EXPSPACE-hardness of reachability games on succinct one-counter nets. We first give a direct self-contained EXPSPACE-hardness proof for such reachability games (by adjust- ing a known PSPACE-hardness proof for emptiness of alternating finite automata with one-letter alphabet); then we reduce reachability games to (bi)simulation games by using a standard “defender-choice” technique. 1 Introduction arXiv:1801.01073v1 [cs.LO] 3 Jan 2018 We concentrate on our contribution, without giving a broader overview of the area here. A remarkable result by G¨oller, Haase, Ouaknine, Worrell [2] shows that model checking a fixed CTL formula on succinct one-counter automata (where counter increments and decre- ments are integers written in binary) is EXPSPACE-hard. Their proof is interesting and nontrivial, and uses two involved results from complexity theory.
    [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 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.
    [Show full text]
  • Lecture 9 1 Interactive Proof Systems/Protocols
    CS 282A/MATH 209A: Foundations of Cryptography Prof. Rafail Ostrovsky Lecture 9 Lecture date: March 7-9, 2005 Scribe: S. Bhattacharyya, R. Deak, P. Mirzadeh 1 Interactive Proof Systems/Protocols 1.1 Introduction The traditional mathematical notion of a proof is a simple passive protocol in which a prover P outputs a complete proof to a verifier V who decides on its validity. The interaction in this traditional sense is minimal and one-way, prover → verifier. The observation has been made that allowing the verifier to interact with the prover can have advantages, for example proving the assertion faster or proving more expressive languages. This extension allows for the idea of interactive proof systems (protocols). The general framework of the interactive proof system (protocol) involves a prover P with an exponential amount of time (computationally unbounded) and a verifier V with a polyno- mial amount of time. Both P and V exchange multiple messages (challenges and responses), usually dependent upon outcomes of fair coin tosses which they may or may not share. It is easy to see that since V is a poly-time machine (PPT), only a polynomial number of messages may be exchanged between the two. P ’s objective is to convince (prove to) the verifier the truth of an assertion, e.g., claimed knowledge of a proof that x ∈ L. V either accepts or rejects the interaction with the P . 1.2 Definition of Interactive Proof Systems An interactive proof system for a language L is a protocol PV for communication between a computationally unbounded (exponential time) machine P and a probabilistic poly-time (PPT) machine V such that the protocol satisfies the properties of completeness and sound- ness.
    [Show full text]
  • 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].
    [Show full text]
  • 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 .
    [Show full text]
  • Arxiv:Quant-Ph/0202111V1 20 Feb 2002
    Quantum statistical zero-knowledge John Watrous Department of Computer Science University of Calgary Calgary, Alberta, Canada [email protected] February 19, 2002 Abstract In this paper we propose a definition for (honest verifier) quantum statistical zero-knowledge interactive proof systems and study the resulting complexity class, which we denote QSZK. We prove several facts regarding this class: The following natural problem is a complete promise problem for QSZK: given instructions • for preparing two mixed quantum states, are the states close together or far apart in the trace norm metric? By instructions for preparing a mixed quantum state we mean the description of a quantum circuit that produces the mixed state on some specified subset of its qubits, assuming all qubits are initially in the 0 state. This problem is a quantum generalization of the complete promise problem of Sahai| i and Vadhan [33] for (classical) statistical zero-knowledge. QSZK is closed under complement. • QSZK PSPACE. (At present it is not known if arbitrary quantum interactive proof • systems⊆ can be simulated in PSPACE, even for one-round proof systems.) Any honest verifier quantum statistical zero-knowledge proof system can be parallelized to • a two-message (i.e., one-round) honest verifier quantum statistical zero-knowledge proof arXiv:quant-ph/0202111v1 20 Feb 2002 system. (For arbitrary quantum interactive proof systems it is known how to parallelize to three messages, but not two.) Moreover, the one-round proof system can be taken to be such that the prover sends only one qubit to the verifier in order to achieve completeness and soundness error exponentially close to 0 and 1/2, respectively.
    [Show full text]
  • 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).
    [Show full text]
  • 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).
    [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]
  • Spring 2020 (Provide Proofs for All Answers) (120 Points Total)
    Complexity Qual Spring 2020 (provide proofs for all answers) (120 Points Total) 1 Problem 1: Formal Languages (30 Points Total): For each of the following languages, state and prove whether: (i) the lan- guage is regular, (ii) the language is context-free but not regular, or (iii) the language is non-context-free. n n Problem 1a (10 Points): La = f0 1 jn ≥ 0g (that is, the set of all binary strings consisting of 0's and then 1's where the number of 0's and 1's are equal). ∗ Problem 1b (10 Points): Lb = fw 2 f0; 1g jw has an even number of 0's and at least two 1'sg (that is, the set of all binary strings with an even number, including zero, of 0's and at least two 1's). n 2n 3n Problem 1c (10 Points): Lc = f0 #0 #0 jn ≥ 0g (that is, the set of all strings of the form 0 repeated n times, followed by the # symbol, followed by 0 repeated 2n times, followed by the # symbol, followed by 0 repeated 3n times). Problem 2: NP-Hardness (30 Points Total): There are a set of n people who are the vertices of an undirected graph G. There's an undirected edge between two people if they are enemies. Problem 2a (15 Points): The people must be assigned to the seats around a single large circular table. There are exactly as many seats as people (both n). We would like to make sure that nobody ever sits next to one of their enemies.
    [Show full text]