|
|
| Line 1: |
Line 1: |
| In [[computational complexity theory]], the '''space hierarchy theorems''' are separation results that show that both deterministic and nondeterministic machines can solve more problems in (asymptotically) more space, subject to certain conditions. For example, a [[deterministic Turing machine]] can solve more [[decision problem]]s in space ''n'' log ''n'' than in space ''n''. The somewhat weaker analogous theorems for time are the [[time hierarchy theorem]]s.
| | 51 yrs old Boat Designer and Repairer Rusty Hyslop from Milton, really likes guitar, property developers in singapore and church/church activities. Is encouraged how huge the world is after going to Maya Site of Copan.<br><br>Also visit my weblog - [http://drive.ilovetheory.com/content/singapore-property-itemizing-0 property developers in singapore list] |
| | |
| The foundation for the hierarchy theorems lies in the intuition that
| |
| with either more time or more space comes the ability to compute more
| |
| functions (or decide more languages). The hierarchy theorems are used
| |
| to demonstrate that the time and space complexity classes form a
| |
| hierarchy where classes with tighter bounds contain fewer languages
| |
| than those with more relaxed bounds. Here we define and prove the
| |
| space hierarchy theorem.
| |
| | |
| The space hierarchy theorems rely on the concept of [[space-constructible function]]s. The deterministic and nondeterministic space hierarchy theorems state that for all space-constructible functions ''f''(''n''),
| |
| | |
| :<math>\operatorname{SPACE}\left(o(f(n))\right) \subsetneq \operatorname{SPACE}(f(n))</math>,
| |
| where SPACE stands for either [[DSPACE]] or [[NSPACE]].
| |
| | |
| == Statement ==
| |
| | |
| Formally, a function <math>f:\mathbb{N} \longrightarrow \mathbb{N}</math> is space-constructible if <math>f(n) \ge \log~n</math> and there exists a Turing machine
| |
| which computes the function <math>f(n)</math> in space <math>O(f(n))</math> when starting
| |
| with an input <math>1^n</math>, where <math>1^n</math> represents a string of <math>n</math> <math>1</math>s. Most of the common functions that we work with are space-constructible, including polynomials, exponents, and logarithms.
| |
| | |
| For every space-constructible function <math>f:\mathbb{N} \longrightarrow
| |
| \mathbb{N}</math>, there exists a language <math>L</math> that is decidable in space
| |
| <math>O(f(n))</math> but not in space <math>o(f(n))</math>.
| |
| | |
| == Proof ==
| |
| | |
| The goal here is to define a language that can be decided in space
| |
| <math>O(f(n))</math> but not space <math>o(f(n))</math>. Here we define the language <math>L</math>:
| |
| <blockquote>
| |
| <math>L = \{~ (\langle M \rangle, 10^k): M \mbox{ does not accept } (\langle M \rangle,
| |
| 10^k) \mbox{ using space } \le f(|\langle M \rangle, 10^k|) ~ \}</math>
| |
| </blockquote>
| |
| | |
| Now, for any machine <math>M</math> that decides a language in space <math>o(f(n))</math>, <math>L</math> will differ in at least one spot from the language of <math>M</math>, namely at the value of <math> (\langle M \rangle, 10^k) </math>. The algorithm for deciding the language <math>L</math> is as follows:
| |
| | |
| # On an input <math>x</math>, compute <math>f(|x|)</math> using space-constructibility, and mark off <math>f(|x|)</math> cells of tape. Whenever an attempt is made to use more than <math>f(|x|)</math> cells, ''reject''.
| |
| # If <math>x</math> is not of the form <math>\langle M \rangle, 10^k</math> for some TM <math>M</math>, ''reject''.
| |
| # Simulate <math>M</math> on input <math>x</math> for at most <math>2^{f(|x|)}</math> steps (using <math>f(|x|)</math> space). If the simulation tries to use more than <math>f(|x|)</math> space or more than <math>2^{f(|x|)}</math> operations, then ''reject''.
| |
| # If <math>M</math> accepted <math>x</math> during this simulation, then ''reject''; otherwise, ''accept''.
| |
| | |
| Note on step 3: Execution is limited to <math>2^{f(|x|)}</math> steps in order to avoid the
| |
| case where <math>M</math> does not halt on the input <math>x</math>. That is, the case where
| |
| <math>M</math> consumes space of only <math>O(f(x))</math> as required, but runs for
| |
| infinite time.
| |
| | |
| The above proof holds for the case of PSPACE whereas we must make some change for the case of NPSPACE. The crucial point is that while on a deterministic TM we may easily invert acceptance and rejection (crucial for step 4), this is not possible on a non-deterministic machine.<br>
| |
| For the case of NPSPACE we will first modify step 4 to:
| |
| # If <math>M</math> accepted <math>x</math> during this simulation, then ''accept''; otherwise, ''reject''.
| |
| We will now prove by contradiction that <math>L</math> can not be decided by a TM using <math>o(f(n))</math> cells.<br>
| |
| Assuming <math>L</math> can be decided by a TM using <math>o(f(n))</math> cells, and following from the [[Immerman–Szelepcsényi theorem]] follows that <math>\overline L</math> can also be determined by a TM (which we will call <math>\overline M</math>) using <math>o(f(n))</math> cells.<br>
| |
| Here lies the contradiction, therefore our assumption must be false:
| |
| # If <math>w = (\langle \overline M \rangle, 10^k)</math> (for some large enough k) is in <math>L</math> then <math>M</math> will accept it, therefore <math>\overline M</math> rejects <math>w</math>, therefore <math>w</math> is not in <math>L</math> (contradiction).
| |
| # If <math>w = (\langle \overline M \rangle, 10^k)</math> (for some large enough k) is not in <math>L</math> then <math>M</math> will reject it, therefore <math>\overline M</math> accepts <math>w</math>, therefore <math>w</math> is in <math>L</math> (contradiction).
| |
| | |
| == Comparison and improvements ==
| |
| | |
| The space hierarchy theorem is stronger than the analogous [[time hierarchy theorem]]s in several ways:
| |
| * It only requires s(n) to be at least log ''n'' instead of at least ''n''.
| |
| * It can separate classes with any asymptotic difference, whereas the time hierarchy theorem requires them to be separated by a logarithmic factor.
| |
| * It only requires the function to be space-constructible, not time-constructible.
| |
| | |
| It seems to be easier to separate classes in space than in time. Indeed, whereas the time hierarchy theorem has seen little remarkable improvement since its inception, the nondeterministic space hierarchy theorem has seen at least one important improvement by Viliam Geffert in his 2003 paper "Space hierarchy theorem revised". This paper made several striking generalizations of the theorem:
| |
| | |
| * It relaxes the space-constructibility requirement. Instead of merely separating the union classes '''DSPACE'''(O(s(n)) and '''DSPACE'''(o(s(n)), it separates '''DSPACE'''(f(n)) from '''DSPACE'''(g(n)) where f(n) is an arbitrary O(s(n)) function and g(n) is a [[computable function|computable]] o(s(n)) function. These functions need not be space-constructible or even monotone increasing.
| |
| * It identifies a [[unary language]], or tally language, which is in one class but not the other. In the original theorem, the separating language was arbitrary.
| |
| * It does not require s(n) to be at least log ''n''; it can be any nondeterministically fully space-constructible function.
| |
| | |
| == Refinement of space hierarchy ==
| |
| | |
| If space is measured as the number of cells used regardless of alphabet size, then SPACE(f(n)) = SPACE(O(f(n))) because one can achieve any linear compression by switching to a larger alphabet. However, by measuring space in bits, a much sharper separation is achievable for deterministic space. Instead of being defined up to a multiplicative constant, space is now defined up to an additive constant. However, because any constant amount of external space can be saved by storing the contents into the internal state, we still have SPACE(f(n)) = SPACE(f(n)+O(1)).
| |
| | |
| Assume that f is space-constructible. SPACE is deterministic.
| |
| * For a wide variety of sequential computational models, including for Turing machines, SPACE(f(n)-[[Big O Notation|ω]](log(f(n)+n))) ⊊ SPACE(f(n)). This holds even if SPACE(f(n)-ω(log(f(n)+n))) is defined using a different computational model than SPACE(f(n)) because the different models can simulate each other with O(log(f(n)+n)) space overhead.
| |
| * For certain computational models, including Turing machines with a fixed number of tapes (with one head per tape) and fixed alphabet size and with delimiters for the visited segment on each tape, SPACE(f(n)-ω(1)) ⊊ SPACE(f(n)).
| |
| | |
| The proof is similar to the proof of the space hierarchy theorem, but with two complications: The universal Turing machine has to be space-efficient, and the reversal has to be space-efficient. One can generally construct universal Turing machines with O(log(space)) space overhead, and under appropriate assumptions, just O(1) space overhead (which may depend on the machine being simulated). For the reversal, the key issue is how to detect if the simulated machine rejects by entering an infinite (space-constrained) loop. Simply counting the number of steps taken would increase space consumption by about f(n). At the cost of a potentially exponential time increase, loops can be detected space-efficiently as follows: <ref>{{cite conference | first = Michael | last = Sipser | title = Halting Space-Bounded Computations | booktitle = Proceedings of the 19th Annual Symposium on Foundations of Computer Science | date = 1978}}</ref>
| |
| | |
| Modify the machine to erase everything and to go to a specific configuration A on success. Use [[depth-first search]] to determine whether A is reachable in the space bound from the starting configuration. The search starts at A and goes over configurations that lead to A. Because of determinism, this can be done in place and without going into a loop. Also (but this is not necessary for the proof), to determine whether the machine exceeds the space bound (as opposed to looping within the space bound), we can iterate over all configurations about to exceed the space bound and check (again using depth-first search) whether the initial configuration leads to any of them.
| |
| | |
| == Corollaries ==
| |
| === Corollary 1 ===
| |
| | |
| ''For any two functions <math>f_1</math>, <math>f_2: \mathbb{N} \longrightarrow
| |
| \mathbb{N}</math>, where <math>f_1</math>(n) is o(<math>f_2</math>(n)) and <math>f_2</math> is space-constructible, SPACE(<math>f_1</math>(n)) <math>\subsetneq</math> SPACE(<math>f_2</math>(n)).''
| |
| | |
| This corollary lets us separate various space complexity classes.
| |
| For any function <math>n^k</math> is space-constructible for any natural
| |
| number k. Therefore for any two natural numbers <math>k_1 < k_2</math> we can
| |
| prove SPACE(<math>n^{k_1}</math>) <math>\subsetneq</math> SPACE(<math>n^{k_2}</math>). We can extend
| |
| this idea for real numbers in the following corollary. This
| |
| demonstrates the detailed hierarchy within the PSPACE class.
| |
| | |
| === Corollary 2 ===
| |
| | |
| ''For any two nonnegative real numbers <math>a_1 < a_2,</math> SPACE(<math>n^{a_1}</math>)
| |
| <math>\subsetneq</math> SPACE(<math>n^{a_2}</math>).''
| |
| | |
| === Corollary 3 ===
| |
| | |
| ''[[NL (complexity)|NL]] <math>\subsetneq</math> [[PSPACE]].''
| |
| | |
| ==== Proof ====
| |
| | |
| [[Savitch's theorem]] shows that NL <math>\subseteq</math> SPACE(<math>\log^2n</math>), while the space hierarchy theorem shows that SPACE(<math>\log^2n) \subsetneq</math> SPACE(<math>n</math>). Thus we get this corollary along with the fact that TQBF <math>\notin</math> NL
| |
| since TQBF is PSPACE-complete.
| |
| | |
| This could also be proven using the non-deterministic space hierarchy theorem to show that NL <math>\subsetneq</math> NPSPACE, and using Savitch's theorem to show that PSPACE = NPSPACE.
| |
| | |
| === Corollary 4 ===
| |
| | |
| [[PSPACE]] <math>\subsetneq</math> [[EXPSPACE]].
| |
| | |
| This last corollary shows the existence of decidable
| |
| problems that are intractable. In other words their decision procedures must use more than polynomial space.
| |
| | |
| === Corollary 5 ===
| |
| | |
| There are problems in '''PSPACE''' requiring an arbitrarily large exponent to solve; therefore '''PSPACE''' does not collapse to '''DSPACE'''(''n''<sup>''k''</sup>) for some constant ''k''.
| |
| | |
| == References ==
| |
| {{reflist}}
| |
| *{{cite book | zbl=1193.68112 | last1=Arora | first1=Sanjeev | authorlink1=Sanjeev Arora | last2=Barak | first2=Boaz | title=Computational complexity. A modern approach | publisher=[[Cambridge University Press]] | year=2009 | isbn=978-0-521-42426-4 }}
| |
| * [[Luca Trevisan]]. [http://www.cs.berkeley.edu/~luca/cs172-04/noteh.pdf Notes on Hierarchy Theorems]. Handout 7. CS172: Automata, Computability and Complexity. U.C. Berkeley. April 26, 2004.
| |
| * Viliam Geffert. [http://portal.acm.org/citation.cfm?id=763728 Space hierarchy theorem revised]. ''Theoretical Computer Science'', volume 295, number 1-3, p.171-187. February 24, 2003.
| |
| * {{cite book | first=Michael | last= Sipser | authorlink=Michael Sipser | year = 1997 | title = Introduction to the Theory of Computation | publisher = PWS Publishing | isbn = 0-534-94728-X}} Pages 306–310 of section 9.1: Hierarchy theorems.
| |
| * {{cite book | first=Christos | last=Papadimitriou | authorlink = Christos Papadimitriou | year = 1993 | title = Computational Complexity | publisher = Addison Wesley | edition = 1st | isbn = 0-201-53082-1}} Section 7.2: The Hierarchy Theorem, pp.143–146.
| |
| | |
| | |
| <!-- Need to add original source here -->
| |
| | |
| [[Category:Articles containing proofs]]
| |
| [[Category:Structural complexity theory]]
| |
| [[Category:Theorems in computational complexity theory]]
| |