Proper Hierarchies in Polylogarithmic Time and Absence of Complete Problems

Abstract

The polylogarithmic time hierarchy structures sub-linear time complexity. In recent work it was shown that all classes $\tilde{\varSigma }_{m}^{ plog }$ or $\tilde{\varPi }_{m}^{ plog }$ ($m \in \mathbb {N}$) in this hierarchy can be captured by semantically restricted fragments of second-order logic. In this paper the descriptive complexity theory of polylogarithmic time is taken further showing that there are strict hierarchies inside each of the classes of the hierarchy. A straightforward consequence of this result is that there are no complete problems for these complexity classes, not even under polynomial time reductions.

The research reported in this paper results from the project Higher-Order Logics and Structures supported by the Austrian Science Fund (FWF: [I2420-N31]). It has also been partly supported by the Austrian Ministry for Transport, Innovation and Technology, the Federal Ministry for Digital and Economic Affairs, and the Province of Upper Austria in the frame of the COMET center SCCH.

1 Introduction

Computations with sub-linear time complexity have not been studied intensively. However, such computations appear rather naturally, e.g. in the area of circuits. Mix Barrington studied the complexity of circuits [9] characterizing a class of families of constant-depth quasi-polynomial size AND/OR-circuits. In particular, he proved that the class of Boolean queries computable by the class of $\mathrm {DTIME}[(\log n)^{O(1)}]$ DCL-uniform families of Boolean circuits of unbounded fan-in, size $2^{{(\log n)}^{O(1)}}$ and depth O(1) coincides with the class of Boolean queries expressible in a fragment $SO^b$ of second-order logic. As used in his study, the complexity class $\mathrm {DTIME}[2^{(\log n)^{O(1)}}]$ is known as quasipolynomial time. Furthermore, the fastest known algorithm for checking graph isomorphisms is in quasipolynomial time [1].

In [3] we started a deeper investigation of sub-linear time computations emphasising complexity classes DPolyLogTime and NPolyLogTime of decision problems that can be solved deterministically or non-deterministically with a time complexity in $O(\log ^k n)$ for some k, where n is as usual the size of the input. We extended these complexity classes to a complete hierarchy, the polylogarithmic time hierarchy, analogous to the polynomial time hierarchy, and for each class $\varSigma _m^{plog}$ or $\varPi _m^{plog}$ ($m \in \mathbb {N}$) in the hierarchy we defined a fragment of semantically restricted second-order logic capturing it [5, 6]. While the hierarchy as a whole captures the same class of problems studied by Mix Barrington, the various classes of the hierarchy provide fine-grained insights into the nature of decision problems decidable in sub-linear time.

With these promising results the natural question occurs, whether there are complete problems in the hierarchy, and what would be an appropriate notion of reduction to define complete problems. Note that for the somehow related complexity class PolyLogSpace it is known since long time that it does not have complete problems.

In this paper we address this problem. We show that for none of the classes $\tilde{\varSigma }_{m}^{ plog }$ and $\tilde{\varPi }_{m}^{ plog }$ ($m \in \mathbb {N}$) in the polylogarithmic time hierarchy there exists a complete problem. It turns out that this result is a rather simple consequence of the existence of proper hierarchies inside each of the classes $\tilde{\varSigma }_{m}^{ plog }$ and $\tilde{\varPi }_{m}^{ plog }$. Note that a similar approach shows the non-existence of complete problems for PolyLogSpace, but the corresponding proof exploits theorems by Hartmanis et al. that cannot be applied to our case, as these theorems (which are well known in complexity theory as the space and time hierarchy theorems) require at least linear time.

The remainder of this paper is organized as follows. Section 2 summarizes the necessary preliminaries for our investigation introducing the complexity classes of the polylogarithmic time hierarchy. This is complemented in Sect. 3 by reviewing $\text {SO}^\textit{plog}$, the polylogarithmically-restricted fragment of second-order logic that is used to define subsets capturing the complexity classes $\tilde{\varSigma }_{m}^{ plog }$ and $\tilde{\varPi }_{m}^{ plog }$. Section 4 introduces concrete decision problems that we use to show the existence of proper hierarchies inside $\tilde{\varSigma }_{m}^{ plog }$ and $\tilde{\varPi }_{m}^{ plog }$. We use the capturing logics to define these problems that are parametrised by $k \in \mathbb {N}$, and the various different values for k give rise to the hierarchies. Theorems showing that we obtain proper hierarchies inside $\tilde{\varSigma }_{m}^{ plog }$ and $\tilde{\varPi }_{m}^{ plog }$ are proven in Sect. 5. Then the non-existence of complete problems arises as a rather straightforward consequence, as we will show in Sect. 6. We conclude with a brief summary in Sect. 7.

2 Polylogarithmic Time Complexity Classes

The sequential access that Turing machines have to their tapes makes it impossible to compute anything in sub-linear time. Therefore, logarithmic time complexity classes are usually studied using models of computation that have random access to their input. As this also applies to the poly-logarithmic complexity classes studied in this paper, we adopt a Turing machine model that has a random access read-only input, similar to the log-time Turing machine in [10].

In the following, $\log n$ always refers to the binary logarithm of n, i.e., $\log _2 n$. With $\log ^k n$ we mean $(\log n)^k$.

A random-access Turing machine is a multi-tape Turing machine with (1) a read-only (random access) input of length $n+1$, (2) a fixed number of read-write working tapes, and (3) a read-write input address-tape of length $\lceil \log n \rceil$.

Every cell of the input as well as every cell of the address-tape contains either 0 or 1 with the only exception of the ($n+1$)st cell of the input, which is assumed to contain the endmark $\triangleleft$. In each step the binary number in the address-tape either defines the cell of the input that is read or if this number exceeds n, then the ($n+1$)st cell containing $\triangleleft$ is read.

Example 2.1

Let polylogCNFSAT be the class of satisfiable propositional formulae in conjunctive normal form with $c \le \lceil \log n \rceil ^k$ clauses, where n is the length of the formula. Note that the formulae in polylogCNFSAT tend to have few clauses and many literals. We define a random-access Turing machine M which decides polylogCNFSAT. The alphabet of M is $\{0,1,\#,+,-\}$. The input formula is encoded in the input tape as a list of $c \le \lceil \log n \rceil ^k$ indices, each index being a binary number of length $\lceil \log n \rceil$, followed by c clauses. For every $1 \le i \le c$, the i-th index points to the first position in the i-th clause. Clauses start with $\#$ and are followed by a list of literals. Positive literals start with a $+$, negative with a −. The $+$ or − symbol of a literal is followed by the ID of the variable in binary. M proceeds as follows: (1) Using binary search with the aid of the “out of range” response $\triangleleft$, compute n and $\lceil \log n \rceil$. (2) Copy the indices to a working tape, counting the number of indices (clauses) c. (3) Non-deterministically guess c input addresses $a_1, \ldots , a_c$, i.e., guess c binary numbers of length $\lceil \log n \rceil$. (4) Using c 1-bit flags, check that each $a_1, \ldots , a_c$ address falls in the range of a different clause. (5) Check that each $a_1, \ldots , a_c$ address points to an input symbol $+$ or −. (6) Copy the literals pointed by $a_1, \ldots , a_c$ to a working tape, checking that there are no complementary literals. (7) Accept if all checks hold.

Let L be a language accepted by a random-access Turing machine M. Assume that for some function f on the natural numbers, M makes at most O(f(n)) steps before accepting an input of length n. If M is deterministic, then we write $L \in \mathrm {DTIME}(f(n))$. If M is non-deterministic, then we write $L \in \mathrm {NTIME}(f(n))$. We define the classes of deterministic and non-deterministic poly-logarithmic time computable problems as follows:

$$\begin{aligned} \mathrm {DPolyLogTime}= \bigcup _{k, c \in \mathbb {N}} \mathrm {DTIME}((\log n)^k \cdot c) \end{aligned}$$

$$\begin{aligned} \mathrm {NPolylogTime}= \bigcup _{k, c \in \mathbb {N}} \mathrm {NTIME}((\log n)^k \cdot c) \end{aligned}$$

The non-deterministic random-access Turing machine in Example 2.1 clearly works in polylog-time. Therefore, polylogCNFSAT $\in \mathrm {NPolylogTime}$.

Recall that an alternating Turing machine comes with a set of states Q that is partitioned into subset $Q_\exists$ and $Q_\forall$ of so-called existential and universal states. Then a configuration c is accepting iff

• c is in a final accepting state,

• c is in an existential state and there exists a next accepting configuration, or

• c is in a universal state, there exists a next configuration and all next configurations are accepting.

In analogy to our definition above we can define a random-access alternating Turing machine. The languages accepted by such a machine M, which starts in an existential state and makes at most O(f(n)) steps before accepting an input of length n with at most m alternations between existential and universal states, define the complexity class $\mathrm {ATIME}(f(n),m)$. Analogously, we define the complexity class $\mathrm {ATIME}^{ op }(f(n),m)$ comprising languages that are accepted by a random-access alternating Turing machine that starts in a universal state and makes at most O(f(n)) steps before accepting an input of length n with at most $m-1$ alternations between universal and existential states. With this we define

$$\begin{aligned} \tilde{\varSigma }_{m}^{ plog } = \bigcup _{k, c \in \mathbb {N}} \mathrm {ATIME}[(\log n)^k \cdot c, m] \qquad \tilde{\varPi }_{m}^{ plog } = \bigcup _{k,c \in \mathbb {N}} \mathrm {ATIME}^{op}[(\log n)^k \cdot c, m] . \end{aligned}$$

The poly-logarithmic time hierarchy is then defined as $\mathrm {PLH} = \bigcup _{m \ge 1} \tilde{\varSigma }_{m}^{ plog }$. Note that $\tilde{\varSigma }_{1}^{ plog } = \mathrm {NPolylogTime}$ holds.

Remark 2.1

Note that a simulation of a $\mathrm {NPolylogTime}$ Turing machine M by a deterministic machine N requires checking all computations in the tree of computations of M. As M works in time $({\log n})^{O(1)}$, N requires time $2^{{\log n}^{O(1)}}$. This implies $\mathrm {NPolylogTime}\subseteq \mathrm {DTIME}(2^{{\log n}^{O(1)}})$, which is the complexity class called quasipolynomial time of the fastest known algorithm for graph isomorphism [1], which further equals the class $\mathrm {DTIME}({n^{{\log n}^{O(1)}}})$¹.

3 Logics for Polylogarithmic Time

The descriptive complexity of the polylogarithmic time complexity classes described in the previous section, has been recently studied in deepth in [3,4,5,6,7], where precise logical characterization of those classes were presented. The logics used in those characterizations are quite useful to think and describe the problems used in this paper to prove proper hierarchies inside polylogarithmic time. In this section we describe these logics and the results regarding their correspondence with the different polylogarithmic time complexity classes.

The capturing results for polylogarithmic time hold over ordered structures. A finite ordered $\sigma$-structure $\mathbf {A}$ is a finite structure of vocabulary $\sigma \cup \{<\}$, where $\le \notin \sigma$ is a binary relation symbol and $<^\mathbf {A}$ is a linear order on A. Every finite ordered structure has a corresponding isomorphic structure, whose domain is an initial segment of the natural numbers. Thus, we assume, as usual, that $A = \{0, 1, \ldots , n-1\}$, where n is the cardinality |A| of A. In the case of non-deterministic polylogarithmic time complexity, the capturing results also assume that $\sigma$ includes $\mathrm {SUCC}$, $\mathrm {BIT}$ and constants for $\log n$, the minimum, second and maximum elements. In every structure $\mathbf{A}$, the symbol $\mathrm {SUCC}$ is interpreted by the successor relation corresponding to the $<^\mathbf{A}$ ordering. The constant symbols 0, 1 and $max$ are in turn interpreted as the minimum, second and maximum elements under the $<^\mathbf{A}$ ordering and the constant $logn$ as $\left\lceil \log |A| \right\rceil$. Finally, $\mathrm {BIT}$ is interpreted by the following binary relation:

$$ \mathrm {BIT}^\mathbf{A} = \{(i, j) \in A^{2} \mid \text { Bit } j \text { in the binary representation of }i \text { is }1\}. $$

W.l.o.g., we assume that all structures have at least three elements. This results in a cleaner presentation, avoiding trivial cases which would unnecessarily complicate some formulae.

Let us start with DPolylogTime. This class is captured by the index logic introduced in [6]. Index logic is two-sorted; variables of the first sort range over the domain of the input structure. Variables of the second sort range over an initial segment of the natural numbers; this segment is bounded by the logarithm of the size of the input structure. Thus, the elements of the second sort represent the bit positions needed to address elements of the first sort. Index logic includes full fixpoint logic on the second sort. Quantification over the first sort, however, is heavily restricted. Specifically, a variable of the first sort can only be bound using an address specified by a subformula that defines the positions of the bits of the address that are set. This “indexing mechanism” lends index logic its name.

The following result confirms that the problems that can be described in the index logic are in $DPolylogTime$ and vice versa.

Theorem 3.1

([6]). Index logic captures $DPolylogTime$ over ordered structures.

Regarding nondeterministic polylogarithmic time, the restricted second-order logic $\mathrm {SO}^{ plog }$ defined in [3,4,5] captures the polylogarithmic-time hierarchy, with its quantifier prenex fragments $\varSigma ^{ plog }_{m}$ and $\varPi ^{ plog }_{m}$ capturing the corresponding levels $\tilde{\varSigma }_{m}^{ plog }$ and $\tilde{\varPi }_{m}^{ plog }$ of this hierarchy, respectively.

$\mathrm {SO}^{ plog }$ is a fragment of second-order logic where second-order quantification range over relations of polylogarithmic size and first-order quantification is restricted to the existential fragment of first-order logic plus universal quantification over variables under the scope of a second-order variable.

Formally, we can inductively define the syntax of $\mathrm {SO}^{ plog }$ as follows:

• Every formula in the existential fragment of first-order logic with equality is a $\mathrm {SO}^{ plog }$ formula.

• If X is a second-order variable of arity r, and $t_1, \ldots , t_r$ are first-order terms, then both $X(t_1, \ldots , t_r)$ and $X(t_1, \ldots , t_r)$ are $\mathrm {SO}^{ plog }$ formulae.

• If $\varphi$ and $\psi$ are $\mathrm {SO}^{ plog }$ formulae, then $(\varphi \wedge \psi )$ and $(\varphi \vee \psi )$ are $\mathrm {SO}^{ plog }$ formulae.

• If $\varphi$ is a $\mathrm {SO}^{ plog }$ formula, X is a second-order variable of arity r and $\bar{x}$ is an r-tuple of first-order variables, then $\forall \bar{x} (X(\bar{x}) \rightarrow \varphi )$ is $\mathrm {SO}^{ plog }$ formula.

• If $\varphi$ is a $\mathrm {SO}^{ plog }$ formula and x is a first-order variable, then $\exists x \varphi$ is a $\mathrm {SO}^{ plog }$ formula.

• If $\varphi$ is a $\mathrm {SO}^{ plog }$ formula and X is a second-order variable, then both $\exists X \varphi$ and $\forall X \varphi$ are $\mathrm {SO}^{ plog }$ formulae.

The most significant restriction of $\mathrm {SO}^{ plog }$ is in its semantics. In addition to its arity, each second-order variable X is associated with another non-negative integer, its exponent, and it is required that any X of arity r and exponent k is interpreted on a structure of domain A as an r-ary relation of cardinality smaller or equal than $\log ^k |A|$. Otherwise, the semantics of $\mathrm {SO}^{ plog }$ follows the standard semantics of second-order logic.

As usual, the fragments $\varSigma ^{ plog }_{m}$ (resp. $\varPi ^{ plog }_{m}$) are defined by considering $\mathrm {SO}^{ plog }$ formulae with m alternating blocks of second-order quantifiers in quantifier prenex (Skolem) normal form, starting with an existential (resp. universal) block. Note that by Lemma 3 in [4], for every $\mathrm {SO}^{ plog }$ formula $\varphi$ there is an equivalent formula $\varphi '$ that is in quantifier prenex normal form. In the following we will assume that the reader is familiar with the techniques that can be applied to transform arbitrary $\mathrm {SO}^{ plog }$ formulae into equivalent formulae in Skolem normal form. Those techniques are detailed in the proof of Lemma 3 in Appendix B in [4].

The following result characterizes precisely the expressive power of $\mathrm {SO}^{ plog }$ in terms of the nondeterministic polylogarithmic time hierarchy. Note that in particular, existential $\mathrm {SO}^{ plog }$ captures $NPolylogTime$.

Theorem 3.2

([3, 5]). Over ordered structures with successor relation, $\mathrm {BIT}$ and constants for $\log n$, the minimum, second and maximum elements, $\varSigma ^{ plog }_m$ captures $\tilde{\varSigma }^{ plog }_m$ and $\varPi ^{ plog }_m$ captures $\tilde{\varPi }^{ plog }_m$ for all $m \ge 1$.

4 Problems that Lead to Proper Hierarchies

Here we introduce the decision problems that we use in the next section to show the existence of proper hierarchies of polylogarithmic-time. In addition, for the nondeterministic classes we give a precise definition of these problems in terms of the logic $\mathrm {SO}^{ plog }$ studied in [3,4,5] and discussed in the previous section.

From now on we work with the class of structures known as word models (see for instance [2]). Let $\pi$ be the vocabulary $\{<, R_0, R_1\}$, where < is a binary relation symbol and $R_0, R_1$ are unary relation symbols. We can identify any binary string (word) $w = a_1 \ldots a_{n}$ in $\{0,1\}^+$ with a $\pi$-structure (word model) ${\mathbf {A}}_w$, where the cardinality of the domain A of ${\mathbf {A}_w}$ equals the length of w, $<^{{\mathbf {A}}_w}$ is a linear order in A, $R_0^{{\mathbf {A}}_w}$ contains the positions in w carrying a 0, and $R_1^{{\mathbf {A}}_w}$ contains the positions in w carrying a 1.

Problem 4.1

($\mathrm {InitialZeros}^{k}$). The problem $\mathrm {InitialZeros}^{k}$ consists on deciding (over word models of signature $\pi$) the language of binary strings which have a prefix of at least $\lceil \log n\rceil ^k$ consecutive zeros, where n is the length of the string.

Problem 4.2

($\mathrm {ConseqZeros}^{k}$). Let $\mathrm {ConseqZeros}^{k}$ denote the problem of deciding the language of binary strings which have at least $\lceil \log n\rceil ^k$ consecutive bits set to 0, where n is the length of the string. This can be expressed formally in $\mathrm {SO}^{ plog }$ as follows:

$$\exists X (|X| = \log ^kn \wedge SEQ (X) \wedge \forall x (X(x) \rightarrow R_0(x))),$$

where X is of arity 1 and exponent k, the expression $|X| = \log ^kn$ denotes the sub-formula which defines that the cardinality of X is $\lceil \log n \rceil ^k$, and $SEQ (X)$ denotes the sub-formula expressing that the elements of X are a contiguous subsequence of the order <.

The sub-formula expressing $|X| = \log ^kn$ can be written as follows:

where Y is of arity k and exponent k, $\bar{x}, \bar{y}, \bar{z}$ denote k-tuples of first-order variables, $SUCCk (\bar{y}, \bar{z})$ denotes a sub-formula expressing that $\bar{z}$ is the immediate successor of $\bar{y}$ in the lexicographical order of k-tuples, and $|X| = |Y|$ expresses that X and Y have equal cardinality. $SUCCk (\bar{y}, \bar{z})$ can be expressed by a quantifier-free $\mathrm {SO}^{ plog }$ formula (for details refer to $SUCC _k$ in Sect. 4 in [4]). In turn, $|X| = |Y|$ can be expressed by an existential $\mathrm {SO}^{ plog }$ formula using second order variables of arity $k+1$ and exponent k (for details refer to Sect. 3.1 in [4]).

Finally, $SEQ (X)$ can be expressed in $\mathrm {SO}^{ plog }$ as follows:

$$\forall x (X(x) \rightarrow \exists y ( SUCC (x, y) \vee \forall z (X(z) \rightarrow z < x)))$$

The whole formula for $\mathrm {ConseqZeros}^{k}$ can then be rewritten in Skolem normal form as a formula in $\varSigma ^{ plog }_{1}$ with second order variables of exponent k.

Problem 4.3

($\mathrm {NoConseqZeros}^{k}$). Let $\mathrm {NoConseqZeros}^{k}$ denote the problem of deciding the language of binary strings which do not have greater than or equal $\lceil \log n\rceil ^k$ consecutive bits set to 0, where n is the length of the string. Since syntactically the negation of a formula in $\mathrm {SO}^{ plog }$ is not always a formula in $\mathrm {SO}^{ plog }$, we cannot just negate the formula for $\mathrm {ConseqZeros}^{k}$ in Problem 4.2 to get the $\mathrm {SO}^{ plog }$ formula for $\mathrm {NoConseqZeros}^{k}$. We can nevertheless define $\mathrm {NoConseqZeros}^{k}$ as follows:

$$\forall X (|X| = \log ^kn \wedge SEQ (X) \rightarrow \exists x (X(x) \wedge R_1(x)))$$

This is equivalent to:

$$\forall X (\lnot (|X| = \log ^kn) \vee \lnot SEQ (X) \vee \exists x (X(x) \wedge R_1(x))).$$

It follows that the negations of the sub-formulae $|X| = \log ^kn$ that we defined in Problem 4.2 is in $\varPi ^{ plog }_{1}$. Regarding $\lnot SEQ (X)$, it can be written in $\mathrm {SO}^{ plog }$ as

$$\exists x y z (X(x) \wedge \lnot X(y) \wedge X(z) \wedge x< y < z).$$

We then get that the formula for $\mathrm {NoConseqZeros}^{k}$ can be rewritten in Skolem normal form as a formula in $\varPi ^{ plog }_{1}$ with second order variables of exponent k.

Problem 4.4

($\mathrm {ExactlyOnce}^{k}$). Let $\mathrm {ExactlyOnce}^{k}$ denote the problem of deciding the language of binary strings which contain the substring $0^{\lceil \log n \rceil ^k}$ exactly once, i.e., s is in $\mathrm {ExactlyOnce}^{k}$ iff $0^{\lceil \log n \rceil ^k}$ is a substring of s and every other substring of s is not $0^{\lceil \log n \rceil ^k}$. This can be expressed formally in $\mathrm {SO}^{ plog }$ by combining the formulae for $\mathrm {ConseqZeros}^{k}$ and $\mathrm {NoConseqZeros}^{k}$ (see Problems 4.2 and 4.3, respectively) as follows:

$$\begin{aligned}&\exists X (|X| = \log ^kn \wedge SEQ (X) \wedge \forall x (X(x) \rightarrow R_0(x)) \\&\quad \qquad \wedge \,\forall Y (Y = X \vee \lnot (|Y| = \log ^kn) \vee \lnot SEQ (Y) \vee \exists x (X(x) \wedge R_1(x)))), \end{aligned}$$

Clearly, all second order variables in the formula need maximum exponent k and the formula itself can be rewritten in Skolem normal form as a formula in $\varSigma ^{ plog }_{2}$.

The formulae expressing the following two problems can be well understood as formulae defining B-trees where the leaves are pointers to positions in the input string.

Problem 4.5

($\mathrm {AtLeastBlocks}^{k}_{l}$). Let $\mathrm {AtLeastBlocks}^{k}_{l}$ for $k,l \ge 0$ denote the problem of deciding the language of binary strings with at least $(\lceil \log n\rceil ^k)^l$ non-overlapping adjacent substrings of the form $0^{\lceil \log n \rceil ^k}$ where n is the length of the string, or equivalently, the language of binary strings which have at least $(\lceil \log n \rceil ^k)^{l+1}$ consecutive bits set to 0.

If $l = 0$ then this is equivalent to $\mathrm {ConseqZeros}^{k}$ and, as discussed in Problem 4.2, it can be expressed in $\varSigma ^{ plog }_{1}$.

If $l = 1$, we can express $\mathrm {AtLeastBlocks}^{k}_{l}$ in $\mathrm {SO}^{ plog }$ as follows:

Here $SEQP (X)$ denotes the sub-formula expressing that X is a set of ordered pairs that form a sequence where every consecutive $(a_1, a_2)$ and $(b_1, b_2)$ in the sequence satisfy that $a_2$ is the immediate predecessor of $b_1$ in the order <. This is clearly expressible by a $\mathrm {SO}^{ plog }$ formula free of second-order quantification. The sub-formulae $min (Z) = x$ and $max (Z) = y$ have the obvious meaning and again can easily be expressed in $\mathrm {SO}^{ plog }$ without using second-order quantification. The whole sentence can be transformed into an equivalent sentence in $\varSigma ^{ plog }_{3}$.

Finally, for every $l \ge 2$, we can express $\mathrm {AtLeastBlocks}^{k}_{l}$ in $\mathrm {SO}^{ plog }$ with formulae of the form:

The sub-formulae of the form $minp (X) = x$ (resp. $maxp (X) = x$) express that x is the smallest first element (resp. biggest second element) of any tuple in X and is easily expressible in $\mathrm {SO}^{ plog }$ by a formula free of second-order quantifiers. We can rewrite the whole formula as a $\varSigma ^{ plog }_{2 \cdot l + 1}$ formula.

Problem 4.6

($\mathrm {ExactlyBlocks}^{k}_{l}$). Let $\mathrm {ExactlyBlocks}^{k}_{l}$ for $k, l \ge 0$ denote the problem of deciding the language of binary strings with exactly $(\lceil \log n\rceil ^k)^l$ non-overlapping adjacent substrings of the form $0^{\lceil \log n \rceil ^k}$ where n is the length of the string, or equivalently, the language of binary strings which contain the substring $0^{(\lceil \log n \rceil ^k)^{l+1}}$ exactly once.

If $l = 0$ then this is equivalent to $\mathrm {ExactlyOnce}^{k}$ and, as discussed in Problem 4.4, it can be expressed in $\varSigma ^{ plog }_{2}$.

If $l = 1$, we can express $\mathrm {ExactlyBlocks}^{k}_{l}$ in $\mathrm {SO}^{ plog }$ as follows:

It is not difficult to see that this formula can be rewritten as a $\varSigma ^{ plog }_{4}$ formula.

Finally, for every $l \ge 2$, we can express $\mathrm {ExactlyBlocks}^{k}_{l}$ in $\mathrm {SO}^{ plog }$ with formulae of the form:

We can rewrite formulae of this form as $\varSigma ^{ plog }_{2 \cdot l + 2}$ formulae.

5 Proper Hierarchies in Polylogarithmic Time

We now present the key results of the paper showing that all the polylogarithmic complexity classes defined in Sect. 2, including every level of the polylogarithmic time hierarchy, contain proper hierarchies defined in terms of the smallest degree of the polynomial required for the decision problems introduced in the previous section.

In order to relate the problems described in the previous section using logics to the polylogarithmic complexity classes defined in terms of random-access Turing machines, we adhere to the usual conventions concerning binary encoding of finite structures [8]. That is, if $\sigma = \{R^{r_1}_1, \ldots , R^{r_p}_p, c_1, \ldots , c_q\}$ is a vocabulary, and $\mathbf{A}$ with $A = \{0, 1, \ldots , n-1\}$ is an ordered structure of vocabulary $\sigma$. Each relation $R_i^\mathbf{A} \subseteq A^{r_i}$ of $\mathbf{A}$ is encoded as a binary string $\mathrm {bin}(R^\mathbf{A}_i)$ of length $n^{r_i}$ where 1 in a given position indicates that the corresponding tuple is in $R_i^\mathbf{A }$. Likewise, each constant number $c^\mathbf{A}_j$ is encoded as a binary string $\mathrm {bin}(c^\mathbf{A}_j)$ of length $\lceil \log n \rceil$. The encoding of the whole structure $\mathrm {bin}(\mathbf{A} )$ is simply the concatenation of the binary strings encodings its relations and constants. The length $\hat{n} = |\mathrm {bin}(\mathbf{A} )|$ of this string is $n^{r_1}+\cdots +n^{r_p} + q \lceil \log n \rceil$, where $n = |A|$ denotes the size of the input structure $\mathbf{A}$. Note that $\log \hat{n} \in O(\lceil \log n \rceil )$, so $\mathrm {NTIME}[\log ^k \hat{n}] = \mathrm {NTIME}[\log ^k n]$ (analogously for $\mathrm {DTIME}$). Therefore, we can consider random-access Turing machines, where the input is the encoding $\mathrm {bin}(\mathbf{A} )$ of the structure A followed by the endmark $\triangleleft$.

The following simple lemmas are useful to prove our hierarchy theorems. They show that the problems in the previous section can be expressed by random-access machines working in the required levels of the hierarchy theorems.

Lemma 5.1

$\mathrm {InitialZeros}^{k}$ (see Problem 4.1) is in $\mathrm {DTIME}(\log ^{k}n)$.

Proof

Assume the input tape encodes a word model $\mathbf {A}$ of signature $\pi$, i.e., a binary string. A deterministic random-access Turing machine can in deterministic time $O(\log n)$ calculate and write in its index-tape the address of the first bit in the encoding of $R_0^{\mathbf {A}}$. Then it only needs to check whether this bit and the subsequent $\lceil \log n \rceil ^k -1$ bits in the input-tape are 1. If that is the case, then the machine accepts the input. Clearly, this process takes time $O(\log ^k n)$.   $\square$

Lemma 5.2

$\mathrm {ConseqZeros}^{k}$ (see Problem 4.2) is in $\mathrm {NTIME}(\log ^{k}n)$.

Proof

Assume the input tape encodes a word model $\mathbf {A}$ of signature $\pi$. A random-access Turing machine M can non-deterministically guess a position i in the input tape which falls within the cells encoding $R^{\mathbf {A}}_0$. This takes time $O(\log n)$. Then M can check (working deterministically) in time $O(log^{k+1} n)$ whether each cell of the input tape between positions i and $i+log^{k+1} n$ has a 0.   $\square$

Lemma 5.3

$\mathrm {NoConseqZeros}^{k}$ (see Problem 4.3) is in $\mathrm {ATIME}^{ op }(\log ^k n,1)$.

Proof

Assume the input tape encodes a word model $\mathbf {A}$ of signature $\pi$. In a universal state, a random-access alternating Turing machine M can check whether for all cell in some position i in the input tape which falls in a position encoding $R^{\mathbf {A}}_0$ and is at distance at least $\lceil \log n \rceil ^k$ from the end of the encoding, there is a position between positions i and $i+\lceil \log n \rceil ^k -1$ with 0. Each of these checking can be done deterministically in time $O(log^{k} n)$. Therefore this machine decides $\mathrm {NoConseqZeros}^{k}$ in $\mathrm {ATIME}^{ op }(\log ^{k} n,1)$.   $\square$

Lemma 5.4

$\mathrm {ExactlyOnce}^{k}$ (see Problem 4.4) is in $\mathrm {ATIME}(\log ^k n,2)$.

Proof

We only need to combine the machines that decide $\mathrm {ConseqZeros}^{k}$ and $\mathrm {NoConseqZeros}^{k}$ in Lemmas 5.2 and 5.3, respectively. An alternating random-access Turing machine M can decide $\mathrm {ExactlyOnce}^{k}$ as follows: Assume the input tape encodes a word model $\mathbf {A}$ of signature $\pi$. Let s and t be the cells that mark the beginning and end of the encoding of $R^{\mathbf {A}}_0$. These cells can be calculated by M in $DTIME(\log n)$. First M checks in an existential state whether there is a position i in the input tape which fall between s and $t - \lceil \log n\rceil ^k + 1$ such that each cell between positions i and $i + \lceil \log n \rceil ^k - 1$ has a 1. Then M switches to a universal state and checks whether for all cell in some position j between s and $t - \lceil \log n \rceil ^k +1$ of the input tape other than position i, there is a cell between positions j and $j+\lceil \log n\rceil ^k - 1$ with 0. If these two checks are successful, then the input string belongs to $\mathrm {ExactlyOnce}^{k}$. We already saw in Lemmas 5.2 and 5.3 that both checks can be done in time $O(\log ^{k} n)$.   $\square$

In order to get tighter upper bounds, in the previous lemmas we explicitly defined the random-access Turing machines that decide the problems. For the following two lemmas we use the upper bounds resulting from the proof of Theorem 3.2 instead, since there seems to be no better upper bounds for these cases. Thus, Lemmas 5.5 and 5.6 follow from the facts that: (a) to evaluate the $\mathrm {SO}^{ plog }$ formulae in Problems 4.5 and 4.6 for $\mathrm {AtLeastBlocks}^{k}_{l}$ and $\mathrm {ExactlyBlocks}^{k}_{l}$, respectively, the machine needs (as shown in the proof of Theorem 3.2 in [4]) to “guess” $\lceil \log n \rceil ^k$ addresses, each of length $\lceil \log n \rceil$; and (b) the formula for $\mathrm {AtLeastBlocks}^{k}_{l}$ and $\mathrm {ExactlyBlocks}^{k}_{l}$ are in $\varSigma ^{ plog }_{2 \times l + 1}$ and $\varSigma ^{ plog }_{2 \times l + 2}$, respectively.

Lemma 5.5

$\mathrm {AtLeastBlocks}^{k}_{l}$ (see Problem 4.5) is in $\mathrm {ATIME}(\log ^{k+1} n,2 \cdot l +1)$.

Lemma 5.6

$\mathrm {ExactlyBlocks}^{k}_{l}$ (see Problem 4.6) is in $\mathrm {ATIME}(\log ^{k+1} n,2 \cdot l + 2)$.

We can now prove our first hierarchy theorem which shows that there is a strict hierarchy of problems inside DPolylogTime.

Theorem 5.1

For every $k > 1$, $\mathrm {DTIME}(\log ^k n) \subsetneq \mathrm {DTIME}(\log ^{k+1} n)$.

Proof

Lemma 5.1 proves that $\mathrm {InitialZeros}^{k+1} \in \mathrm {DTIME}(\log ^{k+1}n)$. Regarding the lower bound, we will show that $\mathrm {InitialZeros}^{k+1}$ (see Problem 4.1) is not in $\mathrm {DTIME}(\log ^{k}n)$.

Let us assume for the sake of contradiction that there is a deterministic random-access Turing machine M that decides $\mathrm {InitialZeros}^{k+1}$ in time $\lceil \log n \rceil ^k \cdot c$, for some constant $c \ge 1$. Take a string s of the form $0^n$ such that $\lceil \log n \rceil ^{k+1} > \lceil \log n \rceil ^k \cdot c$. Let $\mathbf {A}$ be its corresponding word model. Since the running time of M on input $\mathbf {A}$ is strictly less than $\lceil \log n\rceil ^{k+1}$, then there must be at least one position i among the first $\lceil \log n\rceil ^{k+1}$ cells in the encoding of $R_0^{\mathbf {A}}$ in the input tape that was not read in the computation of $M(\mathbf {A})$. Define a string $s' = 0^i10^{n-i-1}$ and a corresponding word model $\mathbf {B}$. Clearly, the output of the computations of $M(\mathbf {A})$ and $M(\mathbf {B})$ are identical. This contradicts the assumption that M decides $\mathrm {InitialZeros}^{k+1}$, since it is not true that the first $\lceil \log n\rceil ^{k+1}$ bits of $s'$ are 0.    $\square$

Our second hierarchy theorem shows that there is also a strict hierarchy of problem inside NPolylogTime.

Theorem 5.2

For every $k > 1$, $\mathrm {NTIME}(\log ^k n) \subsetneq \mathrm {NTIME}(\log ^{k+1} n)$.

Proof

Lemma 5.2 proves that $\mathrm {ConseqZeros}^{k+1} \in \mathrm {NTIME}(\log ^{k+1}n)$. Regarding the lower bound, we will show that $\mathrm {ConseqZeros}^{k+1}$ (see Problem 4.2) is not in $\mathrm {NTIME}(\log ^{k}n)$.

Let us assume for the sake of contradiction that there is a nondeterministic random-access Turing machine M that decides $\mathrm {ConseqZeros}^{k+1}$ in time $\lceil \log n \rceil ^k \cdot c$, for some constant $c \ge 1$. Take a binary string s of the form $0^{\lceil \log n \rceil ^{k+1}}1^{n-\lceil \log n \rceil ^{k+1}}$ such that $\lceil \log n \rceil ^{k+1} > \lceil \log n \rceil ^k \cdot c$. Let $\mathbf {A}$ be its corresponding word model. Since M accepts $\mathbf {A}$, then there is at least one computation $\rho$ of M which accepts $\mathbf {A}$ in at most $\lceil \log n \rceil ^k \cdot c$ steps. Then there must be at least one position i among the first $\lceil \log n \rceil ^{k+1}$ cells in the encoding of $R_0^{\mathbf {A}}$ in the input tape that was not read during computation $\rho$. Define a string $s' = 0^{i}10^{\lceil \log n \rceil ^{k+1}-i-1}1^{n-\lceil \log n \rceil ^{k+1}}$ and a corresponding word model $\mathbf {B}$. Clearly, the accepting computation $\rho$ of $M(\mathbf {A})$ is also an accepting computation of $M(\mathbf {B})$. This contradicts the assumption that M decides $\mathrm {ConseqZeros}^{k+1}$, since it is not true that there are $\lceil \log n \rceil ^{k+1}$ consecutive zeros in $s'$.    $\square$

The following theorem shows that there is a strict hierarchy of problems inside the first level of the $\tilde{\varPi }_m^{ plog }$ hierarchy.

Theorem 5.3

For every $k > 1$, $\mathrm {ATIME}^{ op }(\log ^k n,1) \subsetneq \mathrm {ATIME}^{ op }(\log ^{k+1} n,1)$.

Proof

Lemma 5.3 proves that $\mathrm {NoConseqZeros}^{k+1} \in \mathrm {ATIME}^{ op }(\log ^{k+1} n,1)$. Regarding the lower bound, we will show that $\mathrm {NoConseqZeros}^{k+1}$ (see Problem 4.3) is not in $\mathrm {ATIME}^{ op }(\log ^k n,1)$.

Let us assume for the sake of contradiction that there is an alternating random-access Turing machine M that decides $\mathrm {NoConseqZeros}^{k+1}$ using only universal states and in time $\lceil \log n \rceil ^k \cdot c$, for some constant $c \ge 1$. Take a binary string s of the form $0^{\lceil \log n \rceil ^{k+1}}1^{n-\lceil \log n \rceil ^{k+1}}$ such that $\lceil \log n \rceil ^{k+1} > \lceil \log n \rceil ^k \cdot c$. Let $\mathbf {A}$ be its corresponding word model. From our assumption that M decides $\mathrm {NoConseqZeros}^{k+1}$, we get that there is a rejecting computation $\rho$ of $M(\mathbf {A})$. Since every computation of M which rejects $\mathbf {A}$ must do so reading at most $\lceil \log n \rceil ^k \cdot c$ cells, then there must be at least one position i among the first $\lceil \log n \rceil ^{k+1}$ cells in the encoding of $R_0^{\mathbf {A}}$ in the input tape that was not read during computation $\rho$. Define a string $s' = 0^i10^{{\lceil \log n \rceil ^{k+1}} - i - 1}1^{n-\lceil \log n \rceil ^{k+1}}$ and a corresponding word model $\mathbf {B}$. Clearly, the rejecting computation $\rho$ of $M(\mathbf {A})$ is also a rejecting computation of $M(\mathbf {B})$. This contradicts the assumption that M decides $\mathrm {NoConseqZeros}^{k+1}$, since $s'$ do not have $\lceil \log n\rceil ^{k+1}$ consecutive bits set to 0 and should then be accepted by all computations of M.    $\square$

The following theorem shows that there is a strict hierarchy of problems inside the second level of the $\tilde{\varSigma }_m^{ plog }$ hierarchy.

Theorem 5.4

For every $k > 1$, $\mathrm {ATIME}(\log ^k n,2) \subsetneq \mathrm {ATIME}(\log ^{k+1} n,2)$.

Proof

Lemma 5.4 proves that $\mathrm {ExactlyOnce}^{k+1} \in \mathrm {ATIME}(\log ^{k+1} n,2)$. Regarding the lower bound, we will show that $\mathrm {ExactlyOnce}^{k+1}$ (see Problem 4.4) is not in $\mathrm {ATIME}(\log ^k n,2)$.

We assume for the sake of contradiction that there is an alternating random-access Turing machine M that decides $\mathrm {ExactlyOnce}^{k+1}$ in $\mathrm {ATIME}(\log ^k n,2)$. We further assume, w.l.o.g., that every final state of M is universal. Let M work in time $\lceil \log n \rceil ^k \cdot c$ for some constant c. Take a binary string s of the form $0^{\lceil \log n \rceil ^{k+1}}10^{\lceil \log n \rceil ^{k+1}}1^{n- 2 \cdot \lceil \log n \rceil ^{k+1} -1}$ such that $\lceil \log n \rceil ^{k+1} > \lceil \log n \rceil ^k \cdot c$. Let $\mathbf {A}$ be its corresponding word model. From our assumption that M decides $\mathrm {ExactlyOnce}^{k+1}$, we get that there is a rejecting computation $\rho$ of $M(\mathbf {A})$. Since every computation of M which rejects $\mathbf {A}$ must do so reading at most $\lceil \log n \rceil ^k \cdot c$ cells, then there must be a position i among the first $\lceil \log n \rceil ^{k+1}$ cells in the encoding of $R_0^{\mathbf {A}}$ in the input tape that was not read during computation $\rho$. Define a string $s' = 0^i10^{{\lceil \log n \rceil ^{k+1}} - i - 1}10^{\lceil \log n \rceil ^{k+1}}1^{n- 2\cdot \lceil \log n \rceil ^{k+1} -1}$ and a corresponding word model $\mathbf {B}$. Clearly, the rejecting computation $\rho$ of $M(\mathbf {A})$ is also a rejecting computation of $M(\mathbf {B})$. This contradicts the assumption that M decides $\mathrm {ExactlyOnce}^{k+1}$, since $s'$ has exactly one substring $0^{\lceil \log n\rceil ^{k+1}}$ and should then be accepted by all computations of M.    $\square$

The following result, together with Theorems 5.2 and 5.4, shows that there is a proper hierarchy of problems for every level of the polylogarithmic time hierarchy $\tilde{\varSigma }_{m}^{ plog }$.

Theorem 5.5

For $m > 2$ and $k > 1$, it holds that $\mathrm {ATIME}(\log ^k n,m) \subsetneq \mathrm {ATIME}(\log ^{k+2} n,m)$.

Proof

Since $m > 2$, we have that Lemma 5.5 proves that if m is odd, then $\mathrm {AtLeastBlocks}^{k+1}_{(m - 1)/2}$ is in $\mathrm {ATIME}(\log ^{k+2} n,m)$. Likewise, Lemma 5.6 proves that if m is even, then $\mathrm {ExactlyBlocks}^{k+1}_{(m - 2)/2}$ is in $\mathrm {ATIME}(\log ^{k+2} n,m)$. Regarding the lower bounds, it is easy to see (given our previous results in this section) that: (a) for odd m, $\mathrm {AtLeastBlocks}^{k+1}_{(m - 1)/2}$ is not in $\mathrm {ATIME}(\log ^{k} n,m)$, and (b) for even m, $\mathrm {ExactlyBlocks}^{k+1}_{(m - 2)/2}$ is also not in $\mathrm {ATIME}(\log ^{k} n,m)$. Note that if m is odd, then we can prove (a) by contradiction following a similar argument than in the proof of the lower bound for Theorem 5.2. Likewise, if m is even, then we can prove (b) by contradiction following a similar argument than in the proof of Theorem 5.4.    $\square$

It is clear that by taking the complements of the problems $\mathrm {AtLeastBlocks}^{k}_{l}$ and $\mathrm {ExactlyBlocks}^{k}_{l}$, a similar result holds for each level of the $\varPi ^{ plog }_{m}$ hierarchy.

Theorem 5.6

For $m = 2$ and every $k > 1$, it holds that $\mathrm {ATIME}^{ op }(\log ^k n,m) \subsetneq \mathrm {ATIME}^{ op }(\log ^{k+1} n,m)$. Moreover, For every $m > 2$ and every $k > 1$, it holds that $\mathrm {ATIME}^{ op }(\log ^k n,m) \subsetneq \mathrm {ATIME}^{ op }(\log ^{k+2} n,m)$.

6 On Polylogarithmic-Time and Complete Problems

In this section we investigate whether the concept of complete problem can somehow be applied to the complexity classes DPolylogTime and NPolylogTime. That is, we want to know whether we can isolate the most difficult problems inside these sublinear time complexity classes. The first step towards this objective is to find a suitable concept of many-one reducibility (m-reducibility for short).

It is quite clear that m-reductions with sublinear time bounds do not work. Consider for instance DPolylogTime reductions. Assume there is a complete problem P for the class NPolylogTime under DPolylogTime reductions. Let $P'$ belong to NPolylogTime and let M be a deterministic random-access Turing machine that reduces $P'$ to P in time $c' \cdot log^{k'} n$ for some constant $c'$. Then the output of M given an instance of $P'$ of length n has maximum length $c' \cdot \log ^{k'} n$. This means that, given an input of length n for $P'$ and its reduction, the random-access Turing machine that computes the complete problem P can actually compute P(s) in time $O((\log \log n)^k)$ for some fixed k. This is already highly unlikely. If as one would expect there are more than a single complete problem for the class, then we could keep applying reductions from one problem to the other, infinitely reducing the time required to compute the original problem.

Let us then consider the standard concept of Karp reducibility, i.e., deterministic polynomially bounded many-one reducibility, so that we can avoid the obvious problem described in the previous paragraph. Rather surprisingly, there is no complete problems for DPolylogTime and NPolylogTime, even under these rather expensive reductions for the complexity classes at hand.

Theorem 6.1

DPolylogTime does not have complete problems under deterministic polynomially bounded many-one reductions.

Proof

We prove it by contradiction. Assume that there is such a complete problem P. Since P is in DPolylogTime, then there is a random-access Turing machine M which computes P in time $O(\log ^k n)$ for some fixed k. Thus P belongs to $\mathrm {DTIME}(\log ^k n)$. Let us take the problem $\mathrm {InitialZeros}^{k+1}$ of deciding the language of binary strings which have a prefix of at least $\lceil \log n\rceil ^{k+1}$ consecutive zeros. Since P is complete for the whole class DPolylogTime, there must be a function $f: \{0,1\}^* \rightarrow \{0,1\}^*$, computable in polynomial-time, such that $x \in \mathrm {InitialZeros}^{k+1}$ iff $f(x) \in P$ holds for all $x \in \{0,1\}^*$. It then follows that the size of f(x) is polynomial in the size of x. Let $|f(x)| = |x|^{k'}$, we get that the machine M which computes the complete problem P can also decide $\mathrm {InitialZeros}^{k+1}$ in time $O(\log ^{k} n^{k'}) = O((k' \cdot \log n)^k) = O(\log ^k n)$. This contradicts the fact that $\mathrm {InitialZeros}^{k+1} \not \in \mathrm {DTIME}(\log ^k n)$ as shown in the proof of Theorem 5.1.    $\square$

Using a similar proof than in the previous theorem for DPolylogTime, we can prove that the same holds for NPolylogTime. In fact, we only need to replace the problem $\mathrm {InitialZeros}^{k+1}$ by $\mathrm {ConseqZeros}^{k+1}$ and the reference to Theorem 5.1 by a reference to Theorem 5.2 in the previous proof, adapting the argument accordingly.

Theorem 6.2

NPolylogTime does not have complete problems under deterministic polynomially bounded many-one reductions.

Moreover, using the problems $\mathrm {AtLeastBlocks}^{k}_{l}$ and $\mathrm {ExactlyBlocks}^{k}_{l}$ together with its complements and Theorems 5.5 and 5.6, it is easy to prove that the same holds for every individual level of the polylogarithmic time hierarchy.

Theorem 6.3

For every $m \ge 1$, $\varSigma ^{ plog }_{m}$ and $\varPi ^{ plog }_{m}$ do not have complete problems under deterministic polynomially bounded many-one reductions.

7 Concluding Remarks

In this paper we showed that none of the classes $\tilde{\varSigma }_{m}^{ plog }$ and $\tilde{\varPi }_{m}^{ plog }$ ($m \in \mathbb {N}$) in the polylogarithmic time hierarchy has a complete problem. This result follows from the existence of proper hierarchies inside each of the classes. The proof that such hierarchies exist is constructive by defining concrete problems parameterized by $k \in \mathbb {N}$ for each class. For the definition of these concrete problems we exploit the logics capturing $\tilde{\varSigma }_{m}^{ plog }$ and $\tilde{\varPi }_{m}^{ plog }$, respectively. We expect that these results can be taken further towards an investigation of the strictness of the polylogarithmic time hierarchy as such. We also expect that similar strict hierarchies can be defined in terms of subsets of formulae in $\varSigma ^{ plog }_{m}$ and $\varPi ^{ plog }_{m}$. Notice that the latter does not follow directly from the strict hierarchies proven in this paper, since in the proofs of the characterization results for the polylogarithmic-time hierarchy [3, 5], there is not an exact correspondence between the exponents in the polylogarithmic functions that bound the time complexity of the machines and the exponents in the restricted second-order variables of the $\mathrm {SO}^{ plog }$ formulae that define the machines.