In computational complexity theory, a log-space reduction is a reduction computable by a deterministic Turing machine using logarithmic space. Conceptually, this means the Turing machine can keep a constant number of pointers into the input, along with a logarithmic number of fixed-size integers. It is possible that such a machine may not have space to write down its own output, so the only requirement is that any given bit of the output be computable in log-space. Formally, this reduction is executed via a log-space transducer. Such a machine has polynomially-many configurations, so log-space reductions are also polynomial-time reductions. However, log-space reductions are probably weaker than polynomial-time reductions; while any non-empty, non-full language in P is polynomial-time reducible to any other non-empty, non-full language in P, a log-space reduction from an NL-complete language to a language in L, both of which would be languages in P, would imply the unlikely L = NL. It is an open question if the NP-complete problems are different with respect to log-space and polynomial-time reductions. Log-space reductions are normally used on languages in P, in which case it usually does not matter whether many-one reductions or Turing reductions are used, since it has been verified that L, SL, NL, and P are all closed under log-space Turing reductions, meaning that Turing reductions can be used to show a problem is in any of these classes. However, other subclasses of P such as NC may not be closed under Turing reductions, and so many-one reductions must be used. Just as polynomial-time reductions are useless within P and its subclasses, log-space reductions are useless to distinguish problems in L and its subclasses; in particular, every non-empty, non-full problem in L is trivially L-complete under log-space reductions. While even weaker reductions exist, they are not often used in practice, because complexity classes smaller than L (that is, strictly contained or thought to be strictly contained in L) receive relatively little attention. The tools available to designers of log-space reductions have been greatly expanded by the result that L = SL; see SL for a list of some SL-complete problems that can now be used as subroutines in log-space reductions.
Logspace computable function
A function f : 2 ∗ → 2 ∗ {\displaystyle f:2^{*}\to 2^{*}} is (implicitly) logspace computable if:
Its output length is polynomially bounded: There exists some c > 0 {\displaystyle c>0} such that f ( x ) ≤ | x | c {\displaystyle f(x)\leq |x|^{c}} for all x ∈ 2 ∗ {\displaystyle x\in 2^{*}} .
L f = { ⟨ x , i ⟩ ∣ f ( x ) i = 1 } {\displaystyle L_{f}=\left\{\langle x,i\rangle \mid f(x)_{i}=1\right\}} is in complexity class L.
L f ′ = { ⟨ x , i ⟩ ∣ i ≤ | f ( x ) | } {\displaystyle L_{f}^{\prime }=\{\langle x,i\rangle \mid i\leq |f(x)|\}} is in complexity class L. Intuitively, the first condition states that the function creates outputs that are short enough, such that creating a single pointer on the output will take only logspace. That condition is necessary in order for pointers on the output to exist at all. The second condition states that any particular output location is computable in logspace. The third condition states that checking if a pointer is a valid pointer is decidable in logspace. Equivalently, a function f : 2 ∗ → 2 ∗ {\displaystyle f:2^{*}\to 2^{*}} is logspace computable if it is computed by a Turing machine with a log-length work tape, that halts on any input, and an output tape that is write-only and write-once, meaning that at each step, the machine may either write nothing, or write a bit and move the write-head forward by one. Such a machine is usually called a logspace transducer. Note that such a machine, if it halts, must halt in polynomial steps, since its work tape has log-length. Therefore its output length is polynomially bounded. One intuition is that such a function can be computed by a program that can only keep a constant number of pointers to the input, and a constant number of counters that can only contain integers of size p o l y ( n ) {\displaystyle {\mathsf {poly}}(n)} . This is because a counter machine with a constant number of counters that count up to f ( n ) {\displaystyle f(n)} is equivalent to a Turing machine with space complexity O ( log f ( n ) ) {\displaystyle O(\log f(n))} .
… excerpt ends here. Continue reading the full article.
