The Expressive Power of Higher-Order Datalog

TL;DR

This paper extends classical descriptive complexity results to higher-order Datalog, showing that on ordered databases, k-order Datalog captures (k-1)-EXPTIME, indicating increased expressive power.

Contribution

It generalizes the expressive power of Datalog to higher orders, establishing a precise complexity characterization for k-order Datalog on ordered databases.

Findings

k-order Datalog captures (k-1)-EXPTIME on ordered databases

Higher-order Datalog has greater expressive power than classical Datalog

The results open avenues for further theoretical and practical research

Abstract

A classical result in descriptive complexity theory states that Datalog expresses exactly the class of polynomially computable queries on ordered databases. In this paper we extend this result to the case of higher-order Datalog. In particular, we demonstrate that on ordered databases, for all $k\geq2$, $k$-order Datalog captures $(k-1)$-EXPTIME. This result suggests that higher-order extensions of Datalog possess superior expressive power and they are worthwhile of further investigation both in theory and in practice. This paper is under consideration for acceptance in TPLP.

Tables

Table 1. Table 1 : Characteristics of 𝖯 𝖯 \mathsf{P} used in our analysis.

Symbol	Characteristic of $𝖯$
$l$	maximum length of a rule
$c$	number of constants
$r$	number of rules
$p$	number of predicates
$s$	number of predicate types
$t$	maximum arity of a predicate type

Equations

$$\begin{array}[]{l}\mbox{\tt union(P,Q,X):-P(X).}\\ \mbox{\tt union(P,Q,X):-Q(X).}\end{array}$$

$$\begin{array}[]{l}\mbox{\tt q(a).}\\ \mbox{\tt r(q).}\end{array}$$

$$\begin{array}[]{l}\mbox{\tt p(Q,Q):-Q(a).}\end{array}$$

$$\pi$$

$$\rho$$

$$\begin{array}[]{l}\mbox{\tt p X $\leftarrow$ (X $\approx$ a)}\\ \mbox{\tt q X Y $\leftarrow$ (X $\approx$ Y)}\\ \mbox{\tt r P Q X $\leftarrow$ (X $\approx$ b) $\wedge$ (P X) $\wedge$ (Q Y)}\end{array}$$

$$\begin{array}[]{l}\mbox{\tt p a.}\\ \mbox{\tt q X X.}\\ \mbox{\tt r P Q b $\leftarrow$ (P b),(Q Y).}\end{array}$$

$$\begin{array}[]{rcl}\textit{order}(\iota)&=&0\\ \textit{order}(o)&=&0\\ \textit{order}(\rho_{1}\rightarrow\cdots\rightarrow\rho_{n}\rightarrow o)&=&1+\textit{max}(\{\textit{order}(\rho_{i})\mid 1\leq i\leq n\})\end{array}$$

$$\text{order}((\iota \to o)\to (\iota \to o)\to \iota \to o)=1+\text{max}(\{\text{order}(\iota \to o),\text{order}(\iota )\})=2$$

$$\begin{array}[]{l}\mbox{\tt p a.}\\ \mbox{\tt q R $\leftarrow$ (R b).}\end{array}$$

$$T_{\mathsf{P}}(I)(\mathsf{p})\ d_{1}\cdots d_{n}=\begin{cases}\mathit{true},&\mbox{if there exists a clause $\mathsf{p}\ \mathsf{V}_{1}\cdots\mathsf{V}_{n}\leftarrow\mathsf{E}_{1}\wedge\cdots\wedge\mathsf{E}_{m}$ in $\mathsf{P}$ and}\\ &\mbox{a Herbrand state $s$, such that $\llbracket\mathsf{E}_{i}\rrbracket_{s[\mathsf{V}_{1}/d_{1},\ldots,\mathsf{V}_{n}/d_{n}]}(I)=\mathit{true}$}\\ &\mbox{for all $i\in\{1,\ldots,m\}$}\\ \mathit{false},&\mbox{otherwise.}\end{cases}$$

$$\begin{array}[]{lll}T_{\mathsf{P}}\uparrow 0&=&\perp_{{\cal I}_{\mathsf{P}}}\\ T_{\mathsf{P}}\uparrow(n+1)&=&T_{\mathsf{P}}(T_{\mathsf{P}}\uparrow n)\\ T_{\mathsf{P}}\uparrow\omega&=&\bigsqcup\{T_{\mathsf{P}}\uparrow n\mid n<\omega\}\end{array}$$

$$\begin{array}[]{l}\mbox{\tt input 0 a 1.}\\ \mbox{\tt input 1 b 2.}\\ \mbox{\tt input 2 b 3.}\\ \mbox{\tt input 3 a end.}\end{array}$$

$$\begin{array}[]{l}\mbox{\tt input 0 empty end.}\end{array}$$

$$\begin{array}[]{rcl}\textup{exp}_{0}(x)&=&x\\ \textup{exp}_{n+1}(x)&=&2^{\textup{exp}_{n}(x)}\end{array}$$

$$k-\mathsf{EXPTIME}=\bigcup _{r\in \mathbb{N}}\mathsf{TIME}({\text{exp}}_k(n^r))$$

$$\begin{array}[]{lll}\mbox{\tt base\_zero 0}.&&\\ \mbox{\tt base\_last I}&\leftarrow&\mbox{\tt(input I X end).}\\ \mbox{\tt base\_succ I J}&\leftarrow&\mbox{\tt(input I X J),(input J,A,K).}\\ \mbox{\tt base\_pred I J}&\leftarrow&\mbox{\tt(base\_succ J I).}\end{array}$$

Full text

††volume: 10 (3):

1 Introduction

Higher-order programming languages are widely recognized as offering a more modular and expressive way of programming. The use of higher-order constructs in functional programming has been a key factor for the development and success of the functional paradigm. Functional programmers have embraced the higher-order style of programming because they have realized that it offers significant advantages in everyday programming. Apart from the empirical evidence of the strengths of higher-order functions, there also exist concrete theoretical results that support this claim. For example, it has been demonstrated [Jones (2001)] that if we restrict attention to a functional language that is not Turing-complete, then its higher-order fragments capture broader complexity classes than the lower-order ones.

The situation in logic programming is not so clear-cut. Logic programming languages have traditionally been first-order, offering to programmers only certain restricted higher-order capabilities. There have been some serious attempts to develop general-purpose higher-order logic programming languages, most notably Hilog [Chen et al. (1993)] and $\lambda$-Prolog [Miller and Nadathur (1986)]. Although these systems have not become mainstream, they have found some remarkable application domains beyond those of traditional logic programming. For example, $\lambda$-Prolog has been used for theorem-proving and program analysis. Moreover, Hilog’s ideas have been incorporated in the Flora-2 system which has been used for meta-programming [Yang et al. (2003)] and data integration [Lovrenčić and Čubrilo (1999)]. Also, it has recently been demonstrated that higher-order logic programming can be used to concisely represent complicated user-preferences in deductive databases [Charalambidis et al. (2018)], with some demonstrated applications in airline reservation and movie-selection systems. All the above applications suggest that higher-order logic programming can open new, fresh, and promising directions for logic programming as a whole.

In this paper we provide theoretical results that affirm the power of higher-order logic programming. Intuitively speaking, we demonstrate that Higher-Order Datalog possesses superior expressive power compared to classical Datalog. Our results belong to a research stream that studies the expressive power of fragments or extensions of logic programming languages using complexity-theoretic tools. A classical expressibility theorem in this area states that on ordered databases Datalog captures $\mathsf{PTIME}$ [Papadimitriou (1985), Grädel (1992), Vardi (1982), Immerman (1986), Leivant (1989)]. This is an interesting (and somewhat unexpected) result, because it suggests that a seemingly simple language can express all polynomially computable queries. In this paper we extend this classical result to the case of Higher-Order Datalog. More specifically:

• •

We demonstrate that every language decided by a $k$-order Datalog program, $k\geq 2$, can also be decided by a $(k-1)$-exponential-time bounded Turing machine. This result relies on developing a bottom-up proof procedure for $k$-order Datalog programs, which generalizes the familiar one for classical Datalog programs.

• •

We demonstrate that every language decided by a $(k-1)$-exponential-time bounded Turing machine, $k\geq 2$, can also be decided by a $k$-order Datalog program. The proof actually involves a simulation of the Turing machine by the Higher-Order Datalog program. Our simulation uses the encoding of “big numbers” by higher-order functions (relations in our case) used in [Jones (2001)].

The above results essentially demonstrate that higher-order extensions of Datalog possess superior expressive power than classical Datalog and they are worthwhile of further investigation both in theory and in practice. Additionally, the results show a striking analogy with the expressibility results of [Jones (2001)] regarding higher-order “read-only” functional programs. It may be possible that this analogy can be further exploited to derive additional complexity-theoretic insights for interesting classes of Higher-Order Datalog programs. This possibility is discussed in the concluding section of the paper.

The rest of the paper is organized as follows. Section 2 introduces the syntax and the semantics of Higher-Order Datalog. Section 3 presents the underlying framework for connecting logic programming with complexity theory. Section 4 demonstrates that on ordered databases, for all $k\geq 2$, $k$-order Datalog captures $(k-1)$-$\mathsf{EXPTIME}$. Section 5 gives pointers to future work. A contains a version of the proof that Datalog captures $\mathsf{PTIME}$ on ordered databases; this is needed because our developments are based on extending this classical result. B contains the one direction of our proof that $k$-order Datalog captures $(k-1)$-$\mathsf{EXPTIME}$.

2 Higher-Order Datalog

2.1 The Syntax of Higher-Order Datalog

The language Higher-Order Datalog that we consider in this paper is the function-free subset of the higher-order logic programming language ${\cal H}$ introduced in [Charalambidis et al. (2013)]. Higher-Order Datalog inherited from ${\cal H}$ an important syntactic restriction which ensures that the language retains the usual least fixpoint semantics of classical logic programming. This syntactic restriction was proposed many years ago by W. W. Wadge [Wadge (1991)] (and also later independently by M. Bezem [Bezem (1999)]):

The higher-order syntactic restriction. In the head of every rule in a program, each argument of predicate type must be a variable, and all such variables must be distinct.

Example 1

The following is a legitimate higher-order program that defines the union of two relations P, Q (for the moment we use ad-hoc Prolog-like syntax):

[TABLE]

However, the following program does not satisfy Wadge’s restriction:

[TABLE]

because the predicate constant q appears as an argument in the head of a rule. Similarly, the program:

[TABLE]

is problematic because the predicate variable Q is used twice in the head of the rule.\mathproofbox

We now proceed to the exact definition of the syntax of Higher-Order Datalog. The language is based on a simple type system that supports two base types: $o$, the boolean domain, and $\iota$, the domain of individuals (data objects). The composite types are partitioned into two classes: predicate (assigned to predicate symbols) and argument (assigned to parameters of predicates).

Definition 1

Predicate* and argument types, denoted by $\pi$ and $\rho$ respectively, are defined as follows:*

[TABLE]

As usual, the binary operator $\rightarrow$ is right-associative. It can be easily seen that every predicate type $\pi$ can be written in the form $\rho_{1}\rightarrow\cdots\rightarrow\rho_{n}\rightarrow o$, $n\geq 0$, and $n$ will be called the arity of the type $\pi$; for $n=0$ we assume that $\pi=o$. We proceed by defining the syntax of Higher-Order Datalog:

Definition 2

The alphabet of Higher-Order Datalog consists of the following:

• •

Predicate constants of every predicate type $\pi$ (denoted by lowercase letters or words that start with lowercase letters such as $\mathsf{p,q,is\_zero,\ldots}$).

• •

Predicate variables of every predicate type $\pi$ (denoted by capital letters such as $\mathsf{P,Q,R,\ldots}$).

• •

Individual constants of type $\iota$ (denoted by lowercase letters or words that start with lowercase letters such as $\mathsf{a,b,end,\ldots}$).

• •

Individual variables of type $\iota$ (denoted by capital letters such as $\mathsf{X,Y,Z,\ldots}$).

• •

The inverse implication constant $\leftarrow$, the conjunction symbol $\wedge$, the left and right parentheses, and the equality constant $\approx$ for comparing terms of type $\iota$.

It will always be obvious from context whether a variable name that we use is a predicate or individual one; similarly for the names of predicate and individual constants.

Predicate constants correspond to the predicates that are defined in a program, while predicate and individual variables are used as formal parameters in such predicate definitions. The set consisting of the predicate variables and the individual variables will be called the set of argument variables. Argument variables will be usually denoted by $\mathsf{V}$ and its subscripted versions.

Definition 3

The set of terms of Higher-Order Datalog is defined as follows:

• •

Every predicate variable (respectively predicate constant) of type $\pi$ is a term of type $\pi$; every individual variable (respectively individual constant) of type $\iota$ is a term of type $\iota$;

• •

if $\mathsf{E}_{1}$ is a term of type $\rho\rightarrow\pi$ and $\mathsf{E}_{2}$ a term of type $\rho$ then $(\mathsf{E}_{1}\ \mathsf{E}_{2})$ is a term of type $\pi$.

Definition 4

The set of expressions of Higher-Order Datalog is defined as follows:

• •

A term of type $\rho$ is an expression of type $\rho$;

• •

if $\mathsf{E}_{1}$ and $\mathsf{E}_{2}$ are terms of type $\iota$, then $(\mathsf{E}_{1}\approx\mathsf{E}_{2})$ is an expression of type $o$.

Expressions (respectively terms) that have no variables will often be referred to as ground expressions (respectively ground terms). Expressions of type $o$ will often be referred to as atoms. We will omit parentheses when no confusion arises. To denote that an expression $\mathsf{E}$ has type $\rho$ we will often write $\mathsf{E}:\rho$.

Definition 5

A clause (or rule) of Higher-Order Datalog is a formula $\mathsf{p}\ \mathsf{V}_{1}\cdots\mathsf{V}_{n}\leftarrow\mathsf{E}_{1}\wedge\cdots\wedge\mathsf{E}_{m}$, where $\mathsf{p}$ is a predicate constant of type $\rho_{1}\rightarrow\cdots\rightarrow\rho_{n}\rightarrow o$, $\mathsf{V}_{1},\ldots,\mathsf{V}_{n}$, $n\geq 0$, are argument variables of types $\rho_{1},\ldots,\rho_{n}$ respectively, and $\mathsf{E}_{1},\ldots,\mathsf{E}_{m}$, $m\geq 0$, are atoms. The term $\mathsf{p}\ \mathsf{V}_{1}\cdots\mathsf{V}_{n}$ is called the head of the clause, the variables $\mathsf{V}_{1},\ldots,\mathsf{V}_{n}$ are the formal parameters of the clause and the conjunction $\mathsf{E}_{1}\wedge\cdots\wedge\mathsf{E}_{m}$ is its body. A definitional clause is a clause that additionally satisfies the following two restrictions:

All the formal parameters are distinct variables (i.e., for all $i,j$ such that $1\leq i,j\leq n$ and $i\neq j$, $\mathsf{V}_{i}\neq\mathsf{V}_{j}$). 2. 2.

The only variables that can appear in the body of the clause are its formal parameters and possibly some additional individual variables (variables of type $\iota$).

A definitional program $\mathsf{P}$ of Higher-Order Datalog is a set of definitional program clauses.

In the rest of the paper, when we refer to “clauses” and “programs” we will mean definitional ones. Notice that for uniformity reasons, the above definition requires that all formal parameters are distinct, even the type $\iota$ ones. This is not a real restriction, because two occurrences of the same individual variable in the head of a clause can be replaced by distinct variables, which are then explicitly equated in the body of the clause using the constant $\approx$.

Example 2

Assume that p is of type $\iota\rightarrow o$, q of type $\iota\rightarrow\iota\rightarrow o$ and r of type $(\iota\rightarrow o)\rightarrow(\iota\rightarrow o)\rightarrow\iota\rightarrow o$. The following is a legitimate program of Higher-Order Datalog:

[TABLE]

Notice that the formal parameters of every clause are distinct.

The above somewhat rigid syntax is quite convenient for formal purposes. We will use it in the following subsection when discussing the semantics of Higher-Order Datalog. However, in the rest of the paper we will relax the above strict notation and write in a more Prolog-like syntax.

Example 3

The program of the previous example will be written in the following simpler form:

[TABLE]

In other words, we will allow some common Prolog conventions, such as the usual fact syntax, using the comma instead of $\wedge$, allowing individual constants to appear in the heads of clauses, having multiple occurrences of the same individual variable in the head of a clause, and using the full stop to end clauses. Obviously, every program that uses the Prolog-like syntax can be transformed into the more formal one.

**Remark **

The syntax described above, although somewhat close to the traditional syntax of first-order logic programming, differs from it in one important respect: when defining predicates, we do not use the common tuple notation but instead we have adopted the “currying syntax” that is standard in functional programming languages. For example, in the head of the clause defining the predicate r above, we write r P Q b instead of the more common r(P,Q,b). Currying is an important tool that allows functions (or predicates in our case) to be partially applied, ie., invoked with less arguments than their full arity. As we are going to see in the next sections, partial applications play an important role in our constructions.

The Herbrand universe $U_{\mathsf{P}}$ of a program $\mathsf{P}$ is the set of constants that appear in $\mathsf{P}$ (if no constant appears in $\mathsf{P}$, we select an arbitrary one).

In the rest of the paper we will consider fragments of Higher-Order Datalog based on the order of predicates that appear in programs:

Definition 6

The order of a type is recursively defined as follows:

[TABLE]

The order of a predicate constant (or variable) is the order of its type.

Definition 7

For all $k\geq 1$, $k$-order Datalog is the fragment of Higher-Order Datalog in which all predicate constants have order less than or equal to $k$ and all predicate variables have order less than or equal to $k-1$.

Example 4

Consider again the program of Example 2. Predicates p and q are ordinary first-order ones. The order of r is:

[TABLE]

This program belongs to 2nd-order Datalog because the predicate constants p, q and r have order less than or equal to 2 and the predicate variables P and Q have order 1.

2.2 The Semantics of Higher-Order Datalog

In this subsection we present the semantics of Higher-Order Datalog, which is based on the ideas initially proposed in [Wadge (1991)] and subsequently extended and refined in [Kountouriotis et al. (2005), Charalambidis et al. (2013)]. The key idea is to interpret program predicates as monotonic relations. This ensures that the immediate consequence operator of the program (see Definition 13 later in this subsection), is also monotonic and therefore has a least fixpoint.

We start by defining the semantics of the types of our language. More specifically, we define simultaneously and recursively the semantics $\llbracket\rho\rrbracket$ of a type $\rho$ and a corresponding partial order $\sqsubseteq_{\rho}$ on the elements of $\llbracket\rho\rrbracket$. We adopt the usual ordering of the truth values $\mathit{false}$ and $\mathit{true}$, i.e. $\mathit{false}\leq\mathit{false}$, $\mathit{true}\leq\mathit{true}$ and $\mathit{false}\leq\mathit{true}$. Given posets $A$ and $B$, we write $[A\stackrel{{\scriptstyle m}}{{\rightarrow}}B]$ to denote the set of all monotonic functions from $A$ to $B$.

Definition 8

Let $\mathsf{P}$ be a program. Then:

• •

$\llbracket\iota\rrbracket=U_{\mathsf{P}}$* and $\sqsubseteq_{\iota}$ is the trivial partial order that relates every element of $U_{\mathsf{P}}$ to itself;*

• •

$\llbracket o\rrbracket=\{\mathit{false},\mathit{true}\}$* and $\sqsubseteq_{o}$ is the partial order $\leq$ on truth values;*

• •

$\llbracket\rho\rightarrow\pi\rrbracket=[\llbracket\rho\rrbracket\stackrel{{\scriptstyle m}}{{\rightarrow}}\llbracket\pi\rrbracket]$* and $\sqsubseteq_{\rho\rightarrow\pi}$ is the partial order defined as follows: for all $f,g\in\llbracket\rho\rightarrow\pi\rrbracket$, $f\sqsubseteq_{\rho\rightarrow\pi}g$ iff $f(d)\sqsubseteq_{\pi}g(d)$ for all $d\in\llbracket\rho\rrbracket$.*

We now proceed to define Herbrand interpretations and states.

Definition 9

A Herbrand interpretation $I$ of a program $\mathsf{P}$ is a function that assigns:

• •

to each individual constant $\mathsf{c}$ that appears in $\mathsf{P}$, the element $I(\mathsf{c})=\mathsf{c}$;

• •

to each predicate constant $\mathsf{p}:\pi$ that appears in $\mathsf{P}$, an element $I(\mathsf{p})\in\llbracket\pi\rrbracket$;

Definition 10

A Herbrand state $s$ of a program $\mathsf{P}$ is a function that assigns to each argument variable $\mathsf{V}$ of type $\rho$, an element $s(\mathsf{V})\in\llbracket\rho\rrbracket$.

In the following, $s[\mathsf{V}_{1}/d_{1},\ldots,\mathsf{V}_{n}/d_{n}]$ is used to denote a state that is identical to $s$ the only difference being that the new state assigns to each $\mathsf{V}_{i}$ the corresponding value $d_{i}$.

Definition 11

Let $\mathsf{P}$ be a program, $I$ a Herbrand interpretation, and $s$ a Herbrand state of $\mathsf{P}$. Then, the semantics of expressions is defined as follows:

• •

$\llbracket\mathsf{V}\rrbracket_{s}(I)=s(\mathsf{V})$;

• •

$\llbracket\mathsf{c}\rrbracket_{s}(I)=I(\mathsf{c})$;

• •

$\llbracket\mathsf{p}\rrbracket_{s}(I)=I(\mathsf{p})$;

• •

$\llbracket(\mathsf{E}_{1}\ \mathsf{E}_{2})\rrbracket_{s}(I)=\llbracket\mathsf{E}_{1}\rrbracket_{s}(I)(\llbracket\mathsf{E}_{2}\rrbracket_{s}(I))$;

• •

$\llbracket(\mathsf{E}_{1}\approx\mathsf{E}_{2})\rrbracket_{s}(I)=true$* if $\llbracket\mathsf{E}_{1}\rrbracket_{s}(I)=\llbracket\mathsf{E}_{2}\rrbracket_{s}(I)$ and $\mathit{false}$ otherwise.*

For ground expressions $\mathsf{E}$ we will often write $\llbracket\mathsf{E}\rrbracket(I)$ instead of $\llbracket\mathsf{E}\rrbracket_{s}(I)$ since in this case the meaning of $\mathsf{E}$ is independent of $s$. The notion of model is defined as follows:

Definition 12

Let $\mathsf{P}$ be a program and $M$ be a Herbrand interpretation of $\mathsf{P}$. Then, $M$ is a Herbrand model of $\mathsf{P}$ iff for every clause $\mathsf{p}\ \mathsf{V}_{1}\cdots\mathsf{V}_{n}\leftarrow\mathsf{E}_{1}\wedge\cdots\wedge\mathsf{E}_{m}$ in $\mathsf{P}$ and for every Herbrand state $s$, if for all $i\in\{1,\ldots,m\}$, $\llbracket\mathsf{E}_{i}\rrbracket_{s}(M)=\mathit{true}$ then $\llbracket\mathsf{p}\ \mathsf{V}_{1}\cdots\mathsf{V}_{n}\rrbracket_{s}(M)=\mathit{true}$.

Example 5

Consider the following program, where p is of type $\iota\rightarrow o$ and q of type $(\iota\rightarrow o)\rightarrow o$:

[TABLE]

It can easily be seen that the Herbrand interpretation that assigns to p the relation $\{{\tt a}\}$ and to q the relation $\{\{{\tt b}\},\{{\tt a},{\tt b}\}\}$, is a model of the program. Notice that the meaning of q is monotonic: since it is true of the relation $\{{\tt b}\}$, it has to also be true of the relation $\{{\tt a},{\tt b}\}$ (which is a superset of $\{{\tt b}\}$). Actually, the interpretation we just described is the minimum model of the program, a notion that will be discussed shortly.

We denote the set of Herbrand interpretations of a program $\mathsf{P}$ with ${\cal I}_{\mathsf{P}}$, and define a partial order on ${\cal I}_{\mathsf{P}}$ as follows: for all $I,J\in{\cal I}_{\mathsf{P}}$, $I\sqsubseteq_{{\cal I}_{\mathsf{P}}}J$ iff for every predicate constant $\mathsf{p}:\pi$ that appears in $\mathsf{P}$, $I(\mathsf{p})\sqsubseteq_{\pi}J(\mathsf{p})$. It is easy to prove that $({\cal I}_{\mathsf{P}},\sqsubseteq_{{\cal I}_{\mathsf{P}}})$ is a complete lattice; we denote by $\bigsqcup$ the least upper bound operation and by $\perp_{{\cal I}_{\mathsf{P}}}$ the least element of the lattice, with respect to $\sqsubseteq_{{\cal I}_{\mathsf{P}}}$. Intuitively, $\perp_{{\cal I}_{\mathsf{P}}}$ assigns to every program predicate in $\mathsf{P}$ the empty relation.

We can now define the immediate consequence operator for Higher-Order Datalog programs, which generalizes the corresponding operator for classical Datalog [Lloyd (1987)].

Definition 13

Let $\mathsf{P}$ be a program. The mapping $T_{\mathsf{P}}:{\cal I}_{\mathsf{P}}\rightarrow{\cal I}_{\mathsf{P}}$ is called the immediate consequence operator for $\mathsf{P}$ and is defined for every predicate constant $\mathsf{p}:\rho_{1}\rightarrow\cdots\rightarrow\rho_{n}\rightarrow o$ and $d_{i}\in\llbracket\rho_{i}\rrbracket$ as:

[TABLE]

Define now the following sequence of interpretations:

[TABLE]

We then have the following theorem (see [Wadge (1991), Kountouriotis et al. (2005), Charalambidis et al. (2013)] for more details):

Theorem 1

Let $\mathsf{P}$ be a program and let $M_{\mathsf{P}}=T_{\mathsf{P}}\uparrow\omega$. Then, $M_{\mathsf{P}}$ is the least Herbrand model of $\mathsf{P}$ and the least fixpoint of $T_{\mathsf{P}}$ (with respect to the ordering relation $\sqsubseteq_{{\cal I}_{\mathsf{P}}}$).

3 Decision Problems, Logic Programming, and Complexity Classes

In this section we initiate our investigation regarding the expressive power of Higher-Order Datalog. Our development is based on well-known ideas relating logic programming languages with complexity theory (see for example [Dantsin et al. (2001)] for an introduction of the main concepts).

Let $\Sigma$ be an alphabet. Without loss of generality, we fix $\Sigma=\{a,b\}$. Our goal is to demonstrate that sublanguages of Higher-Order Datalog correspond to interesting complexity classes over $\Sigma$. We first need to specify how strings over $\Sigma$ can be encoded in our setting. For this purpose, we use a ternary predicate input which encodes in an ordered manner the input string. For example, to represent the string abba we use the four facts:

[TABLE]

More generally, an input of length $n>0$ over $\Sigma$ can be encoded with $n$ facts of the above form. Moreover, for input of length $n=0$, namely for the empty string, we use:

[TABLE]

where empty is a constant that denotes the empty string.

Given string $w\in\Sigma^{*}$, we will write ${\cal D}_{w}$ to denote the set of facts that represent $w$ through the input relation. This encoding of input strings is usually referred as the ordered database assumption.

We will assume that every program defines a propositional accept predicate which, intuitively, signals whether a particular input string is accepted by our program. We have the following two definitions:

Definition 14

Let $\Sigma$ be an alphabet. We will say that a Higher-Order Datalog program $\mathsf{P}$ decides a language $L\subseteq\Sigma^{*}$ if for any $w\in\Sigma^{*}$, $w\in L$ iff accept is true in the minimum Herbrand model of $\mathsf{P}\cup{\cal D}_{w}$.

Definition 15

We will say that a set ${\cal Q}$ of Higher-Order Datalog programs captures the complexity class ${\cal C}$, if the set of languages decided by the programs in ${\cal Q}$ coincides with ${\cal C}$.

Assuming the above representation of input strings through the input relation, the following classical result has been obtained in many different contexts [Papadimitriou (1985), Grädel (1992), Vardi (1982), Immerman (1986), Leivant (1989)]:

Theorem 2

The set of first-order Datalog programs captures $\mathsf{PTIME}$.

We give a detailed proof of this theorem in A by refining the expositions given in [Papadimitriou (1985)] and [Dantsin et al. (2001)]. Although this is a well-known result, the reader is advised to first look through this proof before attempting to read the more involved ones in the rest of the paper. Actually, several ideas and predicates defined in A are needed to define the predicates for the higher-order case.

We now proceed to examine the expressive power of Higher-Order Datalog. We will need the following family of functions:

[TABLE]

For all $k\geq 0$, the complexity class $k-\mathsf{EXPTIME}$ is defined as follows:

[TABLE]

Notice that $0-\mathsf{EXPTIME}$ coincides with $\mathsf{PTIME}$. The following theorem, which we will establish, is an extension of Theorem 2 to the case of Higher-Order Datalog:

Theorem 3

For every $k\geq 1$, the set of $k$-order Datalog programs captures $(k-1)$-$\mathsf{EXPTIME}$.

Obviously, for $k=1$ the above theorem gives as a special case Theorem 2. The detailed proof of Theorem 3 for the cases $k\geq 2$, is developed in the next section.

4 Higher-Order Datalog and Exponential Time Bounded Turing Machines

In order to establish Theorem 3, we prove two lemmas. The first one shows that every language decided by a $k$-order Datalog program can also be decided by a $(k-1)$-exponential time bounded Turing machine. More specifically:

Lemma 1

Let $\mathsf{P}$ be a $k$-order Datalog program, $k\geq 2$, that decides a language $L$. Then, there exists a Turing machine that decides $L$ in time $O(\textup{exp}_{k-1}(n^{q}))$, where $n$ is the length of the input string and $q$ is a constant that depends only on $\mathsf{P}$.

The proof of the above lemma is given in B, and is based on calculating the time-complexity of the bottom-up proof procedure for Higher-Order Datalog.

We now demonstrate the following lemma, which is the converse of Lemma 1:

Lemma 2

Let $M$ be a deterministic Turing machine that decides a language $L$ in $(k-1)-\mathsf{EXPTIME}$, $k\geq 2$. Then, there exists a $k$-order Datalog program $\mathsf{P}$ that decides $L$.

The next three subsections establish the proof of the above lemma. The key idea is to construct a $k$-order Datalog program that simulates the $(k-1)$-exponential-time-bounded Turing machine $M$. In order to achieve this, we must use the power of higher-order relations to represent “large numbers” that count the execution steps of the machine. As it turns out, by increasing the order of the programs that we use, we can increase the range of representable numbers.

Assume that $M$ decides $L$ in time $O(\textup{exp}_{k-1}(n^{q}))$. Then there exists an integer constant $d$, such that for every input $w$ of length $n\geq 2$, $M$ terminates after at most $\textup{exp}_{k-1}(n^{d})-1$ steps. The simulation that we will present, produces the correct answer for all inputs of length at least 2 by simulating $\textup{exp}_{k-1}(n^{d})-1$ steps of the Turing machine $M$. Similarly to the first-order case (see A), for the special cases of strings of length 0 or 1 that belong to $L$, the correct answer is produced directly by appropriate rules.

In Subsection 4.1 we demonstrate that for any $d>0$, there exists a second-order Datalog program which, given any input relation of size $n$, can represent all natural numbers up to $2^{n^{d}}-1$. In Subsection 4.2 we show that using $k$-order Datalog, $k>2$, we can represent numbers up to $\textup{exp}_{k-1}(n^{d})-1$. Notice that the case $k=2$ has some differences from the case where $k>2$, and that’s why we devote two different subsections to the two cases. The differences are due to the fact that the simulation for $k=2$ uses tuples in order to represent numbers, while the simulation for $k>2$ uses higher-order predicates for the same purpose.

Finally, in Subsection 4.3 we provide the actual simulation of the $(k-1)$-exponential-time-bounded Turing machine $M$ by the $k$-order Datalog program.

4.1 The Second-Order Case

In this subsection we demonstrate that we can use second-order relations to represent numbers up to $2^{n^{d}}-1$. We use a technique similar to the one introduced in [Jones (2001)]: a number in the range $0,\ldots,2^{n^{d}}-1$ can be represented by a function $f:\{0,\ldots,n^{d}-1\}\rightarrow\{0,1\}$. Such a function is equivalent to a string of $n^{d}$ binary digits. We assume that $f(0)$ is the rightmost bit of the number and $f(n^{d}-1)$ the leftmost one. Such a string can represent any number in the required range.

Second-order Datalog can implement a function such as the above using a binary predicate p $\overline{\tt X}$ V, where $\overline{\tt X}={\tt X}_{1}\cdots{\tt X}_{d}$ is a $d$-tuple (alternatively, $d$ consecutive arguments) that can represent all numbers in the range [math] to $n^{d}-1$ (please see A), and V is a variable that can receive either the constant low or the constant high (corresponding to 0 and 1 respectively).

The main predicates that are defined in this subsection are: ${\tt zero}_{1}$, ${\tt last}_{1}$, is_zero1, ${\tt is\_non\_zero}_{1}$, ${\tt is\_last}_{1}$, ${\tt non\_last}_{1}$, pred1, succ1, equal1, and less_than1. We explain the purpose of each one of them, just before we define it. The subscript 1 in all the above predicates, denotes that we are now using first-order relations in order to represent our numbers (in A we represented smaller numbers using $d$-tuples). Notice that we will also use some additional auxiliary predicates in our definitions as-well-as some predicates from the first-order case defined in A (namely, tuple_zero, tuple_last, tuple_pred).

We start by defining the predicates ${\tt zero}_{1}$ and ${\tt last}_{1}$ that represent the first and last numbers of the range (namely 0 and $2^{n^{d}}-1$ respectively).

[TABLE]

Notice that zero1 returns in its second argument the value low for all values of its first argument (and similarly for last1 and high). We now define a predicate is_zero1 that checks if its argument is equal to the function zero1. The auxiliary predicate (all_to_right1 V N $\overline{\tt X}$) checks if all the bits of N starting from the position indicated by $\overline{\tt X}$ until the right end of N, have the value V (low in our case).

[TABLE]

Similarly we define the predicate ${\tt is\_non\_zero}_{1}$ that succeeds if its argument is not equal to the function ${\tt zero}_{1}$. The predicate (exists_to_right1 V N $\overline{\tt X}$) checks if there exists a bit of N, starting from the position indicated by $\overline{\tt X}$ until the right end of N, that has the value V (high in our case).

[TABLE]

Symmetrically, we can define the predicates ${\tt is\_last}_{1}$ and ${\tt non\_last}_{1}$, as follows:

[TABLE]

Next we define ${\tt pred}_{1}$ to capture the notion of the predecessor of a number. This is one of the cases where partial application and currying (see Remark in Section 2.1) plays an important role in our encoding of big numbers. More specifically, the predicate ${\tt pred}_{1}$ is different than the ${\tt tuple\_pred}$ predicate (see A), in the sense that it does not check if one number is the predecessor of another number; instead, if N is the representation of a number $n$ then the partially applied expression $({\tt pred}_{1}\ {\tt N})$ is the representation of the predecessor of N. The idea is that the predecessor of N, namely (pred1 N), is a number whose binary representation has at position $\overline{\tt X}$ either: (i) the same binary digit as N if there exists some bit of N that is on the right of position $\overline{\tt X}$ that has the value high, or (ii) the inverse binary digit of that of N at position $\overline{\tt X}$, if all the bits of N that are on the right of $\overline{\tt X}$ have the value low.

[TABLE]

Symmetrically, way define succ1 which gives the successor of a given number:

[TABLE]

We will also need the equality of two numbers N and M. We compare them bit by bit, starting from the leftmost possible position and moving to the left.

[TABLE]

Finally, we will need the “less-than” relation, defined as follows:

[TABLE]

In order to represent even larger numbers, we need to extend the above predicates to higher orders. This requires certain modifications to the predicate definitions, as the following subsection demonstrates.

4.2 Extending to Arbitrary Orders

To define numbers larger than $2^{n^{d}}$, we need to generalize the ideas of the previous subsection. For example, a number in the range $0,\ldots,2^{2^{n^{d}}}-1$ can be represented by a function $f:\{0,\ldots,2^{n^{d}}-1\}\rightarrow\{0,1\}$. In other words, to define the numbers and the operations at level $k+1$, for $k\geq 2$, we need to use the numbers and the operations of level $k$. The definitions we give below, have certain differences from the second-order ones given in the previous subsection. This is due to the fact that the second-order predicates, use the tuple-based predicates that are defined in A (while the ones we define below, do not). We start with ${\tt zero}_{k+1}$ and ${\tt last}_{k+1}$. Notice that the parameter X is now a relation (and not a tuple as in the case of zero1 and last1).

[TABLE]

We now define is_zerok+1 which succeeds if its argument is equal to zerok+1:

[TABLE]

Similarly we define the predicate ${\tt non\_zero}_{k+1}$ that succeeds if its argument is not equal to ${\tt zero}_{k+1}$:

[TABLE]

Symmetrically, we define the predicates ${\tt is\_last}_{k+1}$ and ${\tt non\_last}_{k+1}$, as follows:

[TABLE]

Using the above predicates we can now define predk+1 as follows:

[TABLE]

In a symmetric way we define the predicate succk+1 as follows:

[TABLE]

Equality of two numbers is defined as follows:

[TABLE]

Finally, less_thank+1 can be defined in an identical way as in the previous subsection.

4.3 Simulating Turing Machines with Higher-Order Datalog

In this section we demonstrate how we can use $k$-order Datalog to simulate $(k-1)$-exponential-time-bounded Turing machines. The simulation using second-order programs does not differ from the one that uses programs of order greater than or equal to three, except for a minor difference described below.

In order to define the initialization rules for the Turing machine, we will need a predicate that transforms the numbers $0,\ldots,n-1$ that appear in the input relation, to order-$k$ representation of numbers. Recall that such a number is a function from order-$(k-1)$ numbers to the values low and high:

[TABLE]

When $k=2$ the only required change in the above predicate is to replace all the occurrences of X by $\overline{\tt X}$.

The simulation of the exponential-time bounded Turing machine is presented below. Recall (see A) that we assume that in the beginning of its operation, the first $n$ squares of the tape hold the input, the rest of the squares hold the empty character “␣” and the machine starts operating from its initial state denoted by $s_{0}$. If the Turing machine accepts the input then it goes into the special state called yes and remains in this state forever.

One new feature (with respect to the first-order case in A), is the representation of the cursor predicate. In the first-order case we used cursor $\overline{\tt T}$ $\overline{\tt X}$ to mean that at time-point $\overline{\tt T}$ the cursor is located at position $\overline{\tt X}$. In the higher-order case the expression (cursor T) is a number that denotes the position of the cursor, ie., it is a function from positions to the values low and high. We start with the initialization rules:

[TABLE]

We now define the transition rules of the Turing machine. For each transition rule we generate rules for ${\tt state}_{s}$, ${\tt symbol}_{\sigma}$ and ${\tt cursor}$. The transition: “if the head is in symbol $\sigma$ and in state $s$ then write symbol $\sigma^{\prime}$ and go to state $s^{\prime}$”, generates the following:

[TABLE]

We continue with the transition: “if the head is in symbol $\sigma$ and in state $s$ then go to state $s^{\prime}$ and move the head right”, which generates the following:

[TABLE]

We also have the transition: “if the head is in symbol $\sigma$ and in state $s$ then go to state $s^{\prime}$ and move the head left”, which generates the following:

[TABLE]

The inertia rules are the following:

[TABLE]

Finally, we have the following rule that concerns acceptance:

[TABLE]

When $k=2$ the only required change in the clauses given above, is to replace all the occurrences of I in the definition of cursor by $\overline{\tt I}$.

5 Future Work

Theorem 3 presents a striking analogy with Theorem 7.17 of [Jones (2001)] where it is shown that read-only functional programs of order $k\geq 2$ capture $(k-1)$-$\mathsf{EXPTIME}$, and first-order such programs capture $\mathsf{PTIME}$. The functional language that Jones uses has no direct relationship with Datalog, and this makes the analogy even more interesting.

As a possible direction for future research, we would like to investigate whether the complexity results obtained in [Jones (2001)] regarding tail-recursive read-only functional programs, can extend to the case of Higher-Order Datalog. A starting point for this would be to first characterize what tail-recursion means in the context of Higher-Order Datalog. An additional topic for future research would be to investigate the complexity-theoretic benefits of adding negation to Higher-Order Datalog. Such an investigation can be based on the recent proposal for the well-founded semantics of higher-order logic programs [Charalambidis et al. (2018)].

Acknowledgements

The research of the first author was supported by the Software and Knowledge Engineering Laboratory (SKEL) of the Institute of Informatics and Telecommunications of NCSR “Demokritos”.

Appendix A The Expressive Power of First-Order Datalog

In this appendix we present a proof of the well-known theorem [Papadimitriou (1985), Grädel (1992), Vardi (1982), Immerman (1986), Leivant (1989)] that Datalog captures $\mathsf{PTIME}$ (under the assumption that the input strings are encoded, as already discussed, through the input relation). Our proof builds on that of [Papadimitriou (1985)] and [Dantsin et al. (2001)], but gives more technical details.

**Theorem **2

The set of first-order Datalog programs captures $\mathsf{PTIME}$.

Proof A.4**.**

The proof of the above theorem consists of the proofs of the following two statements:

Statement 1

Every language $L$ decided by a Datalog program $\mathsf{P}$, can also be decided by a Turing machine in time $O(n^{q})$, where $n$ is the length of the input string and $q$ is a constant that depends only on $\mathsf{P}$.

Statement 2

Every language $L$ decided by a Turing machine in time $O(n^{q})$, where $n$ is the length of its input, can be decided by a Datalog program $\mathsf{P}$.

{proof*}

[Proof of Statement 1] Assume that the maximum number of atoms that appear in any rule in $\mathsf{P}$ is equal to $l$, the total number of constants that appear in $\mathsf{P}$ is equal to $c$ (including a, b, empty, end, but excluding the $n$ natural numbers that appear in the relation input), the total number of rules in $\mathsf{P}$ is equal to $r$, the total number of predicates is equal to $p$, and the maximum arity of a predicate that appears in $\mathsf{P}$ is $t$. We present a multi-tape Turing machine which decides the language $L$ in time $O(n^{q})$, where $n$ is the length of the input string, for some $q$ that depends only on the above characteristics of $\mathsf{P}$.

The Turing machine, with input $w$, starts by constructing the set of facts ${\cal D}_{w}$ that represent $w$ in the Datalog program (i.e., the relation input), which are stored on a separate tape. Each number that appears as an argument in the relation input is written in binary using $O(\log n)$ bits. The construction of ${\cal D}_{w}$ requires $O(n\cdot\log n)$ time.

Next, the Turing machine executes the usual bottom-up procedure for computing the least fixed-point of a Datalog program through the iterations of the $T_{\mathsf{P}}$ operator. Intuitively, it starts by assigning the empty relation to all predicates in $\mathsf{P}$ and at each iteration it examines each clause of $\mathsf{P}$ and determines if it can generate any new tuples. The relations assigned to predicates in $\mathsf{P}$ are stored each on a separate tape. Observe that there are at most $p\cdot(n+c)^{t}$ tuples in the minimum Herbrand model $M_{\mathsf{P}}$ of $\mathsf{P}$ (in the extreme case where all the predicates have the same maximum arity $t$ and all possible tuples for all possible predicates belong to the minimum model). Therefore, the bottom-up procedure will terminate after at most $p\cdot(n+c)^{t}$ iterations, since at each iteration at least one tuple must be produced. Each such iteration of the bottom-up computation takes polynomial time with respect to $n$:

• •

For every rule, the machine instantiates all the variables using the $(n+c)$ available constants. The number of different such instantiations of a rule is bounded by $(n+c)^{l\cdot t}$.

• •

For each such instantiation it examines if the atoms in the body of the rule have already been produced in a previous step of the computation. Searching through the list of the already produced atoms for a specific predicate takes time $O(t\cdot\log n\cdot(n+c)^{t})$ in the worst case (since the maximum number of atoms that such a list may contain is $(n+c)^{t}$ and the length of each atom is $O(t\cdot\log n)$). Doing this for all atoms in the rule body, requires time $O(l\cdot t\cdot\log n\cdot(n+c)^{t})$. If all atoms in the (instantiated) body of the rule are found in the corresponding lists, then we search the head of the rule in the list that corresponds to its predicate; if it is not found, then it is appended at the end of the list. This search and update requires time $O(t\cdot\log n\cdot(n+c)^{t})$.

• •

Doing the above operation for all the rules of the program requires time $O(r\cdot l\cdot t\cdot\log n\cdot(n+c)^{(l+1)\cdot t})$.

From the above we get that in order to produce the minimum Herbrand model $M_{\mathsf{P}}$ of $\mathsf{P}$, we need time $O(n\cdot\log n+p\cdot r\cdot l\cdot t\cdot\log n\cdot(n+c)^{(l+2)\cdot t})$. Since $p,r,l,t$ and $c$ are constants that depend only on $\mathsf{P}$ and do not depend on $n$, the running time of the Turing machine is $O(n^{q})$ for $q=(l+2)\cdot t$.

The Turing machine returns $yes$ if and only if accept is true in the minimum Herbrand model $M_{\mathsf{P}}$.

{proof*}

[Proof of Statement 2] In order to establish the second statement, we need to define a simulator of the Turing machine in Datalog. Assume that $M$ decides $L$ in time $O(n^{q})$. Then there exists an integer constant $d$, such that for every input $w$ of length $n\geq 2$, $M$ terminates after at most $n^{d}-1$ steps. The Datalog program that is presented below produces the correct answer for all inputs of length at least 2 by simulating $n^{d}-1$ steps of the Turing machine $M$. For the special cases of strings of length 0 or 1 that belong to $L$, the correct answer is produced directly by appropriate rules (notice that for $n=1$, the value of $n^{d}-1$ is 0, regardless of the choice of $d$).

We start by defining predicates base_zero (which is true of 0, ie. of the first argument of the first tuple in the input relation), base_last (which is true of $n-1$, ie., of the first argument of the last tuple in the input relation), base_succ (which, given a number $k$, $0\leq k<n-1$, returns $k+1$), and base_pred (which given $k+1$ returns $k$):

[TABLE]

Given the above predicates, we can simulate counting from 0 up to $n-1$. We extend the range of the numbers we can support up to $n^{d}-1$ for any fixed $d$ by using $d$ distinct arguments in predicates; we view these $d$ arguments more conveniently as $d$-tuples, ie., we use the notation $\bar{\tt X}$ to represent the sequence of $d$ arguments ${\tt X}_{1},\ldots,{\tt X}_{d}$. We define the predicates ${\tt tuple\_zero}$, ${\tt tuple\_last}$ and ${\tt tuple\_base\_last}$ that act on such $d$-tuples and represent the numbers 0, $n^{d}-1$ and $n-1$ respectively.

[TABLE]

To define ${\tt tuple\_succ}$ we need $d$ clauses that have as arguments two tuples having $d$ elements each:

[TABLE]

Now we can easily define tuple_pred as follows:

[TABLE]

The less_than relation over the numbers we consider, is defined as follows:

[TABLE]

We can also define tuple_non_zero, namely the predicate that succeeds if its argument is not equal to zero:

[TABLE]

We now define predicates ${\tt symbol}_{\sigma}$, ${\tt state}_{s}$ and ${\tt cursor}$, for every $\sigma\in\Sigma$ and for every state $s$ of the Turing machine we are simulating. Intuitively, ${\tt symbol}_{\sigma}\ \overline{\tt T}\ \overline{\tt X}$ succeeds if the tape has symbol $\sigma$ in position $\overline{\tt X}$ of the tape at time-step $\overline{\tt T}$, ${\tt state}_{s}\ \overline{\tt T}$ succeeds if the machine is in state $s$ at step $\overline{\tt T}$ and ${\tt cursor}\ \overline{\tt T}\ \overline{\tt X}$ succeeds if the head of the machine points at position $\overline{\tt X}$ at step $\overline{\tt T}$. Since symbols and states are finite there will be a finite number of clauses defining the above predicates. We assume that the Turing machine never attempts to go to the left of its leftmost symbol. Moreover, we assume that in the beginning of its operation, the first $n$ squares of the tape hold the input, the rest of the squares hold the empty character “␣” and the machine starts operating from its initial state denoted by $s_{0}$. If the Turing machine accepts the input then it goes into the special state called yes and stays there forever.

The initialization of the Turing machine is performed by the following clauses:

[TABLE]

For each transition rule we generate a set of clauses. We start with the rule “if the head is in symbol $\sigma$ and in state $s$ then write symbol $\sigma^{\prime}$ and go to state $s^{\prime}$”, which is translated as follows:

[TABLE]

We continue with the transition: “if the head is in symbol $\sigma$ and in state $s$, then go to state $s^{\prime}$ and move the head right”, which generates the following:

[TABLE]

We also have the transition: “if the head is in symbol $\sigma$ and in state $s$ then go to state $s^{\prime}$ and move the head left”, which generates the following:

[TABLE]

We also need to provide “inertia” rules for the tape squares that are not affected by the above rules. These squares are exactly those that have a different position from the one pointed to by the cursor. Therefore, the following clauses will suffice:

[TABLE]

Lastly, the following rule succeeds iff the Turing machine succeeds after $n^{d}-1$ steps.

[TABLE]

In the case of strings of length $n\leq 1$ that belong to $L$, we add appropriate rules to the Datalog program. For example, if $a\in L$, then the following rule is included in the Datalog program:

[TABLE]

This completes the proof of the theorem.

Appendix B Proof of Lemma 1

Lemma B.5**.**

Let $\mathsf{P}$ be a $k$-order Datalog program, $k\geq 2$, that decides a language $L$. Then, there exists a Turing machine that decides the same language in time $O(\textup{exp}_{k-1}(n^{q}))$, where $n$ is the length of the input string and $q$ is a constant that depends only on $\mathsf{P}$.

Proof B.6**.**

Let $\mathsf{P}$ be a $k$-order Datalog program that decides a language $L$. Assume that the maximum length of a rule in $\mathsf{P}$ is equal to $l$, the total number of constants that appear in $\mathsf{P}$ is equal to $c$ (including a, b, empty, end, but excluding the $n$ natural numbers that appear in the relation input), the total number of rules in $\mathsf{P}$ is equal to $r$, the total number of predicates is equal to $p$, the total number of predicates types involved in $\mathsf{P}$ is equal to $s$, and the maximum arity of a predicate type that is involved in $\mathsf{P}$ is $t$. A summary of all these parameters is given in Table B1.

We present a multi-tape Turing machine which decides the language $L$ in time $O(\textup{exp}_{k-1}(n^{q}))$, where $n$ is the length of the input string, for some $q$ that depends only on the above characteristics of $\mathsf{P}$.

The Turing machine, with input $w$, starts by constructing the set of facts ${\cal D}_{w}$ that represent $w$ in the Datalog program (i.e., the relation input), which are stored on a separate tape. Each number that appears as an argument in the relation input is written in binary using $O(\log n)$ bits. It also writes on a separate tape all the elements of the set $\llbracket\iota\rrbracket$ (that is, the $c$ constants that occur in $\mathsf{P}$ and the $n$ numbers that appear in the input relation). This requires $O(n\cdot\log n)$ time.

Subsequently, the Turing machine performs two major phases: (i) it produces all the monotonic relations that are needed for the bottom-up execution of the program, and (ii) it performs instantiations of the rules using these monotonic relations as-well-as individual constants, computing in this way, in a bottom-up manner, the minimum Herbrand model of ${\mathsf{P}}$. The complexity of these two major phases is analyzed in detail below.

Complexity of producing the monotonic relations.

The Turing machine constructs the set $\llbracket\rho\rrbracket$, for every predicate type $\llbracket\rho\rrbracket$ of order at most $k-1$, which is involved in $\mathsf{P}$. The elements of $\llbracket\rho\rrbracket$ are monotonic functions, which are represented by their corresponding relations. Predicate types are considered in increasing order, and for each type $\llbracket\rho\rrbracket$ the set $\llbracket\rho\rrbracket$ is stored on a separate tape. These sets will be used later by the Turing machine, each time that it needs to instantiate predicate variables that occur in the rules of $\mathsf{P}$.

Before we present in more details the above construction and analyze its time complexity, we need to calculate upper bounds for the number of elements in $\llbracket\rho\rrbracket$ and for the length of their representation. We prove that, for every $j$-order predicate $\rho$, the number of elements in $\llbracket\rho\rrbracket$ is at most $\textup{exp}_{j}(t^{j-1}\cdot(n+c)^{t})$ and each of them can be represented using $O(\log n\cdot\textup{exp}_{j-1}(j\cdot t^{j}\cdot(n+c)^{t}))$ symbols. These two statements can be proved simultaneously by induction on $j$, as shown below.

For the basis of the induction, consider a first order predicate type $\rho$ of arity $m\leq t$. Each element in $\llbracket\rho\rrbracket$ corresponds to a set of tuples, where each tuple consists of $m$ constants. Since there are $(n+c)$ different constants in $\mathsf{P}\cup{\cal D}_{w}$, there are $2^{(n+c)^{m}}\leq 2^{(n+c)^{t}}=\textup{exp}_{1}(t^{0}\cdot(n+c)^{t})$ elements in $\llbracket\rho\rrbracket$. Moreover, every element in $\llbracket\rho\rrbracket$ contains at most $(n+c)^{t}$ tuples, each tuple consists of at most $t$ constants and each constant can be represented using $O(\log n)$ symbols. Thus the length of the representation of every element in $\llbracket\rho\rrbracket$ is $O(\log n\cdot t\cdot(n+c)^{t})=O(\log n\cdot\textup{exp}_{0}(1\cdot t^{1}\cdot(n+c)^{t}))$. Thus, the statement holds for $j=1$.

For the induction step, assume that $j>1$ and that our statement holds for all $i<j$. Consider a $j$-order predicate type $\rho=\rho_{1}\rightarrow\cdots\rightarrow\rho_{m}\rightarrow o$ of arity $m\leq t$. Each element in $\llbracket\rho\rrbracket$ corresponds to a subset of $\llbracket\rho_{1}\rrbracket\times\cdots\times\llbracket\rho_{m}\rrbracket$. For every $\nu$, $1\leq\nu\leq m$, $\rho_{\nu}$ is either equal to $\iota$, or is an $i$-order predicate type, with $i<j$. In the former case, $\llbracket\rho_{\nu}\rrbracket$ contains $(n+c)$ elements; in the latter case $\llbracket\rho_{\nu}\rrbracket$ contains at most $\textup{exp}_{i}(t^{i-1}\cdot(n+c)^{t})$ elements, by the induction hypothesis. In both cases $\llbracket\rho_{\nu}\rrbracket$ contains at most $\textup{exp}_{j-1}(t^{j-2}\cdot(n+c)^{t})$ elements. Using some properties of the function exp, we get that the number of elements in $\llbracket\rho\rrbracket$ is bounded by $2^{(\textup{exp}_{j-1}(t^{j-2}\cdot(n+c)^{t}))^{m}}\leq 2^{\textup{exp}_{j-1}(m\cdot t^{j-2}\cdot(n+c)^{t})}\leq 2^{\textup{exp}_{j-1}(t^{j-1}\cdot(n+c)^{t})}=\textup{exp}_{j}(t^{j-1}\cdot(n+c)^{t})$. Moreover, every element in $\llbracket\rho\rrbracket$ corresponds to a relation that contains at most $(\textup{exp}_{j-1}(t^{j-2}\cdot(n+c)^{t}))^{t}\leq\textup{exp}_{j-1}(t^{j-1}\cdot(n+c)^{t})$ tuples; each one of these tuples consists of at most $t$ elements and, by the induction hypothesis, each element can be represented using $O(\log n\cdot\textup{exp}_{j-2}((j-1)\cdot t^{j-1}\cdot(n+c)^{t}))$ symbols. By the properties of the function exp it follows that $t\cdot\textup{exp}_{j-2}((j-1)\cdot t^{j-1}\cdot(n+c)^{t})\leq\textup{exp}_{j-2}((j-1)\cdot t^{j}\cdot(n+c)^{t})\leq\textup{exp}_{j-1}((j-1)\cdot t^{j}\cdot(n+c)^{t})$ and $\textup{exp}_{j-1}(t^{j-1}\cdot(n+c)^{t})\cdot\textup{exp}_{j-1}((j-1)\cdot t^{j}\cdot(n+c)^{t})\leq\textup{exp}_{j-1}(j\cdot t^{j}\cdot(n+c)^{t})$. Thus, the length of the representation of a $j$-order relation is $O(\log n\cdot\textup{exp}_{j-1}(j\cdot t^{j}\cdot(n+c)^{t}))$.

Since $c,t$ and $j$ are constants that do not depend on $n$, it follows that for every $j$-order predicate $\rho$, the number of elements in $\llbracket\rho\rrbracket$ is $O(\textup{exp}_{j}(n^{t+1}))$ and each of these elements can be represented using $O(\textup{exp}_{j-1}(n^{t+1}))$ symbols.

In order to create a list with all the elements of type $\llbracket\rho\rrbracket$ for a $j$-order type $\rho=\rho_{1}\rightarrow\cdots\rightarrow\rho_{m}\rightarrow o$ of arity $m\leq t$, the Turing machine first constructs the cartesian product $S=\llbracket\rho_{1}\rrbracket\times\cdots\times\llbracket\rho_{m}\rrbracket$. Since $\rho_{1},\cdots,\rho_{m}$ have order at most $j-1$, the sets $\llbracket\rho_{1}\rrbracket,\cdots,\llbracket\rho_{m}\rrbracket$ have already been constructed in previous steps of the Turing machine. The construction of $S$ requires time linear to the length of its representation, provided that the sets $\llbracket\rho_{1}\rrbracket,\cdots,\llbracket\rho_{m}\rrbracket$ are stored on separate tapes. Since $\rho$ may have arguments of the same type, this may require to create at most $m-1$ copies of such sets. Notice that the sets $S,\llbracket\rho_{1}\rrbracket,\cdots,\llbracket\rho_{m}\rrbracket$ are actually $j$-order relations, and therefore their representations have length $O(\textup{exp}_{j-1}(n^{t+1}))$. We conclude that the time required to create $S$ is $O(\textup{exp}_{j-1}(n^{t+1}))$ (since $m$ is a constant that does not depend on $n$).

The set $\llbracket\rho\rrbracket$ contains the elements in the powerset $2^{S}$ of $S$ which represent monotonic functions. The set $2^{S}$ can be constructed in time linear to the length of its representation. Since $2^{S}$ is a $(j+1)$-order relation, this length is $O(\textup{exp}_{j}(n^{t+1}))$. Thus, $2^{S}$ can be constructed in time $O(\textup{exp}_{j}(n^{t+1}))$. Now, $\llbracket\rho\rrbracket$ can be obtained from $2^{S}$, by removing elements that represent non-monotonic functions. In order to decide whether a relation in $2^{S}$ belongs to $\llbracket\rho\rrbracket$, it suffices to consider each pair of elements in $S$ and verify that, for this pair, the monotonicity property is not violated. This verification requires time linear to the length of the relation, for each pair of elements in $S$. Thus, the time required to check whether a relation represents a monotonic function is $O((\textup{exp}_{j-1}(n^{t+1}))^{2t}\cdot\textup{exp}_{j-1}(n^{t+1}))$. The number of relations in $2^{S}$ is $O(\textup{exp}_{j}(n^{t+1}))$. Using the properties of the function exp, we get that $(\textup{exp}_{j-1}(n^{t+1}))^{2t}\cdot\textup{exp}_{j-1}(n^{t+1})\cdot\textup{exp}_{j}(n^{t+1})\leq\textup{exp}_{j}(2t\cdot n^{t+1})\cdot\textup{exp}_{j}(n^{t+1})\cdot\textup{exp}_{j}(n^{t+1})\leq\textup{exp}_{j}((2t+2)\cdot n^{t+1})\leq\textup{exp}_{j}(n^{t+2})$. Thus, the removal of relations that do not correspond to monotonic functions requires time $O(\textup{exp}_{j}(n^{t+2}))$.

By adding the times required to construct $S$ and $2^{S}$, and remove non-relevant relations, we conclude that the time to create a list with all the elements in $\llbracket\rho\rrbracket$ is $O(\textup{exp}_{j-1}(n^{t+1}))+O(\textup{exp}_{j}(n^{t+1}))+O(\textup{exp}_{j}(n^{t+2}))=O(\textup{exp}_{j}(n^{t+2}))$.

The above process is executed for each of the $s$ predicate types of order at most $k-1$ involved in $\mathsf{P}$. Since $s$ is a constant that does not depend on $n$, the time required for the construction of all the relations of each predicate type is $O(\textup{exp}_{k-1}(n^{t+2}))$.

Complexity of performing the bottom-up computation.

Next, the Turing machine essentially computes the successive approximations to the minimum Herbrand model $M_{\mathsf{P}}$ of $\mathsf{P}$, by iterative application of the $T_{\mathsf{P}}$ operator (as described at the end of Section 2). For each predicate constant defined in $\mathsf{P}$, the relation that represents its meaning is written on a separate tape; initially all these relations are empty. At each iteration of the $T_{\mathsf{P}}$ operator, new tuples may be added to the meaning of predicate constants. In order to calculate one iteration of $T_{\mathsf{P}}$, the Turing machine considers each clause in $\mathsf{P}$ and examines what new tuples it can produce. More specifically, given a rule, it replaces every individual variable that appears in the rule by a constant symbol and every predicate variable with a monotonic relation of the same type as the variable; moreover, it replaces every predicate constant, say $\mathsf{q}$, that appears in the body of the clause with the relation that has been computed for $\mathsf{q}$ during the previous iterations of $T_{\mathsf{P}}$. It then checks if the body of the instantiated clause evaluates to true: this is performed by essentially checking if elements belong to sets. If an instantiation of a clause body evaluates to true, the instantiated head is added to the meaning of the head predicate.

Observe that there are at most $p\cdot(\textup{exp}_{k-1}(t^{k-2}\cdot(n+c)^{t}))^{t}$ tuples in the minimum Herbrand model $M_{\mathsf{P}}$ of $\mathsf{P}$ (in the extreme case, all the predicates have order $k$, the same maximum arity $t$ and all possible tuples for all possible predicates belong to the minimum model). Therefore, the bottom-up procedure will terminate after at most $p\cdot(\textup{exp}_{k-1}(t^{k-2}\cdot(n+c)^{t}))^{t}$ iterations, since at each iteration at least one tuple must be produced. Since $(\textup{exp}_{k-1}(t^{k-2}\cdot(n+c)^{t}))^{t}\leq\textup{exp}_{k-1}(t^{k-1}\cdot(n+c)^{t})$ and $k,p,t$ are constants that do not depend on $n$, the number of iterations is $O(\textup{exp}_{k-1}(n^{t+1}))$.

We calculate a bound of the time that is required for each one of the above iterations:

• •

For every rule in the program, the Turing machine instantiates each individual variable in the rule using elements in $\llbracket\iota\rrbracket$. Moreover, it instantiates each predicate variables of type $\rho$ with relations representing monotonic functions in $\llbracket\rho\rrbracket$ (recall that these sets have been constructed in the first phase of the execution of the Turing machine). Finally, it replaces every predicate constant in the body of the rule with the relation that has already been computed for it during the previous iterations of $T_{\mathsf{P}}$. By the syntactic rules of Higher-Order Datalog programs, predicate variables may have order at most $k-1$. Thus, the number of different such instantiations of a rule is bounded by $(\textup{exp}_{k-1}(t^{k-2}\cdot(n+c)^{t}))^{l}$. Since $(\textup{exp}_{k-1}(t^{k-2}\cdot(n+c)^{t}))^{l}\leq\textup{exp}_{k-1}(l\cdot t^{k-2}\cdot(n+c)^{t})$ and $k,l,t$ are constants that do not depend on $n$, the number of different instantiations for each rule is $O(\textup{exp}_{k-1}(n^{t+1}))$.

• •

Each rule contains a constant number of (individual or predicate) variables. Since all predicate variables have order at most $k-1$, each variable is replaced by at most $O(\textup{exp}_{k-2}(n^{t+1}))$ symbols. Thus, the length of the instantiated rule is $O(\textup{exp}_{k-2}(n^{t+1}))$. Moreover, the instantiation can be computed in time linear to its length.

• •

For each such instantiation the Turing machine examines if the body of the rule evaluates to true. This may require at most $l$ rewritings of the instantiated body of the rule, each resulting after partially applying a predicate to its first argument. Each rewriting requires time linear to the length of the instantiated rule, that is, $O(\textup{exp}_{k-2}(n^{t+1}))$. Since $l$ does not depend on $n$, the total time that is needed to examine if the body of the rule evaluates to true is $O(\textup{exp}_{k-2}(n^{t+1}))$.

• •

If the body of some instantiated rule evaluates to true, then we search the head of the rule in the list that corresponds to its predicate; if it is not found, then it is inserted in the list. This search and insertion requires time linear to the length of this list, which is $O(\textup{exp}_{k-1}(n^{t+1}))$.

• •

The total time needed to repeat the above process for every instantiation of a specific rule is $O(\textup{exp}_{k-1}(n^{t+1}))\cdot O(\textup{exp}_{k-1}(n^{t+1}))=O((\textup{exp}_{k-1}(n^{t+1}))^{2})$.

• •

Since the number of rules $r$ does not depend on $n$, the total time required for one iteration of the $T_{\mathsf{P}}$ operator is also $O((\textup{exp}_{k-1}(n^{t+1}))^{2})$.

From the above we get that in order to produce the minimum Herbrand model $M_{\mathsf{P}}$ of $\mathsf{P}$, we need time $O(\textup{exp}_{k-1}(n^{t+1}))\cdot O((\textup{exp}_{k-1}(n^{t+1}))^{2})=O((\textup{exp}_{k-1}(n^{t+1}))^{3})$. By the properties of the function exp, it is $(\textup{exp}_{k-1}(n^{t+1}))^{3}\leq\textup{exp}_{k-1}(3n^{t+1})\leq\textup{exp}_{k-1}(n^{t+2})$.

*We conclude that the running time of the Turing machine is $O(\textup{exp}_{k-1}(n^{q}))$ for $q=t+2$. The Turing machine returns $yes$ if and only if accept is true in the minimum Herbrand model $M_{\mathsf{P}}$. This completes the proof of the lemma. *