DeepAI

# Supportive Oracles for Parameterized Polynomial-Time Sub-Linear-Space Computations in Relation to L, NL, and P

We focus our attention onto polynomial-time sub-linear-space computation for decision problems, which are parameterized by size parameters m(x), where the informal term "sub linear" means a function of the form m(x)^ε· polylog(|x|) on input instances x for a certain absolute constant ε∈(0,1) and a certain polylogarithmic function polylog(n). The parameterized complexity class PsubLIN consists of all parameterized decision problems solvable simultaneously in polynomial time using sub-linear space. This complexity class is associated with the linear space hypothesis. There is no known inclusion relationships between PsubLIN and para-NL (nondeterministic log-space class), where the prefix "para-" indicates the natural parameterization of a given complexity class. Toward circumstantial evidences for the inclusions and separations of the associated complexity classes, we seek their relativizations. However, the standard relativization of Turing machines is known to violate the relationships of L⊆NL=co-NL⊆DSPACE[O(^2n)]∩P. We instead consider special oracles, called NL-supportive oracles, which guarantee these relationships in the corresponding relativized worlds. This paper vigorously constructs such NL-supportive oracles that generate relativized worlds where, for example, para-L≠para-NL⊈PsubLIN and para-L≠para-NL⊆PsubLIN.

09/29/2017

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

We aim at investigating the solvability/insolvability of nondeterministi...
06/21/2022

### Parameterized-NL Completeness of Combinatorial Problems by Short Logarithmic-Space Reductions and Immediate Consequences of the Linear Space Hypothesis

The concept of space-bounded computability has become significantly impo...
11/05/2018

### Probabilistic Parameterized Polynomial Time

We examine a parameterized complexity class for randomized computation w...
11/15/2018

### State Complexity Characterizations of Parameterized Degree-Bounded Graph Connectivity, Sub-Linear Space Computation, and the Linear Space Hypothesis

The linear space hypothesis is a practical working hypothesis, which ori...
02/28/2019

### A Hierarchy of Polynomial Kernels

In parameterized algorithmics, the process of kernelization is defined a...
02/08/2021

### A full complexity dichotomy for immanant families

Given an integer n≥ 1 and an irreducible character χ_λ of S_n for some p...
06/23/2022

### On the Complexity of Problems on Tree-structured Graphs

In this paper, we introduce a new class of parameterized problems, which...

## 1 Prelude: Quick Overview

### 1.1 Size Parameters and Parameterized Decision Problems

Among decision problems computable in polynomial time, nondeterministic logarithmic-space (or log-space, for short) computable problems are of special interest, partly because these problems contain practical problems, such as the directed - connectivity problem () and the 2-CNF Boolean formula satisfiability problem (). Those problems form a complexity class known as (nondeterministic log-space class).

For many problems, their computational complexity have been discussed, from a more practical aspect, according to the “size” of particular items of each given instance. As a concrete example of such a “size,” let us consider an efficient algorithm of Barnes, Buss, Ruzzo, and Schieber [2] that solves DSTCON on input graphs of vertices and edges simultaneously using time and space for an appropriately chosen constant . In this case, the number of vertices and the number of edges in a directed graph are treated as the “size” or the “basis unit” of measuring the computational complexity of DSTCON. For an input CNF Boolean formula, in contrast, we can take the number of variables and the number of clauses as the “size” of the Boolean formula. In a more general fashion, we denote the “size” of instance by and we call this function a size parameter of a decision problem . A decision problem together with a size parameter naturally forms a parameterized decision problem and we use a special notation to describe it.

Throughout this paper, we intend to study the properties of parameterized decision problems and their collections. Such collections are distinctively called parameterized complexity classes. To distinguish such parameterized complexity classes from standard binary-size complexity classes, we often append the term “para-” as in and , which are respectively the parameterizations of and (see Section 2 for their formal definitions).

The aforementioned parameterized decision problems and , where and respectively indicate the number of vertices and the number of variables, fall into [12]. It is, however, unclear whether we can improve the performance of the aforementioned algorithm of Barnes et al. to run using only space for a certain absolute constant and a certain polylogarithmic (or polylog, for short) function . Given a size parameter , the informal term “sub linear” generally refers to a function of the form for a certain constant and a certain polylog function . We denote by the collection of all parameterized decision problems solved by deterministic Turing machines running simultaneously in (polynomial) time using (sub-linear) space [12]. It follows that . Various sub-linear reducibilities was further studied in [13] in association with . The linear space hypothesis (LSH), which is a practical working hypothesis proposed in [12], asserts that cannot belong to , where is a variant of with an extra restriction that every 2-CNF Boolean formula given as an instance must have each variable appearing at most 3 times in the form of literals. We do not know whether LSH is true or even . A characterization of LSH was given in [14] in connection to state complexity of finite automata.

### 1.2 Relativizations of L, NL, P, and PsubLIN

The current knowledge seems not good enough to determine the exact complexity of in comparison with , , and . This fact makes us look for relativizations of these classes by way of forcing underlying Turing machines to make queries to appropriately chosen oracles. The notion of relativization in computational complexity theory dates back to an early work of Baker, Gill, and Solovay [1], who constructed various relativized worlds in which various inclusion and separation relationships among , , and are possible. Generally speaking, relativization is a methodology by which we can argue that a certain mathematical property holds or does not hold in the presence of external information source, called an oracle. The use of an oracle creates a desired relativized world where certain desired conditions, such as together with , hold. In a similar vein, we want to discuss the possibility/impossibility of the inclusion of in by considering relativized worlds where various conflicting relationships between and hold.

Unlike and , it has been known that there is a glitch in defining the relativization of . Ladner and Lynch [7] first considered relativization of in a way similar to that of Baker, Gill, and Solovay [1]. Despite our knowledge regarding basic relationships among , , and , this relativization leads to the existence of oracles and such that and although holds in the unrelativized world. Quite different from time-bounded oracle Turing machines, there have been several suggested models for space-bounded oracle Turing machines. Ladner-Lynch relativization does not always guarantee both relationships and since certain oracles refute those relations. This looks like contradicting the fact that, in the un-relativised world, , , and hold [3, 8, 10, 11], where .

Another, more restrictive relativization model was proposed in 1984 by Ruzzo, Simon, and Tompa [9], where an oracle machine behaves deterministically while writing a query word on its query tape. More precisely, after a query tape becomes blank, if the oracle machine starts writing the first symbol of a query word, then the machine must make deterministic moves until the query word is completed and an oracle is called. After the oracle answers, the query tape is automatically erased to be blank again and a tape head instantly jumps back to the initial tape cell. This restrictive model can guarantee the inclusions for any oracle ; however, it is too restrictive because it leads to the conclusion that iff for any oracle [6].

In this paper, we expect our relativization of an underlying machine to guarantee that all log-space nondeterministic oracle Turing machines can be simulated by polynomial-time deterministic Turing machines, yielding three relationships that , , and , where is the parameterization of and is the collection of all for which belongs to .

In spite of an amount of criticism, relativization remains an important research subject to pursue. Returning to parameterized complexity classes, nonetheless, it is possible to consider “conditional” relativizations that support the aforementioned three relations. To distinguish such relativization from the ones we have discussed so far, we need a new type of relativization, which we will explain in the next subsection. In Section 5, we will return to a discussion on the usefulness (and the vindication) of this new relativization.

### 1.3 Main Contributions

We use the notation to denote the collection of all parameterized decision problems solvable by oracle Turing machines with adaptive access to oracle simultaneously using time and space on all inputs for a certain constant and a certain polylog function .

A key concept of our subsequent discussion is “supportive oracles.” Instead of restricting the way of accessing oracles (such as non-adaptive queries and limited number of queries), we use the most natural query mechanism but we force the oracles to support certain known inclusion relationships among complexity classes. In this way, an oracle is said to be -supportive if the following three relations hold: (1) , (2) , and (3) . Note that Condition (1) is always satisfied for any oracle .

We first claim the existence of recursive -supportive oracles generating various relativized worlds where three classes , , and have specific computational power. Notice that holds for all oracles .

###### Theorem 1.1

There exist recursive -supportive oracles , , , and satisfying the following conditions.

1. .

2. .

3. .

4. .

The difficulty in proving each claim in Theorem 1.1 lies in the fact that we need to (i) deal with the fluctuations of the values of size parameters of parameterized decision problems (notice that the standard binary length of inputs is monotonically increasing) and to (ii) satisfy three or four conditions simultaneously for parameterized complexity classes by avoiding any conflict occurring during the construction of the desired oracles.

We can prove other relationships among , , and . Concerning a question of whether or not , we can present four different relativized worlds in which and separately hold between and in relation to .

###### Theorem 1.2

There exist recursive -supportive oracles , , , and satisfying the following conditions.

1. .

2. .

3. .

4. .

The relationships given in Theorems 1.11.2 suggest that any relativizable proof is not sufficient to separate , , , and .

## 2 Preliminaries

We briefly explain basic terminology necessary for the later sections. We use to denote the set of all natural numbers (i.e., nonnegative integers) and we set . Given a number , expresses the set . In this paper, all polynomials have nonnegative integer coefficients and all logarithms are taken to the base . We define as follows. First, we set and for each index . Finally, we set to be the minimal number satisfying .

An alphabet is a nonempty finite set and a string over is a finite sequence of elements of . A language over is a subset of . We freely identify a decision problem with its associated language over . The length (or size) of a string is the total number of symbols in and is denoted . We write for the set when is clear from the context. A function (resp., ) is polynomially bounded if there exists a polynomial satisfying (resp., ) for all .

We use deterministic Turing machines (DTMs) and nondeterministic Turing machines (NTMs), each of which has a read-only input tape and a rewritable work tape. If necessary, we also attach a write-onlyA tape is write only if a tape head must move to the right whenever it write any non-blank symbol. output tape. All tapes have the left endmarker and stretch to the right. Additionally, an input tape has the right endmarker . When a DTM begins with an initial state and, whenever it enters a halting state (either an accepting state or a rejecting state), it halts. We say that a DTM accepts (resp., rejects) input if starts with written on an input tape (surrounded by the two endmarkers) and enters an accepting (resp., a rejecting) state. Similarly, an NTM accepts if there exists a series of nondeterministic choices that lead the NTM to an accepting state. Otherwise, the NTM rejects . A machine is said to recognize a language if, for all , accepts , and for all , rejects .

The notation (resp., ) refers to the class of all languages recognized by DTMs (resp., NTMs) using space , where “” is a symbolic input size. Moreover, stands for the class of languages recognized by DTMs in time . It is known that [3, 8, 10, 11].

An oracle is an external device that provides useful information to an underlying Turing machine, which is known as an oracle Turing machine. In this paper, oracles are simply languages over a certain alphabet. An oracle Turing machine is equipped with an extra query tape, in which the machine writes a query word, say, and enters a query state that triggers an oracle query. We demand that any query tape should be write only because, otherwise, the query tape can be used as an extra work tape composed of polynomially many tape cells. Triggered by an oracle query, an oracle responds by modifying the machine’s inner state from to either or , depending on or , respectively. Simultaneously, the query tape becomes empty and its tape head is returned to . Given an oracle Turing machine and an oracle , the notation expresses the set of all strings accepted by relative to .

A size parameter is a function from to for a certain alphabet . A log-space size parameter is a size parameter for which there exists a DTM equipped with a write-only output tape that takes a string and produces on the output tape using space. As a special size parameter, we write “” to denote the size parameter defined by for any . The notation indicates the set of all log-space size parameters. Given a size parameter and any index , we set . Note that for any distinct pair and that . A pair with a decision problem (equivalently, a language) and a size parameter is called a parameterized decision problem and any collection of parameterized decision problems is called a parameterized complexity class. We informally use the term “parameterization” for underlying decision problems and complexity classes if we supplement size parameters to their instances.

As noted in Section 1.1, the prefix “para-” is used to distinguish parameterized complexity classes from standard complexity classes. With this convention, for two functions and , the notation , where “” in “” indicates a symbolic size parameter with a symbolic input , denotes the collection of all parameterized decision problems with log-space size parameters, each of which is solved (or recognized) by a certain DTM in time using space . Its nondeterministic variant is denoted by . We set to be and to be . Moreover, we set to be . When we take , those parameterized complexity classes coincide with the corresponding “standard” complexity classes. In addition, we define as . Given a parameterized complexity class , its complement class is composed of all parameterized decision problems for which belongs to . The relativization of with an oracle is denoted by and is obtained by replacing underlying Turing machines for with oracle Turing machines. In a similar fashion, we define , , and .

Formally, we introduce the notion of -supportive oracles.

###### Definition 2.1

An oracle is said to be -supportive if the following three conditions hold: (1) , (2) , and (3) .

Although Condition (1) holds for all oracles , we include it for a clarity reason.

In the subsequence sections, we will provide the proofs of Theorems 1.11.2.

## 3 Proofs of Theorem 1.1

We will give necessary proofs that verify our main theorems. We begin with proving Theorem 1.1.

Our goal is to construct oracles , , , and that satisfy Theorem 1.1(1)–(4). Here, we start with the first claim of Theorem 1.1.

Proof of (1).   Note that, if , then is -supportive because we obtain . Let be any -complete problem (via log-space many-one reductions). We first claim that . Since , we obtain . Since is -complete, it follows that , as requested.

In the proofs of Theorem 1.1(2)–(4) that will follow shortly, we need several effective enumerations of pairs consisting of machines and size parameters. First, let be an effective enumeration of all such pairs satisfying that, for each index , is in and is a DTM running in time at most using space at most on all inputs and for all oracles for appropriately chosen constants and . Moreover, let denote an effective enumeration of pairs for which each belongs to and each is a DTM running in time at most using space at most on all inputs and for all oracles for a certain constant . Next, we use an effective enumeration , where each is in and each DTMs runs in time at most on all inputs and for all oracles, where is an absolute positive constant. We also assume an effective enumeration such that, for each , is in and is an NTM running in time at most using space at most on all inputs and for all oracles for a certain absolute constant . For notational simplicity, we write to express an oracle machine obtained from by exchanging between and . With this notation, each relative to oracle together with induces a parameterized decision problem in .

Since every log-space size parameter is computed by a certain log-space DTM equipped with an output tape, we can enumerate all log-space size parameters by listing all such DTMs as . For each index , we write for the size parameter computed by as long as it is obvious from the context. Since is polynomially bounded, it is possible to assume that for all and , where is an absolute positive constant.

Our construction of the desired oracles will proceed by stages. To prepare such stages, for a given finite set , let us define an index set together with an appropriate effective enumeration of all elements in defined by the following linear order on : (1) holds for all and (2) iff either or . Given a number , let . Note that . We also define a linear ordering on with respect to in the following way: letting , iff one of the following conditions hold: , , and (lexicographically). According to this ordering , we choose all elements of one by one in the increasing order.

Proof of (2).   We wish to construct an oracle that meets the following four conditions: (i) , (ii) , (iii) , and (iv) . These conditions obviously ensure the desired claim of .

We want to introduce two example languages for (i) and (ii). First, we set and for all , where . We write for and set . It is not difficult to show that belongs to for any oracle by running the following algorithm: first produce all words one by one, query them to obtain from , remember all answer bits , and finally query . Similarly, we define and for each and set , where . Note that for any oracle . Through our oracle construction, we will define two sequences and . For readability, we set , , and for any and .

In this proof, we set and define as stated before. For each , we want to construct two sets and . At Stage , we set and . Moreover, we set two counters and to . In what follows, we deal with Stage and the values of and . By induction hypothesis, we assume that, for all , and have been already defined. Moreover, we assume that, for all and , and have been appropriately defined. For simplicity, let and .

During the construction process of , the value of may fluctuate, depending on , and this fact may have many words reserved, leaving no room for inserting extra strings to define in (c)–(d). To avoid such a situation, we will use and its linear ordering with respect to . For our convenience, let and .

(a) Case . Our target is Condition (i). Consider the size parameter . If , then we skip this case and move to Case . Now, let us assume otherwise. We try to find a room for diagonalization by avoiding the reserved words set in the previous stages. For this purpose, we first check whether there exist a number and a string satisfying that (*) and, for any , , where . The latter condition is to make enough room for as well as the constructions in (c)–(d). If (*) is not satisfied for all and , then we skip this case. Assuming that (*) is satisfied for certain and , we fix such a pair for the subsequent argument.

Take the machine and the input . Recall that runs in time at most using space at most . Let . Although may possibly query all words of the form for , it cannot remember all oracle answers , because the work tape space of is smaller than . From this fact and also by (*), there is a set for which . We define to include , all queried words of on relative to , and , where and for all . Note that . Before leaving this case, we set to be and then increment the counter from to .

(b) Case . Hereafter, we try to satisfy Condition (ii). For this purpose, let us assume that and have been updated. We will make an argument similar to (a) using instead of . We skip this case and move to Case if . Otherwise, we check if there are a number and a string satisfying that (*) and for any index , where . If no pair satisfies (*), then we skip this case as well. Next, we assume (*) for certain and . We consider the machine and feed the input to . We then choose a set , where , satisfying . Note that cannot remember all values for any using its work tape because the work tape space is bounded by . Let be composed of , all queried words of on relative to , and , where and for all . Finally, we set and increment the counter from to .

(c) Case . We target Condition (iii). Consider and its linear ordering with respect to . We inductively choose all pairs in one by one in the increasing order. For each element , let us consider with and . For convenience, we write to denote the union of all for any with . Similarly, we write . In this case, we need to find an appropriate query word deterministically to simulate on . Since , it follows that . We set .

Here, we define a new machine as follows. On input , query all words of the form for any of length . Note that the number of different ’s is , which is at most . Collect all answers from an oracle. Let be the sequence of oracle answers in order. Finally, make a query of . If the oracle answers YES, accept ; otherwise, reject . Take strings of the form in so that, for the string obtained from , is not in . We include all those strings into . It follows that iff . Next, we define to include all queried strings of , , and , where is the word determined by the query answers. In the end, we set and .

(d) Case . We aim at Condition (iv). Consider and its linear ordering with respect to . Choose all pairs one by one and define two sets and . We run on the input with the oracle . Note that runs in time at most using space at most for all oracles. Note that since