The 2CNF Boolean Formula Satisfiability Problem and the Linear Space Hypothesis

We aim at investigating the solvability/insolvability of nondeterministic logarithmic-space (NL) decision, search, and optimization problems parameterized by natural size parameters using simultaneously polynomial time and sub-linear space. We are particularly focused on $\mathrm{2SAT}_3$ -- a restricted variant of the 2CNF Boolean (propositional) formula satisfiability problem in which each variable of a given 2CNF formula appears at most 3 times in the form of literals -- parameterized by the total number $m_{vbl}(\phi)$ of variables of each given Boolean formula $\phi$. We propose a new, practical working hypothesis, called the linear space hypothesis (LSH), which asserts that $(\mathrm{2SAT}_3,m_{vbl})$ cannot be solved in polynomial time using only ``sub-linear'' space (i.e., $m_{vbl}(x)^{\varepsilon}\, polylog(|x|)$ space for a constant $\varepsilon\in[0,1)$) on all instances $x$. Immediate consequences of LSH include $\mathrm{L}l\neq\mathrm{NL}$, $\mathrm{LOGDCFL}\neq\mathrm{LOGCFL}$, and $\mathrm{SC}\neq \mathrm{NSC}$. For our investigation, we fully utilize a key notion of ``short reductions'', under which the class $\mathrm{PsubLIN}$ of all parameterized polynomial-time sub-linear-space solvable problems is indeed closed.

1 Motivational Discussion and Quick Overview

Space Complexity of Parameterized 2SAT
Since Cook [4] demonstrated its NP-completeness in 1971, the Boolean (propositional) formula satisfiability problem (SAT) of determining whether or not a given Boolean formula is satisfied by a suitably-chosen variable assignment has been studied extensively for about 50 years.As its restricted variant, the kCNF Boolean (propositional) formula satisfiability problem (kSAT) for an integer index k ≥ 3, whose input formulas are of k-conjunctive normal form (kCNF), has also been a centerpiece of computational complexity theory.Since kSAT is complete for NP (nondeterministic polynomial time) [4], its solvability is linked to the computational complexity of all other NP problems in such a way that, if kSAT is solvable in polynomial time, then so are all other NP problems.It is also known that kSAT is polynomial-time reducible to 3SAT and vice versa.A recent study has been focused on the solvability of kSAT with n Boolean variables and m clauses within "sub-exponential" (which means 2 εn poly(n + m) for an absolute constant ε ∈ (0, 1) and a suitable polynomial poly(•)) runtime.In this line of study, Impagliazzo, Paturi, and Zane [12] took a new approach toward kSAT and its search version, Search-kSAT, parameterized by the number m vbl (x) of all Boolean variables and the number m cls (x) of all clauses in a given kCNF formula x as natural "size parameters" (which were called "complexity parameters" in [12]).To discuss such sub-exponential-time solvability for a wide range of NP-complete problems, Impagliazzo et al. further devised a crucial notion of sub-exponential-time reduction family (or SERF-reduction), which preserves the sub-exponential-time complexity, and they cleverly demonstrated that the aforementioned size parameters m vbl (x) and m cls (x) make Search-kSAT SERF-equivalent (namely, the two problems are SERF-reducible to each other).Motivated by a fine role of SERF-reducibility, Impagliazzo and Paturi [11] formally proposed, as a working hypothesis, the exponential time hypothesis (ETH), and later Impagliazzo, Paturi, and Zane [12] extended it into the strong exponential time hypothesis (SETH), which asserts the insolvability of kSAT parameterized by m vbl (x) (succinctly denoted in this paper by (kSAT, m vbl )) within sub-exponential time for all indices k ≥ 3. Their hypothesis turned out to be a stronger assertion than P = NP and it has led to intriguing consequences, including finer lower bounds on the solvability of various parameterized NP problems (see, e.g., a survey [17]).
Whereas SETH concerns with kSAT for k ≥ 3, we are focused on the remaining case of k = 2.The decision problem 2SAT is known to be complete 6 for NL (nondeterministic logarithmic space) under logspace reductions.Since 2SAT already enjoys a polynomial-time algorithm (because of NL ⊆ P), we are more concerned with how much memory space such an algorithm demands to run.An elaborate algorithm solves 2SAT with n variables and m clauses using simultaneously polynomial time and (n/2 c √ log n ) polylog(m + n) space (Theorem 4.3), where c > 0 is a fixed constant and polylog(•) is a suitable polylogarithmic function.This space bound is slightly below n; however, it is not yet known that 2SAT parameterized by m vbl (x) or m cls (x) can be solved in polynomial time using strictly "sub-linear" space, where the informal term "sublinear" for a size parameter m(x) refers to a function of the form m(x) ε ℓ(|x|) on input instances x for a certain absolute constant ε ∈ [0, 1) and an appropriately-chosen polylogarithmic function ℓ(n).Of course, this multiplicative factor ℓ(|x|) becomes redundant if m(x) is relatively large (for example, m(x) ≥ log k |x| for a large constant k > 0) and thus "sub-linear" turns out to be simply m(x) ε .
In parallel to a restriction of SAT onto kSAT, we further limit 2SAT to 2SAT k for polynomial-time sub-linear-space solvability, where 2SAT k (k-bounded 2SAT) consists of all satisfiable formulas in which each variable appears as literals in at most k clauses.Notice that 2SAT k for each k ≥ 3 is also NL-complete (Proposition 4.1) as 2SAT is; by contrast, kSAT 2 already falls into L for any index k ≥ 2.

Sub-Linear Space and Short Reductions
A decision problem L parameterized by a size parameter m forms a parameterized decision problem expressed as (L, m).Naturally, we can expand L (logarithmic-space complexity class) and P (polynomial-time complexity class) by parameterizing their associated decision problems and, for clarity reason, we respectively denote these parameterized complexity classes by para-L and para-P.Similarly, all parameterized decision problems solvable in polynomial time using sub-linear space then form a parameterized complexity class PsubLIN (whose prefix "P" refers to "polynomial time" and suffix "subLIN" stands for "sub-linear space"), which is located between para-L and para-P.This new complexity class PsubLIN naturally includes, for example, DCFL (deterministic context-free) because Cook [5] earlier showed that every language in DCFL is recognized in polynomial time using O(log 2 n)-space, 7 where n indicates input size.Unfortunately, there is no known separation among para-L, para-NL, PsubLIN, and para-P.
It turns out that PsubLIN does not seem to be closed under standard log-space reductions; thus, those reductions are no longer useful tools to discuss the solvability of NL-complete problems within polynomial time and sub-linear space.Therefore, we need to introduce a much weaker form of reductions, called short reductions, which preserve the polynomial-time sub-linear-space complexity.Intuitively speaking, a short reduction is a reduction between two parameterized decision problems computed by a reduction machine (or a reduction function) that can generate strings of certain sizes proportional to or less than sizes of its input strings.In particular, we will define three types of such short reductions in Section As noted earlier, Impagliazzo et al. demonstrated in [12,Corollary 2] that, for any number k ≥ 3, (kSAT, m vbl ) is SERF-equivalent to (kSAT, m cls ).Similarly, we can construct a short reduction from 2SAT 3 with m vbl to 2SAT 3 with m cls , and vice verse; in other words, (2SAT 3 , m vbl ) and (2SAT 3 , m cls ) are equivalent under short L-T-reductions (Lemma 4.2(2)).On the contrary, such equivalence is not known for 2SAT and this circumstance signifies the importance of 2SAT 3 in the study of polynomial-time sub-linear-space computability.
Another importance of 2SAT 3 can be demonstrated by showing that 2SAT 3 is hard for a natural subclass of NL, which we call Syntactic NL or simply SNL under short SLRF-T-reductions.An SNL sentence Φ is of the form ∀y s ψ, starting with second-order existential "functional" quantifiers, followed by first-order universal quantifiers, ranging over specified domains.Their precise definitions will be given in Section 4. Such an SNL sentence can capture essential, syntactic structures of some of NL-complete problems.Let para-SNL stand for the collection of all parameterized decision problems (P, m) in which P is expressed "syntactically" by an appropriate SNL-formula Φ and m(x) equals the size of one of the domains associated with Φ.For its slightly restricted subclass para-SNL ω , we further claim in Proposition 4.11 that (2SAT 3 , m vbl ) is hard for para-SNL ω under short SLRF-T-reductions.
1.3 A New, Practical Working Hypothesis for 2SAT 3 Since its introduction in 2001, ETH and SETH for kSAT (k ≥ 3) have served as a driving force to obtain finer lower bounds on the sub-exponential-time computability of various parameterized NP problems, since those bounds do not seem to be obtained directly from the popular assumption of P = NP.In a similar vein, we wish to propose a new, practical working hypothesis, called the linear space hypothesis (LSH) for 2SAT 3 , in which no deterministic algorithm solves (2SAT 3 , m vbl ) simultaneously in polynomial time and sub-linear space.More precisely: Definition 1.1 [The Linear Space Hypothesis (LSH) for 2SAT 3 with m vbl ] For any choice of ε ∈ [0, 1) and any polylogarithmic function ℓ, no deterministic Turing machine solves 2SAT 3 parameterized by m vbl in time polynomial in m(x) using m vbl (x) ε ℓ(|x|) space, where x refers to an input instance to 2SAT 3 .
It turns out that m vbl in the above definition can be replaced by m cls (Proposition 5.1(2)), and we therefore tend to omit the reference to m vbl and refer to the hypothesis as "LSH for 2SAT 3 ."From this working hypothesis LSH for 2SAT 3 , we can draw various conclusions, including L = NL, LOGDCFL = LOGCFL, and SC = NSC (Theorem 5.2), where NSC is the nondeterministic counterpart of Steve's class SC.This consequence allows us to expect that LSH for 2SAT 3 will lead to finer, better consequences than what the popular assumption like L = NL can lead to.
We present in Section 5.2 two useful characterizations of the hypothesis LSH for 2SAT 3 .The first characterization concerns with the (2, k)-entry {0, 1}-linear programming problem (LP 2,k ), in which we check whether there exists a {0, 1}-vector x satisfying Ax ≥ b for a rational m × n matrix A and a rational vector b of dimension n, provided that each row of A has at most two nonzero entries and each column of A has at most k non-zero entries.For this problem, we use two size parameters m col (x) and m row (x), which respectively indicate the numbers of columns and of rows of A for any instance x = (A, b) given to LP 2,k .
The second characterization uses the degree-k directed s-t connectivity problem (kDSTCON) of asking whether a path from a given vertex s to another vertex t exists in a given directed graph G whose vertices have degree (i.e., indegree plus outdegree) at most k.For an instance x = (G, s, t) to kDSTCON, we concentrate on two size parameters m ver (x) and m edg (x), which respectively denote the number of vertices and that of edges in G.
As a characterization theorem (Theorem 5.6), we prove that the following two statements are logically equivalent to LSH for 2SAT 3 : (i) LSH for LP 2,3 with either m row or m col and (ii) LSH for 3DSTCON with either m ver or m edg .These characterizations are shown by the use of the aforementioned short reducibilities, which are specifically designed to preserve the polynomial-time sub-linear-space computability.
Naturally, we can ask what consequences we can draw from our working hypothesis LSH for 2SAT 3 .In Section 6, we will present four examples of such applications.
(1) As the first example, we look into NL search problems.A special NL search problem, called Search-1NFA, is to find an input of length n accepted by a given 1nfa M that disallows any λ-move (or λ-transition).We use the size parameter m nf a (x) = |Q||Σ|n defined for each instance x = (M, 1 n ) given to Search-1NFA.We show that, for any constant ε ∈ (0, 1/2), no |x| O(1) -time O(m nf a (x) 1/2−ε )-space algorithm solves Search-1NFA on all instances x (Theorem 6.1).
(2) In another NL search problem, Search-UOCK, we are asked for finding, for a given string w and for a sequence (w 1 , w 2 , . . ., w n ) of n strings, an index sequence (i 1 , . . ., i k ) in increasing order that makes the concatenation w i1 • • • w i k equal to w.As a natural size parameter, we set m elm (x) = n for each instance x of the form (w, (w 1 , w 2 , . . ., w n )).We then show that, for any constant ε > 0, there is no |x| O(1) -time O(m elm (x) 1/2−ε )-space algorithm working for Search-UOCK on all instances x (Theorem 6.2).
(3) Let us consider an NL optimization (or NLO) problem, called Max-HPP, studied in [23,24].By setting m col (x) = n for each instance x, we show that no |x| O(1) -time O(k 1/3 log m col (x))-space algorithm that finds (1 + 1 k )-approximate solutions for Max-HPP on all instances x (Theorem 6.3).(4) As the fourth example, we are focused on unary 1nfa's, which work on single-letter input alphabets.For any given n-state unary 1nfa, there is always a unary 1dfa of O(n log n) states that produces the same outputs as the 1nfa does (see, e.g., [8]).We show that, for any constant ε ∈ (0, 1), there is no |x| O(1) -time O(n ε )-space algorithm that converts each n-state unary 1nfa into an equivalent 1dfa of O(n log n) state (Theorem 6.6).

A Recent Progress after Our Preliminary Report
Since the first publication of this paper as a preliminary report [26], there have been five papers [27,28,29,30,31] addressing fascinating results relevant to the linear space hypothesis.
In [28], the parameterized decision problems are proven to be closely connected to state-complexity classes defined by finite automata.In particular, the author presented a characterization of the hypothesis LSH for 2SAT 3 using the state complexity of transformation of certain types of nondeterministic finite automata to deterministic ones.More importantly, the "nonuniform" version of LSH for 2SAT 3 (called the nonuniform linear space hypothesis) was further introduced and characterized in terms of certain types of nonuniform state complexity.In [27], the author explored the properties of the short reducibilities, further expanded the scope of these reducibilities to search problems, and drew a picture of a large landscape of the relative complexity of various combinatorial problems via short reductions.In [30], three additional parameterized decision problems were introduced and proven to be "equivalent" to (2SAT 3 , m vbl ) by short reductions.In [31], the author further studied fine-grained space complexities of various parameterized decision problems in direct connection to LSH for 2SAT 3 .In [29], the author provided circumstantial evidences that the validity of LSH for 2SAT 3 might be quite difficult to verify by demonstrating two contradictory relativized worlds in which LSH holds and LSH fails.
We hope that the working hypothesis LSH for 2SAT 3 (and also its nonuniform version) will stimulate the study on the space complexity of "tractable" problems in general and eventually lead us to a rich research area that we have not yet seen in the past literature.

Basic Concepts and Notation
This section will provide fundamental concepts and notation necessary to read through the rest of the paper.Let N denote the set of all natural numbers (i.e., nonnegative integers) and set N + = N − {0}.Two notations R and R ≥0 denote respectively the set of all real numbers and that of all nonnegative real numbers.For any two integers m and n with m ≤ n, the integer interval [m, n] Z refers to the set {m, m + 1, m + 2, . . ., n}.We particularly abbreviate [1, n] Z as [n] when n ≥ 1.For technical convenience, when n < 1, we additionally set [n] = ∅.Given a set S, P(S) expresses the power set of S, namely, the set of all subsets of S. For two sets A and B, their symmetric difference A△B is the set (A − B) ∪ (B − A).For a basic knowledge on graphs, see textbooks, e.g., [7].Additionally, for a vertex v of a graph, we use the notation deg(v) to denote the degree of v, where the generic term "degree" refers to the sum of the indegree and outdegree.
In this paper, all polynomials are assumed to have nonnegative integer coefficients and all logarithms are taken to the base 2, provided that "log 0" is conventionally set to be 0. A polylogarithmic (or polylog) function ℓ is a function mapping N to R ≥0 such that there exists a polynomial p for which ℓ(n) = p(log n) holds for all n ∈ N.For the sake of readability, we abuse the informal notation "polylog(n)" to indicate an appropriately-chosen polylog function ℓ in n.Let Polylog denote the set of all polylog functions.
An alphabet is a finite nonempty set Σ of "symbols" or "letters," and a string over Σ is a finite sequence of symbols in Σ.The length of a string x is the total number of symbols used in x and we use the notation |x| to denote it.The empty string has length 0 and it is always denoted by λ.Let Σ * denote the set of all strings over Σ.A language over Σ is a subset of Σ * .Hereafter, we freely identify a decision problem P with its associated language.Given a number n ∈ N, the notation Σ n (resp., Σ ≤n , Σ ≥n ) denotes the set of all strings of length exactly n (resp., length at most n, length at least n) over Σ.Moreover, we set Σ <n = Σ ≤n − Σ n and Σ >n = Σ ≥n − Σ n .The notation CFL refers to the family of all context-free languages and DCFL is the deterministic counterpart of CFL.Refer to textbooks, e.g., [8] for more detail.
Turing machines are generally used to solve a mathematical problem.Throughout this paper, we use the following form of Turing machines.Our Turing machine consists of a read-only input tape, (possibly) a write-once output tape, and a constant number of read/write work tapes.A tape head of a write-once tape moves to the right if it writes a non-blank symbol, and it stays still on a blank tape cell otherwise.All other tape heads always move in both directions (to the right and to the left).We sometimes abbreviate a nondeterministic Turing machine as an NTM and a deterministic Turing machine as a DTM.As customary, we define P as the complexity class of all decision problems solved by DTMs in polynomial time.As its subclasses, SC (resp., L) is defined in terms of polynomial-time, polylogarithmic-space (resp., logarithmicspace) DTMs.Moreover, NSC and NL denote respectively the nondeterministic counterparts of SC and L.
In a course of our study on polynomial-time sub-linear-space computability, it is convenient to expand the standard framework of decision problems to problems that are parameterized by properly chosen "size parameters" (called "complexity parameters" in [12]), which serve as a basis unit of the time/space complexity of an underlying algorithm.In this respect, we naturally follow a framework of Impagliazzo, Paturi, and Zane [12] to work with a flexible choice of size parameters.
Given an alphabet Σ of a target decision problem, a size parameter is formally a function from Σ * to N. A standard size parameter from Σ * to N measures the total number |x| of symbols in an instance x over Σ and it is often denoted by ||.For any size parameter m : Σ * → N, we say that m is polynomially bounded if there exists a polynomial p satisfying m(x) ≤ p(|x|) for all strings x ∈ Σ * and that m is polynomially honest if there is a polynomial p such that |x| ≤ p(m(x)) for all x ∈ Σ * .In addition, m is said to be almost non-zero if there is a finite set S ⊆ Σ * satisfying m(x) > 0 for all instances x in Σ * − S.
In the rest of this paper, we focus our attention on the following "log-space" size parameters.
Definition 2.1 A log-space size parameter m(x) for a mathematical problem P is a function mapping Σ * (where Σ is an input alphabet used for P ) to N such that (1) m is polynomially bounded for all instances of P and (2) m must be computed by a certain DTM that takes input x and outputs m(x) in unary (i.e., produces a string 1 m(x) ) on a write-once output tape using at most c log |x| + d space for certain fixed constants c, d > 0.
As key examples of log-space size parameters, for any graph-related problem (such as 3DSTCON in Section 5.2), we define m edg (x) and m ver (x) respectively to be the total number of edges and that of vertices in each graph instance x given to the problem.It is not difficult to show that m ver and m edg are indeed log-space size parameters.To emphasize the use of size parameter m, we explicitly write (P, m) instead of P .For clarity reason, we call this pair (P, m) a parameterized decision problem and any collection of such parameterized decision problems is conveniently called a parameterized complexity class.Given a size parameter m, we say that a multi-tape Turing machine M uses logarithmic space (or log space, for short) with respect to m if there exist two absolute constants c, d ≥ 0 for which each of the work tapes (not including input and output tapes) used by M on x are upper-bounded by c log m(x) + d on every input x.Similarly, M runs in polynomial time with respect to m if there is a polynomial p such that M halts within p(m(x)) steps for all instances x.As long as m is polynomially bounded and almost non-zero, those two concepts with respect to m coincide with the ones with respect to the standard size parameter ||.
Two specific notations L and NL respectively stand for the classes of all decision problems solvable on multi-tape deterministic and nondeterministic Turing machines using log space with respect to ||.It is known that the additional requirement of "polynomial runtime" does not change those classes.To distinguish from a standard complexity class C, we use the prefix "para-" as in para-C to denote the corresponding parameterized complexity class.By appropriately parameterizing all standard decision problems, we obtain a parameterization of standard complexity classes.For example, the parameterized NL, denoted by para-NL, is composed of all parameterized decision problems (K, m) with decision problems (or equivalently, languages) K and log-space size parameters m for which there are polynomials p, constants c, d > 0, and NTMs M solving (or recognizing) K in time at most p(m(x)) using space at most c log m(x) + d on all instances x given to K. Another example is the parameterized L, denoted by para-L, which consists of all parameterized decision problems (K, m) with log-space size parameters m solvable deterministically in time m(x) O(1) using space O(log m(x)) on all instances x to K.For time-bounded computing, para-P refers to the collection of all parameterized decision problems (L, m) with log-space size parameters m for which a certain DTM recognizes L in time polynomial in m(x).
More generally, we formulate a parameterized complexity class para-PDTIME,SPACE(•) as follows.
Definition 2.2 Given a function s : N × N → N, the notation para-PDTIME,SPACE(s(|x|, m(x))), where x is a "symbolic" instance, expresses the collection of all parameterized decision problems (P, m) with languages L and log-space size parameters m that are solvable deterministically in time m(x) O(1) (i.e., polynomial time) using space O(s(|x|, m(x))) on any instance x given to P .
With the use of the above notation, for example, para-L can be expressed concisely as para-PDTIME,SPACE(log m(x)).From a different perspective, many standard complexity classes, such as L, NL, and P, can be treated as special cases of para-L, para-NL, and para-P when restricted to the standard size parameter ||.Hereafter, we freely identify a language K with its parameterization (K, ||).
To define NL search problems and NL optimization problems in Section 6, it is convenient for us to use a practical model of "auxiliary Turing machine" (see, e.g., [24] for details).An auxiliary Turing machine is a multi-tape deterministic Turing machine equipped with an extra "read-once" auxiliary input tape, in which a tape head scans each auxiliary input symbol only once by moving from left to right.Following [24], let us define two auxiliary complexity classes, auxL and auxFL.Given two alphabets Σ and Γ, a decision problem P with P ⊆ Σ * × Γ * is in auxL if there exist a polynomial p and an auxiliary Turing machine M that takes a standard input x and an auxiliary input y of length p(|x|) and decides whether M accepts (x, y) or rejects it in time polynomial in |x| using space logarithmic in |x|.Its functional version is denoted by auxFL, provided that each underlying auxiliary Turing machine is equipped with an extra write-once output tape and that the machine produces output strings of at most polynomial length by moving from left to right.We call a function f : Σ * 1 → Σ * 2 (for two alphabets Σ 1 and Σ 2 ) polynomially bounded if there exists a polynomial p satisfying |f (x)| ≤ p(|x|) for all instances x ∈ Σ * 1 .With this terminology, the last requirement of auxFL actually states that all functions are polynomially bounded.Remember that FL is defined by Turing machines with no auxiliary tapes or auxiliary inputs.

Sub-Linear Space and Short Reductions
Let us recall from [11,12] that the term "sub-exponential" means 2 εm(x) poly(|x|) on all instances x for a certain fixed constant ε ∈ (0, 1) and a certain polynomially bounded function poly(n).As a good analogy, we wish to use the term "sub-linear" to address functions of the form m(x) ε polylog(|x|) on instances x for a certain constant ε ∈ (0, 1) and a certain polylog function polylog(n).As noted in Section 1.2, the multiplicative factor polylog(|x|) can be eliminated whenever m(x) is relatively large.Our main subject of this paper is sub-linear-space computability restricted to polynomially-bounded runtime.
Firstly, we wish to provide basic concepts associated with parameterized decision problems.A parameterized decision problem (P, m) is said to be solvable in polynomial time using sub-linear space if, for a certain choice of constant ε ∈ (0, 1), there exist a DTM M ε , a polynomial p ε , and a polylog function ℓ ε for which M solves P simultaneously taking at most p ε (m(x)) steps and using at most m(x) ε ℓ ε (|x|) tape cells for all instances x given to P .Notice that, when m is polynomially bounded (i.e., there exists a polynomial r satisfying m(x) ≤ r(|x|) for all x), we can replace p ε (|x|m(x)) by p ε (|x|).
The notation PsubLIN expresses the collection of all parameterized decision problems (P, m) with logspace size parameters m that are solvable in polynomial time using sub-linear space.Using the notation para-PDTIME,SPACE(•) given in Definition 2.2, PsubLIN is formally defined as where x is a "symbolic" instance and m is a "symbolic" size parameter.It thus follows that para-L ⊆ PsubLIN ⊆ para-P but none of these inclusions is known to be proper.
The notion of "reducibility" among decision problems is quite useful in measuring the relative complexity of the problems.For the parameterized complexity class PsubLIN, in particular, we need a restricted form of reducibility, which we call "short" reducibility, satisfying a special property that any outcome of the reduction is linearly upper-bounded in size by an input of the reduction.Let us formally introduce such restricted reductions for parameterized decision problems of our interest.
We begin with a description of L-m-reducibility for parameterized decision problems.This is a straightforward extension of the L-m-reducibility for decision problems (or languages).Given two parameterized decision problems (P 1 , m 1 ) and (P 2 , m 2 ), we say that (P 1 , m 1 ) is L-m-reducible to (P 2 , m 2 ), denoted by (P 1 , m 1 ) ≤ L m (P 2 , m 2 ), if there exists a function f ∈ FL (which is called a reduction function) and two constants k 1 , k 2 > 0 such that, for any input string x, (i) x ∈ P 1 iff f (x) ∈ P 2 and (iii) m 2 (f (x)) ≤ m 1 (x) k1 + k 1 .Notice that, since all functions in FL are, by their definition, polynomially bounded, the inequality |f (x)| ≤ |x| c1 + c 2 holds for two fixed constants c 1 , c 2 > 0.
Concerning polynomial-time sub-linear-space solvability, a restricted variant of L-m-reducibility, which we call the short L-m-reducibility (or sL-m-reducibility, in short), is defined by replacing the equality m To express this new reducibility, we use a new notation of ≤ sL m .We further say that (P 1 , m 1 ) is equivalent to (P 2 , m 2 ) via short L-m-reductions if (P 1 , m 1 ) is reducible to (P 2 , m 2 ) and vice visa via appropriate short L-m-reductions.
When many-one reducibility is too restrictive to use, we need a stronger notion of Turing reduction.To fit into a framework of polynomial-time sub-linear-space computability, we use a polynomial-time sub-linearspace reduction family (SLRF, for short), performed by oracle Turing machines, which is called a reduction machine.Our oracle Turing machine M is equipped with an extra write-once query tape.Once M finishes writing a query word, say, z on the query tape from left to right, M enters a query state q query .The query word is then sent to an oracle, which is an external information source, and the query tape is automatically erased and its tape head returns to the initial cell.The oracle informs the machine of its answer by changing the machine's inner state from q query to either q yes (an affirmative answer) or q no (a negative answer).In the case where the oracle returns strings instead of yes/no answers, we further equip M with a read-once answer tape, on which the oracle writes its answer and M reads this answer only once by moving its tape head from left to right with (possibly) stopping at any time.The above process is generally referred to as an oracle query and this process is assumed to take only a single step.
) time using at most m 1 (x) ε ℓ ε (|x|) space, provided that its query tape is not subject to this space bound, and (2) if M P2 ε (x) makes a query to P 2 with a query word z, then z must satisfy both m 2 (z) ≤ m 1 (x) k1 + k 1 and |z| ≤ |x| k2 + k 2 .The short SLRF-T-reducibility (or sSLRF-T-reducibility, for short) is obtained from the SLRF-reducibility by substituting m 2 (z) ≤ k 1 m 1 (x) + k 1 for the above inequality m 2 (z) ≤ m 1 (x) k1 + k 1 .We use the notation ≤ sSLRF T to address this restricted reducibility.In the following quick example, we see how a short SLRF-T-reduction works between two parameterized decision problems.
Thus, this reduction is indeed short SLRF-T-reduction.
In the case where the space usage of M ε in Definition 3.1 is limited to O(log |x|), since the value ε becomes irrelevant, we use a different notation of ≤ sL T for ≤ sSLRF T .For any reduction ≤ r , a decision problem P is said to be ≤ r -hard for a given class C of problems if every problem Q in C is ≤ r -reducible to P .When P further belongs to C, it is said to be ≤ r -complete for C. We use the notation ≤ r (C) to express the collection of all problems that are ≤ r -reducible to certain problems in C. When C is a singleton, say, C = {A}, we write ≤ r (A) instead of ≤ r ({A}).
We begin with proving simple relationships between short reductions and non-short reductions.
Lemma 3.3 Let P 1 , P 2 be decision problems and let m 1 , m 2 be size parameters.
(1) The first implication is obtained by substituting a reduction machine M for the reduction function f in the definition of ≤ L T .For the second implication, we further need to replace M by M ε .This is possible because, for each value ε > 0 and for any fixed constants c, d > 0, the inequality c log n + d ≤ n ε holds for all but finitely many numbers n in N.
( Proof. (1) We intend to show the target statement only for the reducibility ≤ sSLRF T over parameterized decision problems because the other reducibility ≤ SLRF T can be treated with only a slight modification.The reflexivity of ≤ sSLRF T is trivial by considering the "identity" reduction.As for the transitivity of ≤ SLRF T , assume that (P 1 , m 1 ) ≤ sSLRF T (P 2 , m 2 ) and (P 2 , m 2 ) ≤ sSLRF T (P 3 , m 3 ) for three parameterized decision problems (P 1 , m 1 ), (P 2 , m 2 ), and (P 3 , m 3 ).Given any constant ε > 0, we take two oracle Turing machines M 1,ε and M 2,ε that solve (P 1 , m 1 ) and (P 2 , m 2 ) with the help of oracles (P 2 , m 2 ) and (P 3 , m 3 ), respectively.Moreover, we take positive constants k 1 and k 2 , and a polylog function ℓ 1 for M 1,ε , and k ′ 1 , k ′ 2 , and ℓ 2 for M 2,ε , as specified in the definition of ≤ sSLRF

T
. In what follows, we wish to construct a new reduction machine from (P 1 , m 1 ) to (P 3 , m 3 ).
The desired reduction machine N works as follows.On input x, N simulates M 1,ε on x.When M 1,ε makes a query of word z i to P 2 , instead of making an actual query, N starts simulating M 2,ε on z i with an appropriate access to P 3 used as an oracle.In this simulation, whenever M 2,ε queries a word u j , we force P 3 to return its oracle answer directly to N .Hence, the actual query words of N match those of M 2,ε .If M 2,ε finally enters either an accepting state or a rejecting state, then N regards it as an oracle answer of P 2 to the query of Here, it is important to note that the space usage for query words of M 2,ε is not included here, because these words are directly written down on the query tape of N .
For any sufficiently long string x, the space usage ℓ(x) of N on the instance x is upper-bounded by the sum of m 1 (x) ε ℓ 1 (|x|) (work space used by M 1,ε on x), max i {log |z i |} (work space needed to produce query words z i of M 1,ε ), and max i {m for a suitably chosen polylog function ℓ ′ .Moreover, the size of query words u j generated by N is upperbounded by m 3 (u j ), which is at most Since N correctly solves (or recognizes) P 1 using P 3 as an oracle, N is therefore a short SLRF-reduction machine, as requested.
Since (P 2 , m 2 ) ∈ PsubLIN, we take a constant ε ∈ [0, 1) and a DTM M 2 solving (P 2 , m 2 ) in polynomial time using m 2 (x) ε ℓ 2 (|x|) space, where ℓ 2 (•) is a certain polylog function.For this constant ε, we take a reduction machine M 1 that reduces (P 1 , m 1 ) to (P 2 , m 2 ) in polynomial time using space at most m 1 (x) ε ℓ 1 (|x|) for a certain polylog function ℓ 1 .Moreover, there are two constants Let us define a new DTM N that solves (P 1 , m 1 ) by simulating M 1 .On input x, during the simulation of M 1 on x, whenever M 1 makes the ith query of the form y i , N stops the simulation and starts to simulate M 2 on y i .After M 2 enters either an accepting state or a rejecting state, N treats it as an oracle answer a yi to the query and then resumes the simulation of M 1 using this value a yi .
Clearly, N runs in polynomial time.An appropriate implementation of N requires work space of at most cm 1 (x where ℓ is an appropriately chosen polylog function.Therefore, (P 1 , m 1 ) is solvable in polynomial time using sub-linear space; in other words, (P 1 , m 1 ) belongs to PsubLIN.
(3) We will show the statement only for the case of ≤ L m and ≤ sL m since the other cases are similarly treated in essence.Therefore, our goal here is to construct inductively two decision problems X and Y satisfying that (X, m) ≤ L m (Y, m) and (X, m) ≤ sL m (Y, m) for a certain log-space size parameter m.Fix our alphabet Σ = {1} and set m(x) = |x| for all x ∈ Σ * .We take two effective enumerations of all ≤ sL m -reduction functions over the alphabet Σ as g 1 , g 2 , . . .(with possible repetitions) and of all natural numbers as k 1 , k 2 , . . .(with possible repetitions) so that the set and for all strings x ∈ Σ * .For the construction of X and Y , we use the special function f : Σ * → Σ * defined by setting f (1 n ) = 1 n 2 for any index n ∈ N and f (y) = λ for any binary string y not in Σ * .
The construction of the desired decision problems X and Y proceeds by stages.At Stage 0, we set n 0 = 0, x 0 = λ, and X 0 = Y 0 = ∅.At Stage i ≥ 1, by induction hypothesis, we assume that n i−1 , x i−1 , X i−1 , and Y i−1 have been already defined.We further assume that There are two cases to consider separately.
Finally, we verify that (X, m) ≤ sL m (Y, m).Assume that (X, m) ≤ sL m (Y, m) via a certain reduction g.Take the minimum index i satisfying g = g i and consider Stage i.Let x = x i .Either x i ∈ X i or x i / ∈ X i holds.If x i ∈ X i , then case (ii) happens, and thus 4 The 2CNF Boolean Formula Satisfiability Problem and Syntactic NL We will make a brief discussion on the space complexity of 2SAT and 2SAT 3 and the complexity class SNL.As noted in Section 1.1, 2SAT is NL-complete under L-m-reductions.Here, a Boolean (propositional) formula is made up by variables and logical connectives {∨, ∧, ¬} and a variable assignment assigns either True (1) or False (0) to each variable.A literal is either a variable x or its negation x.Given such a literal v, the succinct notation v indicates x if v is a variable x, and v indicates x if v is the negation of x.This notation is useful because we do not need to worry about whether or not v is a variable.
For practical reason, we always assume the existence of an efficient encoding scheme of Boolean formulas into unique binary strings for which each variable (as well as logical connectives) is encoded into an O(log mn)bit string, where n is the total number of variables and m is the total number of clauses.

Properties of 2SAT 3
We further restrict 2SAT by limiting the number of occurrences of variables in the form of literals in each Boolean formula.Fix k ∈ N + arbitrarily.We denote by 2SAT k the collection of all formulas φ in 2SAT such that, for each variable v in φ, the total number of occurrences of v and v is at most k.Since 2SAT 1 and 2SAT 2 are solvable using only log space, we hereafter force our attention on the case of k ≥ 3.
In what follows, we are focused on two specific size parameters: m vbl (x) and m cls (x), which respectively denote the total number of variables and that of clauses appearing in formula-related instance x (not necessarily limited to instances of 2SAT).Based on the fact that 2SAT is NL-complete [15], we derive the following conclusion: (2SAT, ||) ≤ L m (2SAT 3 , ||).Let φ denote any 2CNF formula given to 2SAT.If φ contains a unit clause of x and another unit clause of x for a certain variable x, then we define f (φ) = x ∧ x.Hereafter, we assume otherwise.We recursively modify φ according to the following rules.If x ∨ x is a clause of φ, then we delete it.If φ contains a clause of either x or x ∨ x (resp., x or x ∨ x) for a certain variable x, then we first delete the unit clause of x and all clauses of the form x ∨ y (resp., x ∨ y) for any literal y / ∈ {x, x} and then include x ∨ x (resp., x ∨ x).After the above modification of φ, let V 3 denote the set of all variables, each of which appears as literals in more than 3 distinct clauses.For each variable x ∈ V 3 , we set C x to be the set of all clauses containing literals of x.For readability, for any clause x ∨ y in C x , we also include y ∨ x into C x if x and y are distinct literals.Let us assume that C x has the form {x ∨ y i , 1 , and x By the above modification procedure, φ ′ is a 2CNF formula whose clauses have "exactly" two distinct literals each.Such a formula is called an exact 2CNF formula.It also follows that, for each variable, its literals appear at most 3 times.Thus, φ ′ is indeed an instance to 2SAT 3 .It is also clear that φ ′ is satisfiable iff φ is satisfiable.Moreover, we can produce φ ′ from φ using only log space.Therefore, 2SAT is L-mreducible to 2SAT 3 , as requested.✷ Concerning 2SAT k , the following important properties hold.For any reduction ≤ r defined in Section 3, we write (P 1 , m 1 ) ≡ r (P 2 , m 2 ) if (P 1 , m 1 ) is equivalent to (P 2 , m 2 ) via ≤ r -reductions; in other words, both Proof.Let m ∈ {m vbl , m cls } and k ≥ 3.
(1) Firstly, the short reducibility (2SAT 3 , m) ≤ sL m (2SAT k , m) trivially holds by considering the "identity" reduction.Next, we want to show that (2SAT k , m) ≤ sL m (2SAT 3 , m).Let us recall the proof of Proposition 4.1, in which any 2CNF Boolean formula φ given to 2SAT k is transformed into another formula φ ′ , which is an instance to 2SAT 3 .This modification implies that m vbl (φ From these inequalities, we conclude that (2SAT k , m) is short L-m-reducible to (2SAT 3 , m).
(2) Here, we simply take the identity function as a reduction function.This function is a short Lm-reduction function because of the fact that, for every 2CNF Boolean formula φ given to 2SAT 3 , two inequalities m cls (φ) ≤ 6m vbl (φ) and m vbl (φ) ≤ 2m cls (φ) follow.✷ Contrary to Lemma 4.2(2), it is still unknown whether (2SAT, m vbl ) ≡ sL m (2SAT, m cls ) or even (2SAT, m vbl ) ≡ sL T (2SAT, m cls ).This situation signifies the difference between 2SAT and 2SAT 3 .To solve 2SAT in polynomial time, we need the space usage slightly larger than sub-linear space.The time-space complexity of 2SAT can be derived from a deterministic algorithm designed to solve the directed s-t connectivity problem8 DSTCON of determining whether there exists a path from a vertex s to another vertex t (succinctly called an s-t path) in a given directed graph G = (V, E).For practicality, every vertex is assumed to be expressed as an O(log |V ||E|)-bit string.In 1998, Barnes et al. [2] presented such a polynomial-time algorithm for DSTCON, which uses slightly more than sub-linear space, or more precisely, As we have noted earlier, our proof of this theorem needs Proposition 5.7(1), which will be proven later in Section 5. Given a Boolean formula φ, the notation |φ| denotes the size of φ expressed in binary by an appropriate encoding.
Proof of Theorem 4.3.Proposition 5.7 (1) states that (DSTCON, m ver ) ≡ sL T (2SAT, m vbl ) and (DSTCON, m edg ) ≡ sL T (2SAT, m cls ).Therefore, the time/space complexity of 2SAT can be derived directly from a deterministic algorithm that solves DSTCON.Earlier, Barnes et al. [2] presented a polynomial-time algorithm, say, M for DSTCON with n vertices, which operates using at most n 1−c/ √ log n space for a certain fixed constant c > 0.
Let φ be any 2CNF Boolean formula, given as an instance to 2SAT, with n variables and m clauses.Here, we consider only the case where φ contains more than one clause and one variable since, otherwise, the case is trivial.It then follows that |φ| ≤ (m + n) k for a certain constant k > 0. In the case (b) of the proof of Proposition 5.7(1), a directed graph in such a way that making queries of the form (G φ , v, w) to (DSTCON, m ver ) solves (2SAT, m vbl ).The space usage for each oracle query is at most c log |φ| for a certain constant c > 0; thus, this value is further upper-bounded by ck log(m + n).In order to remove the oracle, we further replace "making an oracle query" by "running M on the same query word as an input".The space required for running M is at most Therefore, (2SAT, m vbl ) can be solved in polynomial time using 2 Syntactic NL or SNL Among all natural subclasses of NP, the complexity class SNP has played a special role in capturing many graph-theoretical features of NP problems in terms of second-order predicate sentences [6,18].By taking a different approach, Immerman [9] provided a first-order logical framework to capture L and NL.In a similar spirit, we turn our attention to a syntactically restricted subclass of para-NL defined by syntactic NL sentences or SNL sentences.Each SNL sentence gives rise to a logical framework to a parameterized decision problem.We begin with an introduction of the syntax of our logical system.A vocabulary (an input signature or an input relation) T is a finite set {(S i , k i ), c j , 0, n, suc, pred | i ∈ [d], j ∈ [d ′ ]} of predicate symbols S i of arity k i ≥ 0 (or k i -arity predicate symbol) and constant symbols 0, n, and other specific symbols c j expressing "input objects" (such as particular vertices or edges of a graph and particular sizes of columns and rows of a matrix) of the target mathematical problem for certain constants d, d ′ ∈ N + .We also allow the use of two designated function symbols: the successor function suc(•) and the predecessor function pred(•) whose meanings are suc(i) = i + 1 and pred(i) = max{0, i − 1} for any i ∈ N. We abbreviate suc(suc(i)) as suc 2 (i) and suc(suc 2 (i)) as suc 3 (i), etc.
Here, we use two types of variables.First-order variables, denoted by i, j, . . ., u, v, . .., range over natural numbers and input objects (such as vertices or edges of a graph and entries of a matrix) of the mathematical problem.Second-order variables, denoted by P, Q, . .., range over binary relations whose first argument takes a natural number and the second argument takes an input object.
Atomic formulas have the following forms: S j (u 1 , . . ., u ki ), P (i, v), u = v, and i ≤ j, where i, j, u, v, u 1 , . . ., u ki are terms composed of first-order variables, constant symbols, and function symbols, and P is a second-order variable.In particular, i, j are number-related terms and u, v, u 1 , . . ., u ki are terms composed of all other input objects.Formulas are built inductively from atomic formulas by connecting them with logical connectives (→, ¬, ∨, ∧) and first/second-order quantifiers (∀, ∃).Notice that → and pred are included here for our convenience although they are redundant.
In what follows, we concentrate on the specific case where second-order variables represent "functions".Hence, it is convenient to introduce a variant of the second-order quantifier.We use the special notation ∃ f P [ψ(P )] with a formula ψ containing no second-order quantifiers as a shorthand for ∃P [ψ(P ) ∧ F unc(P )], where F unc(P ) is a unique sentence over a second-order variable P that expresses that P (•, •) works as a "function"; namely, F unc(P ) ≡ F unc 1 (P ) ∧ F unc 2 (P ), where F unc 1 (P ) ≡ ∀i∃w[P (i, w)] and F unc 2 (P ) ≡ ∀i∀u∀v [P (i, u) ∧ P (i, v) → u = v].We particularly call "∃ f " the functional existential quantifier.
} denote a vocabulary.An syntactic NL sentence (or an SNL sentence) over T is a second-order sentence Φ of the form: ψ j (P 1 , . . ., P l , i 1 , . . ., i r , y 1 , . . ., y s , S 1 , . . ., S d , c 1 , . . ., c d ′ )], where l, r, s, t ∈ N, each ψ j , j ∈ [t], is a quantifier-free second-order formula such that no two ψ j 's share any common first-order variables.Here, P 1 , . . ., P l are second-order binary variables representing functions, i 1 , . . ., i r are first-order variables representing natural numbers, and y 1 , . . ., y s are also first-order variables representing all other input objects.Each ψ j should satisfies the following two second-order variable requirements: (i) each ψ j contains only second-order variables of the form P j (i, v 1 ), P j (suc(i), v 2 ), P j (suc 2 (i), v 3 ), . . ., P j (suc a (i), v a+1 ) for a fixed constant a ∈ N + and (ii) ψ j can be rewritten in the logically equivalent form of finite disjunctions (not necessarily in the normal form) satisfying the following condition: there are only at most two disjuncts containing second-order variables and each of them must have the form where R is an appropriate subformula including no second-order variable.
Since second-order variables represent "functions", the second-order variable requirement limits the number of simultaneous accesses to those functions by allowing only inputs of the functions to be taken from a small set {i, suc(i), suc 2 (i), . . ., suc a (i)}.
Next, we explain semantics of SNL sentences Φ.
]}, a relational structure S over T is a set of tuples (U i , D i , k i ) and (c j , V j ) with finite universes U i and V j of "input objects" (including natural numbers) and domains D i associated with predicate symbols S i in T satisfying D i ⊆ U ki i , and constants cj in V j .The constant symbols c j are interpreted as cj and the predicate symbols S i are interpreted as D i in the following way: when objects s1 , s2 , . . ., sk in U i are assigned respectively to variables x 1 , x 2 , . . ., x k , S i (x 1 , x 2 , . . ., x k ) is evaluated to be true (resp., false) iff (s 1 , s2 , . . ., sk ) } serves as a size parameter of the underlying mathematical problem, then it is briefly referred to as a structure size of S.
A relational structure S over T is said to describe (or represent ) an instance x of the target mathematical problem if every input object appearing in x has its associated predicate symbol in T in its universe and domain in S or its associated constant symbol in T in its universe.For example, an instance x = (G, s, t) given to DSTCON with G = (V G , E G ) can be represented by T = {(V, 1), (E, 2), s, t} and , where V G and E G are expressed by predicate symbols V and E, respectively, and s and t are expressed by constant symbols s and t, respectively.Definition 4.6 Let Φ denote an SNL sentence described in Definition 4.4 with variables P 1 , . . ., P l , i 1 , . . ., i r , y 1 , . . ., y s .A domain structure D for Φ is the union of three sets , and {(y j , U ′′ j )} j∈[s] , which provide the scopes of "variables" of Φ in the following manner, where e j and e ′ j are fixed constants in N + .Each second-order variable P j (j ∈ [l]) ranges over [e j ] × U ′ j .Each first-order variable i j (j ∈ [r]) ranges over [e ′ j ] and each variable y j (j ∈ [s]) ranges over U ′′ j .
Since a domain structure D provides sets of input objects, which semantically limit the scopes of quantifiers in a given SNL sentence Φ, we explicitly write such sets inside Φ to clarify the scope of quantifiers.For example, using sets I, U , and U ′ , we write ∃P ⊆ I × U [B(P )] and ∀z ∈ U ′ [B(z)] instead of ∃P [B(P )] and ∀z[B(z)], respectively.
When a relational structure S and a domain structure D are given, it is possible to evaluate the validity of an SNL sentence Φ by interpreting all predicate symbols and all constant symbols of Φ as domains and constants in S by assigning input objects in S and D to variables appropriately.This evaluation makes Φ either "true" or "false".Given a mathematical problem A and an SNL sentence Φ, we say that Φ syntactically expresses A if, for any instance x to A, there are a relational structure S x describing x and a domain structure D x for Φ satisfying the following: x ∈ A iff Φ is true on S x and D x .We denote by para-SNL the collection of all parameterized decision problems (A, m) with log-space size parameters m such that (1) there exist a vocabulary T and an SNL sentence Φ for which Φ syntactically expresses A and (2) for each instance x given to A, m(x) equals the structure size of the corresponding relational structure S x .
Let us present a simple example of para-SNL problem.Here, we consider the parameterized decision problem (DSTCON, m ver ).
Example 4.7 Take an instance x = (G, s, t) given to DSTCON, where G = (V G , E G ), s, t ∈ V G , s is a source, and t is a sink.Let n = m ver (x) = |V G |.For convenience, we expand an s-t path to an extended s-t path by padding extra t's to the tail of the original s-t path to make the obtained sequence have length exactly n.Recall the aforementioned vocabulary T = {(V, 1), (E, 2), s, t} for DSTCON.Let us consider Φ defined as: where three formulas F 0 , F 1 , and F 2 are defined as follows.
The predicate P (i, v) asserts that v is the ith vertex of an extended s-t path of length n.Notice that F 0 , F 1 , and F 2 share no common first-order variables.It is not difficult to see that (DSTCON, m ver ) is syntactically expressed by Φ.Since each quantifier-free formula F i contains only two occurrences of P , the second-order variable requirements are satisfied; thus, Φ is indeed an SNL sentence.Therefore, (DSTCON, m ver ) belongs to para-SNL.
To make a connection to (2SAT 3 , m vbl ), we further introduce an extra requirement imposed on SNL sentences with relational structures and domain structures.
Let us consider the subformula F 2 (P, i, u, w) used in Example 4.7 associated with an instance x = (G, s, t), where G = (V G , E G ) and n = |V G |.It follows that, for each pair (ī, ū) ∈ [n]×V G of input objects, (i) if (ū, w) ∈ E G , then F 2 (P, ī, ū, w) is clearly true but (ii) if (ū, w) / ∈ E G , then F 2 (P, ī, ū, w) is "undefined" (i.e., evaluated to be neither true or false).Moreover, the cardinality of the set { w ∈ V G | F 2 (P, ī, ū, w) is undefined } equals the outdegree of ū.Thus, this set gets larger as n grows.We wish to limit the cardinality of such a set.Definition 4.8 The parameterized complexity class para-SNL ω is composed of all parameterized decision problems (A, m) in para-SNL that enjoys the following extra requirement.Let Φ denote any SNL-sentence of the form given in Definition 4.4 with t quantifier-free subformulas ψ j (P 1 , . . ., P l , i, y, S 1 , . . ., S d , c 1 , . . ., c d ′ ) together with (hidden) sentence F unc(P i ) for all i ∈ [l], where i = (i 1 , . . ., i r ) and y = (y 1 , . . ., y s ).Assume that Φ syntactically expresses A by a certain relational structure S x and a certain domain structure D x associated with each instance x given to A and that m(x) equals a certain structure size of S x .We demand that the sentence ( l h=1 F unc(P h )) must be "expressed" inside Φ with no use of existential quantifiers "∃" in the following sense: ψ j ] is true.Notice that each ψ j must satisfy the second-order variable requirements.
As an example, we demonstrate that a simple variant of (3DSTCON, m ver ) falls in para-SNL ω .This variant is exact3DSTCON, which is obtained by limiting 3DSTCON to only directed graphs in which s is a source, t is a sink, every non-source, non-sink vertex has exactly three edges, and any source (i.e., of indegree 0) has exactly two outgoing edges.It is easy to show that (exact3DSTCON, m ver ) is ≤ sL m -equivalent to (3DSTCON, m ver ).Lemma 4.9 (exact3DSTCON, m ver ) ≡ sL m (3DSTCON, m ver ).
Proof.It is trivial that (exact3DSTCON, m ver ) ≤ sL m (3DSTCON, m ver ).To show the converse reducibility, let x = (G, s, t) be any instance given to 3DSTCON.If s is not a source, then we remove all incoming edges to s.If t is not a sink, then we also remove all outgoing edges from t. Hereafter, we assume that s is a source and t is a sink.In the case where s is adjacent to 3 vertices v 1 , v 2 , and v 3 , we remove all edges from s and then add a new vertex v s and new edges (s, v S ), (s, v 1 ), (v s , v 2 ), (v s , v 3 ).For the other vertices of G, we inductively choose them one by one.For each v, we add a new vertex v ′ and an edge (v, v ′ ) (resp., two new vertices v ′ , v ′′ and two edges (v, v ′ ), (v, v ′′ )) if v has degree 2 (resp., indegree 0 and outdegree 1).The added vertices are sinks of indegree 1.The resulting graph is clearly an instance of exact3DSTCON.✷ Let us demonstrate that (exact3DSTCON, m ver ) is actually in para-SNL ω .
Example 4.10 Let us consider an instance x = (G, s, t) with G = (V G , E G ) given to exact3DSTCON.We assume that G satisfies the aforementioned requirement of 3DSTCON.To express this x, we intend to define a second-order sentence Ψ as: where F 0 and F 1 are the same as in Example 4.7, and F ′ 2 , F ′ 3 , and F ′ 4 are defined in the following fashion.1.
, and F ′ 4 share no common first-order variables and that Ψ satisfies the secondorder variable requirements.
As a key statement concerning para-SNL ω , we exhibit the hardness of (2SAT 3 , m vbl ) for para-SNL ω under short SLRF-T-reductions.Let (A, m) ∈ para-SNL ω and take a vocabulary We assume that A is syntactically expressed by an SNL sentence Φ of the form ψ j over T , as in Definition 4.4, where each ψ j is a quantifier-free subformula composed of free variables P 1 , . . ., P l , i 1 , . . ., i r , y 1 , . . ., y s , the constant symbols c 1 , c 2 , . . ., c d ′ , and the predicate symbols S 1 , . . ., S d .By the second-order variable requirements, there are at most a + 1 variables P k 's in each ψ j .For simplicity, we convert all occurrences of the logical connective "implication" (→) into combinations of {∧, ∨} and negation of literals.We further assume that negation (¬) appears only in front of those predicates by rewriting ψ j using De Morgan's laws.For convenience, let ı = (i 1 , i 2 , . . ., i r ) and y = (y 1 , y 2 , . . ., y s ).
Let x be any instance given to A.
} denote a relational structure over T , representing this particular instance x.By the choice of S x , there is a structure size of S x , which is equal to the value m(x).Corresponding to x, we further take a domain structure D x for Φ.By the definition of para-SNL ω , there is a constant γ ≥ 1 that satisfies Definition 4.8.
We conduct the following transformation of Φ using S x and D x .We arbitrarily fix an index j ∈ [t].Notice that ψ j is a Boolean combination of predicates of the following forms: S k (t , respectively, provided by D x .We assign those values to the corresponding variable symbols and write the resulting formula as ψ j (ī, ȳ).We first replace P k ( t1 , t2 ) in ψ j (ī, ȳ) by a new free variable symbol z k, t1, t2 , where t1 and t2 are values obtained from t 1 and t 2 by assigning values in (ī, ȳ) to all variable symbols, respectively.Next, we determine the validity of each predicate S k (ī ′ , ȳ′ ) in ψ j (ī, ȳ) by checking whether (ī ′ , ȳ′ ) ∈ D k and we then replace S k (ī ′ , ȳ′ ) by either True (1) or False (0) according to its evaluation result, where ī′ and ȳ′ are appropriate subsequences of ī and ȳ, respectively.Similarly, other formulas of the forms t ′ 1 = t ′ 2 and s ′ 1 ≤ s ′ 2 are evaluated to be either True or False.We write the obtained formula as ψ ′ j (ī, ȳ).If ψ ′ j (ī, ȳ) is either true or false independent of the unknown values of all the introduced variables z k, t1, t2 , then we replace this formula by True or False, respectively.Let us denote by ψ ′′ j (ī, ȳ) the resulting formula and move to the next choice.We then obtain the conjunction of all subformulas ψ ′′ j (ī, ȳ) over all values (ī, ȳ) We write this conjunction as ψ j,conj .Finally, we convert ψ j,conj to an equivalent 2CNF formula, say, ψj,conj .
Since each disjunct in ψj,conj that contains P k 's has the form Each variable z k, t1, t2 appears in only subformulas that are "undefined" by the variable assignment, and thus it appears at most a constant number of times in ψj,conj in the form of literals.The final 2CNF formula is t j=1 ψj,conj .Since there are t 2CNF formulas ψ1,conj , . . ., ψt,conj , the total number of times that each new variable appears as literals in the entire conjunction t j=1 ψj,conj is upper-bounded by a certain fixed constant, say, k * .Since the aforementioned transformation can be done by a DTM using only log space, this DTM serves as a Turing reduction from (A, m) to (2SAT k * , m vbl ).By Lemma 4. Since LSH for 2SAT 3 leads to, e.g., L = NL as shown above, this working hypothesis is expected to lead to finer, better consequences than what the assumption L = NL can lead to.Although the working hypothesis LSH concerns with 2SAT 3 , it may possibly carry over to 2SAT.However, it is not clear that LSH for 2SAT 3 is logically equivalent to LSH for 2SAT.
Lemma 5.3 Assuming that LSH for 2SAT 3 is true, the following two statements hold. Proof.
(1) Assume that ≤ sSLRF Proof.Assume the working hypothesis LSH for 2SAT 3 .To make our argument simple, we set Σ = {0, 1} and m A (x) = m B (x) = |x| as the standard size parameter (i.e., binary bit length) ||.For convenience, we further introduce the notation DTIME,SPACE(t(n), s(n)) to denote the collection of all "languages" recognized deterministically in time O(t(n)) using space O(s(n)).Given an oracle Turing machine M and a language A, we write L(M, A) for the family of all languages recognized by M using A as an oracle.
The following argument is inspired by Ladner's in [16].Consider all reduction machines M satisfying that M O runs in time at most |x| k using space at most |x| and queries only words of length at most k|x| + k for any input x and any oracle O, where k is a fixed positive constant.We enumerate them effectively as {(M 1 , k 1 ), (M 2 , k 2 ), . ..} so that, given an index i ∈ N + , we can generate an appropriately defined code of M n and k n in polynomial time using O(log n) space.
Since every NL problem can be solved deterministically in polynomial time, we prepare a DTM M 2SAT that recognizes 2SAT 3 in polynomial time.In what follows, we will construct S A and S B stage by stage to satisfy the following two requirements for each index i ∈ N + : (i) R A,i : A = L(M i , B) and (ii) R B,i : B = L(M i , A).For this purpose, we inductively construct a series {(S A,j , S B,j )} j∈N and then define A j = 2SAT 3 ∩ S A,j and B j = 2SAT 3 ∩ S B,j for any j ∈ N. In the end, we set S A = j∈N S A,j and S B = j∈N S B,j .Initially, we define n 0 = 0 and S A,0 = S B,0 = ∅.
(1) Firstly, we concentrate on Stage 2i + 1 (i ≥ 0).Assume that n 2i , S A,2i , and S B,2i have been already defined.Notice that A 2i and B 2i are both finite sets.We define C 2i+1 to be L(M i , B 2i ) ∩ Σ >n2i .We then assert that (C 2i+1 △2SAT 3 ) ∩ Σ >n2i is an infinite set.Assuming otherwise, we now want to lead to the conclusion of 2SAT 3 ∈ PsubLIN.Since C 2i+1 △2SAT 3 is finite in Σ >n2i and Σ ≤n2i is also a finite set, we conclude that C 2i+1 △2SAT 3 is finite.This makes it possible to recognize 2SAT 3 by computing C 2i+1 .By running M i with the oracle B 2i to compute C 2i+1 , we can short SLRF-T-reduce (2SAT 3 , m vbl ) to (B 2i , ||).Since B 2i is finite, it thus follows that 2SAT 3 ∈ PsubLIN.This is a clear contradiction against our assumption of LSH for 2SAT 3 .As a consequence, there must be infinitely many strings z in (C 2i+1 △2SAT 3 )∩ Σ >n2i .Among those strings, we choose the lexicographically first string z 0 .We choose n 2i+1 (which will be determined later) to satisfy that 2i+1 .The former requirement implies that M B2i i (z 0 ) does not make any queries of length more than n 2i+1 .Let S B,2i+1 = S B,2i and From S A,2i+1 and S B,2i+1 , we obtain A 2i+1 and B 2i+1 .We then claim that ) as well.By the choice of z 0 , it therefore follows that z 0 ∈ A△L(M i , B).This makes the requirement R A,i satisfied.
(2) At Stage 2i (i ≥ 1), in contrast, we define Similarly to (1), we can show that (C 2i △2SAT 3 ) ∩ Σ >n2i−1 is infinite.We then take the lexicographically first string z 1 in (C 2i △2SAT 3 ) ∩ Σ >n2i−1 .Choose n 2i (which will be defined later) so that Obviously, we obtain z 1 ∈ S B,2i .A similar argument to (1) proves that z 1 ∈ B 2i △L(M i , A 2i ).This further leads to z 1 ∈ B△L(M i , A), which makes the requirement R B,i satisfied. ( it suffices to discuss how to compute the set {n j } j∈N of numbers. To determine the value n i , let us consider the following procedure N .On input λ, sequentially determine n 0 , n 1 , n 2 , . . .by stages in the following manner.We implement an internal counter to count the number of steps taken to execute the following procedure.Assume that, at Stage 2i, the number n 2i is already constructed (in unary) on a work tape.At Stage 2i + 1, we try to find the lexicographically first string z 0 ∈ Σ >n2i for which z 0 ∈ L(M i , B 2i )△2SAT 3 .This can be done as follows.Remember that M i may possibly produce query words w of length more than |z| on a query tape.However, since we require only the information on the length of w, we do not need to write down w on any work tape.We lexicographically choose strings z of length more than n 2i one by one and write z on a work tape.We run M B2i i on z.Note that we can easily determine oracle answers of B 2i by firstly checking the length of each query word w and comparing it with {n j } j≤2i−1 without making actual queries to any oracle.We then run M 2SAT on z.We check if either (i) M B2i i accepts z and M 2SAT rejects z or (ii) M B2i i rejects z and M 2SAT accepts z.If this is the case, then we set this z to be z 0 and additionally "idle" for |z 0 | 2 steps.Otherwise, we continue choosing the next string z.As shown above, z 0 belongs to A 2i+1 △L(M i , B 2i+1 ).Now, using the counter, we define n 2i+1 to be the number of steps needed to obtain z 0 and idle for |z 0 | 2 steps.Up to this point, we need only work space at most |z 0 |, which is upper-bounded by √ n 2i+1 because of the extra idling steps.In a similar way, we assume that, at Stage 2i − 1, n 2i−1 is already constructed.At Stage 2i, we find the lexicographically first string z 1 ∈ Σ >n2i−1 satisfying that z 1 ∈ L(M i , A 2i−1 )△2SAT 3 .This implies that z 1 ∈ B 2i △L(M i , A 2i ).We set n 2i to be the number of steps needed to obtain z 1 and idle for |z 1 | 2 steps.
We define a machine N A for S A by partly simulating N as follows.We equip N A with an internal counter to count the number of simulation steps of N .On input x, compute |x| and simulate N on λ within |x| steps.If n j is constructed within |x| steps and n j < |x|, then we continue the simulation of N .If the counter reaches |x| while constructing n j , then we stop the simulation.This number j is an odd number, then accept x or else reject x.Since N A runs in time O(|x|) using space O( |x|), it thus follows that S A ∈ DTIME,SPACE(n, √ n).Similarly, we define N B by changing "odd number" to "even number".By the definition of N B , we obtain S B ∈ DTIME,SPACE(n, √ n) as well.✷

Alternative Characterizations of LSH
Let us rephrase the working hypothesis LSH for 2SAT 3 in a slightly different way.We define δ(2SAT 3 ) to express the infimum of a real number ε ∈ [0, 1] for which there exist a polynomial p, a polylog function ℓ, and a DTM solving 2SAT 3 simultaneously within time p(m vbl (x)) and at most m vbl (x) ε ℓ(|x|) space on all instances x.If we abbreviate δ(2SAT 3 ) as δ 3 , then there are three possible cases: (i) and (iii) δ 3 = 1.Clearly, exactly one of them must be true.The space bound of n/2 O( √ log n) in Theorem 4.3 for 2SAT leads to a conclusion of 0 ≤ δ 3 ≤ 1, but the bound is not strong enough to imply δ 3 < 1. Proposition 5.5, nonetheless, asserts that the hypothesis LSH for 2SAT 3 exactly matches (iii).
(Only If-part) On the contrary, we assume that δ 3 < 1.This means that, for any constant ε ∈ (δ 3 , 1), there exists a DTM that solves 2SAT 3 in time polynomial in m vbl (x) using m vbl (x) ε ℓ(|x|) space on all instances x for a certain polylog function ℓ(•).Since ε < 1, it is clear that this statement contradicts LSH for 2SAT 3 .✷ In the rest of this subsection, we wish to seek two more characterizations of the working hypothesis LSH for 2SAT 3 .For this purpose, we choose two specific NL decision problems parameterized by appropriately chosen size parameters.The first problem is a variant of a well-known NP-complete problem, called the {0, 1}-linear programming problem (LP 2 ).Hereafter, a vector of dimension n means an n × 1 matrix and a rational number is treated as a pair of appropriate integers.For two vectors x and y of dimension n, the notation x ≥ y expresses that, for any index i ∈ [n], the ith entry of x is at least the ith entry of y.Fix k ∈ N + arbitrarily.
(2,k)-Entry {0, 1}-Linear Programming Problem (LP 2,k ): Instance: a rational m n matrix A and a rational vector b of dimension n, where m, n ∈ N + and each row of A has at most two nonzero entries and each column of A has at most k non-zero entries.
We implicitly assume that every entry value of A and b is expressed as an O(log mn)-bit string.As natural size parameters, for each instance x = (A, b) given to LP 2,k , we take the number n of columns and the number m of rows of A and express them as m col (x) and m row (x), respectively.
Another NL decision problem to consider is a variant of DSTCON, discussed in Section 4.1, concerning a path between two particular vertices in a given directed graph.
Degree-k Directed s-t Connectivity Problem (kDSTCON): • Instance: a directed graph G whose vertices have degree (i.e., indegree plus outdegree) at most k, and two designated vertices s and t in G. • Question: is there any path from s to t (called an s-t-path) of G?
For any instance x = (G, s, t) given to kDSTCON, m ver (x) and m edg (x) respectively denote the number of vertices and that of edges in G. Obviously, m ver (x) + m edg (x) ≤ |x|, where |x| denotes the length of a binary encoding of x.
Theorem 5.6 provides two alternative definitions of LSH in terms of LP 2,3 and 3DSTCON.
Theorem 5. 6 The following statements are logically equivalent.This theorem allows us to use LP 2,3 and 3DSTCON for LSH as ideal substitutes for 2SAT 3 .Moreover, the choice of two size parameters in each case turns out to be irrelevant.
In what follows, we want to prove Theorem 5.6.To prove this theorem, we need two supporting assertions, Propositions 5.7 and 5.8.Notice that these propositions actually assert the results, which are slightly more general than what we truly need for the proof of Theorem 5.6.-reductions (and thus ≤ sL m -reductions) by Lemma 3.4(2).However, this contradicts our assumption.Therefore, we reach the conclusion that (LP 2,3 , m col ) / ∈ PsubLIN.The above argument for (LP 2,3 , m col ) works also for (LP 2,3 , m row ).
It is possible to show (2 ⇒ 1) by a similar argument used for (1 ⇒ 2).The remaining case for 3DSTCON is similarly treated using Lemma 5.7 (2).✷ To complete the proof of Theorem 5.6, it still remains to prove Propositions 5.7 and 5.8.For the proof of Proposition 5.7, we need the following observation (Lemma 5.9) that, unlike kSAT with k ≥ 3, any formula in 2SAT can be characterized purely by its clause structure.A similar observation was made in the proof of [15,Theorem 4].
To describe Lemma 5.9, let us recall the notion of exact 2CNF formula from the proof of Proposition 4.1.It is important to remark that any clause of an exact 2CNF formula must have "distinct" literals.When an exact 2CNF formula φ is given as an instance, we introduce its corresponding directed graph G φ = (V φ , E φ ) as follows.Let V φ be the set of all literals of variables in φ and let For two vertices u, v ∈ V φ , the notation u ❀ v expresses that there is a path in G φ from u to v. Lemma 5.9 An exact 2CNF formula φ is unsatisfiable iff either one of the following two cases holds: (1) there is a vertex v ∈ V φ such that v ❀ v and v ❀ v in G φ or (2) there are two distinct vertices w 1 , w 2 ∈ V φ such that w 1 ❀ w 1 , w 1 ❀ w 2 , and w 2 ❀ w 2 in G φ .These paths in (1) and ( 2) are called contradictory chains of φ.
For completeness, we include the proof of Lemma 5.9.For a directed graph G, its underlying undirected graph is obtained directly from G by replacing all directed edges of G with their corresponding undirected edges.
Proof of Lemma 5.9.(If-part) Let φ be any exact 2CNF formula and take the corresponding directed graph G φ = (V φ , E φ ).Assume the existence of a contradictory chain (x 1 , x 2 , . . ., x k ) of φ that satisfies either Condition (1) or (2) stated in the lemma.Toward a contradiction, we further assume that φ is satisfiable.Let us take a variable assignment σ that makes φ true.For each index i ∈ [k − 1], since (x i , x i+1 ) ∈ E, the corresponding clause of φ must have the form either x i ∨ x i+1 or x i+1 ∨ x i .Therefore, it follows that σ(x i ) = 1 implies σ(x i+1 ) = 1.From this, we conclude that (*) for any i, j ∈ [k] with i < j, if σ(x i ) = 1 then σ(x j ) = 1.
(Only If-part) Assume that an exact 2CNF formula φ is unsatisfiable.Consider the directed graph G φ associated with φ.Group together all clauses in φ (by appropriately changing the order of the clauses) into disjoint 2CNF subformulas φ 1 , φ 2 , . . ., φ k so that the underlying undirected graphs of their corresponding graphs G φ1 , G φ2 , . . ., G φ k are connected components of the underlying undirected graph of G φ .Assuming that Condition (1) does not hold, we want to verify that Condition (2) is true.
Let us define a new variable assignment σ of φ by choosing an index r sequentially from [k] and then defining the value of σ for all variables of the subformula φ r .Assume that φ r has the form nr i=1 (x i ∨ x i+1 ) for certain literals x 1 , x 2 , . . ., x nr +1 with n r ∈ N. Recall that each clause x i ∨ x i+1 (or x i+1 ∨ x i ) of φ is translated into two edges (x i , x i+1 ) and (x i+1 , x i ) of G. Naturally, φ r introduces a path y in G φr .We assume that y contains no cycle whose elements are all distinct variables by ignoring negations (i.e., by identifying x and x as the same "variable"), because, if there is a cycle (x i1 , . . ., x im ) with x i1 = x im for which all variables x ij are mutually distinct by ignoring negations, then we can remove this cycle from G φr with preserving the unsatisfiability of φ r .Let y = (x 1 , x 2 , . . ., x e ) for a certain constant e ≥ 1.
Initially, we set σ(x 1 ) = 0, and thus we obtain σ(x 1 ) = 1.Sequentially, we pick i from [e] one by one and concentrate on an edge i , x i+1 ).If x i+1 coincides with x c (or x c ) for a certain index c < i + 1, then the value σ(x i+1 ) must be already defined.In contrast, if σ has not yet assigned any value to x i+1 (as well as x i+1 ), then we newly set σ(x i+1 ) = 0, and thus σ(x i+1 ) = 1 follows.In the case where σ(x i ) = 0 for all i ∈ [e], since σ(φ r ) becomes 1, we move to the next index r.Since φ is unsatisfiable, eventually we find r and i for which x i appears inside φ r and σ(x i ) = 0.Among those x i 's, we choose the smallest index i forcing σ(x i ) to be 1.This means that σ(x i ) must have been defined earlier in our construction, and thus x i coincides with a certain literal x c with c < i.Since Condition (1) is false, no x j (i < j ≤ e) coincides with x c .For any j (i < j ≤ e), if σ(x j ) has not been defined, then we set σ(x j ) = 1.If σ(x j ) = 1 for all j ∈ [i − 1, e] Z , then we obtain σ(φ r ) = 1.Since φ is unsatisfiable, there is an index d (i < d ≤ e) for which σ(x d ) = 0; namely, x d coincides with x a for a with 1 ≤ a < d.Since σ(x a ) = 1, i ≤ a < d follows.This implies Condition (2) by setting w 1 = x c and w 2 = x a .
✷ Now, we return to Proposition 5.7 and describe its proof.Given a Boolean formula φ, the notation |φ| expresses the size of φ when φ is expressed in binary by an appropriate encoding scheme.For the proof that follows below, we need to convert each 2CNF formula into its logically equivalent exact 2CNF formula.Such a conversion has been described in the proof of Proposition 4.1.The resulting formula is succinctly referred to as the exact 2CNF version of the original 2CNF formula.
A literal is called negative if it is the negation of a certain variable.Otherwise, it is called positive.
Proof of Proposition 5.7.
(1) Here, we will describe the proof of the first statement of the proposition by splitting the proof into the following two parts (i) and (ii).(i) We first wish to prove (DSTCON, m ver ) ≤ sL T (2SAT, m vbl ) and (DSTCON, m edg ) ≤ sL T (2SAT, m cls ).Given an instance x = (G, s, t) with G = (V, E) of DSTCON, without loss of generality, we assume that s is a unique source (i.e., of indegree 0) and t is a sink (i.e., of outdegree 0) because this assumption can be achieved by modifying the original graph G to another graph From the instance x = (G, s, t), we define a new Boolean formula φ x as follows.All vertices in G are treated as "variables" in φ x .We prepare two fresh variables z s and z t and set φ x as (s ∨ z s ) ∧ (s ∨ z s ) ∧ ( (v,w)∈E (v ∨ w)) ∧ (t ∨ z t ) ∧ (t ∨ z t ).Clearly, φ x is an exact 2CNF formula.It also follows that m cls (φ x ) = |E| + 4 ≤ 4m edg (x) and m vbl (φ x ) = |V | + 2 ≤ 2m ver (x).Here, we intend to claim: Assuming that Claim (*) is true, we define M to be a deterministic oracle Turing machine that takes x as an input and queries (the encoding of) φ x to 2SAT, which is used as an oracle.If the oracle answers "no", then M accepts x; otherwise, M rejects it.By Claim (*), M turns out to be a short reduction witnessing (DSTCON, m ver ) ≤ sL T (2SAT, m vbl ) as well as (DSTCON, m edg ) ≤ sL T (2SAT, m cls ).In what follows, we want to verify Claim (*).Let us assume that φ x is unsatisfiable and consider the directed graph G φx = (V φx , E φx ) induced from φ x .Although G φx may not be the same as G, it follows that (i) for any vertices u, w ∈ V , (u, w) ∈ E φx (or (w, u) ∈ E φx ) iff (u, w) ∈ E and (ii) for any u ∈ V and w ∈ V φx − {z s , z t }, (u, w) ∈ E φx (or (u, w) ∈ E φx ) implies w ∈ V .Lemma 5.9 then yields a contradictory chain (x 1 , x 2 , . . ., x k ) of φ x in G φx .Notice by the definition of G φx that the "anti-chain" (x k , x k−1 , . . ., x 1 ) is also a contradictory chain of φ x in G φx .For convenience, we take the shortest contradictory chain y = (x 1 , x 2 , . . ., x k ).Here, we assert that this chain y has the form (s, z ′ s , s, x 4 , . . ., x k−3 , t, z ′ t , t) with positive literals x 3 , . . ., x k−3 or its anti-chain, where z ′ s ∈ {z s , z s } and z ′ t ∈ {z t , z t }.(a) Consider the case where y is of the form v 1 ❀ v 1 ❀ v 1 with v 1 is a positive literal.There must be a transition point in the subpath v 1 ❀ v 1 from a negative literal x i to a positive literal x i+1 .By the definition of φ x , we can conclude that either (x i , x i+1 ) = (z s , s) or (x i , x i+1 ) = (s, z s ).In the former case, since z s cannot be v 1 , i > 1 and x i−1 = s follow.In a similar way, a transition point on the subpath v 1 ❀ v 1 from a positive literal x j to a negative literal x j+1 leads to the conclusion that either (x j , x j+1 ) = (z t , t) or (x j , x j+1 ) = (t, z t ).In the former case, we obtain j > 1 and x j−1 = t.As a consequence, y has a subpath of the form (s, z ′ s , s, x i ′ , . . ., x j ′ , t, z ′ t , t) for appropriate i ′ and j ′ .(b) Consider the next case where y is of the form w 1 ❀ w 1 ❀ w 2 ❀ w 2 with positive literal w 1 .An argument similar to (a) shows the existence of an index i in the subpath w 1 ❀ w 1 satisfying either • Instance: a 1nfa M = (Q, Σ, δ, q 0 , F ) with no λ-moves, and a parameter 1 n .
• Solution: an input string x of length n accepted by M .
As a meaningful size parameter m nf a , we set m nf a (x) to be |Q||Σ|n for any given instance x = (M, 1 n ).Note that m nf a is almost non-zero and polynomially bounded.Theorem 6.1 Assuming that LSH for 2SAT 3 , for every fixed value ε ∈ (0, 1/2], there is no |x| O(1) -time O(m nf a (x) 1/2−ε )-space algorithm for Search-1NFA on all instances x.

Proof.
Toward a contradiction, we assume that Search-1NFA is solvable by a certain DTM M in time polynomial in |y| using space at most cm nf a (y) 1/2−ε on all instances y, where c and ε are positive constants.Our aim is to show that (3DSTCON, m ver ) can be solved in polynomial time using sub-linear space, because this contradicts LSH for 3DSTCON, which is equivalent to LSH for 2SAT 3 by Theorem 5.6.
Let x = (G, s, t) be any instance given to 3DSTCON with G = (V, E) and s, t ∈ V .Assume that s = t since the case of s = t is trivial.Let n = m ver (x).Associated with this x, we want to define a non-λ-move 1nfa N = (Q, Σ, δ, q 0 , F ). Firstly, we set Q = V and Σ = [3], and define q 0 = s and F = {t}.For each vertex v ∈ V , let us consider its neighbor out(v) = {w ∈ V | (v, w) ∈ E}.We assume that all elements in out(v) are enumerated in a fixed linear order as out(v) = {w 1 , w 2 , . . ., w kv } with 0 ≤ k v ≤ 3, where k v = 0 means out(v) = ∅.The transition function δ is defined for such v and for any ∈ Σ as δ(v, i) Suppose that γ is a path from s to t in G and let γ , . . ., w kv i }, and we then define z to be the string ℓ(v 1 )ℓ(v 2 ) • • • ℓ(v d−1 )0 n−d+1 of length n.When N reads this string z, it eventually enters v d , which is a final state, and therefore N accepts z.On the contrary, in the case where there is no s-t path in G, N never accepts any input.Therefore, it follows that (*) G has an s-t path iff N accepts z.
Finally, we set y = (N, 1 n ) as the desired instance to Search-1NFA parameterized by m nf a .Note that m nf a (y) = |Q||Σ|n ≤ 3|V | 2 = 3m ver (z) 2 .By Statement (*), 3DSTCON is solvable by running M on y in polynomial time; moreover, the space required for this computation is upper-bounded by cm nf a (y) 1/2−ε ≤ 2cm ver (x) 1−2ε , which is obviously sub-linear because of ε > 0. ✷ In 1995, Jenner [13] presented a few variants of the well-known {0, 1}-knapsack problem and showed the NL-completeness of these variants.Here, we choose one of them, which fits into the NL-search framework by a small modification.Given a string x, its substring z is said to be unique in x if there exists exactly one pair (u, v) satisfying x = uzv.It is easy to check, for given strings x and z, whether or not z is a unique substring of x.

Unique Ordered Concatenation Knapsack Search Problem (Search-UOCK):
• Instance: a string w and a sequence (w 1 , w 2 , . . ., w n ) of strings over a certain fixed alphabet Σ such that, for every index i ∈ [n], if w i is a substring of w, then w i is unique.
It is convenient to assume that (w 1 , w 2 , . . ., w n ) is given in the form w 1 #w 2 # • • • #w n #, where # is a distinguished separator symbol not in Σ.Our reasonable choice of size parameter m elm for Search-UOCK is the number of all the elements w 1 , w 2 , . . ., w n in the above definition (namely, m elm (x) = n for each instance x).Obviously, m elm is a log-space size parameter.Theorem 6.2 If LSH for 2SAT 3 holds, then, for any ε > 0, there is no |x| O(1) -time O(m elm (x) 1/2−ε )-space algorithm for Search-UOCK working on all instances x.

Proof.
Notice that m elm is polynomially bounded and m elm (x) > 0 for any valid instance x given to Search-UOCK.Let us thus assume that there are two constants ε, c > 0, a polynomial p, and a p(|x|)-time cm elm (x) 1/2−ε -space algorithm A solving Search-UOCK on all instances x.We will use this algorithm A to solve (3DSTCON, m ver ) in polynomial time using sub-linear space because this obviously contradicts LSH for 3DSTCON, which implies LSH for 2SAT 3 by Theorem 5.6(3).
Let x = (G, s, t) denote any instance given to 3DSTCON with G = (V, E).Note that |E| ≤ 3|V |.For simplicity of our argument, without loss of generality, let V = {1, 2, . . ., n}, s = 1, and t = n.Now, we define i, j = (i − 1)n + j for each pair i, j ∈ [n].Firstly, we modify G into another directed graph Moreover, we set s ′ = 1, s and t ′ = n, t .This new graph G ′ satisfies the following property, called the topological order : for any pair i, j ∈ V ′ , (i, j) ∈ E ′ implies i < j.
Consider the triplet (G ′ , s ′ , t ′ ), which is also an instance of 3DSTCON.From this instance, we define w = bin(1)#bin(2)# • • • #bin(n)#, where bin(i) indicates the binary representation of a natural number i and # is a designated separator not in {0, 1}.For each edge (i, j) ∈ E ′ , we further define w ij = bin(i + 1)#bin(i + 2)# • • • #bin(j)#.It follows by the definition that, for each (i, j), if w ij is a substring of w, then w ij must be unique in w.Clearly, the sequence z x = (w, w ij ) (i,j)∈E ′ is an instance of Search-UOCK satisfying that m elm (z x ) = |E ′ | ≤ 3n 2 = 3m ver (x) 2 .
Given any instance x, we can solve (3DSTCON, m edg ) by running A on the corresponding input z x in time polynomial in |x| using space at most cm elm (z) 1/2−ε , which is upper-bounded by 3cm ver (x) 1−2ε .Therefore, we conclude that (3DSTCON, m edg ) ∈ PsubLIN, as requested.✷

Nonapproximability of NL Optimization Problems
The next practical application of the working hypothesis LSH for 2SAT 3 targets the area of combinatorial NL optimization.We will briefly explain several key concepts of NL optimization problems.Refer to [23,24] for the precise definitions of these concepts.An NL optimization problem (or an NLO problem, for short) P is a quadruple (I, SOL, mes, goal), where I is a set of (admissible) instances in L, SOL(x) is a set of solutions for each x ∈ I with the set I • SOL = {(x, y) | x ∈ I, y ∈ SOL(x)} from auxL, mes is a function in auxFL mapping I • SOL to N + , and goal is in {max, min}.Let NLO stand for the class of all NLO problems.An optimal solution y for instance x of P must satisfy mes(x, y) = mes * (x), where mes * (x) = goal y∈SOL(x) {mes(x, y)}.The performance ratio R of a solution y of P for x is defined as R(x, y) = max{ mes * (x) mes(x,y) , mes(x,y) mes * (x) }.We say that an NLO problem P is solvable in log space if there is a DTM that takes any instance x ∈ I and outputs an optimal solution in SOL(x) using space O(log |x|).We write LO NLO (log-space computable NL optimization) to denote the class of all NLO problems solvable in log space.
We are focused on a problem that does not seem to be solvable using log space but can be approximated using log space.A log-space approximation scheme for an NLO problem P is a DTM M that takes any input of the form (x, k) and outputs a solution y of P for x using space at most f (k) log |x| for a certain log-space computable function f : N → N for which the performance ratio R satisfies R(x, y) ≤ 1 + 1 k .Such a solution y is called a (1 + 1 k )-approximate solution.The notation LSAS NLO denotes the class of all NLO problems that have log-space approximation schemes.It then follows that LO NLO ⊆ LSAS NLO ⊆ NLO.
In 2007, Tantau [23] presented an NL maximization problem, called Max-HPP, which falls into LSAS NLO .This problem was later rephrased in [25] in terms of complete graphs and it was shown to be computationally hard for LO NLO under approximation-preserving exact NC 1 -reduction.
For an n × n matrix A and two indices i, j ∈ [n], we write A ij to denote the (i, j)-entry of A. • Measure: the total weight w(S) = d−1 j=1 A ij ij+1 .We use the total number n of columns of a given matrix A as our desirable size parameter m col (A, d, i 1 ).In what follows, we show that, under the assumption of LSH for 2SAT 3 , (Max-HPP, m col ) cannot have polynomial-time O(k 1/3 log m col (x))-space approximation schemes of finding (1 + 1 k )-approximate solutions for instances x.Theorem 6.3 If LSH for 2SAT 3 is true, then there is no |x| O(1) -time O(k 1/3 log m col (x))-space algorithm that, on all instances (x, k), finds (1 + 1 k )-approximate solutions of Max-HPP for x.To prove this theorem, we give a useful supporting lemma.Let g : N → N be any function.An optimization problem (I, SOL, mes, goal) parameterized by m is said to be g(m(x))-bounded if mes(x, y) ≤ g(m(x)) holds for any (x, y) ∈ I • SOL.called unary 1nfa's and unary 1dfa's.It is easy to show that each unary 1nfa M can be converted into a unary 1dfa M ′ that accepts the same input as the original 1nfa does.We call such a unary 1dfa an equivalent 1dfa.More precisely, for any given n-state unary 1nfa, there is always an equivalent unary 1dfa of O(n log n) states.A standard procedure of such transformation requires polynomial-time and O(n) space (cf.[8]).We quickly review this transformation procedure.Lemma 6.5 For any given n-state unary 1nfa, there is always an equivalent unary 1dfa of O(n log n) states.

Maximum
Proof.Given an n-state unary 1nfa N , we first transform it to an equivalent 1nfa N ′ with no λ-moves (or λ-transitions).The number of states required for this new 1nfa is O(n log n).Write ñ for this number and let N ′ = (Q, {0}, {⊳}, δ, q 0 , F ) with Q = {q i | i ∈ [0, ñ − 1] Z }.Starting with this N ′ , we wish to construct the desired unary 1dfa M = (Q ′ , {0}, {⊳}, δ ′ , p 0 , F ′ ).The elements of Q ′ are inductively defined as follows.Let p 0 = {q 0 }.For each index i ∈ [ñ − 2], we assume by induction hypothesis that p i = {q j1 , q j2 , . . ., q jt } with t ≤ ñ has been already defined.We then define p i+1 = k∈[t] δ(q j k , 0) and set δ ′ (p i , 0) = p i+1 .When p i+1 contains an element in F , we place p i+1 into F ′ .We stop this construction procedure as long as either p i+1 becomes empty or i + 1 becomes ñ − 1.For such i, we additionally set δ ′ (p i , 0) = p i .Clearly, this new machine M is deterministic and uses at most ñ states.Moreover, it follows that M accepts (resp., rejects) x iff N ′ accepts (resp., rejects) x. ✷ The transformation algorithm described in the above proof requires O(n log n) space.Under LSH for 2SAT 3 , nonetheless, we can demonstrate that this space bound cannot be made significantly smaller.Theorem 6.6 If LSH for 2SAT 3 is true, then, for any constant ε ∈ [0, 1), there is no polynomial-time O(n ε )-space algorithm that takes an n-state unary 1nfa as input and produces an equivalent unary 1dfa of O(n log n) states.
Proof.We assume that the existence of a constant ε ∈ [0, 1) and a polynomial-time an ε -space algorithm A that generates from an n-state unary 1nfa an equivalent 1dfa of at most cn log n + c states, where a and c are appropriate positive constants.The size of A's output may be assumed to be upper-bounded by a ′ n e + a ′ for certain constants a ′ , e > 0. To lead to a contradiction, we want to solve (3DSTCON, m ver ) in polynomial time using sub-linear space since this yields a contradiction against LSH for 3DSTCON, and thus against LSH 2SAT 3 by Theorem 5.6.
Next, we run A to construct from N an equivalent unary 1dfa M of, say, m states, where m ≤ cn log n+c.Note that each inner state of M is expressed by a certain string stored in A's tape cells.Thus, to handle each inner state, we need to remember only the starting and ending cells that contain the string describing this inner state.We generate z = 0 ⌈cn log n+c⌉+1 and then simulate M on the input z within a ′ n e + a ′ time using O(log (a ′ n e + a ′ )) (= O(log n)) space.If M accepts z, then we accept x; otherwise, we reject x.Since |z| ≥ |Q| and M is an equivalent machine, we accept x exactly when there exists an s-t path in G.The work space required to execute this procedure is at most an ε + c ′ log n, which is further upper-bounded by c ′′ m ver (x) ε for suitable constants c ′ , c ′′ > 0.
Hence, we can solve (3DSTCON, m ver ) in polynomial time using sub-linear space, as requested.✷

A Brief Discussion and Future Challenges
The standard theory of time complexity has been concentrated on the kCNF Boolean formula satisfiability problem (kSAT) for indices k ≥ 3; however, it has paid little attention to 2SAT because 2SAT is considered as a tractable problem (i.e., a polynomial-time solvable problem).To fill the void in the study of 2SAT, this paper is particularly focused on the space complexity of 2SAT, while runtime is still limited to polynomials.We have demonstrated in Theorem 4.3 that a good polynomial-time algorithm can solve 2SAT using n 1−c/ √ log n space, which is slightly larger than sub linear in the sense of this paper (i.e., n ε for a certain constant ε ∈ [0, 1)).
In a course of our study, we have considered a natural variant of 2SAT, 2SAT k for any k ∈ N + , and we have raised a legitimate question of whether 2SAT 3 is solvable within polynomial time using only sublinear space.In a way analogous to the exponential time hypothesis (ETH) and the strong exponential time hypothesis (SETH) for kSAT (k ≥ 3) [11,12], we have introduced in Section 1.3 a practical working

Example 3 . 2
We show a simple example of short SLRF-T-reduction from (CLIQUE, ||) to (ExactCLIQUE, ||).The decision problem CLIQUE asks whether a given undirected graph G has a clique (i.e., a complete subgraph) of size k.The problem ExactCLIQUE is similar but checks if the graph has the maximal clique of size k.The desired reduction machine M works as follows.Given an instance G, k of CLIQUE with a graph G = (V, E) and a positive integer k, M inductively picks a number i in [k, |v|] Z , generates G, i on a query tape, and makes a query to the oracle ExactCLIQUE, assuming a suitable encoding G, i of G and i.As soon as an oracle answer becomes affirmative during this inductive process, M accepts the input.If the oracle never returns any positive answer, then M rejects the input.To produce each query word, M needs only O(1) work space.Moreover, the binary size of each query word

Lemma 3 .4 1 . 2 .
) This comes from the definitions of ≤ L m and ≤ sL m , as well as ≤ SLRF T and ≤ sSLRF T .✷ Next, we show three statements, which concern with basic properties of SLRF-T-and sSLRF-Treductions.The reducibilities ≤ SLRF T and ≤ sSLRF T are reflexive and transitive.A similar statement holds for ≤ L m and ≤ sL m , and ≤ L T and ≤ sL T .The parameterized complexity class PsubLIN is closed under ≤ sSLRF T -reductions.3.There exist two parameterized problems (X, m) and (Y, m) with a log-space size parameter m and recursive decision problems X and Y such that (X, m) ≤ SLRF T (Y, m) and (X, m) ≤ sSLRF T (Y, m).A similar statement holds also for ≤ L m and ≤ sL m .
all indices i ∈ [l] and j ∈ [m].Let φ ′ be the conjunction of all clauses obtained by this modification.

√
log n for an appropriate constant c > 0).Using the assertion that (2SAT, m vbl ) is short L-T-reducible to (DSTCON, m ver ), shown in Proposition 5.7(1), we can solve (2SAT, m vbl ) in polynomial time using n/2 O( √ log n) space.Theorem 4.3 For a certain constant c > 0 and a certain polylog function ℓ, 2SAT with n variables and m clauses is solvable in polynomial time using n 1−c/ √ log n ℓ(m + n) space.

Proof.
It suffices to prove that every problem (A, m) in para-SNL ω can be reduced to (2SAT k , m vbl ) by an appropriate short SLRF-T-reduction, where k is a certain large constant, because (2SAT k , m vbl ) ≡ sSLRF T (2SAT 3 , m vbl ) by Lemma 4.2(1).
Hot Potato Problem (Max-HPP): • Instance: an n × n matrix A whose entries are drawn from [n], a number d ∈ [n], and a start index i 1 ∈ [n], where n ∈ N + .• Solution: an index sequence S = (i 1 , i 2 , . . ., i d ) of length d with i j ∈ [n] for any j ∈ [d].