DOCSLIB.ORG

Relations Between Complexity Classes

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Relations Between Complexity Classes Outline Relations between Complexity Classes K. Subramani1 1Lane Department of Computer Science and Electrical Engineering West Virginia University General Techniques Subramani Complexity Classes Outline Outline 1 Complexity of Classes Specification Complements of complexity classes 2 The Hierarchy Theorem Setup Lemmata The Theorem Consequences of the Hierarchy Theorem Subramani Complexity Classes Outline Outline 1 Complexity of Classes Specification Complements of complexity classes 2 The Hierarchy Theorem Setup Lemmata The Theorem Consequences of the Hierarchy Theorem Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Outline 1 Complexity of Classes Specification Complements of complexity classes 2 The Hierarchy Theorem Setup Lemmata The Theorem Consequences of the Hierarchy Theorem Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification Class Characteristics (i) Model of Computatiion - multi-string Turing Machine (ii) Mode of Computation - Deterministic or Non-deterministic (iii) Resource of interest - Time, space, etc. (iv) Bound - A function f : N!N . Definition A complexity class is the set of all languages decided by a multi-string string Turing machine M operating in the appropriate mode and such that for any input x, M spends at most f (jxj) of the specified resource. Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification Class Characteristics (i) Model of Computatiion - multi-string Turing Machine (ii) Mode of Computation - Deterministic or Non-deterministic (iii) Resource of interest - Time, space, etc. (iv) Bound - A function f : N!N . Definition A complexity class is the set of all languages decided by a multi-string string Turing machine M operating in the appropriate mode and such that for any input x, M spends at most f (jxj) of the specified resource. Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification Class Characteristics (i) Model of Computatiion - multi-string Turing Machine (ii) Mode of Computation - Deterministic or Non-deterministic (iii) Resource of interest - Time, space, etc. (iv) Bound - A function f : N!N . Definition A complexity class is the set of all languages decided by a multi-string string Turing machine M operating in the appropriate mode and such that for any input x, M spends at most f (jxj) of the specified resource. Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification Class Characteristics (i) Model of Computatiion - multi-string Turing Machine (ii) Mode of Computation - Deterministic or Non-deterministic (iii) Resource of interest - Time, space, etc. (iv) Bound - A function f : N!N . Definition A complexity class is the set of all languages decided by a multi-string string Turing machine M operating in the appropriate mode and such that for any input x, M spends at most f (jxj) of the specified resource. Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification Class Characteristics (i) Model of Computatiion - multi-string Turing Machine (ii) Mode of Computation - Deterministic or Non-deterministic (iii) Resource of interest - Time, space, etc. (iv) Bound - A function f : N!N . Definition A complexity class is the set of all languages decided by a multi-string string Turing machine M operating in the appropriate mode and such that for any input x, M spends at most f (jxj) of the specified resource. Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification Class Characteristics (i) Model of Computatiion - multi-string Turing Machine (ii) Mode of Computation - Deterministic or Non-deterministic (iii) Resource of interest - Time, space, etc. (iv) Bound - A function f : N!N . Definition A complexity class is the set of all languages decided by a multi-string string Turing machine M operating in the appropriate mode and such that for any input x, M spends at most f (jxj) of the specified resource. Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification Class Characteristics (i) Model of Computatiion - multi-string Turing Machine (ii) Mode of Computation - Deterministic or Non-deterministic (iii) Resource of interest - Time, space, etc. (iv) Bound - A function f : N!N . Definition A complexity class is the set of all languages decided by a multi-string string Turing machine M operating in the appropriate mode and such that for any input x, M spends at most f (jxj) of the specified resource. Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification Class Characteristics (i) Model of Computatiion - multi-string Turing Machine (ii) Mode of Computation - Deterministic or Non-deterministic (iii) Resource of interest - Time, space, etc. (iv) Bound - A function f : N!N . Definition A complexity class is the set of all languages decided by a multi-string string Turing machine M operating in the appropriate mode and such that for any input x, M spends at most f (jxj) of the specified resource. Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification Class Characteristics (i) Model of Computatiion - multi-string Turing Machine (ii) Mode of Computation - Deterministic or Non-deterministic (iii) Resource of interest - Time, space, etc. (iv) Bound - A function f : N!N . Definition A complexity class is the set of all languages decided by a multi-string string Turing machine M operating in the appropriate mode and such that for any input x, M spends at most f (jxj) of the specified resource. Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification Class Characteristics (i) Model of Computatiion - multi-string Turing Machine (ii) Mode of Computation - Deterministic or Non-deterministic (iii) Resource of interest - Time, space, etc. (iv) Bound - A function f : N!N . Definition A complexity class is the set of all languages decided by a multi-string string Turing machine M operating in the appropriate mode and such that for any input x, M spends at most f (jxj) of the specified resource. Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification (contd.) Definition A function f is said to be a proper complexity function, if (8n ≥ 0)(f (n + 1) ≥ f (n)) and there exists a k-string Turing machine Mf = (K ; Σ; δ; s) with input and output, which on input x, computes uf (jxj) in O(jxj + f (jxj) steps and uses O(f (jxj) space besides its input. Typical proper complexity functions p c, n, n!, n, log n,... Notational Convenience TIME(f ), SPACE(f ), NTIME(f ), NSPACE(f ). Parameterized complexity classes: k j (i) P = TIME(n ) = [j>0TIME(n ). k j nk (ii) NP = NTIME(n ) = [j>0NTIME(n ). (v) EXP = TIME(2 ) = j k n (iii) PSPACE = SPACE(n ) = [j>0TIME(2 ). j [j>0SPACE(n ). (vi) L = SPACE(log n). (iv) NPSPACE = NSPACE(nk ) = (vii) NL = NSPACE(log n). j [j>0NSPACE(n ). Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification (contd.) Definition A function f is said to be a proper complexity function, if (8n ≥ 0)(f (n + 1) ≥ f (n)) and there exists a k-string Turing machine Mf = (K ; Σ; δ; s) with input and output, which on input x, computes uf (jxj) in O(jxj + f (jxj) steps and uses O(f (jxj) space besides its input. Typical proper complexity functions p c, n, n!, n, log n,... Notational Convenience TIME(f ), SPACE(f ), NTIME(f ), NSPACE(f ). Parameterized complexity classes: k j (i) P = TIME(n ) = [j>0TIME(n ). k j nk (ii) NP = NTIME(n ) = [j>0NTIME(n ). (v) EXP = TIME(2 ) = j k n (iii) PSPACE = SPACE(n ) = [j>0TIME(2 ). j [j>0SPACE(n ). (vi) L = SPACE(log n). (iv) NPSPACE = NSPACE(nk ) = (vii) NL = NSPACE(log n). j [j>0NSPACE(n ). Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification (contd.) Definition A function f is said to be a proper complexity function, if (8n ≥ 0)(f (n + 1) ≥ f (n)) and there exists a k-string Turing machine Mf = (K ; Σ; δ; s) with input and output, which on input x, computes uf (jxj) in O(jxj + f (jxj) steps and uses O(f (jxj) space besides its input. Typical proper complexity functions p c, n, n!, n, log n,... Notational Convenience TIME(f ), SPACE(f ), NTIME(f ), NSPACE(f ). Parameterized complexity classes: k j (i) P = TIME(n ) = [j>0TIME(n ). k j nk (ii) NP = NTIME(n ) = [j>0NTIME(n ). (v) EXP = TIME(2 ) = j k n (iii) PSPACE = SPACE(n ) = [j>0TIME(2 ). j [j>0SPACE(n ). (vi) L = SPACE(log n). (iv) NPSPACE = NSPACE(nk ) = (vii) NL = NSPACE(log n). j [j>0NSPACE(n ). Subramani Complexity Classes Complexity of Classes Specification The Hierarchy Theorem Complements of complexity classes Specification (contd.) Definition A function f is said to be a proper complexity function, if (8n ≥ 0)(f (n + 1) ≥ f (n)) and there exists a k-string Turing machine Mf = (K ; Σ; δ; s) with input and output, which on input x, computes uf (jxj) in O(jxj + f (jxj) steps and uses O(f (jxj) space besides its input. Typical proper complexity functions p c, n, n!, n, log n,... Notational Convenience TIME(f ), SPACE(f ), NTIME(f ), NSPACE(f ). Parameterized complexity classes: k j (i) P = TIME(n ) = [j>0TIME(n ). k j nk (ii) NP = NTIME(n ) = [j>0NTIME(n ). (v) EXP = TIME(2 ) = j k n (iii) PSPACE = SPACE(n ) = [j>0TIME(2 ). j [j>0SPACE(n ). (vi) L = SPACE(log n). (iv) NPSPACE = NSPACE(nk ) = (vii) NL = NSPACE(log n).
Load more

Recommended publications
  • Complexity Theory Lecture 9 Co-NP Co-NP-Complete
    Complexity Theory 1 Complexity Theory 2 co-NP Complexity Theory Lecture 9 As co-NP is the collection of complements of languages in NP, and P is closed under complementation, co-NP can also be characterised as the collection of languages of the form: ′ L = x y y <p( x ) R (x, y) { |∀ | | | | → } Anuj Dawar University of Cambridge Computer Laboratory NP – the collection of languages with succinct certificates of Easter Term 2010 membership. co-NP – the collection of languages with succinct certificates of http://www.cl.cam.ac.uk/teaching/0910/Complexity/ disqualification. Anuj Dawar May 14, 2010 Anuj Dawar May 14, 2010 Complexity Theory 3 Complexity Theory 4 NP co-NP co-NP-complete P VAL – the collection of Boolean expressions that are valid is co-NP-complete. Any language L that is the complement of an NP-complete language is co-NP-complete. Any of the situations is consistent with our present state of ¯ knowledge: Any reduction of a language L1 to L2 is also a reduction of L1–the complement of L1–to L¯2–the complement of L2. P = NP = co-NP • There is an easy reduction from the complement of SAT to VAL, P = NP co-NP = NP = co-NP • ∩ namely the map that takes an expression to its negation. P = NP co-NP = NP = co-NP • ∩ VAL P P = NP = co-NP ∈ ⇒ P = NP co-NP = NP = co-NP • ∩ VAL NP NP = co-NP ∈ ⇒ Anuj Dawar May 14, 2010 Anuj Dawar May 14, 2010 Complexity Theory 5 Complexity Theory 6 Prime Numbers Primality Consider the decision problem PRIME: Another way of putting this is that Composite is in NP.
    [Show full text]
  • NP-Completeness: Reductions Tue, Nov 21, 2017
    CMSC 451 Dave Mount CMSC 451: Lecture 19 NP-Completeness: Reductions Tue, Nov 21, 2017 Reading: Chapt. 8 in KT and Chapt. 8 in DPV. Some of the reductions discussed here are not in either text. Recap: We have introduced a number of concepts on the way to defining NP-completeness: Decision Problems/Language recognition: are problems for which the answer is either yes or no. These can also be thought of as language recognition problems, assuming that the input has been encoded as a string. For example: HC = fG j G has a Hamiltonian cycleg MST = f(G; c) j G has a MST of cost at most cg: P: is the class of all decision problems which can be solved in polynomial time. While MST 2 P, we do not know whether HC 2 P (but we suspect not). Certificate: is a piece of evidence that allows us to verify in polynomial time that a string is in a given language. For example, the language HC above, a certificate could be a sequence of vertices along the cycle. (If the string is not in the language, the certificate can be anything.) NP: is defined to be the class of all languages that can be verified in polynomial time. (Formally, it stands for Nondeterministic Polynomial time.) Clearly, P ⊆ NP. It is widely believed that P 6= NP. To define NP-completeness, we need to introduce the concept of a reduction. Reductions: The class of NP-complete problems consists of a set of decision problems (languages) (a subset of the class NP) that no one knows how to solve efficiently, but if there were a polynomial time solution for even a single NP-complete problem, then every problem in NP would be solvable in polynomial time.
    [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]
  • Chapter 24 Conp, Self-Reductions
    Chapter 24 coNP, Self-Reductions CS 473: Fundamental Algorithms, Spring 2013 April 24, 2013 24.1 Complementation and Self-Reduction 24.2 Complementation 24.2.1 Recap 24.2.1.1 The class P (A) A language L (equivalently decision problem) is in the class P if there is a polynomial time algorithm A for deciding L; that is given a string x, A correctly decides if x 2 L and running time of A on x is polynomial in jxj, the length of x. 24.2.1.2 The class NP Two equivalent definitions: (A) Language L is in NP if there is a non-deterministic polynomial time algorithm A (Turing Machine) that decides L. (A) For x 2 L, A has some non-deterministic choice of moves that will make A accept x (B) For x 62 L, no choice of moves will make A accept x (B) L has an efficient certifier C(·; ·). (A) C is a polynomial time deterministic algorithm (B) For x 2 L there is a string y (proof) of length polynomial in jxj such that C(x; y) accepts (C) For x 62 L, no string y will make C(x; y) accept 1 24.2.1.3 Complementation Definition 24.2.1. Given a decision problem X, its complement X is the collection of all instances s such that s 62 L(X) Equivalently, in terms of languages: Definition 24.2.2. Given a language L over alphabet Σ, its complement L is the language Σ∗ n L. 24.2.1.4 Examples (A) PRIME = nfn j n is an integer and n is primeg o PRIME = n n is an integer and n is not a prime n o PRIME = COMPOSITE .
    [Show full text]
  • Succinctness of the Complement and Intersection of Regular Expressions Wouter Gelade, Frank Neven
    Succinctness of the Complement and Intersection of Regular Expressions Wouter Gelade, Frank Neven To cite this version: Wouter Gelade, Frank Neven. Succinctness of the Complement and Intersection of Regular Expres- sions. STACS 2008, Feb 2008, Bordeaux, France. pp.325-336. hal-00226864 HAL Id: hal-00226864 https://hal.archives-ouvertes.fr/hal-00226864 Submitted on 30 Jan 2008 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Symposium on Theoretical Aspects of Computer Science 2008 (Bordeaux), pp. 325-336 www.stacs-conf.org SUCCINCTNESS OF THE COMPLEMENT AND INTERSECTION OF REGULAR EXPRESSIONS WOUTER GELADE AND FRANK NEVEN Hasselt University and Transnational University of Limburg, School for Information Technology E-mail address: [email protected] Abstract. We study the succinctness of the complement and intersection of regular ex- pressions. In particular, we show that when constructing a regular expression defining the complement of a given regular expression, a double exponential size increase cannot be avoided. Similarly, when constructing a regular expression defining the intersection of a fixed and an arbitrary number of regular expressions, an exponential and double expo- nential size increase, respectively, can in worst-case not be avoided.
    [Show full text]
  • Notes on Space Complexity of Integration of Computable Real
    Notes on space complexity of integration of computable real functions in Ko–Friedman model Sergey V. Yakhontov Abstract x In the present paper it is shown that real function g(x)= 0 f(t)dt is a linear-space computable real function on interval [0, 1] if f is a linear-space computable C2[0, 1] real function on interval R [0, 1], and this result does not depend on any open question in the computational complexity theory. The time complexity of computable real functions and integration of computable real functions is considered in the context of Ko–Friedman model which is based on the notion of Cauchy functions computable by Turing machines. 1 2 In addition, a real computable function f is given such that 0 f ∈ FDSPACE(n )C[a,b] but 1 f∈ / FP if FP 6= #P. 0 C[a,b] R RKeywords: Computable real functions, Cauchy function representation, polynomial-time com- putable real functions, linear-space computable real functions, C2[0, 1] real functions, integration of computable real functions. Contents 1 Introduction 1 1.1 CF computablerealnumbersandfunctions . ...... 2 1.2 Integration of FP computablerealfunctions. 2 2 Upper bound of the time complexity of integration 3 2 3 Function from FDSPACE(n )C[a,b] that not in FPC[a,b] if FP 6= #P 4 4 Conclusion 4 arXiv:1408.2364v3 [cs.CC] 17 Nov 2014 1 Introduction In the present paper, we consider computable real numbers and functions that are represented by Cauchy functions computable by Turing machines [1]. Main results regarding computable real numbers and functions can be found in [1–4]; main results regarding computational complexity of computations on Turing machines can be found in [5].
    [Show full text]
  • NP As Games, Co-NP, Proof Complexity
    CS 6743 Lecture 9 1 Fall 2007 1 Importance of the Cook-Levin Theorem There is a trivial NP-complete language: k Lu = {(M, x, 1 ) | NTM M accepts x in ≤ k steps} Exercise: Show that Lu is NP-complete. The language Lu is not particularly interesting, whereas SAT is extremely interesting since it’s a well-known and well-studied natural problem in logic. After Cook and Levin showed NP-completeness of SAT, literally hundreds of other important and natural problems were also shown to be NP-complete. It is this abundance of natural complete problems which makes the notion of NP-completeness so important, and the “P vs. NP” question so fundamental. 2 Viewing NP as a game Nondeterministic computation can be viewed as a two-person game. The players are Prover and Verifier. Both get the same input, e.g., a propositional formula φ. Prover is all-powerful (but not trust-worthy). He is trying to convince Verifier that the input is in the language (e.g., that φ is satisfiable). Prover sends his argument (as a binary string) to Verifier. Verifier is computationally bounded algorithm. In case of NP, Verifier is a deterministic polytime algorithm. It is not hard to argue that the class NP of languages L is exactly the class of languages for which there is a pair (Prover, Verifier) with the property: For inputs in the language, Prover convinces Verifier to accept; for inputs not in the language, any string sent by Prover will be rejected by Verifier. Moreover, the string that Prover needs to send is of length polynomial in the size of the input.
    [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]
  • Glossary of Complexity Classes
    App endix A Glossary of Complexity Classes Summary This glossary includes selfcontained denitions of most complexity classes mentioned in the b o ok Needless to say the glossary oers a very minimal discussion of these classes and the reader is re ferred to the main text for further discussion The items are organized by topics rather than by alphab etic order Sp ecically the glossary is partitioned into two parts dealing separately with complexity classes that are dened in terms of algorithms and their resources ie time and space complexity of Turing machines and complexity classes de ned in terms of nonuniform circuits and referring to their size and depth The algorithmic classes include timecomplexity based classes such as P NP coNP BPP RP coRP PH E EXP and NEXP and the space complexity classes L NL RL and P S P AC E The non k uniform classes include the circuit classes P p oly as well as NC and k AC Denitions and basic results regarding many other complexity classes are available at the constantly evolving Complexity Zoo A Preliminaries Complexity classes are sets of computational problems where each class contains problems that can b e solved with sp ecic computational resources To dene a complexity class one sp ecies a mo del of computation a complexity measure like time or space which is always measured as a function of the input length and a b ound on the complexity of problems in the class We follow the tradition of fo cusing on decision problems but refer to these problems using the terminology of promise problems
    [Show full text]
  • Complements of Nondeterministic Classes • from P
    Complements of Nondeterministic Classes ² From p. 133, we know R, RE, and coRE are distinct. { coRE contains the complements of languages in RE, not the languages not in RE. ² Recall that the complement of L, denoted by L¹, is the language §¤ ¡ L. { sat complement is the set of unsatis¯able boolean expressions. { hamiltonian path complement is the set of graphs without a Hamiltonian path. °c 2011 Prof. Yuh-Dauh Lyuu, National Taiwan University Page 181 The Co-Classes ² For any complexity class C, coC denotes the class fL : L¹ 2 Cg: ² Clearly, if C is a deterministic time or space complexity class, then C = coC. { They are said to be closed under complement. { A deterministic TM deciding L can be converted to one that decides L¹ within the same time or space bound by reversing the \yes" and \no" states. ² Whether nondeterministic classes for time are closed under complement is not known (p. 79). °c 2011 Prof. Yuh-Dauh Lyuu, National Taiwan University Page 182 Comments ² As coC = fL : L¹ 2 Cg; L 2 C if and only if L¹ 2 coC. ² But it is not true that L 2 C if and only if L 62 coC. { coC is not de¯ned as C¹. ² For example, suppose C = ff2; 4; 6; 8; 10;:::gg. ² Then coC = ff1; 3; 5; 7; 9;:::gg. ¤ ² But C¹ = 2f1;2;3;:::g ¡ ff2; 4; 6; 8; 10;:::gg. °c 2011 Prof. Yuh-Dauh Lyuu, National Taiwan University Page 183 The Quanti¯ed Halting Problem ² Let f(n) ¸ n be proper. ² De¯ne Hf = fM; x : M accepts input x after at most f(j x j) stepsg; where M is deterministic.
    [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]