PAC Model-Free Reinforcement Learning

Total Page:16

File Type:pdf, Size:1020Kb

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. Beyond its smaller storage and ex- be bounded by a polynomial in the environment size perience requirements, Delayed Q-learning’s and approximation parameters, with high probabil- per-experience computation cost is much less ity, PAC-MDP (Probably Approximately Correct in than that of previous PAC algorithms. Markov Decision Processes). All algorithms known to be PAC-MDP to date involve the maintenance and solution (often by value iteration or mathemat- 1. Introduction ical programming) of an internal MDP model. Such In the reinforcement-learning (RL) problem (Sutton algorithms, including Rmax (Brafman & Tennenholtz, 3 & Barto, 1998), an agent acts in an unknown or in- 2002), E (Kearns & Singh, 2002), and MBIE (Strehl completely known environment with the goal of max- & Littman, 2005), are called model-based algorithms imizing an external reward signal. One of the funda- and have relatively high space and computational com- mental obstacles in RL is the exploration-exploitation plexities. Another class of algorithms, including most dilemma: whether to act to gain new information (ex- forms of Q-learning (Watkins & Dayan, 1992), make plore) or to act consistently with past experience to no effort to learn a model and can be called model free. maximize reward (exploit). This paper models the RL It is difficult to articulate a hard and fast rule di- problem as a Markov Decision Process (MDP) envi- viding model-free and model-based algorithms, but ronment with finite state and action spaces. model-based algorithms generally retain some transi- Appearing in Proceedings of the 23 rd International Con- tion information during learning whereas model-free ference on Machine Learning, Pittsburgh, PA, 2006. Copy- algorithms only keep value-function information. In- right 2006 by the author(s)/owner(s). stead of formalizing this intuition, we have decided to PAC Model-Free Reinforcement Learning adopt a crisp, if somewhat unintuitive, definition. For current state. We assume that rewards all lie between π π our purposes, a model-free RL algorithm is one whose 0 and 1. For any policy π, let VM (s)(QM (s, a)) denote space complexity is asymptotically less than the space the discounted, infinite-horizon value (action-value or required to store an MDP. Q-value) function for π in M (which may be omitted from the notation) from state s. If T is a positive in- π Definition 1 A learning algorithm is said to be teger, let VM (s, T ) denote the T -step value function of 2 π P∞ j−1 model free if its space complexity is always o(S A), policy π. Specifically, VM (s) = E[ j=1 γ rj] and where S is the number of states and A is the number π PT j−1 VM (s, T ) = E[ j=1 γ rj] where [r1, r2,...] is the of actions of the MDP used for learning. reward sequence generated by following policy π from state s. These expectations are taken over all possi- Although they tend to have low space and computa- ble infinite paths the agent might follow. The optimal tional complexity, no model-free algorithm has been ∗ ∗ policy is denoted π and has value functions VM (s) proven to be PAC-MDP. In this paper, we present a ∗ and QM (s, a). Note that a policy cannot have a value new model-free algorithm, Delayed Q-learning, and greater than 1/(1 − γ) in any state. prove it is the first such algorithm. The hardness of learning an arbitrary MDP as mea- 3. Learning Efficiently sured by sample complexity is still relatively unex- plored. For simplicity, we let O˜(·)(Ω(˜ ·)) represent O(·) In our discussion, we assume that the learner receives (Ω(·)) where logarithmic factors are ignored. When we S, A, , δ, and γ as input. The learning problem is consider only the dependence on S and A, the lower defined as follows. The agent always occupies a sin- bound of Kakade (2003) says that with probability gle state s of the MDP M. The learning algorithm greater than 1 − δ, the sample complexity of any algo- is told this state and must select an action a. The rithm will be Ω(˜ SA). However, the best upper bound agent receives a reward r and is then transported to known provides an algorithm whose sample complex- another state s0 according to the rules from Section 2. ity is O˜(S2A) with probability at least 1 − δ. In other This procedure then repeats forever. The first state words, there are algorithms whose sample complex- occupied by the agent may be chosen arbitrarily. ity is known to be no greater than approximately the There has been much discussion in the RL community number of bits required to specify an MDP to fixed over what defines efficient learning or how to define precision. However, there has been no argument prov- sample complexity. For any fixed , Kakade (2003) de- ing that learning to act near-optimally takes as long fines the sample complexity of exploration (sam- as approximating the dynamics of an MDP. We solve ple complexity, for short) of an algorithm A to be the this open problem, first posed by Kakade (2003), by number of timesteps t such that the non-stationary showing that Delayed Q-learning has sample complex- ˜ policy at time t, At, is not -optimal from the current ity O(SA), with high probability. Our result therefore 1 At ∗ state , st at time t (formally V (st) < V (st) − ). proves that efficient RL is possible without learning a We believe this definition captures the essence of mea- model of the environment from experience. suring learning. An algorithm A is then said to be PAC-MDP (Probably Approximately Correct in 2. Definitions and Notation Markov Decision Processes) if, for any and δ, the sample complexity of A is less than some polynomial in This section introduces the Markov Decision Process the relevant quantities (S, A, 1/, 1/δ, 1/(1 − γ)), with notation used throughout the paper; see Sutton and probability at least 1 − δ. Barto (1998) for an introduction. An MDP M is a five tuple hS, A, T, R, γi, where S is the state space, A The above definition penalizes the learner for exe- is the action space, T : S × A × S → R is a transi- cuting a non--optimal policy rather than for a non- tion function, R : S ×A → R is a reward function, and optimal policy. Keep in mind that, with only a finite 0 ≤ γ < 1 is a discount factor on the summed sequence amount of experience, no algorithm can identify the of rewards. We also let S and A denote the number of optimal policy with complete confidence. In addition, states and the number of actions, respectively. From due to noise, any algorithm may be misled about the state s under action a, the agent receives a random underlying dynamics of the system. Thus, a failure reward r, which has expectation R(s, a), and is trans- probability of at most δ is allowed. See Kakade (2003) ported to state s0 with probability T (s0|s, a). A policy for a full motivation of this performance measure. is a strategy for choosing actions. Only deterministic 1 Note that At is completely defined by A and the policies are dealt with in this paper. A stationary pol- agent’s history up to time t. icy is one that produces an action based on only the PAC Model-Free Reinforcement Learning 4. Delayed Q-learning as long as performing the update would result in a new Q-value estimate that is at least 1 smaller than In this section we describe a new reinforcement- the previous estimate. In other words, the following learning algorithm, Delayed Q-learning. equation must be satisfied for an update to occur: Delayed Q-learning maintains Q-value estimates, m ! 1 X Q(s, a) for each state-action pair (s, a). At time Q (s, a) − (r + γV (s )) ≥ 2 . (2) t m ki ki ki 1 t(= 1, 2,...), let Qt(s, a) denote the algorithm’s cur- i=1 rent Q-value estimate for (s, a) and let Vt(s) denote maxa∈A Qt(s, a).
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]
  • 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]
  • 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]