Stratified Negation in Limit Datalog Programs

1 Introduction

Data analysis tasks are becoming increasingly important in information systems. Although these tasks are currently implemented using code written in standard programming languages, in recent years there has been a significant shift towards declarative solutions where the definition of the task is clearly separated from its implementation [Alvaro et al., 2010; Markl, 2014; Seo et al., 2015; Wang et al., 2015; Shkapsky et al., 2016; Kaminski et al., 2017].

Languages for declarative data analysis are typically rulebased, and they have already been implemented in reasoning engines such as BOOM [Alvaro et al., 2010], DeALS [Shkapsky et al., 2016], Myria [Wang et al., 2015], SociaLite [Seo et al., 2015], Overlog [Loo et al., 2009], Dyna [Eisner and Filardo, 2011], and Yedalog [Chin et al., 2015].

Formally, such declarative languages can be seen as variants of logic programming equipped with means for capturing quantitative aspects of the data, such as arithmetic function symbols and aggregates. It is, however, well-known since the '90s that the combination of recursion with numeric computations in rules easily leads to semantic difficulties [Mumick et al., 1990; Kemp and Stuckey, 1991; Beeri et al., 1991; Van Gelder, 1992; Consens and Mendelzon, 1993; Ganguly et al., 1995; Ross and Sagiv, 1997; Mazuran et al., 2013], and/or undecidability of reasoning [Dantsin et al., 2001; Kaminski et al., 2017]. In particular, undecidability carries over to the languages underpinning the aforementioned reasoning engines for data analysis.

Kaminski et al. [2017] have recently proposed the language of limit Datalog programs-a decidable variant of negation-free Datalog equipped with arithmetic functions over the integers that is expressive enough to capture many data analysis tasks. The key feature of limit programs is that all intensional predicates with a numeric argument are limit predicates, the extension of which represents minimal (min) or maximal (max) bounds of numeric values. For instance, if we encode a weighted directed graph as facts over a ternary edge predicate and a unary node predicate in the obvious way, then the following rules encode the all-pairs shortest path problem, where the ternary min limit predicate d is used to encode the distance from any node to any other node in the graph as the length of a shortest path between them.

The semantics of min predicates is defined such that a fact d(u, v, k) is entailed from these rules and a dataset if and only if the distance from u to v is at most k; as a result, all facts d(u, v, k′ ) with k′ ≥ k are also entailed. This is in contrast to standard first order predicates, where there is no semantic relationship between d(u, v, k) and d(u, v, k′ ). The intended semantics of limit predicates can be axiomatised using rules over standard predicates; in particular, our example limit program is equivalent to a standard logic program consisting of rules (1), (2), and the following rule (3), where d is now treated as a regular first-order predicate:

Kaminski et al. [2017] showed that, under certain restrictions on the use of multiplication, reasoning (i.e., fact entailment) over limit programs is decidable and CONP-complete in data complexity; then, they proposed a practical fragment with tractable data complexity.

Limit Datalog programs as defined in prior work are, however, positive and hence do not allow for negation-as-failure in the body of rules. Non-monotonic negation applied to limit atoms can be useful, not only to express a wider range of data analysis tasks, but also to declaratively obtain solutions to problems where the cost of such solutions is defined by a positive limit program. For instance, our example limit program consisting of rules (1) and (2) provides the length of a shortest path between any two nodes, but does not provide access to any of the paths themselves-an issue that we will be able to solve using non-monotonic negation.

In this paper, we study the language of limit programs with stratified negation-as-failure. Our language extends both positive limit Datalog as defined in prior work and plain (function-free) Datalog with stratified negation. We argue that our language provides useful additional expressivity, but at the expense of increased complexity of reasoning; for programs with restricted use of multiplication, complexity jumps from CONP-completeness in the case of positive programs, to ∆P2 -completeness for programs with stratified negation. We also show that the tractable fragment of positive limit programs defined in [Kaminski et al., 2017] can be seamlessly extended with stratified negation while preserving tractability of reasoning; furthermore, the extended fragment is sufficiently expressive to capture the relevant data analysis tasks.

The proofs of all our results are given in an extended version of this paper available online at arXiv:1804.09473.

2 Preliminaries

In this section we recapitulate the syntax and semantics of Datalog programs with integer arithmetic and stratified negation (see e.g., [Dantsin et al., 2001] for an excellent survey).

Syntax We assume a fixed vocabulary of countably infinite, mutually disjoint sets of predicates equipped with nonnegative arities, objects, object variables, and numeric variables. Each position 1 ≤ i ≤ n of an n-ary predicate is of either object or numeric sort. An object term is an object or an object variable. A numeric term is an integer, a numeric variable, or of the form s1 + s2, s1 - s2, or s1 × s2 where s1 and s2 are numeric terms and +, -, and × are the standard arithmetic functions. A constant is an object or an integer. A standard atom is of the form B(t1, . . . , tn), with B an n-ary predicate and each ti a termmatching the sort of the i-th position of B. A (standard) positive literal is a standard atom, and a (standard) negative literal is of the form notα, for α a standard atom. A comparison atom is of the form (s1 < s2) or (s1 ≤ s2), with < and ≤ the usual comparison predicates over the integers, and s1 and s2 numeric terms. We write (s1 .= s2) as an abbreviation for (s1 ≤ s2) ∧ (s2 ≤ s1). A term, atom or literal is ground if it has no variables.

A rule r has the form ∧i µi ∧ ∧j βj → α, where the body ∧i µi ∧ ∧j βj is a possibly empty conjunction of standard literals µi and comparison atoms βj, and the head α is a standard atom. We assume without loss of generality that standard body literals are function-free; indeed, a conjunction with a functional term s can be equivalently rewritten by replacing s with a fresh variable x and adding (x .= s) to the conjunction. A rule r is safe if each object variable in r occurs in a positive literal in the body of r. A ground instance of r is obtained from r by substituting each variable by a constant of the right sort.

A fact is a rule with empty body and a function-free standard atom in the head that has no variables in object positions and no repeated variables in numeric positions. Intuitively, a variable in a fact says that the fact holds for every integer in the position. As a convention, we will omit → and use symbol ∞ instead of variables when writing facts. A dataset D is a finite set of facts. Dataset D is ordered if (i) it contains facts first(a1), next(a1, a2), . . . , next(an-1, an), last(an) for some repetition-free enumeration a1, . . . , an of all objects in D; and (ii) it contains no other facts over predicates first, next , and last . A program is a finite set of safe rules; without loss of generality we assume that distinct rules do not share variables. A predicate B is intensional (IDB) in a program P if B occurs in P in the head of a rule that is not a fact; otherwise, B is extensional (EDB) in P. Program P is positive if it has no negative literals, and it is semi-positive if negation occurs only in front of EDB atoms. A stratification of P is a function λ mapping each predicate to a positive integer such that, for each rule with the head over a predicate A and each standard body literal µ over B, we have λ(B) ≤ λ(A) if µ is positive, and λ(B) < λ(A) if µ is negative. Program P is stratified if it admits a stratification. Given a stratification λ, we write P[i] for the i-th stratum of P over λ-that is, the set of all rules in P whose head predicates A satisfy λ(A) = i. Note that each stratum is a semi-positive program.

Semantics A (Herbrand) interpretation I is a possibly infinite set of ground facts (i.e., facts without ∞). Interpretation I satisfies a ground atom α, written I |= α, if either (i) α is a standard atom such that evaluation of the arithmetic functions in α under the usual semantics over integers produces a fact in I; or (ii) α is a comparison atom that evaluates to true under the usual semantics. Interpretation I satisfies a ground negative literal notα, written I |= notα, if I ̸|= α. The notion of satisfaction is extended to conjunctions of ground literals, rules, and programs as in first-order logic, with all variables in rules implicitly universally quantified. If I satisfies a program P, then I is a model of P. For I a Herbrand interpretation and R a (possibly infinite) semi-positive set of rules, let SR(I) be the set of facts α such that ϕ → α is a ground instance of a rule in R and I |= ϕ. Given a program P and a stratification λ of P, for each i, j ≥ 0 we define interpretation I j i by induction on i and j:

The materialisation M(P) of P is the interpretation I∞ k , for k the greatest number such that P[k] ̸= ∅. The materialisation of a program does not depend on the chosen stratification. A stratified program P entails a fact α, written P |= α, if α′ ∈ M(P) for every ground instance α′ of α. For positive programs, this definition coincides with the usual first-order notion of entailment: for P positive and α a fact, P |= α if and only if I |= α holds for all I |= P.

Reasoning We study the computational properties of checking whether P ∪ D |= α, for P a program, D a dataset, and α a fact. We are interested in data complexity, which assumes that only D and α form the input while P is fixed. Unless otherwise stated, all numbers in the input are coded in binary, and the size ‖P‖ of P is the size of its representation. Checking P ∪D |= α is undecidable even if the only arithmetic function in P is + [Dantsin et al., 2001] and predicates have at most one numeric position [Kaminski et al., 2017].

We use standard definitions of the basic complexity classes such as P, NP, CONP, and FP. Given a complexity class C, PC is the class of decision problems solvable in polynomial time by deterministic Turing machines with an oracle for a problem in C; functional class FPC is defined similarly. Finally, ∆P2 is a synonym for P NP .

3 Stratified Limit Programs

We introduce stratified limit programs as a language that can be seen as either a semantic or a syntactic restriction of Datalog with integer arithmetic and stratified negation. Our language is also an extension of that in [Kaminski et al., 2017] with stratified negation.

Definition 1. A stratified limit program is a pair (P, τ ) where

• P is a stratified program where each predicate either has no numeric position, in which case it is an object predicate, or only its last position is numeric, in which case it is a numeric predicate, and
• τ is a partial function from numeric predicates to {min,max} that is total on the IDB predicates in P and on predicates occurring in non-ground facts.

A numeric predicate A is a min (or max) limit predicate if τ(A) = min (or τ(A) = max, respectively). Numeric predicates that are not limit predicates are ordinary. An atom, fact or literal is numeric, limit, etc. if so is the used predicate.

All notions defined on ordinary Datalog programs P (such as EDB and IDB predicates, stratification, etc.) transfer to limit programs (P, τ ) by applying them to P. We often abuse notation and write P instead of (P, τ) when τ is clear from the context or immaterial. Whenever we consider a union of two limit programs, we silently assume that they coincide on τ. Finally, we denote ≤ (or ≥) by ⪯A if A is a max (or, respectively, min) limit predicate.

Intuitively, a limit fact B(⃗a, k) says that the value of B for a tuple of objects ⃗a is k or more, if B is max, or k or less, if B is min. For example, a min limit fact d(u, v, k) in our allpairs shortest path example says that node v is reachable from node u via a path with cost k or less. The intended semantics of limit predicates can be axiomatised using standard rules as given next.

Definition 2. An interpretation I satisfies a limit program (P, τ) if it satisfies the program P ∪ ax(P), where ax(P) contains the following rule for each limit predicate A in P:

The materialisation M(P, τ) of (P, τ) is M(P ∪ ax(P)); and (P, τ) entails α, written (P, τ) |= α, if α ∈ M(P, τ).

We next demonstrate the use of stratified negation on examples. One of the main uses of negation of a limit atom is to 'access' the limit value (e.g., the length of a shortest path) attained by the atom in the materialisation of previous strata, and then exploit such values in further computations. To facilitate such use of negation in examples, we introduce a new operator as syntactic sugar in the language.

Definition 3. The least upper bound expression ⌈A(⃗s, n)⌉ of a max (or min) limit atom A(⃗s, n) is the conjunction A(⃗s, n)∧not A(⃗s, m)∧(m .= n+t) where t = 1 (or t = -1, respectively) and m is a fresh variable.

Clearly, I |= ⌈A(⃗a, k)⌉ for I an interpretation and A(⃗a, k) a ground atom if k is the limit integer such that I |= A(⃗a, k).

Example 4. An input of the single-pair shortest path problem can be encoded in the obvious way as a dataset Dsp using a ternary ordinary numeric predicate edge to represent the graph's weighted edges, and unary facts source(u) and target(v) to identify the source and target nodes u and v, respectively. The stratified limit program Psp given next computes, together with Dsp (where all edge weights are positive), a DAG over a binary object predicate sp-edge such that every maximal path in the DAG is a shortest path from u to v.

The first stratum consists of rules (4) and (5), and computes the length of a shortest path from u to all other nodes using the min predicate ds; in particular, Psp ∪Dsp |= ⌈ds(v, k)⌉ if and only if k is the length of a shortest path from u to v. Then, in a second stratum, the program computes the sp-edge predicate such that Psp ∪Dsp |= sp-edge(a, b) if and only if the edge (a, b) is part of a shortest path from u to v. ✁

Example 5. The closeness centrality of a node in a strongly connected weighted directed graph G is a measure of how central the node is in the graph [Sabidussi, 1966]; variants of this measure are useful, for instance, for the analysis of market potential. Most commonly, closeness centrality of a node u is defined as 1/ ∑v node in G d(u, v), where d(u, v) is the length of a shortest path from u to v; the sum in the denominator is often called the farness centrality of v. We next give a limit program computing a node of maximal closeness centrality in a given directed graph. We encode a graph as an ordered dataset Dcc using, as before, a unary object predicate node and a ternary ordinary numeric predicate edge. Program Pcc consists of rules (8)-(16), where d, fness ′ and fness are min predicates, and centre ′ and centre are object predicates.

The first stratum consists of rules (8)-(12). Rules (8) and (9) compute the distance (length of a shortest path) between any two nodes. Rules (10)-(12) then compute the farness centrality of each node based on the aforementioned distances; for this, the program exploits the order predicates to iterate over the nodes in the graph while recording the best value obtained so far in the iteration using an auxiliary predicate fness ′ . In the second stratum (rules (13)-(16)), the program uses negation to compute the node of minimum farness centrality (and hence of maximum closeness centrality), which is recorded using the centre predicate; the order is again exploited to iterate over nodes, and an auxiliary predicate centre ′ is used to record the current node of the iteration and the node with the best centrality encountered so far. ✁

4 Stratified Limit-Linear Programs

By results in [Kaminski et al., 2017], checking fact entailment is undecidable even for positive limit programs. Essentially, this follows from the fact that checking rule applicability over a set of facts requires solving arbitrary non-linear inequalities over integers-that is, solving the 10th Hilbert problem, which is undecidable. To regain decidability, they proposed a restriction on positive limit programs, called limitlinearity, which ensures that every program satisfying the restriction can be transformed using a grounding technique so that all numeric terms in the resulting program are linear. In particular, this implies that rule applicability can be determined by solving a system of linear inequalities, which is feasible in NP. As a result, fact entailment for positive limitlinear programs is CONP-complete in data complexity.

We next extend the notion of limit-linearity to programs with stratified negation, and define semi-grounding as a way to simplify a limit-linear program by replacing certain types of variables with constants. We then prove that fact entailment is ∆P2 -complete in data complexity for such programs. All programs in our previous examples are limit-linear as per the definition given next.

Definition 6. A numeric variable n is guarded in a rule r of a stratified limit program if

• either n occurs in a positive ordinary literal in r;
• or the body of r contains the literals

where A is a max (or min) predicate, t = 1 (or t = -1, respectively), and n ∈ {n1, n2}.

Rule r is limit-linear if each numeric term in r is of the form s0 + ∑ni=1 si ×mi, where each mi is a distinct numeric variable not occurring in r in a (positive or negative)

ordinary numeric literal, term s0 uses only variables occurring in a positive ordinary literal in r, and terms si with i ≥ 1 use only variables that are guarded in r and do not use +. A limit-linear program contains only limit-linear rules.

A rule r is semi-ground if all variables in r are numeric and occur only in limit and comparison atoms. The semigrounding of a program P is obtained by replacing, in every rule r in P, each object variable and each numeric variable occurring in an ordinary numeric atom in r with a constant in P in all possible ways.

It is easily seen that the semi-grounding of a limit-linear program P entails the same facts as P for every dataset. Furthermore, as in prior work, Definition 6 ensures that the semi-grounding of a positive limit-linear program contains only linear numeric terms; finally, for programs with stratified negation, it ensures that negation can be eliminated while preserving limit-linearity when the program is materialised stratum-by-stratum, as we will discuss in detail later on.

Decidability of fact entailment for positive limit-linear programs is established by first semi-grounding the program and then reducing fact entailment over the resulting program to the validity problem of Presburger formulas [Kaminski et al., 2017]-that is, first-order formulas interpreted over the integers and composed using only variables, constants 0 and 1, functions + and -, and the comparisons.

The extension of such a reduction to stratified limit programs, however, is complicated by the fact that in the presence of negation-as-failure, entailment no longer coincides with classical first-order entailment. We thus adopt a different approach, where we show decidability and establish data complexity upper bounds according to the following steps.

Step 1. We extend the results in [Kaminski et al., 2017] for positive programs by showing that, for every positive limitlinear program P and dataset D, we can compute in FP NP a finite representation of its (possibly infinite) materialisation M(P ∪ D) (see Lemma 8 and Corollary 9). This representation is called the pseudo-materialisation of P ∪ D.

Step 2. We further extend the results in Step 1 to semipositive limit-linear programs, where negation occurs only in front of EDB predicates. For this, we show that fact entailment for such programs can be reduced in polynomial time in the size of the data to fact entailment over semi-ground positive limit-linear programs by exploiting the notion of a reduct (see Definition 10 and Lemma 11). Thus, we can assume existence of an FP NP oracle O for computing the pseudomaterialisation of a semi-positive limit-linear program.

Step 3. We provide an algorithm (see Algorithm 1) that decides entailment of a fact α by a stratified limit-linear program P using oracle O from Step 2. The algorithm maintains a pseudo-materialisation J, which is initially empty and is constructed bottom-up stratum by stratum. In each step i, the algorithm updates the pseudo-materialisation by applying O to the union of the pseudo-materialisation for stratum i-1 and the rules in the i-th stratum. The final J, from which entailment of α is obtained, is computed using a constant number of oracle calls in the size of the data, which yields a ∆P2 data complexity upper bound (Proposition 13 and Theorem 15).

In what follows, we specify each of these steps. We start by formally defining the notion of a pseudo-materialisation P(P) of a stratified limit program P, which compactly represents the materialisation M(P). Intuitively, M(P) can be infinite because it can contain, for any limit predicate B and tuple of objects ⃗a of suitable arity, an infinite number of facts of the formB(⃗a, k). However, if the materialisation has facts of this form, then either there is a limit value ℓ such that B(⃗a, k) ∈ M(P) for each k ⪯B ℓ and B(⃗a, k′ ) /∈ M(P) for each k′ ≻B ℓ, or B(⃗a, k) ∈ M(P) for every integer k. As argued in prior work, it then suffices for the pseudomaterialisation to contain only a single fact B(⃗a, ℓ) in the former case, or B(⃗a,∞) in the latter case.

Definition 7. A pseudo-interpretation J is a set of facts such that ∞ occurs only in facts over limit predicates and k = k′ holds for all facts B(⃗a, k) and B(⃗a, k′ ) in J with limit B.

The pseudo-materialisation of a limit program P, written P(P), is the (unique) pseudo-interpretation such that

1. an object or ordinary numeric fact is contained in P(P) if and only if it is contained inM(P); and
2. for each limit predicate B, object tuple ⃗a, and integer ℓ,
3. B(⃗a, ℓ) ∈ P(P) if and only if B(⃗a, ℓ) ∈ M(P) and B(⃗a, k) ̸∈M(P) for all k ≻B ℓ, and
4. B(⃗a,∞) ∈ P(P) if and only if B(⃗a, k) ∈M(P) for all integers k.

We now strengthen the results in [Kaminski et al., 2017] by establishing a bound on the size of pseudo-materialisations of positive, limit-linear programs.

Lemma 8. Let P be a semi-ground, positive, limit-linear program, and let D be a limit dataset. Then |P(P ∪ D)| ≤ |P ∪ D| and the magnitude of each integer in P(P ∪ D) is bounded polynomially in the largest magnitude of an integer in P ∪D, exponentially in |P|, and double-exponentially in maxr∈P ‖r‖u, where ‖r‖u stands for the size of the representation of r assuming that all numbers take unit space.

By Lemma 8, the pseudo-materialisation of P ∪ D contains at most linearly many facts; furthermore, the size of each such fact is bounded polynomially once P is considered fixed. Hence, the pseudo-materialisation of P can be computed in FP NP in data complexity, even if P is not semi-ground.

Corollary 9. Let P be a positive, limit-linear program. Then the function mapping each limit dataset D to P(P ∪ D) is computable in FP NP in ‖D‖.

In our second step, we extend this result to semi-positive programs. For this, we start by defining the notion of a reduct of a semi-positive limit-linear program P. The reduct is obtained by first computing a semi-ground instance P ′ of P and then eliminating all negative literals in P ′ while preserving fact entailment. Intuitively, negative literals can be eliminated because they involve only EDB predicates; as a result, their extension can be computed in polynomial time from the facts in P alone. To eliminate a ground negative literal µ, it suffices to check whether µ is entailed by the facts in P and simplify all rules containing µ accordingly; in turn, limit literals involving a numeric variable m can be rewritten as comparisons of m with a constant computed from the facts in P.

Definition 10. Let P be a semi-positive, limit-linear program and let D be the subset of all facts in P. The reduct of P is obtained by first computing the semi-grounding P ′ of P

ALGORITHM 1:

Parameter: oracle O computing P(P ′ ) for P ′ a semi-positive, limit-linear program Input: stratified, limit-linear programP, fact α Output: true if P |= α 1 compute a stratification λ of P 2 J ··= ∅ 3 for i := 1 to max{k | P[k] ̸= ∅} do 4 J ··= O(P[i] ∪ J) 5 end 6 return true if α is satisfied in J and false otherwise

and then applying the following transformations to each rule r ∈ P ′ and each negative body literal µ in r:

1. if µ = notα, for α a ground atom, delete r if D |= α, and delete µ from r otherwise,
2. if µ = notA(⃗a,m) is a non-ground limit literal, then
3. delete r if D |= A(⃗a, k) for each integer k;
4. delete µ from r if D ̸|= A(⃗a, k) for each k; and
5. replace µ in r with (k ≺A m) otherwise, where D |= ⌈A(⃗a, k)⌉.

Note that semi-ground programs disallow non-ground negative literals over ordinary numeric predicates, which is why these are not considered in Definition 10. As shown by the following lemma, reducts allow us to reduce fact entailment for semi-positive, limit-linear programs to semi-ground, positive, limit-linear programs.

Lemma 11. For P a semi-positive, limit-linear program and D a limit dataset, P ′ the reduct of P ∪ D, and α a fact, we have P ∪D |= α if and only if P ′ |= α. Moreover P ′ can be computed in polynomial time in ‖D‖, ‖P ′ ‖ is polynomially bounded in ‖D‖, and maxr∈P ′ ‖r‖u ≤ maxr∈P∪D ‖r‖u.

The results in Lemma 8 and Lemma 11 imply that the pseudo-materialisation of a semi-positive, limit-linear program can be computed in FP NP in data complexity.

Lemma 12. Let P be a semi-positive, limit-linear program. Then the function mapping each limit dataset D to P(P ∪D) is computable in FP NP in ‖D‖.

We are now ready to present Algorithm 1, which decides entailment of a fact α by a stratified limit-linear program P. The algorithm uses an oracle O for computing the pseudo-materialisation of a semi-positive program. The existence of such oracle and its computational bounds are ensured by Lemma 12. Algorithm 1 constructs the pseudomaterialisation P(P) of P stratum by stratum in a bottomup fashion. For each stratum i, the algorithm uses oracle O to compute the pseudo-materialisation of the program consisting of the rules in the current stratum and the facts in the pseudo-materialisation computed for the previous stratum. Once P(P) has been constructed, entailment of α is checked directly over P(P).

Correctness of the algorithm is immediate by the properties of O and the correspondence between pseudomaterialisations and materialisations. Moreover, if oracle O runs in FPC in data complexity, for some complexity class C, then it can only return a pseudo-interpretation that is polynomially bounded in data complexity; as a result, Algorithm 1

runs in PC since the number of strata of P does not depend on the input dataset.

Proposition 13. If oracle O is computable in FPC in data complexity, then Algorithm 1 runs in PC in data complexity.

The following upper bound immediately follows from the correctness of Algorithm 1 and Proposition 13.

Lemma 14. For P a stratified, limit-linear program and α a fact, deciding P |= α is in ∆P2 in data complexity.

The matching lower bound is obtained by reduction from the ODDMINSAT problem [Krentel, 1988]. An instance M of ODDMINSAT consists of a repetition-free tuple of variables 〈xN, . . . , x0〉 and a satisfiable propositional formula ϕ over these variables. The question is whether the truth assignment σ satisfying ϕ for which the tuple 〈σ(xN), . . . , σ(x0)〉 is lexicographically minimal, assuming false < true, among all satisfying truth assignments of ϕ has σ(x0) = true. In our reduction, M is encoded as a dataset DM using object predicates or and not to encode the structure of ϕ and numeric predicates to encode the order of variables in 〈xN, . . . , x0〉; a fixed, two-strata programPmodd then goes through all assignments σ in the ascending lexicographic order and evaluates the encoding of ϕ on σ until it finds some σ that makes ϕ true; Pmodd then derives fact minOdd if and only if σ(x0) = true. Thus, Pmodd ∪ DM |= minOdd if and only if M belongs to the language of ODDMINSAT.

Theorem 15. For P a stratified, limit-linear program and α a fact, deciding P |= α is ∆P2 -complete in data complexity. The lower bound holds already for programs with two strata.

5 A Tractable Fragment

Tractability in data complexity is an important requirement in data-intensive applications. In this section, we propose a syntactic restriction on stratified, limit-linear programs that is sufficient to ensure tractability of fact entailment in data complexity. Our restriction extends that of type consistency in prior work to account for negation. The programs in Examples 4 and 5 are type-consistent.

Definition 16. A semi-ground, limit-linear rule r is typeconsistent if

• each numeric term t in r is of the form k0 + ∑ni=1 ki ×mi where k0 is an integer and each ki, 1 ≤ i ≤ n, is a nonzero integer, called the coefficient of variable mi in t;
• each numeric variable occurs in exactly one standard body literal;
• each numeric variable in a negative literal is guarded;
• if the head A(⃗a, s) of r is a limit atom, then each unguarded variable occurring in s with a positive (or negative) coefficient also occurs in the body in a (unique) positive limit literal that is of the same (or different, respectively) type (i.e., min vs. max) as A;
• for each comparison (s1 < s2) or (s1 ≤ s2) in r, each unguarded variable occurring in s1 with a positive (or negative) coefficient also occurs in a (unique) positive min (or max, respectively) body literal, and each unguarded variable occurring in s2 with a positive (or negative) coefficient occurs in a (unique) positive max (or min, respectively) body literal.

A semi-ground, stratified, limit-linear program is typeconsistent if all of its rules are type-consistent. A stratified limit-linear program P is type-consistent if the program obtained by first semi-grounding P and then simplifying all numeric terms as much as possible is type-consistent.

Similarly to type-consistency for positive programs, Definition 16 ensures that divergence of limit facts to ∞ can be detected in polynomial time when constructing a pseudomaterialisation (see [Kaminski et al., 2017] for details). Furthermore, the conditions in Definition 16 have been crafted such that the reduct of a semi-positive type-consistent program (and hence of any intermediate program considered while materialising a stratified program) can be trivially rewritten into a positive type-consistent program. For this, it is essential to require a guarded use of negation (see third condition in Definition 16).

Lemma 17. For P a semi-positive, type-consistent program and D a limit dataset, the reduct of P ∪ D is polynomially rewritable to a positive, semi-ground, type-consistent program P ′ such that, for each fact α, P ∪D |= α if and only if P ′ |= α.

Lemma 17 allows us to extend the polytime algorithm in [Kaminski et al., 2017] for computing the pseudo-materialisation of a positive type-consistent program to semi-positive programs, thus obtaining a tractable implementation of oracle O restricted to type-consistent programs. This suffices since Algorithm 1, when given a type-consistent program as input, only applies O to type-consistent programs. Thus, by Proposition 13, we obtain a polynomial time upper bound on the data complexity of fact entailment for type-consistent programs with stratified negation. Since plain Datalog is already P-hard in data complexity, this upper bound is tight.

Theorem 18. For P a stratified, type-consistent program and α a fact, deciding P |= α is P-complete in data complexity.

Finally, as we show next, our extended notion of type consistency can be efficiently recognised.

Proposition 19. Checking whether a stratified, limit-linear program is type-consistent is in LOGSPACE.

6 Conclusion and FutureWork

Motivated by declarative data analysis applications, we have extended the language of limit programs with stratified negation-as-failure. We have shown that the additional expressive power provided by our extended language comes at a computational cost, but we have also identified sufficient syntactic conditions that ensure tractability of reasoning in data complexity. There are many avenues for future work. First, it would be interesting to formally study the expressive power of our language. Since type-consistent programs extend plain (function-free) Datalog with stratified negation, it is clear that they capture P on ordered datasets [Dantsin et al., 2001], and we conjecture that the full language of stratified limit-linear programs captures ∆P2 . From a more practical perspective, we believe that limit programs can naturally express many tasks that admit a dynamic programming solution (e.g., variants of the knapsack problem, and many others). Conceptually, a dynamic programming approach can be seen as a three-stage process: first, one constructs an acyclic 'graph of subproblems' that orders the subproblems from smallest to largest; then, one computes a shortest/longest path over this graph to obtain the value of optimal solutions; finally, one backwards-computes the actual solution by tracing back in the graph. Capturing the third stage seems to always require non-monotonic negation (as illustrated in our path computation example), whereas the first stage may or may not require it depending on the problem. Finally, the second stage can be realised with a (recursive) positive program. Second, our formalism should be extended with aggregate functions. Although certain forms of aggregation can be simulated using arithmetic functions and iterating over the object domain by exploiting the ordering, having aggregation explicitly would allow us to express certain tasks in a more natural way. Third, we would like to go beyond stratified negation and investigate the theoretical properties of limit Datalog under wellfounded [Van Gelder et al., 1991] or the stable model semantics [Gelfond and Lifschitz, 1988]. Finally, we plan to implement our reasoning algorithms and test them in practice.

Acknowledgments

This research was supported by the EPSRC projects DBOnto, MaSI3 , and ED3 .