DOCSLIB.ORG

Descriptive Complexity

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Descriptive Complexity Descriptive Complexity Neil Immerman College of Computer and Information Sciences University of Massachusetts, Amherst Amherst, MA, USA people.cs.umass.edu/˜immerman Neil Immerman Descriptive Complexity P = 1 [ DTIME[nk ] k=1 P is a good mathematical wrapper for “truly feasible”. co-r.e. complete r.e. complete co-r.e. r.e. Recursive co-NP complete NP complete co-NP NP NP co-NP ∩ P complete P “truly feasible” “truly feasible” is FO(CFL) the informal set of problems we can FO(REGULAR) solve exactly on all reasonably sized FO instances. Neil Immerman Descriptive Complexity P is a good mathematical wrapper for “truly feasible”. co-r.e. complete r.e. complete co-r.e. r.e. P = Recursive 1 [ DTIME[nk ] k=1 co-NP complete NP complete co-NP NP NP co-NP ∩ P complete P “truly feasible” “truly feasible” is FO(CFL) the informal set of problems we can FO(REGULAR) solve exactly on all reasonably sized FO instances. Neil Immerman Descriptive Complexity co-r.e. complete r.e. complete co-r.e. r.e. P = Recursive 1 [ DTIME[nk ] k=1 P is a good co-NP complete NP complete co-NP NP mathematical NP co-NP ∩ wrapper for “truly P complete P feasible”. “truly feasible” “truly feasible” is FO(CFL) the informal set of problems we can FO(REGULAR) solve exactly on all reasonably sized FO instances. Neil Immerman Descriptive Complexity NTIME[t(n)]: a mathematical fiction 0 0 0 0 input w, w = n 0 j j 0 0 0 N accepts w 0 1 0 t(n) if at least s 0 2 0 one of the 2t(n) 0 0 0 paths accepts. 0 0 0 0 0 0 t(n) 0 Neil Immerman Descriptive Complexity b b b b 1 2 3 ··· t(n) Many optimization problems we want to solve are NP complete. SAT, TSP, 3-COLOR, CLIQUE, . As descison problems, all NP complete problems are isomorphic. co-r.e. complete r.e. complete NP = co-r.e. r.e. 1 Recursive [ NTIME[nk ] k=1 co-NP complete NP complete SAT SAT co-NP NP NP co-NP ∩ P complete P “truly feasible” FO(CFL) FO(REGULAR) FO Neil Immerman Descriptive Complexity As descison problems, all NP complete problems are isomorphic. co-r.e. complete r.e. complete NP = co-r.e. r.e. 1 Recursive [ NTIME[nk ] k=1 Many optimization problems we want co-NP complete NP complete to solve are NP SAT SAT co-NP NP NP co-NP complete. ∩ P complete P SAT, TSP, 3-COLOR, “truly CLIQUE, . feasible” FO(CFL) FO(REGULAR) FO Neil Immerman Descriptive Complexity co-r.e. complete r.e. complete NP = co-r.e. r.e. 1 Recursive [ NTIME[nk ] k=1 Many optimization problems we want co-NP complete NP complete to solve are NP SAT SAT co-NP NP NP co-NP complete. ∩ P complete P SAT, TSP, 3-COLOR, “truly CLIQUE, . feasible” FO(CFL) As descison problems, all NP FO(REGULAR) complete problems are isomorphic. FO Neil Immerman Descriptive Complexity co-r.e. complete r.e. complete NP = co-r.e. r.e. 1 Recursive [ NTIME[nk ] k=1 Many optimization PSPACE problems we want co-NP complete NP complete to solve are NP SAT SAT co-NP NP NP co-NP complete. ∩ P complete P SAT, TSP, 3-COLOR, “truly CLIQUE, . feasible” FO(CFL) As descison problems, all NP FO(REGULAR) complete problems are isomorphic. FO Neil Immerman Descriptive Complexity co-r.e. complete r.e. complete NP = co-r.e. r.e. 1 Recursive [ NTIME[nk ] k=1 EXPTIME Many optimization PSPACE problems we want co-NP complete NP complete to solve are NP SAT SAT co-NP NP NP co-NP complete. ∩ P complete P SAT, TSP, 3-COLOR, “truly CLIQUE, . feasible” FO(CFL) As descison problems, all NP FO(REGULAR) complete problems are isomorphic. FO Neil Immerman Descriptive Complexity S ··· ··· Restrict attention to the complexity of computing individual bits of the output, i.e., decision problems. How hard is it to check if input has property S ? How rich a language do we need to express property S? There is a constructive isomorphism between these two approaches. Descriptive Complexity Query Answer Computation q1 q2 qn 7! 7! a1 a2 ai am ··· ··· ··· Neil Immerman Descriptive Complexity S ··· ··· How hard is it to check if input has property S ? How rich a language do we need to express property S? There is a constructive isomorphism between these two approaches. Descriptive Complexity Query Answer Computation q1 q2 qn 7! 7! a1 a2 ai am ··· ··· ··· Restrict attention to the complexity of computing individual bits of the output, i.e., decision problems. Neil Immerman Descriptive Complexity How rich a language do we need to express property S? There is a constructive isomorphism between these two approaches. Descriptive Complexity Query Answer Computation q1 q2 qn 7! 7! a1 a2 ai am ··· ··· S ··· ··· ··· Restrict attention to the complexity of computing individual bits of the output, i.e., decision problems. How hard is it to check if input has property S ? Neil Immerman Descriptive Complexity There is a constructive isomorphism between these two approaches. Descriptive Complexity Query Answer Computation q1 q2 qn 7! 7! a1 a2 ai am ··· ··· S ··· ··· ··· Restrict attention to the complexity of computing individual bits of the output, i.e., decision problems. How hard is it to check if input has property S ? How rich a language do we need to express property S? Neil Immerman Descriptive Complexity Descriptive Complexity Query Answer Computation q1 q2 qn 7! 7! a1 a2 ai am ··· ··· S ··· ··· ··· Restrict attention to the complexity of computing individual bits of the output, i.e., decision problems. How hard is it to check if input has property S ? How rich a language do we need to express property S? There is a constructive isomorphism between these two approaches. Neil Immerman Descriptive Complexity Think of the Input as a Finite Logical Structure Graph G = ( v ;:::; vn ; ; E; s; t) f 1 g ≤ ¨* H ¨¨ H ¨ r r HHj HH ¨¨* ¨¨* t s H ¨ ¨ r Hj¨H r ¨ r H 2 H Σg = (E ; s; t) r Hj r r Binary String w = ( p ;:::; p ; ; S) A f 1 8g ≤ S = p ; p5; p7; p f 2 8g 1 Σs = (S ) w = 01001011 Neil Immerman Descriptive Complexity In this setting, with the structure of interest being the finite input, FO is a weak, low-level complexity class. First-Order Logic input symbols: from Σ variables: x; y; z;::: boolean connectives: ; ; ^ _ : quantifiers: ; 8 9 numeric symbols: =; ; +; ; min; max ≤ × α x y(E(x; y)) (Σg) ≡8 9 2L β x y(x y S(x)) (Σs) ≡9 8 ≤ ^ 2L β S(min) (Σs) ≡ 2L Neil Immerman Descriptive Complexity First-Order Logic input symbols: from Σ variables: x; y; z;::: boolean connectives: ; ; ^ _ : quantifiers: ; 8 9 numeric symbols: =; ; +; ; min; max ≤ × α x y(E(x; y)) (Σg) ≡8 9 2L β x y(x y S(x)) (Σs) ≡9 8 ≤ ^ 2L β S(min) (Σs) ≡ 2L In this setting, with the structure of interest being the finite input, FO is a weak, low-level complexity class. Neil Immerman Descriptive Complexity Fagin’s Theorem: NP = SO 9 s d t b a c f g e Second-Order Logic: FO plus Relation Variables Φ R1 G1 B1 x y ((R(x) G(x) B(x)) (E(x; y) 3color ≡ 9 8 _ _ ^ ! ( (R(x) R(y)) (G(x) G(y)) (B(x) B(y))))) : ^ ^ : ^ ^ : ^ s d t b a c f g e Neil Immerman Descriptive Complexity s d t b a c f g e Second-Order Logic: FO plus Relation Variables Fagin’s Theorem: NP = SO 9 Φ R1 G1 B1 x y ((R(x) G(x) B(x)) (E(x; y) 3color ≡ 9 8 _ _ ^ ! ( (R(x) R(y)) (G(x) G(y)) (B(x) B(y))))) : ^ ^ : ^ ^ : ^ s d t b a c f g e Neil Immerman Descriptive Complexity co-r.e. complete r.e. complete co-r.e. r.e. Recursive EXPTIME PSPACE SO co-NP complete PTIME Hierarchy NP complete SAT SAT SO SO co-NP ∀ ∃ NP NP co-NP ∩ P complete P “truly feasible” FO(CFL) FO(REGULAR) FO Neil Immerman Descriptive Complexity C(i) ( j > i) A(j) B(j) ≡ 9 ^ ^ ( k:j > k > i)(A(k) B(k)) 8 _ Q+(i) A(i) B(i) C(i) ≡ ⊕ ⊕ Addition is First-Order Q+ : STRUC[Σ ] STRUC[Σs] AB ! A a1 a2 ... an−1 an B + b1 b2 ... bn−1 bn S s1 s2 ... sn−1 sn Neil Immerman Descriptive Complexity Q+(i) A(i) B(i) C(i) ≡ ⊕ ⊕ Addition is First-Order Q+ : STRUC[Σ ] STRUC[Σs] AB ! A a1 a2 ... an−1 an B + b1 b2 ... bn−1 bn S s1 s2 ... sn−1 sn C(i) ( j > i) A(j) B(j) ≡ 9 ^ ^ ( k:j > k > i)(A(k) B(k)) 8 _ Neil Immerman Descriptive Complexity Addition is First-Order Q+ : STRUC[Σ ] STRUC[Σs] AB ! A a1 a2 ... an−1 an B + b1 b2 ... bn−1 bn S s1 s2 ... sn−1 sn C(i) ( j > i) A(j) B(j) ≡ 9 ^ ^ ( k:j > k > i)(A(k) B(k)) 8 _ Q+(i) A(i) B(i) C(i) ≡ ⊕ ⊕ Neil Immerman Descriptive Complexity Quantifiers are Parallel Assume array A[x]: x = 1;:::; r in memory. x(A(x)) write(1); proc p : if (A[i] = 0) then write(0) 8 ≡ i 01 Parallel Machines: CRAM[t(n)] = CRCW-PRAM-TIME[t(n)]-HARD[nO(1)] P P r 1 P 2 Global Memory P3 P 4 P 5 Neil Immerman Descriptive Complexity x(A(x)) write(1); proc p : if (A[i] = 0) then write(0) 8 ≡ i 01 Parallel Machines: Quantifiers are Parallel CRAM[t(n)] = CRCW-PRAM-TIME[t(n)]-HARD[nO(1)] Assume array A[x]: x = 1;:::; r in memory.
Load more

Recommended publications
  • Infinitary Logic and Inductive Definability Over Finite Structures
    University of Pennsylvania ScholarlyCommons Technical Reports (CIS) Department of Computer & Information Science November 1991 Infinitary Logic and Inductive Definability Over Finite Structures Anuj Dawar University of Pennsylvania Steven Lindell University of Pennsylvania Scott Weinstein University of Pennsylvania Follow this and additional works at: https://repository.upenn.edu/cis_reports Recommended Citation Anuj Dawar, Steven Lindell, and Scott Weinstein, "Infinitary Logic and Inductive Definability Over Finite Structures", . November 1991. University of Pennsylvania Department of Computer and Information Science Technical Report No. MS-CIS-91-97. This paper is posted at ScholarlyCommons. https://repository.upenn.edu/cis_reports/365 For more information, please contact [email protected]. Infinitary Logic and Inductive Definability Over Finite Structures Abstract The extensions of first-order logic with a least fixed point operators (FO + LFP) and with a partial fixed point operator (FO + PFP) are known to capture the complexity classes P and PSPACE respectively in the presence of an ordering relation over finite structures. Recently, Abiteboul and Vianu [AV91b] investigated the relation of these two logics in the absence of an ordering, using a mchine model of generic computation. In particular, they showed that the two languages have equivalent expressive power if and only if P = PSPACE. These languages can also be seen as fragments of an infinitary logic where each ω formula has a bounded number of variables, L ∞ω (see, for instance, [KV90]). We present a treatment of the results in [AV91b] from this point of view. In particular, we show that we can write a formula of FO + LFP and P from ordered structures to classes of structures where every element is definable.
    [Show full text]
  • 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]
  • On the Randomness Complexity of Interactive Proofs and Statistical Zero-Knowledge Proofs*
    On the Randomness Complexity of Interactive Proofs and Statistical Zero-Knowledge Proofs* Benny Applebaum† Eyal Golombek* Abstract We study the randomness complexity of interactive proofs and zero-knowledge proofs. In particular, we ask whether it is possible to reduce the randomness complexity, R, of the verifier to be comparable with the number of bits, CV , that the verifier sends during the interaction. We show that such randomness sparsification is possible in several settings. Specifically, unconditional sparsification can be obtained in the non-uniform setting (where the verifier is modelled as a circuit), and in the uniform setting where the parties have access to a (reusable) common-random-string (CRS). We further show that constant-round uniform protocols can be sparsified without a CRS under a plausible worst-case complexity-theoretic assumption that was used previously in the context of derandomization. All the above sparsification results preserve statistical-zero knowledge provided that this property holds against a cheating verifier. We further show that randomness sparsification can be applied to honest-verifier statistical zero-knowledge (HVSZK) proofs at the expense of increasing the communica- tion from the prover by R−F bits, or, in the case of honest-verifier perfect zero-knowledge (HVPZK) by slowing down the simulation by a factor of 2R−F . Here F is a new measure of accessible bit complexity of an HVZK proof system that ranges from 0 to R, where a maximal grade of R is achieved when zero- knowledge holds against a “semi-malicious” verifier that maliciously selects its random tape and then plays honestly.
    [Show full text]
  • Week 1: an Overview of Circuit Complexity 1 Welcome 2
    Topics in Circuit Complexity (CS354, Fall’11) Week 1: An Overview of Circuit Complexity Lecture Notes for 9/27 and 9/29 Ryan Williams 1 Welcome The area of circuit complexity has a long history, starting in the 1940’s. It is full of open problems and frontiers that seem insurmountable, yet the literature on circuit complexity is fairly large. There is much that we do know, although it is scattered across several textbooks and academic papers. I think now is a good time to look again at circuit complexity with fresh eyes, and try to see what can be done. 2 Preliminaries An n-bit Boolean function has domain f0; 1gn and co-domain f0; 1g. At a high level, the basic question asked in circuit complexity is: given a collection of “simple functions” and a target Boolean function f, how efficiently can f be computed (on all inputs) using the simple functions? Of course, efficiency can be measured in many ways. The most natural measure is that of the “size” of computation: how many copies of these simple functions are necessary to compute f? Let B be a set of Boolean functions, which we call a basis set. The fan-in of a function g 2 B is the number of inputs that g takes. (Typical choices are fan-in 2, or unbounded fan-in, meaning that g can take any number of inputs.) We define a circuit C with n inputs and size s over a basis B, as follows. C consists of a directed acyclic graph (DAG) of s + n + 2 nodes, with n sources and one sink (the sth node in some fixed topological order on the nodes).
    [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]
  • NP-Completeness Part I
    NP-Completeness Part I Outline for Today ● Recap from Last Time ● Welcome back from break! Let's make sure we're all on the same page here. ● Polynomial-Time Reducibility ● Connecting problems together. ● NP-Completeness ● What are the hardest problems in NP? ● The Cook-Levin Theorem ● A concrete NP-complete problem. Recap from Last Time The Limits of Computability EQTM EQTM co-RE R RE LD LD ADD HALT ATM HALT ATM 0*1* The Limits of Efficient Computation P NP R P and NP Refresher ● The class P consists of all problems solvable in deterministic polynomial time. ● The class NP consists of all problems solvable in nondeterministic polynomial time. ● Equivalently, NP consists of all problems for which there is a deterministic, polynomial-time verifier for the problem. Reducibility Maximum Matching ● Given an undirected graph G, a matching in G is a set of edges such that no two edges share an endpoint. ● A maximum matching is a matching with the largest number of edges. AA maximummaximum matching.matching. Maximum Matching ● Jack Edmonds' paper “Paths, Trees, and Flowers” gives a polynomial-time algorithm for finding maximum matchings. ● (This is the same Edmonds as in “Cobham- Edmonds Thesis.) ● Using this fact, what other problems can we solve? Domino Tiling Domino Tiling Solving Domino Tiling Solving Domino Tiling Solving Domino Tiling Solving Domino Tiling Solving Domino Tiling Solving Domino Tiling Solving Domino Tiling Solving Domino Tiling The Setup ● To determine whether you can place at least k dominoes on a crossword grid, do the following: ● Convert the grid into a graph: each empty cell is a node, and any two adjacent empty cells have an edge between them.
    [Show full text]
  • 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 defines commands to typeset (almost) all of the complexity classes you’ll find 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]
  • Canonical Models and the Complexity of Modal Team Logic
    On the Complexity of Team Logic and its Two-Variable Fragment Martin Lück Leibniz Universität Hannover, Germany [email protected] Abstract. We study the logic FO(∼), the extension of first-order logic with team semantics by unrestricted Boolean negation. It was recently shown axiomatizable, but otherwise has not yet received much attention in questions of computational complexity. In this paper, we consider its two-variable fragment FO2(∼) and prove that its satisfiability problem is decidable, and in fact complete for the recently introduced non-elementary class TOWER(poly). Moreover, we classify the complexity of model checking of FO(∼) with respect to the number of variables and the quantifier rank, and prove a di- chotomy between PSPACE- and ATIME-ALT(exp, poly)-completeness. To achieve the lower bounds, we propose a translation from modal team logic MTL to FO2(∼) that extends the well-known standard translation from modal logic ML to FO2. For the upper bounds, we translate to a fragment of second-order logic. Keywords: team semantics, two-variable logic, complexity, satisfiability, model checking 2012 ACM Subject Classification: Theory of computation → Complexity theory and logic; Logic; 1. Introduction In the last decades, the work of logicians has unearthed a plethora of decidable fragments of first-order logic FO. Many of these cases are restricted quantifier prefixes, such as the BSR-fragment which contains only ∃∗∀∗-sentences [30]. Others include the guarded arXiv:1804.04968v1 [cs.LO] 13 Apr 2018 fragment GF [1], the recently introduced separated fragment SF [32, 34], or the two-variable fragment FO2 [13, 27, 31].
    [Show full text]
  • Theory of Computation
    A Universal Program (4) Theory of Computation Prof. Michael Mascagni Florida State University Department of Computer Science 1 / 33 Recursively Enumerable Sets (4.4) A Universal Program (4) The Parameter Theorem (4.5) Diagonalization, Reducibility, and Rice's Theorem (4.6, 4.7) Enumeration Theorem Definition. We write Wn = fx 2 N j Φ(x; n) #g: Then we have Theorem 4.6. A set B is r.e. if and only if there is an n for which B = Wn. Proof. This is simply by the definition ofΦ( x; n). 2 Note that W0; W1; W2;::: is an enumeration of all r.e. sets. 2 / 33 Recursively Enumerable Sets (4.4) A Universal Program (4) The Parameter Theorem (4.5) Diagonalization, Reducibility, and Rice's Theorem (4.6, 4.7) The Set K Let K = fn 2 N j n 2 Wng: Now n 2 K , Φ(n; n) #, HALT(n; n) This, K is the set of all numbers n such that program number n eventually halts on input n. 3 / 33 Recursively Enumerable Sets (4.4) A Universal Program (4) The Parameter Theorem (4.5) Diagonalization, Reducibility, and Rice's Theorem (4.6, 4.7) K Is r.e. but Not Recursive Theorem 4.7. K is r.e. but not recursive. Proof. By the universality theorem, Φ(n; n) is partially computable, hence K is r.e. If K¯ were also r.e., then by the enumeration theorem, K¯ = Wi for some i. We then arrive at i 2 K , i 2 Wi , i 2 K¯ which is a contradiction.
    [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]
  • Interactive Oracle Proofs with Constant Rate and Query Complexity∗†
    Interactive Oracle Proofs with Constant Rate and Query Complexity∗† Eli Ben-Sasson1, Alessandro Chiesa2, Ariel Gabizon‡3, Michael Riabzev4, and Nicholas Spooner5 1 Technion, Haifa, Israel [email protected] 2 University of California, Berkeley, CA, USA [email protected] 3 Zerocoin Electronic Coin Company (Zcash), Boulder, CO, USA [email protected] 4 Technion, Haifa, Israel [email protected] 5 University of Toronto, Toronto, Canada [email protected] Abstract We study interactive oracle proofs (IOPs) [7, 43], which combine aspects of probabilistically check- able proofs (PCPs) and interactive proofs (IPs). We present IOP constructions and techniques that let us achieve tradeoffs in proof length versus query complexity that are not known to be achievable via PCPs or IPs alone. Our main results are: 1. Circuit satisfiability has 3-round IOPs with linear proof length (counted in bits) and constant query complexity. 2. Reed–Solomon codes have 2-round IOPs of proximity with linear proof length and constant query complexity. 3. Tensor product codes have 1-round IOPs of proximity with sublinear proof length and constant query complexity. (A familiar example of a tensor product code is the Reed–Muller code with a bound on individual degrees.) For all the above, known PCP constructions give quasilinear proof length and constant query complexity [12, 16]. Also, for circuit satisfiability, [10] obtain PCPs with linear proof length but sublinear (and super-constant) query complexity. As in [10], we rely on algebraic-geometry codes to obtain our first result; but, unlike that work, our use of such codes is much “lighter” because we do not rely on any automorphisms of the code.
    [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]