DOCSLIB.ORG

Space Complexity

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read 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” ComputabilityandComplexity 18-5 ComputabilityandComplexity 18-6 Proof Blum’sAxioms 1.isobvious. Blumproposedthatanyusefuldynamiccomplexitymeasureshould 2. satisfythefollowingproperties: Notethatifthemachinehas kstatesand lsymbolsinthealphabet, ⋅ ⋅ r •isdefinedexactlywhenϕ (x) M(x)isdefined thentherearepossibleconfiguratk r l ioninvolvingatmost r M visitedcellsonthesecondtape ϕ = •Theproblem:forgiven M,x,r ,doesisdecidableM (x) r Ifthesameconfigurationoccurstwiceduringthecomputation M(x), thenthemachinegoesintoaninfiniteloopand M(x)(aswellas TheoremSpace T isapropercomplexitymeasure )isnotdefinedSpace M (x) Thereforeafterperformingstepsk ⋅ r ⋅l r M(x)either halts,or visitsmorethan rcells,or goesintoaninfiniteloop 1 ComputabilityandComplexity 18-7 ComputabilityandComplexity 18-8 SpaceComplexityofProblems SpaceComplexityClasses Aswithtimecomplexity,wecannotdefineanexactspacecomplexity foralanguage,butwecangiveanasymptoticform… Nowweareinapositiontodivideupthedecidablelanguagesinto classes,accordingtotheirspacecomplexity Definition Foranyfunction f,wesaythatthespacecomplexityofa Definition decidablelanguage Lisin O(f)ifthereexistsaTuring Thespacecomplexityclass SPACE[ f]isdefinedtobetheclass Machine Twhichdecides L,andconstantsandn0 c ofalllanguageswithtimecomplexityin O(f) > suchthatforallinputs xwith | x | n0 ≤ Space T (x) cf (| x |) (Note,itissometimescalled DSPACE[ f]—forDeterministicSpace) ComputabilityandComplexity 18-9 ComputabilityandComplexity 18-10 PolynomialSpace Timevs.Space Aswithtime,wecanobtainarobustspacecomplexityclassby •Visitingacelltakesatleastonetimestep,sowehave consideringallpolynomialspacecomplexityclasses Theorem TIME[ f ] ⊆ SPACE[ f ] Definition PSPACE = SPACE[ nk ] •Amoresubtleanalysis,basedonthefactthatthereareonly U f (n) k≥0 differentp|Q |⋅ f (n ⋅ |) Σ | ossibleconfigurationswith f(n)non- blanktapecells,gives Theorem SPACE[ f ] ⊆ TIME[ f ⋅k f ] ComputabilityandComplexity 18-11 ComputabilityandComplexity 18-12 ReusingSpace All Thepreviousresultsuggeststhatagivenamountofspaceismore Languages usefulthanagivenamountoftime DecidableLanguages Thisisbecausespacecanbereused Forexample, Satisfiability canbesolvedinlinearspace,bytrying P NP PSPACE eachpossibleassignment,oneatatime,reusingthesamespace Theorem NP ⊆ PSPACE 2 ComputabilityandComplexity 18-13 ComputabilityandComplexity 18-14 ProblemsinPSPACE Quantified Boolean Formula Generalized Geography Instance:AquantifiedBooleanformula Instance:Agamefor2playersconsistingofadirectedgraphG, Φ = andastartvertexs.Playerstaketurnstomovealong (Q1 X1 )( Q2 X 2 )K(Qn X n ) B(X 1, X 2 ,K, X n ) theedgesfromthecurrentvertex.Aplayerwhocannot whereeachisaBooleanvarX iable,B(X , X ,K, X ) l 1 2 n movewithoutreturningtoavertexalreadyvisitedloses isaBooleanexpressioninvolvingandX1, X 2 ,K, X n ∃ ∀ Question:Isthereawinningstrategyforthefirstplayer? eachisaquantifier(Ql or ). Question:Is Φlogicallyvalid? Complexity 13-15 Complexity 13-16 PSPACE-CompleteProblem QuantifiedBooleanFormula PSPACE-Completeness Instance:AquantifiedBooleanformula Φ = (Q1 X1 )( Q2 X 2 )K(Qn X n ) B(X 1, X 2 ,K, X n ) whereeachisaBooleanvarX l iable,B(X 1, X 2 ,K, X n ) Definition isaBooleanexpressioninvolvingandX1, X 2 ,K, X n Alanguage Lissaidtobe PSPACE -completeif,forany ∃ ∀ eachisaquantifier(Ql or ). ∈ ≤ A PSPACE , A L Question:Is Φlogicallyvalid? Theorem QBF isPSPACE-complete Complexity 13-17 Complexity 13-18 Proof Firstweshowthat QBF isin PSPACE, usingthefollowingrecursive Thisalgorithmispolynomialspace,because algorithm •oneveryroundofrecursionitneedstostoreonlyatransformed FortheinputBooleansentence Φ copyoftheinputformula •If Φcontainsnoquantifiers,thenitcontainsnovariables,only •thedepthofrecursionisthenumberofvariables, m constants.Evaluatethisexpression;acceptifitis true ; otherwisereject •Therefore,ituses m⋅|Φ|space Φ = ∃ Ψ Φ Φ ∨Φ •If X then is true ifandonlyifis|X =0 |X =1 true . Φ Φ Recursivelycallthealgorithmon|X =0 and,andaccept|X =1 ifoneofthemisaccepted;otherwisereject Φ = ∀ Ψ Φ Φ ∧Φ •If X then is true ifandonlyifis|X =0 |X =1 true . Φ Φ Recursivelycallthealgorithmon|X =0 and,andaccept|X =1 ifbothofthemisaccepted;otherwisereject 3 Complexity 13-19 Complexity 13-20 WhenprovingCook’stheoremwemanagedtodefineaBooleanCNF Φ Φ formulasuchthatT (X ) T (X ) istrueifandonlyifthevalues ofvariablesdescribeinacertainwayaleX galconfigurationofthe •Let Abealanguagein PSPACE Turingmachine T •Let TbeadeterministicTuringMachinethatdecides A ThenweconstructedaformulawΨ (X ,Y ) hichistrueifandonlyif withspacecomplexity f(n), where fisapolynomial T andrepresentlegalconfigurations,X Y sayand,andC1 C2 TcangofromtoinatmostonestC C ep •Chooseanencodingforthecomputation T(x)thatuses 1 2 k·f(| x|) symbolsforeachconfiguration Thelengthofbothformulasispolynomialintheamountoftapecells Ψ •Letbetheinitialconfiguration,andC0 betheacceptingCa involvedinthecomputation.DenotethelengthofbyT g(| x|) configuration WeconstructaformulawhiΩ( X ,Y ,t) chistrueifandonlyif andrepresentlegalconfigurations,X Y sayand,andC1 C2 t TcangofromtoinatmostC1 C2 2 steps Ω Finally, Taccepts xifandonlyif(C0 ,Ca , f (| x |)) istrue Complexity 13-21 Theformulaisbuiltrecursively Straightforwardapproach: Ω = Ψ (X ,Y )0, T (X ,Y ) Ω(X ,Y ,t) = ∃Z ( Ω(X ,Z ,t − )1 ∧ Ω(Z ,Y ,t − ))1 ItdoesnotworkbecauseΩ(X ,Y , f (| x isbuildof|)) 2 f (| x|) Ψ formulas T (X ,Y ) Thereareuniversalquantifierstodothejob! Ω(X ,Y ,t) = ∃Z ∀(U ,V ) (((( U ,V ) = ( X ,Z )) ∨ (( U ,V ) = (Z ,Y ))) ∧ Ω(U ,V ,t − ))1 ThelengthofthisformulaisO( f (| x |) g(| x |)) 4.
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 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.
    [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]