DOCSLIB.ORG

Space Complexity Space Is a Computation Resource

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Space Complexity Space Is a Computation Resource Space Complexity Space is a computation resource. Unlike time it can be reused. Computational Complexity, by Fu Yuxi Space Complexity 1 / 43 Synopsis 1. Space Bounded Computation 2. Logspace Reduction 3. PSPACE Completeness 4. Savitch Theorem 5. NL Completeness 6. Immerman-Szelepcs´enyiTheorem Computational Complexity, by Fu Yuxi Space Complexity 2 / 43 Space Bounded Computation Computational Complexity, by Fu Yuxi Space Complexity 3 / 43 Space Bounded Computation Let S : N ! N and L ⊆ f0; 1g∗. We say that L 2 SPACE(S(n)) if there is some c and some TM deciding L that never uses more than cS(n) nonblank worktape locations on inputs of length n. Computational Complexity, by Fu Yuxi Space Complexity 4 / 43 Space Constructible Function Suppose S : N ! N and S(n) ≥ log(n). 1. S is space constructible if there is a Turing Machine that computes the function n 1 7! xS(n)y in O(S(n)) space. 2. S is space constructible if there is a Turing Machine that upon receiving 1n uses exactly S(n)-space. The second definition is slightly less general than the first. Computational Complexity, by Fu Yuxi Space Complexity 5 / 43 Space Bounded Computation, the Nondeterministic Case L 2 NSPACE(S(n)) if there is some c and some NDTM deciding L that never uses more than cS(n) nonblank worktape locations on inputs of length n, regardless of its nondeterministic choices. For space constructible function S(n) we could allow a machine in NSPACE(S(n)) to diverge and to use more than cS(n) space in unsuccessful computation paths. Computational Complexity, by Fu Yuxi Space Complexity 6 / 43 Configuration A configuration of a running TM M with input x consists of the following: I the state; I the content of the work tape; [In the study of space complexity one may always assume that there is one work tape.] I the head positions. We write Cstart for the unique initial configuration. We assume that there is a single accepting configuration Caccept. Computational Complexity, by Fu Yuxi Space Complexity 7 / 43 Configuration Graph A configuration graph GM;x of M with input x is a directed graph: I the nodes are configurations; I the arrows are one-step computations. \M accepts x" iff \there is a path in GM;x from Cstart to Caccept". Computational Complexity, by Fu Yuxi Space Complexity 8 / 43 Reachability Predicate for Configuration Graph Suppose M is an S(n)-space TM. I A vertex of GM;x is described using O(S(jxj)) bits. O(S(jxj)) I Therefore GM;x has at most 2 nodes. 0 There is an O(S(n))-size CNF 'M;x such that for every two configurations C and C , 0 0 'M;x (C; C ) = 1 iff C ! C is an edge in GM;x . 0 0 I 'M;x (C; C ) can be checked by essentially comparing C and C bit by bit. It can be accomplished in both I O(S(n)) time, and I O(log S(n)) space. Computational Complexity, by Fu Yuxi Space Complexity 9 / 43 Space vs. Time Theorem. Suppose S(n): N ! N is space constructible. Then TIME(S(n)) ⊆ SPACE(S(n)) ⊆ NSPACE(S(n)) ⊆ TIME(2O(S(n))): An algorithm proving that NSPACE(S(n)) ⊆ TIME(2O(S(n))) starts by constructing O(S(n)) GM;x in 2 time, and then applies the breadth first search algorithm to GM;x . Computational Complexity, by Fu Yuxi Space Complexity 10 / 43 Space vs. Time Theorem. For all space constructible S(n), TIME(S(n)) ⊆ SPACE(S(n)= log S(n)). 1. Hopcroft, Paul and Valiant. On Time versus Space and Related Problems. FOCS, 1975. Computational Complexity, by Fu Yuxi Space Complexity 11 / 43 Space Complexity Class def [ PSPACE = SPACE(nc ); c>0 def [ NPSPACE = NSPACE(nc ); c>0 L def= SPACE(log(n)); NL def= NSPACE(log(n)): Computational Complexity, by Fu Yuxi Space Complexity 12 / 43 Games are Harder than Puzzles NP ⊆ PSPACE: Computational Complexity, by Fu Yuxi Space Complexity 13 / 43 Example The following problems are in L: def EVEN = fx j x has an even number of 10sg; def PLUS = f(xmy; xny; xm + ny) j m; n 2 Ng; def MULP = f(xmy; xny; xm × ny) j m; n 2 Ng: Computational Complexity, by Fu Yuxi Space Complexity 14 / 43 PATH is in NL PATH = fhG; s; ti j there is a path from s to t in the digraph Gg. Theorem. PATH 2 NL. Proof. Both a node and a counter can be stored in logspace. Computational Complexity, by Fu Yuxi Space Complexity 15 / 43 Universal Turing Machine without Space Overhead Theorem. There is a universal TM that operates without space overhead for input TM's with space complexity ≥ log(n). A universal TM can simulate Mα by recording all the non-blank tape content of Mα in its single work tape. A counter is used to store the location of the reader at x. Some additional space, whose size depends only on Mα, is needed for bookkeeping. Computational Complexity, by Fu Yuxi Space Complexity 16 / 43 Space Hierarchy Theorem Theorem. If f ; g are space constructible such that f (n) = o(g(n)), then SPACE(f (n)) ( SPACE(g(n)): We design V by modifying the universal machine so that I V(x) simulates Mx (x), and I it stops when it is required to use more than g(n) space, and I it negates the result after it completes simulation. If V was executed in f (n) space, then V = Mα for some large enough α so that V can complete the simulation of Mα on α. But then Mα(α) = V(α) = Mα(α). 1. J. Hartmanis and R. Stearns. On the Computational Complexity of Algorithms. Transactions of AMS, 117:285-306, 1965. Computational Complexity, by Fu Yuxi Space Complexity 17 / 43 Logspace Reduction Computational Complexity, by Fu Yuxi Space Complexity 18 / 43 Logspace Reduction A function f : f0; 1g∗ ! f0; 1g∗ is implicitly logspace computable if the following hold: 1. 9c:8x:jf (x)j ≤ cjxjc , 2. fhx; ii j i ≤ jf (x)jg 2 L and 3. fhx; ii j f (x)i = 1g 2 L. Problem B is logspace reducible to problem C, written B ≤L C, if there is an implicitly logspace computable f such that x 2 B iff f (x) 2 C. I Logspace reductions are Karp reductions. [The converse implication is unknown.] I All known NP-completeness results can be established using logspace reduction. Computational Complexity, by Fu Yuxi Space Complexity 19 / 43 Transitivity of Logspace Reduction Lemma. If B ≤L C and C ≤L D then B ≤L D. Let Mf ; Mg be logspace machines that compute x; i 7! f (x)i respectively y; j 7! g(y)j . We construct a machine that, given input x; j with j ≤ jg(f (x))j, outputs g(f (x))j . I The machine operates as if f (x) were stored on a virtual tape. I It stores the address i of the current cell of the virtual tape. I It uses O(log jf (x)j) = O(log jxj) space to calculate g(f (x))j . Computational Complexity, by Fu Yuxi Space Complexity 20 / 43 Logspace Computability A function f : f0; 1g∗ ! f0; 1g∗ is logspace computable if it can be computed by a TM that has a write-once output tape using O(log n) work tape space. Lemma. Implicitly logspace computability = logspace computability. Computational Complexity, by Fu Yuxi Space Complexity 21 / 43 PSPACE Completeness Computational Complexity, by Fu Yuxi Space Complexity 22 / 43 Space Completeness 0 0 A language L is PSPACE-hard if L ≤L L for every L 2 PSPACE. If in addition L0 2 PSPACE then L0 is PSPACE-complete. Computational Complexity, by Fu Yuxi Space Complexity 23 / 43 Quantified Boolean Formula A quantified Boolean formula (QBF) is a formula of the form Q1x1Q2x2 ::: Qnxx :'(x1;:::; xn) where each Qi is one of the two quantifiers 8; 9, x1;:::; xn range over f0; 1g, and ' is a quantifier free Boolean formula containing no free variables other than x1;:::; xn. Let TQBF be the set of true QBFs. Computational Complexity, by Fu Yuxi Space Complexity 24 / 43 Quantified Boolean Formula Suppose ' is a CNF. I ' 2 SAT if and only if 9ex:' 2 TQBF. I ' 2 TAUTOLOGY if and only if 8ex:' 2 TQBF. Computational Complexity, by Fu Yuxi Space Complexity 25 / 43 Stockmeyer-Meyer Theorem. TQBF is PSPACE-complete. 1. Larry Stockmeyer, Albert Meyer. Word Problems Requiring Exponential Time. STOC, 1973. Computational Complexity, by Fu Yuxi Space Complexity 26 / 43 Proof of Stockmeyer-Meyer Theorem TQBF 2 PSPACE. Suppose = Q1x1Q2x2 ::: Qnxx :'(x1;:::; xn). I A counter of length n can be identified to an assignment. I Apply the depth first tree traversal. We actually have a linear space algorithm. Computational Complexity, by Fu Yuxi Space Complexity 27 / 43 Proof of Stockmeyer-Meyer Theorem Let M be a TM that decides L in polynomial space, say S(n) space. ∗ 2 We reduce x 2 f0; 1g to a QBF 'x of size O(S(jxj) ) in logspace such that M(x) = 1 iff 'x is true. 0 0 1. Construct in logspace 0 such that 0(C; C ) is true if and only if C ! C . 0 i 0 2. Let i (C; C ) be true if and only if there exists a path of length ≤ 2 from C to C . It can be defined by the following formula, which is computable in logspace. 00 1 2 1 2 00 1 00 2 0 1 2 9C 8D 8D :((D =C ^ D =C ) _ (D =C ^ D =C )) ) i−1(D ; D ): 2 3.
Load more

Recommended publications
  • Sustained Space Complexity
    Sustained Space Complexity Jo¨elAlwen1;3, Jeremiah Blocki2, and Krzysztof Pietrzak1 1 IST Austria 2 Purdue University 3 Wickr Inc. Abstract. Memory-hard functions (MHF) are functions whose eval- uation cost is dominated by memory cost. MHFs are egalitarian, in the sense that evaluating them on dedicated hardware (like FPGAs or ASICs) is not much cheaper than on off-the-shelf hardware (like x86 CPUs). MHFs have interesting cryptographic applications, most notably to password hashing and securing blockchains. Alwen and Serbinenko [STOC'15] define the cumulative memory com- plexity (cmc) of a function as the sum (over all time-steps) of the amount of memory required to compute the function. They advocate that a good MHF must have high cmc. Unlike previous notions, cmc takes into ac- count that dedicated hardware might exploit amortization and paral- lelism. Still, cmc has been critizised as insufficient, as it fails to capture possible time-memory trade-offs; as memory cost doesn't scale linearly, functions with the same cmc could still have very different actual hard- ware cost. In this work we address this problem, and introduce the notion of sustained- memory complexity, which requires that any algorithm evaluating the function must use a large amount of memory for many steps. We con- struct functions (in the parallel random oracle model) whose sustained- memory complexity is almost optimal: our function can be evaluated using n steps and O(n= log(n)) memory, in each step making one query to the (fixed-input length) random oracle, while any algorithm that can make arbitrary many parallel queries to the random oracle, still needs Ω(n= log(n)) memory for Ω(n) steps.
    [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]
  • A Short History of Computational Complexity
    The Computational Complexity Column by Lance FORTNOW NEC Laboratories America 4 Independence Way, Princeton, NJ 08540, USA [email protected] http://www.neci.nj.nec.com/homepages/fortnow/beatcs Every third year the Conference on Computational Complexity is held in Europe and this summer the University of Aarhus (Denmark) will host the meeting July 7-10. More details at the conference web page http://www.computationalcomplexity.org This month we present a historical view of computational complexity written by Steve Homer and myself. This is a preliminary version of a chapter to be included in an upcoming North-Holland Handbook of the History of Mathematical Logic edited by Dirk van Dalen, John Dawson and Aki Kanamori. A Short History of Computational Complexity Lance Fortnow1 Steve Homer2 NEC Research Institute Computer Science Department 4 Independence Way Boston University Princeton, NJ 08540 111 Cummington Street Boston, MA 02215 1 Introduction It all started with a machine. In 1936, Turing developed his theoretical com- putational model. He based his model on how he perceived mathematicians think. As digital computers were developed in the 40's and 50's, the Turing machine proved itself as the right theoretical model for computation. Quickly though we discovered that the basic Turing machine model fails to account for the amount of time or memory needed by a computer, a critical issue today but even more so in those early days of computing. The key idea to measure time and space as a function of the length of the input came in the early 1960's by Hartmanis and Stearns.
    [Show full text]
  • Lecture 4: Space Complexity II: NL=Conl, Savitch's Theorem
    COM S 6810 Theory of Computing January 29, 2009 Lecture 4: Space Complexity II Instructor: Rafael Pass Scribe: Shuang Zhao 1 Recall from last lecture Definition 1 (SPACE, NSPACE) SPACE(S(n)) := Languages decidable by some TM using S(n) space; NSPACE(S(n)) := Languages decidable by some NTM using S(n) space. Definition 2 (PSPACE, NPSPACE) [ [ PSPACE := SPACE(nc), NPSPACE := NSPACE(nc). c>1 c>1 Definition 3 (L, NL) L := SPACE(log n), NL := NSPACE(log n). Theorem 1 SPACE(S(n)) ⊆ NSPACE(S(n)) ⊆ DTIME 2 O(S(n)) . This immediately gives that N L ⊆ P. Theorem 2 STCONN is NL-complete. 2 Today’s lecture Theorem 3 N L ⊆ SPACE(log2 n), namely STCONN can be solved in O(log2 n) space. Proof. Recall the STCONN problem: given digraph (V, E) and s, t ∈ V , determine if there exists a path from s to t. 4-1 Define boolean function Reach(u, v, k) with u, v ∈ V and k ∈ Z+ as follows: if there exists a path from u to v with length smaller than or equal to k, then Reach(u, v, k) = 1; otherwise Reach(u, v, k) = 0. It is easy to verify that there exists a path from s to t iff Reach(s, t, |V |) = 1. Next we show that Reach(s, t, |V |) can be recursively computed in O(log2 n) space. For all u, v ∈ V and k ∈ Z+: • k = 1: Reach(u, v, k) = 1 iff (u, v) ∈ E; • k > 1: Reach(u, v, k) = 1 iff there exists w ∈ V such that Reach(u, w, dk/2e) = 1 and Reach(w, v, bk/2c) = 1.
    [Show full text]
  • 26 Space Complexity
    CS:4330 Theory of Computation Spring 2018 Computability Theory Space Complexity Haniel Barbosa Readings for this lecture Chapter 8 of [Sipser 1996], 3rd edition. Sections 8.1, 8.2, and 8.3. Space Complexity B We now consider the complexity of computational problems in terms of the amount of space, or memory, they require B Time and space are two of the most important considerations when we seek practical solutions to most problems B Space complexity shares many of the features of time complexity B It serves a further way of classifying problems according to their computational difficulty 1 / 22 Space Complexity Definition Let M be a deterministic Turing machine, DTM, that halts on all inputs. The space complexity of M is the function f : N ! N, where f (n) is the maximum number of tape cells that M scans on any input of length n. Definition If M is a nondeterministic Turing machine, NTM, wherein all branches of its computation halt on all inputs, we define the space complexity of M, f (n), to be the maximum number of tape cells that M scans on any branch of its computation for any input of length n. 2 / 22 Estimation of space complexity Let f : N ! N be a function. The space complexity classes, SPACE(f (n)) and NSPACE(f (n)), are defined by: B SPACE(f (n)) = fL j L is a language decided by an O(f (n)) space DTMg B NSPACE(f (n)) = fL j L is a language decided by an O(f (n)) space NTMg 3 / 22 Example SAT can be solved with the linear space algorithm M1: M1 =“On input h'i, where ' is a Boolean formula: 1.
    [Show full text]
  • Complexity Slides
    Basics of Complexity “Complexity” = resources • time • space • ink • gates • energy Complexity is a function • Complexity = f (input size) • Value depends on: – problem encoding • adj. list vs. adj matrix – model of computation • Cray vs TM ~O(n3) difference TM time complexity Model: k-tape deterministic TM (for any k) DEF: M is T(n) time bounded iff for every n, for every input w of size n, M(w) halts within T(n) transitions. – T(n) means max {n+1, T(n)} (so every TM spends at least linear time). – worst case time measure – L recursive à for some function T, L is accepted by a T(n) time bounded TM. TM space complexity Model: “Offline” k-tape TM. read-only input tape k read/write work tapes initially blank DEF: M is S(n) space bounded iff for every n, for every input w of size n, M(w) halts having scanned at most S(n) work tape cells. – Can use less tHan linear space – If S(n) ≥ log n then wlog M halts – worst case measure Complexity Classes Dtime(T(n)) = {L | exists a deterministic T(n) time-bounded TM accepting L} Dspace(S(n)) = {L | exists a deterministic S(n) space-bounded TM accepting L} E.g., Dtime(n), Dtime(n2), Dtime(n3.7), Dtime(2n), Dspace(log n), Dspace(n), ... Linear Speedup THeorems “WHy constants don’t matter”: justifies O( ) If T(n) > linear*, tHen for every constant c > 0, Dtime(T(n)) = Dtime(cT(n)) For every constant c > 0, Dspace(S(n)) = Dspace(cS(n)) (Proof idea: to compress by factor of 100, use symbols tHat jam 100 symbols into 1.
    [Show full text]
  • Space Complexity
    ComputabilityandComplexity 18-1 ComputabilityandComplexity 18-2 MeasuringSpace Sofarwehavedefinedcomplexitymeasuresbasedonthetimeused bythealgorithm SpaceComplexity Nowweshalldoasimilaranalysisbasedonthespaceused IntheTuringMachinemodelofcomputationthisiseasytomeasure —justcountthenumberoftapecellsreadduringthecomputation Definition1 ThespacecomplexityofaTuringMachine Tisthe functionsuchthatSpaceT SpaceisthenumberofT (x ) distincttapecellsvisitedduringthecomputation T(x) ComputabilityandComplexity (Notethatif T(x)doesnothalt,thenisundefSpace T (x) ined.) AndreiBulatov ComputabilityandComplexity 18-3 ComputabilityandComplexity 18-4 Palindromes AnotherDefinition Considerthefollowing3-tapemachinedecidingifaninputstringisapalindrome •Thefirsttapecontainstheinputstringandisneveroverwritten ByDef.1,thespacecomplexityofthismachineisn •Themachineworksinstages.Onstage iitdoesthefollowing However,itseemstobefairtodefineitsspacecomplexityas log n -thesecondtapecontainsthebinaryrepresentationof i -themachinefindsandremembersthe i-thsymbolofthestringby (1)initializingthe3 rd string j =1 ;(2)if j< ithenincrement j; Definition2 Let TbeaTuringMachinewith2tapessuchthat (3)if j= ithenrememberthecurrentsymbolbyswitchingto thefirsttapecontainstheinputandneveroverwritten.The correspondentstate spacecomplexityof TisthefunctionsuchthatSpace T -inasimilarwaythemachinefindsthe i-thsymbolfromtheend isthenumberofSpace T (x) distinctcellsonthesecondtape ofthestring visitedduringthecomputation T(x) -ifthesymbolsareunequal,haltwith“no” •Ifthe i-thsymbolistheblanksymbol,haltwith“yes”
    [Show full text]
  • Complexity Theory Lectures 1–6
    Complexity Theory 1 Complexity Theory Lectures 1–6 Lecturer: Dr. Timothy G. Griffin Slides by Anuj Dawar Computer Laboratory University of Cambridge Easter Term 2009 http://www.cl.cam.ac.uk/teaching/0809/Complexity/ Cambridge Easter 2009 Complexity Theory 2 Texts The main texts for the course are: Computational Complexity. Christos H. Papadimitriou. Introduction to the Theory of Computation. Michael Sipser. Other useful references include: Computers and Intractability: A guide to the theory of NP-completeness. Michael R. Garey and David S. Johnson. Structural Complexity. Vols I and II. J.L. Balc´azar, J. D´ıaz and J. Gabarr´o. Computability and Complexity from a Programming Perspective. Neil Jones. Cambridge Easter 2009 Complexity Theory 3 Outline A rough lecture-by-lecture guide, with relevant sections from the text by Papadimitriou (or Sipser, where marked with an S). Algorithms and problems. 1.1–1.3. • Time and space. 2.1–2.5, 2.7. • Time Complexity classes. 7.1, S7.2. • Nondeterminism. 2.7, 9.1, S7.3. • NP-completeness. 8.1–8.2, 9.2. • Graph-theoretic problems. 9.3 • Cambridge Easter 2009 Complexity Theory 4 Outline - contd. Sets, numbers and scheduling. 9.4 • coNP. 10.1–10.2. • Cryptographic complexity. 12.1–12.2. • Space Complexity 7.1, 7.3, S8.1. • Hierarchy 7.2, S9.1. • Descriptive Complexity 5.6, 5.7. • Cambridge Easter 2009 Complexity Theory 5 Complexity Theory Complexity Theory seeks to understand what makes certain problems algorithmically difficult to solve. In Data Structures and Algorithms, we saw how to measure the complexity of specific algorithms, by asymptotic measures of number of steps.
    [Show full text]
  • PAC Model-Free Reinforcement Learning
    PAC Model-Free Reinforcement Learning Alexander L. Strehl [email protected] Lihong Li [email protected] Department of Computer Science, Rutgers University, Piscataway, NJ 08854 USA Eric Wiewiora [email protected] Computer Science and Engineering Department University of California, San Diego John Langford [email protected] TTI-Chicago, 1427 E 60th Street, Chicago, IL 60637 USA Michael L. Littman [email protected] Department of Computer Science, Rutgers University, Piscataway, NJ 08854 USA Abstract When evaluating RL algorithms, there are three es- For a Markov Decision Process with finite sential traits to consider: space complexity, computa- state (size S) and action spaces (size A per tional complexity, and sample complexity. We define state), we propose a new algorithm—Delayed a timestep to be a single interaction with the environ- Q-Learning. We prove it is PAC, achieving ment. Space complexity measures the amount of mem- near optimal performance except for O˜(SA) ory required to implement the algorithm while compu- timesteps using O(SA) space, improving on tational complexity measures the amount of operations the O˜(S2A) bounds of best previous algo- needed to execute the algorithm, per timestep. Sam- rithms. This result proves efficient reinforce- ple complexity measures the amount of timesteps for ment learning is possible without learning a which the algorithm does not behave near optimally model of the MDP from experience. Learning or, in other words, the amount of experience it takes takes place from a single continuous thread of to learn to behave well. experience—no resets nor parallel sampling We will call algorithms whose sample complexity can is used.
    [Show full text]
  • On the Space Complexity of Randomized Synchronization
    On the Space Complexity of Randomized Synchronization FAITH FICH University of Toronto, Toronto, Ont., Canada MAURICE HERLIHY Brown University, Providence, Rhode Island AND NIR SHAVIT Tel-Aviv University, Tel-Aviv, Israel Abstract. The “wait-free hierarchy” provides a classification of multiprocessor synchronization primitives based on the values of n for which there are deterministic wait-free implementations of n-process consensus using instances of these objects and read-write registers. In a randomized wait-free setting, this classification is degenerate, since n-process consensus can be solved using only O(n) read-write registers. In this paper, we propose a classification of synchronization primitives based on the space complexity of randomized solutions to n-process consensus. A historyless object, such as a read-write register, a swap register, or a test&set register, is an object whose state depends only on the last nontrivial operation that was applied to it. We show that, using historyless objects, V(=n) object instances are necessary to solve n-process consensus. This lower bound holds even if the objects have unbounded size and the termination requirement is nondeterministic solo termination, a property strictly weaker than randomized wait-freedom. This work was supported by the Natural Science and Engineering Research Council of Canada grant A1976 and the Information Technology Research Centre of Ontario, ONR grant N00014-91-J-1046, NSF grant 8915206-CCR and 9520298-CCR, and DARPA grants N00014-92-J-4033 and N00014-91- J-1698. A preliminary version of this paper appears in the Proceedings of 12th Annual ACM Symposium on Principles of Distributed Computing (Ithaca, N.Y., Aug.
    [Show full text]
  • Space Complexity and LOGSPACE
    Space Complexity and LOGSPACE Michal Hanzlík∗ Abstract This paper deal with the computational complexity theory, with emphasis on classes of the space complexity. One of the most impor- tant class in this field is LOGSPACE. There are several interesting results associated with this class, namely theorems of Savitch and Im- merman – Szelepcsényi. Techniques that are used when working with LOGSPACE are different from those known from the time complexity because space, compared to time, may be reused. There are many open problems in this area, and one will be mentioned at the end of the paper. 1 Introduction Computational complexity focuses mainly on two closely related topics. The first of them is the notion of complexity of a “well defined” problem and the second is the ensuing hierarchy of such problems. By “well defined” problem we mean that all the data required for the computation are part of the input. If the input is of such a form we can talk about the complexity of a problem which is a measure of how much resources we need to do the computation. What do we mean by relationship between problems? An important tech- nique in the computational complexity is a reduction of one problem to an- other. Such a reduction establish that the first problem is at least as difficult to solve as the second one. Thus, these reductions form a hierarchy of prob- lems. ∗Department of Mathematics, Faculty of Applied Sciences, University of West Bohemia in Pilsen, Univerzitní 22, Plzeň, [email protected] 1.1 Representation In mathematics one usually works with mathematical objects as with abstract entities.
    [Show full text]
  • Complexity Classes
    CHAPTER Complexity Classes In an ideal world, each computational problem would be classified at least approximately by its use of computational resources. Unfortunately, our ability to so classify some important prob- lems is limited. We must be content to show that such problems fall into general complexity classes, such as the polynomial-time problems P, problems whose running time on a determin- istic Turing machine is a polynomial in the length of its input, or NP, the polynomial-time problems on nondeterministic Turing machines. Many complexity classes contain “complete problems,” problems that are hardest in the class. If the complexity of one complete problem is known, that of all complete problems is known. Thus, it is very useful to know that a problem is complete for a particular complexity class. For example, the class of NP-complete problems, the hardest problems in NP, contains many hundreds of important combinatorial problems such as the Traveling Salesperson Prob- lem. It is known that each NP-complete problem can be solved in time exponential in the size of the problem, but it is not known whether they can be solved in polynomial time. Whether ? P and NP are equal or not is known as the P = NP question. Decades of research have been devoted to this question without success. As a consequence, knowing that a problem is NP- complete is good evidence that it is an exponential-time problem. On the other hand, if one such problem were shown to be in P, all such problems would be been shown to be in P,a result that would be most important.
    [Show full text]