Log-space reduction

In computational complexity theory, a log-space reduction is a reduction computable by a deterministic Turing machine using logarithmic space. Conceptually, this means it 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 Turing reductions^{[citation needed]}, 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^{[citation needed]}.

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 ${\displaystyle f:2^{*}\to 2^{*}}$ is (implicitly) logspace computable iff:^[1]: 88

• It is polynomially bounded: There exists some ${\displaystyle c>0}$ such that ${\displaystyle f(x)\leq |x|^{c}}$ for all ${\displaystyle x\in 2^{*}}$.
• ${\displaystyle L_{f}=\left\{\langle x,i\rangle \mid f(x)_{i}=1\right\}}$ is in complexity class L.
• ${\displaystyle L_{f}^{\prime }=\{\langle x,i\rangle |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 ${\displaystyle f:2^{*}\to 2^{*}}$ is logspace computable iff there exists a Turing machine with a log-length work tape, 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.^[1]: 94 Such a machine is usually called a logspace transducer.

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 registers that can only contain integers of size ${\displaystyle {\mathsf {poly}}(n)}$.

Closure

Logspace reduction

A language ${\displaystyle L}$ is logspace reducible to another language ${\displaystyle L'}$, notated as ${\displaystyle L\leq _{l}L'}$, iff there exists an implicitly logspace computable function ${\displaystyle f}$ such that ${\displaystyle x\in L\iff f(x)\in L'}$.

A language ${\displaystyle L}$ is NL-complete iff it is NL, and any language in NL is logspace reducible to it.