Answer Set Programming modulo Acyclicity ? Jori Bomanson1 , Martin Gebser1,2 , Tomi Janhunen1 , Benjamin Kaufmann2 , and Torsten Schaub2,3?? 1 2

Aalto University, HIIT University of Potsdam 3 INRIA Rennes

Abstract. Acyclicity constraints are prevalent in knowledge representation and applications where acyclic data structures such as DAGs and trees play a role. Recently, such constraints have been considered in the satisfiability modulo theories (SMT) framework, and in this paper we carry out an analogous extension to the answer set programming (ASP) paradigm. The resulting formalism, ASP modulo acyclicity, offers a rich set of primitives to express constraints related to recursive structures. The implementation, obtained as an extension to the stateof-the-art answer set solver CLASP, provides a unique combination of traditional unfounded set checking with acyclicity propagation. The interplay of these orthogonal checks is experimentally evaluated by equipping logic programs with supplementary acyclicity constraints.

1

Introduction

Acyclic data structures such as DAGs and trees occur frequently in applications. For instance, Bayesian [9] and Markov [8] network learning as well as Circuit layout [13] are based on respective conditions. When logical formalisms are used for the specification of such structures, dedicated acyclicity constraints are called for. Recently, such constraints have been introduced in the satisfiability modulo theories (SMT) framework [4] for extending Boolean satisfiability in terms of graph-theoretic properties [19, 5]. The idea of satisfiability modulo acyclicity [17] is to view Boolean variables as conditionalized edges of a graph and to require that the graph remains acyclic under variable assignments. Moreover, the respective theory propagators for acyclicity have been implemented in contemporary CDCL-based satisfiability (SAT) solvers [6], MINISAT [11] and GLUCOSE [2], which offer a promising machinery for solving applications involving acyclicity constraints. In this paper, we consider acyclicity constraints in the context of answer set programming (ASP) [3], featuring a rule-based language for knowledge representation. While SAT solvers with explicit acyclicity constraints offer an alternative mechanism to implement ASP via appropriate translations into SAT modulo acyclicity [17], the goal of this paper is different: the idea is to incorporate acyclicity constraints into ASP, thus accounting for extended rule types [27] as well as reasoning tasks like enumeration and optimization. The resulting formalism, ASP modulo acyclicity, offers a rich set ? ??

A short version of this paper will appear at LPNMR’15. Affiliated with Simon Fraser University, Canada, and IIIS Griffith University, Australia.

of primitives to express constraints related to recursive structures. The implementation, obtained as an extension to the state-of-the-art answer set solver CLASP [22], provides a unique combination of traditional unfounded set [29] checking and acyclicity propagation [19]. This novel combination is experimentally evaluated to assess the interplay of both reasoning mechanisms. The rest of this paper is structured as follows. The basic notions of answer set programming are recalled in Section 2. The extension by explicit acyclicity constraints is worked out in Section 3, where we characterize relationships between ASP modulo acyclicity and standard ASP that pave the way for solving approaches implemented in the state-of-the-art ASP solver CLASP. The experimental evaluation of the new extension follows in Section 4. Finally, the results of the paper are discussed in Section 5.

2

Background

We consider logic programs built from rules and optimization statements of the forms: a ← b1 , . . . , bn , not c1 , . . . , not cm .

(1)

{a} ← b1 , . . . , bn , not c1 , . . . , not cm .

(2)

a ← k ≤ [b1 = w1 , . . . , bn = wn , not c1 = wn+1 , . . . , not cm = wn+m ]. (3) #minimize[b1 = w1 , . . . , bn = wn , not c1 = wn+1 , . . . , not cm = wn+m ]. (4) Symbols a, b1 , . . . , bn , c1 , . . . , cm stand for (propositional) atoms, k, w1 , . . . , wn+m for non-negative integers, and not for (default) negation. Atoms like bi and negated atoms like not ci are called positive and negative literals, respectively. For a normal (1), choice (2), or weight (3) rule r, we denote its head atom by head(r) = a and its + − body by B(r). By B(r) = {b1 , . . . , bn } and B(r) = {c1 , . . . , cm }, we refer to the positive and negative body atoms of r. When r is a weight rule or an optimization statement of the form (4), the respective sequence of weighted literals is denoted by WL(r), + − and its restrictions to positive or negative literals are denoted by WL(r) and WL(r) . − A normal rule r such that head(r) ∈ B(r) is called an integrity constraint, and we below skip head(r) and not head(r) for brevity, where head(r) is an arbitrary atom occurring in r only. A weight constraint program P , or simply a program, is a finite set of rules; P is a choice program if it consists of normal and choice rules only, and a positive program if it involves neither negation nor choice rules. A program P may be accompanied by an optimization statement declaring weighted literals to be minimized. , let head(P ) = {head(r) | r ∈ P } and At(P ) = head(P ) ∪ S Given a +program P − (B(r) ∪ B(r) ) denote the sets of head atoms or all atoms, respectively, ocr∈P curring in P . The defining rules of an atom a ∈ At(P ) are Def P (a) = {r ∈ P | head(r) = a}. An interpretation I ⊆ At(P ) satisfies B(r) for a normal or choice rule r + − iff B(r) ⊆ I and B(r) ∩I = ∅. The weighted literals of aPweight rule or optimization P statement r evaluate to vI (WL(r)) = 1≤i≤n,bi ∈I wi + 1≤i≤m,ci ∈I / wn+i ; when r is a weight rule, I satisfies B(r) iff k ≤ vI (WL(r)). For any rule r, we write I |= B(r) iff I satisfies B(r), and I |= r iff I |= B(r) implies head(r) ∈ I. The supporting rules of P with respect to I are SRP (I) = {r ∈ P | head(r) ∈ I, I |= B(r)}. Moreover, I is a model of P , denoted by I |= P , iff I |= r for every r ∈ P such that r is a normal

or weight rule. A model I of P is a supported model of P when head(SRP (I)) = I. Note that any positive program P possesses a unique least model, denoted by LM(P ). I + For a normal or choice rule r, B(r) = B(r) denotes the reduct of B(r) with I − + respect to an interpretation I, and B(r) = (max{0, k − vI (WL(r) )} ≤ WL(r) ) is the reduct of B(r) for a weight rule r. The reduct of a program P with respect to I an interpretation I is P I = {head(r) ← B(r) | r ∈ SRP (I)}. Then, I is a stable I model of P iff I |= P and LM(P ) = I. When P is accompanied by an optimization statement r, a stable (or supported) model I of P is optimal iff there is no stable (or supported) model I 0 of P such that vI 0 (WL(r)) < vI (WL(r)). While any stable model of P is a supported model of P as well, the converse does not hold in general. However, the following concept provides a tighter notion of support achieving such a correspondence. Definition 1. A model I of a program P is well-supported by a set R ⊆ SRP (I) of rules iff head(R) = I and there is some ordering r1 , . . . , rn of R such that, for each I 1 ≤ i ≤ n, head({r1 , . . . , ri−1 }) |= B(ri ) . In fact, a (supported) model I of a program P is stable iff I is well-supported by some subset of SRP (I), and several such subsets may exist. The notion of well-support counteracts circularity in the positive dependency graph DG+ (P ) = hAt(P ), i of P , whose edge relation a  b holds for all a, b ∈ At(P ) such that head(r) = a and b ∈ B(r)+ for some rule r ∈ P . If a  b, we also write ha, bi ∈ DG+ (P ). The strongly connected components (SCCs) of DG+ (P ) are maximal subsets C ⊆ At(P ) such that all contained atoms are connected to one another by directed paths in DG+ (P ). For an atom a ∈ At(P ), we denote the SCC containing a by SCCP (a).

3

Acyclicity Constraints

In [19], the SAT problem has been extended by explicit acyclicity constraints. The basic idea is to label edges of a directed graph with dedicated Boolean variables. While satisfying the clauses of a SAT instance referring to these labeling variables, also the directed graph consisting of edges whose labeling variables are true must be kept acyclic. Thus, the graph behind the labeling variables imposes an additional constraint on satisfying assignments. In what follows, we propose a similar extension of logic programs subject to stable model semantics. Definition 2. An acyclicity extension of a logic program P is a pair hV, ei, where 1. V is a set of nodes and 2. e : At(P ) → V × V is a partial injection that maps atoms of P to edges. In the sequel, a program P is called an acyclicity program if it is accompanied by an acyclicity extension hV, ei. To define the semantics of acyclicity programs, we identify the graph of the acyclicity check as follows. Given an interpretation I ⊆ At(P ), we write e(I) for the set of edges e(a) induced by atoms a ∈ I for which e(a) is defined. For a given acyclicity extension hV, ei, the graph e(At(P )) is the maximal one that

can be obtained under any interpretation and is likely to contain cycles. If not, then the extension can be neglected altogether as no cycles can arise. To be precise about the acyclicity condition being imposed, we recall that a graph hV, Ei with the set E ⊆ V 2 of edges has a cycle iff there is a non-trivial directed path from any node v ∈ V back to itself via the edges in E. An acyclic graph hV, Ei has no cycles of this kind. Definition 3. Let P be an acyclicity program with an acyclicity extension hV, ei. An interpretation M ⊆ At(P ) is a stable (or supported) model of P subject to hV, ei iff M is a stable (or supported) model of P such that the graph hV, e(M )i is acyclic. Example 1. Consider a directed graph hV, Ei and the task to find a Hamiltonian cycle through the graph, i.e., a cycle that visits each node of the graph exactly once. Let us encode the graph by introducing the fact node(v) for each v ∈ V and the fact edge(v, u) for each hv, ui ∈ E. Then, it is sufficient (i) to pick beforehand an arbitrary initial node, say v0 , for the cycle, (ii) to select for each node exactly one outgoing and one incoming edge to be on the cycle, and (iii) to check that the cycle is not completed before the path spanning along the selected edges returns to v0 . Assuming that a predicate hc is used to represent selected edges, the following (first-order) rules similar to those in [20] express (ii): 1{hc(v, u) : edge(v, u)}1 ← node(v).

(5)

1{hc(v, u) : edge(v, u)}1 ← node(u).

(6)

To enforce (iii), we introduce an acyclicity extension hV, ei, where e maps an atom hc(v, u) to an edge hv, ui whenever v and u are different from v0 . The mechanisms to implement acyclicity extensions in practice are described in Section 4.  Our next objective is to relate acyclicity programs to ordinary logic programs in terms of translations. It is well-known that logic programs subject to stable model semantics can express reachability in graphs, which implies that also acyclicity is expressible. To this end, we present a translation based on elimination orderings [18]. Definition 4. Let P be an acyclicity program with an acyclicity extension hV, ei. The translation TrEL (P, V, e) extends P as follows. 1. For each atom a ∈ At(P ) such that e(a) = hv, ui, the rules: el(v, u) ← not a.

(7)

el(v, u) ← el(u).

(8)

2. For each node v ∈ V such that hv, u1 i, . . . , hv, uk i are the edges in e(At(P )) starting from v: el(v) ← el(v, u1 ), . . . , el(v, uk ). ← not el(v).

(9) (10)

The intuitive reading of the new atom el(v, u) is that the edge hv, ui ∈ e(At(P )) has been eliminated, meaning that it cannot belong to any cycle. Analogously, the atom el(v) denotes the elimination of a node v ∈ V . By the rule (7), an edge hv, ui is eliminated when the atom a such that e(a) = hv, ui is false, while the rule (8) is applicable once the end node u is eliminated. Then, the node v gets eliminated by the rule (9) if all edges starting from it are eliminated. Finally, the constraint (10) ensures that all nodes are eliminated. That is, the success of the acyclicity test presumes that el(v, u) or el(v), respectively, is derivable for each edge hv, ui ∈ e(At(P )) and each node v ∈ V . Theorem 1. Let P be an acyclicity program with an acyclicity extension hV, ei and TrEL (P, V, e) its translation into an ordinary logic program. 1. If M is a stable model of P subject to hV, ei, then M 0 = M ∪ {el(v, u) | hv, ui ∈ e(At(P ))} ∪ {el(v) | v ∈ V } is a stable model of TrEL (P, V, e). 2. If M 0 is a stable model of TrEL (P, V, e), then M = M 0 ∩ At(P ) is a stable model of P subject to hV, ei. Example 2. Consider the following acyclicity program P : p ← q, x. ws(r1 ) ← dep(p, q), dep(p, x). ← p, not ws(r1 ), p ← q, r. ws(r2 ) ← dep(p, q), dep(p, r). not ws(r2 ), p ← q, s. ws(r3 ) ← dep(p, q), dep(p, s). not ws(r3 ), p ← r, s. ws(r4 ) ← dep(p, r), dep(p, s). not ws(r4 ). q ← r, s. ws(r5 ) ← dep(q, r), dep(q, s). ← q, not ws(r5 ), q ← y. ws(r6 ) ← dep(q, y). not ws(r6 ). r ← p, q. ws(r7 ) ← dep(r, p), dep(r, q). ← r, not ws(r7 ), {r} ← q, y. ws(r8 ) ← dep(r, q), dep(r, y). not ws(r8 ). s ← p, q. ws(r9 ) ← dep(s, p), dep(s, q). ← s, not ws(r9 ), {s} ← q, y. ws(r10 ) ← dep(s, q), dep(s, y). not ws(r10 ). {x}. {y}. ws(r11 ). ws(r12 ). ← x, not ws(r11 ). ← y, not ws(r12 ). {dep(p, q)} ← q. {dep(q, r)} ← r. {dep(r, p)} ← p. {dep(s, p)} ← p. {dep(p, r)} ← r. {dep(q, s)} ← s. {dep(r, q)} ← q. {dep(s, q)} ← q. {dep(p, s) } ← s. {dep(q, y)} ← y. {dep(r, y)} ← y. {dep(s, y)} ← y. {dep(p, x)} ← x. Let the acyclicity extension hV, ei of P consist of the nodes V = {p, q, r, s, x, y}, and atoms of the form dep(v, u) indicate the mapping e(dep(v, u)) = hv, ui to edges. Observe that the nodes in V correspond to atoms in P and that dep(v, u) atoms in the bodies of rules with ws(ri ) in the head match (positive) dependencies in a corresponding rule ri . In fact, P matches the outcome of applying the translation introduced in Definition 5 below to the subprogram P 0 consisting of the rules with elements of V = {p, q, r, s, x, y} in their heads, and later on we also specify additional constraints pruning redundant stable models. Here we first use P with the acyclicity extension hV, ei to illustrate how it can be mapped to an ordinary logic program via TrEL (P, V, e). When interpreted in the standard way, P admits 620 stable models, out of which 68 remain in view of the acyclicity condition on the graph induced by true dep(v, u)

atoms. For instance, eight stable models M are such that M ∩ V = {p, q, r, s, y}, and additional dep(v, u) atoms reflect well-supports, where dep(q, y) as well as ws(r6 ) are true and express that the rule q ← y must be applied in order to establish q. Then, the choice rules for r and s can be triggered, indicated by the atoms dep(v, q) and dep(v, y) for v ∈ {r, s}; finally, p is derived when at least two of the atoms dep(p, q), dep(p, r), and dep(p, s) hold, which yields four stable models containing ws(r8 ) and ws(r10 ) along with ws(r2 ), ws(r3 ), and/or ws(r4 ). The other four stable models include dep(v, q) and dep(v, y) as well as ws(r8 ) or ws(r10 ), for either v = r or v = s, along with dep(p, q), dep(p, v), and ws(r2 ) or ws(r3 ); the derivation of u = s, when v = r, or u = r, when v = s, is then based on dep(u, p), dep(u, q), and ws(r7 ) or ws(r9 ), where dep(u, y) and thus ws(r8 ) or ws(r10 ) may hold in addition. In terms of P , these options to pick dep(v, u) atoms vary in whether the rule p ← r, s or one among r ← p, q and s ← p, q is well-supporting, while the acyclicity condition on dep(p, r), dep(p, s), dep(r, p), and dep(s, p) prohibits using rules of both kinds simultaneously. In order to capture the acyclicity condition by an ordinary program, P can be augmented with the following rules of the forms (7)–(10): el(p, q) ← not el(p, r) ← not el(p, s) ← not el(p, x) ← not el(q, r) ← not el(q, s) ← not el(q, y) ← not el(r, p) ← not el(r, q) ← not el(r, y) ← not el(s, p) ← not el(s, q) ← not el(s, y) ← not ← not el(p). ← not el(r).

dep(p, q). el(p, q) ← el(q). dep(p, r). el(p, r) ← el(r). dep(p, s). el(p, s) ← el(s). dep(p, x). el(p, x) ← el(x). dep(q, r). el(q, r) ← el(r). dep(q, s). el(q, s) ← el(s). dep(q, y). el(q, y) ← el(y). dep(r, p). el(r, p) ← el(p). dep(r, q). el(r, q) ← el(q). dep(r, y). el(r, y) ← el(y). dep(s, p). el(s, p) ← el(p). dep(s, q). el(s, q) ← el(q). dep(s, y). el(s, y) ← el(y). ← not el(q). ← not el(x). ← not el(s). ← not el(y).

el(p) ← el(p, q), el(p, r), el(p, s), el(p, x). el(q) ← el(q, r), el(q, s), el(q, y). el(r) ← el(r, p), el(r, q), el(r, y). el(s) ← el(s, p), el(s, q), el(s, y). el(x). el(y).

As stated in Theorem 1, the resulting ordinary logic program TrEL (P, V, e) captures the 68 stable models of P subject to hV, ei. Note that each stable model of TrEL (P, V, e) includes all el(v, u) and el(v) atoms introduced in the above program part.  Transformations in the other direction are of interest as well, i.e., the goal is to capture stable models by exploiting the acyclicity constraint. While the existing translation from ASP into SAT modulo acyclicity [17] provides a starting point for such a transformation, the target syntax is given by rules, including weight rules of the form (3), rather than clauses. Definition 5. Let P be a weight S constraint program. The acyclicity translation of P consists of TrACYC (P ) = a∈At(P ) TrACYC (P, a) with an acyclicity extension hAt(P ), ei such that e(dep(a, b)) = ha, bi for each edge ha, bi ∈ DG+ (P ), where TrACYC (P, a) extends Def P (a) for each atom a ∈ At(P ) as follows.

1. For each edge ha, bi ∈ DG+ (P ), the choice rule: {dep(a, b)} ← b.

(11)

2. For each defining rule (1) or (2) of a, the rule: ws(r) ← dep(a, b1 ), . . . , dep(a, bn ), not c1 , . . . , not cm .

(12)

3. For each defining rule (3) of a, the rule: ws(r) ← k ≤ [dep(a, b1 ) = w1 , . . . , dep(a, bn ) = wn , not c1 = wn+1 , . . . , not cm = wn+m ]. (13) 4. For Def P (a) = {r1 , . . . , rk }, the constraint: ← a, not ws(r1 ), . . . , not ws(rk ).

(14)

The rules (12) and (13) specify when r provides well-support for a, i.e., the head atom a non-circularly depends on B(r)+ = {b1 , . . . , bn }. The constraint (14) expresses that a ∈ At(P ) must have a well-supporting rule r ∈ Def P (a) whenever a is true. To this end, respective dependencies have to be established in terms of the choice rules (11). Theorem 2. Let P be a weight constraint program and TrACYC (P ) its translation into an acyclicity program with an acyclicity extension hAt(P ), ei. 1. If M is a stable model of P , then there is an ordering r1 , . . . , rn of some R ⊆ SRP (M ) such that M 0 = M ∪ {ws(r) | r ∈ R} ∪ {dep(head(ri ), b) | 1 ≤ i ≤ n, b ∈ Bi }, where Bi ⊆ B(ri )+ ∩ head({r1 , . . . , ri−1 }) for each 1 ≤ i ≤ n, is a supported model of TrACYC (P ) subject to hAt(P ), ei. 2. If M 0 is a supported model of TrACYC (P ) subject to hAt(P ), ei, then M = M 0 ∩ At(P ) is a stable model of P and M is well-supported by R = {r | ws(r) ∈ M 0 }. Note that the first item would also hold when Bi = B(ri )+ ∩ head({r1 , . . . , ri−1 }) enforces edges to all established atoms in a body. However, such strictness is inappropriate in the presence of additional constraints for weight rules, given in Definition 7 below. It is well-known that supported and stable models coincide for tight logic programs [15, 12]. The following theorem shows that translations produced by TrACYC possess an analogous property subject to the acyclicity extension hAt(P ), ei. This opens up an interesting avenue for investigating the efficiency of stable model computation—either using unfounded set checking or the acyclicity constraint, or both. Theorem 3. Let P be a weight constraint program and TrACYC (P ) its translation into an acyclicity program with an acyclicity extension hAt(P ), ei. Then, M is a supported model of TrACYC (P ) subject to hAt(P ), ei iff M is a stable model of TrACYC (P ) subject to hAt(P ), ei.

Example 3. The acyclicity program P subject to hV, ei in Example 2 is the acyclicity translation TrACYC (P 0 ) of the subprogram P 0 given by the rules that do not include atoms of the form dep(v, u) or ws(ri ). The subprogram P 0 has five stable models: ∅, {x}, {q, y}, {p, q, r, s, y}, and {p, q, r, s, x, y}. They map to 68 supported models of TrACYC (P 0 ), all of which are stable.  As witnessed by Theorems 2 and 3, the translation TrACYC provides means to capture stability in terms of the acyclicity constraint. However, the computational efficiency of the translation can be improved when additional constraints governing dep(v, u) atoms are introduced. The purpose of these constraints is to falsify dependencies in settings where they are not truly needed. We first concentrate on choice programs and will then extend the consideration to weight rules below. The following definition adopts the cases from [17] but reformulates them in terms of rules rather than clauses. Definition 6. Let P be a choice program. The strong acyclicity translation of P , denoted by TrACYC+ (P ), extends TrACYC (P ) as follows. 1. For each ha, bi ∈ DG+ (P ), the constraint: ← dep(a, b), not a.

(15)

2. For each ha, bi ∈ DG+ (P ) and r ∈ Def P (a) such that b ∈ / B(r)+ , the constraint: ← dep(a, b), ws(r).

(16)

Intuitively, dependencies from a are not needed if a is false (15). Quite similarly, a particular dependency may be safely prevented (16) if the well-support for a is provided by a rule r not involving this dependency. Example 4. The strong acyclicity translation TrACYC+ (P 0 ) of P 0 as in Example 3 augments TrACYC (P 0 ), given by P subject to hV, ei in Example 2, with the constraints: ← dep(p, q), ← dep(p, r), ← dep(p, s), ← dep(p, x), ← dep(q, r), ← dep(q, y), ← dep(r, p), ← dep(r, y), ← dep(s, p), ← dep(s, y),

not not not not not not not not not not

p. p. p. p. q. q. r. r. s. s.

← dep(p, r), ← dep(p, s), ← dep(p, r), ← dep(p, q), ← dep(q, s), ← dep(q, r), ← dep(r, q),

ws(r1 ). ws(r2 ). ws(r3 ). ws(r4 ). not q. ws(r6 ). not r.

← dep(s, q), not s.

← dep(p, s), ← dep(p, x), ← dep(p, x), ← dep(p, x), ← dep(q, y), ← dep(q, s), ← dep(r, y), ← dep(r, p), ← dep(s, y), ← dep(s, p),

ws(r1 ). ws(r2 ). ws(r3 ). ws(r4 ). ws(r5 ). ws(r6 ). ws(r7 ). ws(r8 ). ws(r9 ). ws(r10 ).

The addition of these constraints to TrACYC (P 0 ) reduces the number of supported (and stable) models from 68 to 17. For instance, three of the eight supported models M extending M ∩ V = {p, q, r, s, y} are eliminated, namely, the ones containing S1 = {dep(p, q), dep(p, r), dep(p, s), ws(r2 ), ws(r3 ), ws(r4 )}, S2 = {dep(r, p), dep(r, q), dep(r, y), ws(r7 ), ws(r8 )}, or S3 = {dep(s, p), dep(s, q), dep(s, y), ws(r9 ), ws(r10 )}.

In fact, atoms of the form dep(v, u) in S1 , S2 , or S3 lead to redundant well-supports, e.g., ws(r4 ) ∈ S1 yields that dep(p, r) and dep(p, s) suffice to support p, so that dep(p, q) is unnecessary. However, five non-redundant supported models M such that M ∩ V = {p, q, r, s, y} still reflect different options to pick well-supporting rules.  The strong acyclicity translation for weight rules includes additional subprograms. Definition 7. Let P be a weight constraint program and r ∈ P a weight rule of the form (3), where head(r) = a, |{b1 , . . . , bn }| = n, and w1 , . . . , wn are ordered such that wi−1 ≤ wi for each 1 < i ≤ n. The strong acyclicity translation TrACYC+ (P ) of P is fortified as follows. 1. For 1 < i ≤ n, the rules: nxt(r, i) ← dep(a, bi−1 ).

(17)

nxt(r, i) ← nxt(r, i − 1).

(18)

chk(r, i) ← nxt(r, i), dep(a, bi ).

(19)

2. The weight rule: red(r) ← k ≤ [chk(r, 2) = w2 , . . . , chk(r, n) = wn , not c1 = wn+1 , . . . , not cm = wn+m ]. (20) 3. For each ha, bi ∈ DG+ (P ) such that b ∈ B(r)+ , the constraint: ← dep(a, b), red(r).

(21)

The idea is to cancel dependencies ha, bi ∈ DG+ (P ) by the constraint (21) when the well-support obtained though r can be deemed redundant by the rule (20). To this end, the rules of the forms (17) and (18) identify an atom among b1 , . . . , bn of smallest weight having an active dependency from a, i.e., dep(a, bi ) is true, provided such an i exists. By the rules of the form (19), any further dependencies are extracted, and (20) checks whether the remaining literals are sufficient to reach the bound k. If so, all dependencies from a are viewed as redundant. This check covers also cases where, e.g., negative literals suffice to satisfy the body and positive dependencies play no role. Example 5. The subprogram P 0 and P = TrACYC (P 0 ) as in Example 3 can be modified to yield equivalent weight constraint programs. To this end, reconsider P and hV, ei, given in Example 2, and assume that the rules with head p or ws(r1 ), . . . , ws(r4 ), respectively, as well as the integrity constraint including p, are replaced by: p ← q, x. p ← 3 ≤ [q = 1, r = 2, s = 2]. ← p, not ws(r1 ), not ws(r2 ).

ws(r1 ) ← dep(p, q), dep(p, x). ws(r2 ) ← 3 ≤ [dep(p, q) = 1, dep(p, r) = 2, dep(p, s) = 2].

This translation TrACYC (P 0 ) still yields 68 supported models subject to hV, ei. Its strong version TrACYC+ (P 0 ) is obtained by replacing integrity constraints, given in Example 4, that contain atoms of the form dep(p, u) for u ∈ {q, r, s, x} as follows:

← dep(p, q), not p. ← dep(p, r), not p. ← dep(p, s), not p. ← dep(p, x), not p. ← dep(p, r), ws(r1 ). ← dep(p, s), ws(r1 ). ← dep(p, x), ws(r2 ). nxt(r2 , 2) ← dep(p, q). nxt(r2 , 3) ← dep(p, r). nxt(r2 , 2) ← nxt(r2 , 1). nxt(r2 , 3) ← nxt(r2 , 2). chk(r2 , 2) ← nxt(r2 , 2), dep(p, r). chk(r2 , 3) ← nxt(r2 , 3), dep(p, s). red(r2 ) ← 3 ≤ [chk(r2 , 2) = 2, chk(r2 , 3) = 2]. ← dep(p, q), red(r2 ). ← dep(p, r), red(r2 ). ← dep(p, s), red(r2 ). As in Example 4, the addition of these constraints to TrACYC (P 0 ) reduces the number of supported models to 17. In particular, the redundant model M that extends M ∩V = {p, q, r, s, y} and contains {dep(p, q), dep(p, r), dep(p, s), ws(r2 )} is denied since nxt(r2 , 2), nxt(r2 , 3), chk(r2 , 2), chk(r2 , 3), and red(r2 ) follow from dep(v, u) atoms. That is, dep(p, r) and dep(p, s) are sufficient for well-support through r2 , so that dep(p, q) is unnecessary. In turn, three non-redundant supported models can be obtained from M by dropping either dep(p, q), dep(p, r), or dep(p, s).  The transformations TrACYC and TrACYC+ can be adjusted to take SCCs into account and, in practice, only their component-aware versions have been implemented. Definitions 5 and 6 require the following revisions to incorporate SCCs. Given an atom a ∈ At(P ) and the component SCCP (a), the atoms dep(a, bi ) in the rules (12) and (13) are replaced by bi if bi ∈ / SCCP (a). Rules of the forms (11), (15), (16), and (21) are only needed if b ∈ SCCP (a). As regards Definition 7, the condition for ordering the weight rule is refined so that, for some 1 ≤ k ≤ n, {b1 , . . . , bk } ⊆ SCCP (a), {bk+1 , . . . , bn } ∩ SCCP (a) = ∅, and wi−1 ≤ wi for each 1 < i ≤ k. Then, the rules (17)–(19) are restricted to 1 < i ≤ k. Finally, the atoms chk(r, i) in the rule (20) are replaced by bi for k < i ≤ n. Note that the relationships among models established in Theorems 2 and 3 remain valid for the strong translation TrACYC+ as well as component-aware versions of TrACYC and TrACYC+ . As a consequence, the correspondence between stable models and supported models subject to acyclicity carries forward to optimal models in the presence of optimization statements. Example 6. For P 0 as in Example 3 and a ∈ {p, q, r, s}, we have that SCCP 0 (a) = {p, q, r, s}. Hence, the component-aware version of TrACYC+ (P 0 ) replaces the atoms dep(p, x), dep(q, y), dep(r, y), and dep(s, y) in P , given in Example 2, by x or y, respectively, so that the corresponding edges no longer contribute to the acyclicity extension induced by e(dep(v, u)) = hv, ui. Moreover, among the constraints shown in Example 4, those mentioning some of the four obsolete dep(v, u) atoms are simply dropped. Note that all supported models extending M ∩ V = {p, q, r, s, y} include dep(r, q) and dep(s, q), leading to ws(r8 ) and ws(r10 ) because dep(r, y) and dep(s, y) are not needed as prerequisites anymore. Hence, the constraints ← dep(r, p), ws(r8 ) and ← dep(s, p), ws(r10 ) suppress edges associated with dep(r, p) and dep(s, p). Since the latter were still admissible in Example 4, the component-aware translation further reduces the number of non-redundant supported models such that M ∩ V = {p, q, r, s, y} from five to three. In total, we obtain eight non-redundant supported models capturing the five stable models given in Example 3. 

4

Experiments

Acyclicity programs are implemented in the development version 3.2.0-R45720 of CLASP 4 [22], using a propagator for acyclicity reasoning similar to the one introduced in [19], and will be supported from the forthcoming release 3.2.0 on. On the one hand, a program may define the dedicated predicate edge(v, u) to declare e( edge(v, u)) = hv, ui. For instance, the rule edge(v, u) ← hc(v, u), v 6= n0 , u 6= n0 specifies the acyclicity extension for the Hamiltonian cycle encoding consisting of (5) and (6) in Example 1. On the other hand, the tool LP 2 ACYC5 [17], version 1.29, implements TrACYC as well as TrACYC+ and thus allows for capturing stable models by supported models subject to an acyclicity extension. In fact, we used ordinary ASP encodings and LP 2 ACYC to compare the performance of CLASP performing usual unfounded set or acyclicity checking, below abbreviated by UFS or ACYC, respectively. The ACYC mode allows for “backward” inference of forbidden edges, i.e., (unassigned) atoms standing for edges that would close a cycle are falsified, and we abbreviate the use of such propagation by BCYC. Moreover, we denote the application of ACYC or BCYC relative to TrACYC+ by ACYC+ and BCYC+. Given that stable and supported models coincide for acyclicity programs obtained by translation, each of the acyclicity checking variants can be combined with UFS, and we refer to such a combination by appending /UFS to the respective mode, e.g., ACYC+/UFS denotes acyclicity along with unfounded set checking relative to TrACYC+ . Note that all modes but UFS, which matches standard ASP solving, are based on translation into acyclicity programs. Our benchmark set6 consists of four classes of decision problems, Hamiltonian Cycle (Cycle) [28], Labyrinth (Laby) [1], Sokoban (Soko) [24], and Wire Routing (Route) [10], as well as three optimization problems, Bayesian Network Structure Learning (Bayes) [9], Chordal Markov Network Learning (Markov) [8], and Incremental Scheduling (Sched) [7]. The instances of each problem are non-tight [15, 12], so that unfounded set and/or acyclicity checking is required for solving them. All experiments were run single-threaded with CLASP’s trendy configuration, which turned out to boost the search performance (8 timeouts less than the default configuration in baseline UFS mode), on a Linux machine equipped with Intel Quad-Core Xeon E5520 2.27GHz processors, imposing a limit of 600 seconds wall-clock time and no (effective) memory limit per run, where a timeout is counted as 600 seconds within average runtimes. Table 1 provides average runtimes in seconds and numbers of timeouts for each CLASP mode, highlighting the minimum values per benchmark class in boldface, where the number of instances per class is given at the top. In terms of timeouts, we observe that regular unfounded set checking, i.e., UFS, is ahead or equal to acyclicity checking modes. However, recall that acyclicity checking is applied to TrACYC or TrACYC+ translations, thus not using native encodings in terms of acyclicity programs, which may still boost the performance on a problem-specific level. Nevertheless, for some classes, different acyclicity checking modes yield the same number of timeouts and smaller average runtimes than UFS. This applies to ACYC, using plain acyclicity checking, on 4 5 6

http://sourceforge.net/projects/potassco/ http://research.ics.aalto.fi/software/asp/lp2acyc/ http://www.cs.uni-potsdam.de/clasp/?page=experiments

Mode Cycle #60 Laby #20 Soko #30 Route #23 Bayes #30 Markov #21 Sched #18 UFS 36.0 0 255.3 4 182.6 2 5.8 0 116.8 0 100.7 0 281.2 7 ACYC 373.6 37 261.0 6 350.7 10 134.5 4 66.3 0 120.3 1 320.9 8 BCYC 266.3 26 286.7 7 256.2 7 111.5 2 84.6 0 54.1 0 324.2 7 ACYC/UFS 209.4 18 279.2 4 174.6 3 11.4 0 103.1 1 170.2 3 348.2 9 BCYC/UFS 209.2 19 314.3 6 179.7 4 10.0 0 104.3 1 72.5 0 340.3 9 ACYC+ 118.0 7 366.7 7 336.7 10 137.2 4 106.2 1 61.5 0 340.9 9 BCYC+ 85.3 5 279.6 5 230.4 5 138.6 4 102.2 2 39.9 0 341.1 9 ACYC+/UFS 115.9 8 311.8 5 176.6 4 15.4 0 110.3 1 171.4 3 367.5 9 BCYC+/UFS 91.9 6 212.7 4 170.2 3 12.3 0 122.5 2 111.5 1 360.6 9 Table 1. Benchmark results comparing unfounded set and acyclicity checking

the optimization problem Bayes. Its strengthening by additional constraints in TrACYC+ along with backward propagation, BCYC+, yields the best performance for the Markov class, and the respective combination with unfounded set checking, BCYC+/UFS, leads to the shortest average runtime (and fewest timeouts) on the decision problem Laby, where BCYC+/UFS and UFS each solve an instance on which the other mode times out. In contrast, Cycle constitutes a negative example in which translation and acyclicity checking deteriorate performance, even if combined with UFS. Comparing the different acyclicity checking modes to each other, using backward propagation may significantly improve performance, as observed on the gaps between ACYC and BCYC as well as ACYC+ and BCYC+ for the Cycle and Soko classes. However, these are also the problems where UFS has advantages (in terms of timeouts), and combining acyclicity with unfounded set checking largely outweighs backward propagation here. On the other hand, the Markov class, where combinations with UFS deteriorate performance, shows that backward propagation does not become obsolete when unfounded set checking is used in addition. The latter turns out to be particularly helpful for the Route class, although no combination catches up to pure UFS. Regarding the effect of TrACYC+ , the Cycle class yields significant advantages of the ACYC+ and BCYC+ modes compared to their ACYC and BCYC counterparts. In turn, on the optimization problem Bayes, omitting the additional constraints of TrACYC+ saves some overhead. In summary, the benchmark results in Table 1 show that the use of TrACYC or TrACYC+ and likewise of backward propagation on the solver side matter, although there is no winning strategy that would dominate for all classes of problems. Similarly, combining acyclicity with unfounded set checking can be advantageous, especially in cases where acyclicity checking has difficulties on its own, but it may also lead to overhead instead of gains. In fact, when using TrACYC or TrACYC+ , acyclicity and unfounded set checking both deal with the same concern of guaranteeing that a supported model is also well-supported. Hence, applying different mechanisms serving the same purpose is partially redundant. In direct encodings, which are beyond the scope of this paper, a user has the option to customize whether to apply acyclicity or unfounded set checking for particular purposes. Thus, acyclicity programs enrich the available modeling constructs.

5

Discussion

In this paper, we propose a novel SMT-style extension of ASP by explicit acyclicity constraints in analogy to [19]. These kinds of constraints have not been directly addressed in previous SMT-style extensions of ASP [23, 26, 25]. The new extension, herein coined ASP modulo acyclicity, offers a unique set of primitives for applications involving DAGs or tree structures. One interesting application is the embedding of ASP itself, given that unfounded set checking can be captured (Theorem 2). The utilized notion of well-supporting rules resembles source pointers [27], used in native answer set solvers to record rules justifying true atoms. In fact, a major contribution of this work is the implementation of new translations and principles in tools. Firstly, version 1.29 of LP 2 ACYC implements TrACYC and TrACYC+ relative to SCCs of an input program. Given that the implementation covers extended rule types, weight constraint programs output by the grounder GRINGO [20] can be processed. Secondly, from release 3.2.0 onward, CLASP [22] will have the acyclicity propagator built in. Due to an orthogonal implementation, all other features of CLASP remain at users’ disposal. For instance, it is possible to perform enumeration and optimization, not supported by ACYCMINISAT and ACYCGLUCOSE [19], which turned out to be competitive on translations of logic programs (without extended rules) into SAT modulo acyclicity [17]. Upon enumeration, a replication of supported (and stable) models under translations can be avoided by using the projection capabilities of CLASP [21]. Last but not least, acyclicity programs enrich the variety of modeling primitives available to users. Acknowledgments. This work was funded by AoF (251170), DFG (SCHA 550/8 and 550/9), as well as DAAD and AoF (57071677/279121).

References 1. M. Alviano, F. Calimeri, G. Charwat, M. Dao-Tran, C. Dodaro, G. Ianni, T. Krennwallner, M. Kronegger, J. Oetsch, A. Pfandler, J. P¨uhrer, C. Redl, F. Ricca, P. Schneider, M. Schwengerer, L. Spendier, J. Wallner, and G. Xiao. The fourth answer set programming competition: Preliminary report. In P. Cabalar and T. Son, editors, Proceedings of the Twelfth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR’13), volume 8148 of Lecture Notes in Artificial Intelligence, pages 42–53. Springer-Verlag, 2013. 2. G. Audemard and L. Simon. Predicting learnt clauses quality in modern SAT solvers. In C. Boutilier, editor, Proceedings of the Twenty-first International Joint Conference on Artificial Intelligence (IJCAI’09), pages 399–404. AAAI/MIT Press, 2009. 3. C. Baral. Knowledge Representation, Reasoning and Declarative Problem Solving. Cambridge University Press, 2003. 4. C. Barrett, R. Sebastiani, S. Seshia, and C. Tinelli. Satisfiability modulo theories. In Biere et al. [6], pages 825–885. 5. S. Bayless, N. Bayless, H. Hoos, and A. Hu. SAT modulo monotonic theories. In B. Bonet and S. Koenig, editors, Proceedings of the Twenty-ninth National Conference on Artificial Intelligence (AAAI’15), pages 3702–3709. AAAI Press, 2015. 6. A. Biere, M. Heule, H. van Maaren, and T. Walsh, editors. Handbook of Satisfiability, volume 185 of Frontiers in Artificial Intelligence and Applications. IOS Press, 2009.

7. F. Calimeri, M. Gebser, M. Maratea, and F. Ricca. The design of the fifth answer set programming competition. In M. Leuschel and T. Schrijvers, editors, Technical Communications of the Thirtieth International Conference on Logic Programming (ICLP’14). Theory and Practice of Logic Programming, 14(4-5):Online Supplement, 2014. 8. J. Corander, T. Janhunen, J. Rintanen, H. Nyman, and J. Pensar. Learning chordal Markov networks by constraint satisfaction. In C. Burges, L. Bottou, Z. Ghahramani, and K. Weinberger, editors, Proceedings of the Twenty-seventh Annual Conference on Neural Information Processing Systems (NIPS’13), pages 1349–1357. NIPS Foundation, 2013. 9. James Cussens. Bayesian network learning with cutting planes. In F. Cozman and A. Pfeffer, editors, Proceedings of the Twenty-seventh International Conference on Uncertainty in Artificial Intelligence (UAI’11), pages 153–160. AUAI Press, 2011. 10. M. Denecker, J. Vennekens, S. Bond, M. Gebser, and M. Truszczy´nski. The second answer set programming competition. In Erdem et al. [14], pages 637–654. 11. N. E´en and N. S¨orensson. An extensible SAT-solver. In E. Giunchiglia and A. Tacchella, editors, Proceedings of the Sixth International Conference on Theory and Applications of Satisfiability Testing (SAT’03), volume 2919 of Lecture Notes in Computer Science, pages 502–518. Springer-Verlag, 2004. 12. E. Erdem and V. Lifschitz. Tight logic programs. Theory and Practice of Logic Programming, 3(4-5):499–518, 2003. 13. E. Erdem, V. Lifschitz, and M. Wong. Wire routing and satisfiability planning. In J. Lloyd, V. Dahl, U. Furbach, M. Kerber, K. Lau, C. Palamidessi, L. Pereira, Y. Sagiv, and P. Stuckey, editors, Proceedings of the First International Conference on Computational Logic (CL’00), volume 1861 of Lecture Notes in Computer Science, pages 822–836. Springer-Verlag, 2000. 14. E. Erdem, F. Lin, and T. Schaub, editors. Proceedings of the Tenth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR’09), volume 5753 of Lecture Notes in Artificial Intelligence. Springer-Verlag, 2009. 15. F. Fages. Consistency of Clark’s completion and the existence of stable models. Journal of Methods of Logic in Computer Science, 1:51–60, 1994. 16. E. Ferm´e and J. Leite, editors. Proceedings of the Fourteenth European Conference on Logics in Artificial Intelligence (JELIA’14), volume 8761 of Lecture Notes in Artificial Intelligence. Springer-Verlag, 2014. 17. M. Gebser, T. Janhunen, and J. Rintanen. Answer set programming as SAT modulo acyclicity. In T. Schaub, G. Friedrich, and B. O’Sullivan, editors, Proceedings of the Twenty-first European Conference on Artificial Intelligence (ECAI’14), pages 351–356. IOS Press, 2014. 18. M. Gebser, T. Janhunen, and J. Rintanen. ASP encodings of acyclicity properties. In C. Baral, G. De Giacomo, and T. Eiter, editors, Proceedings of the Fourteenth International Conference on Principles of Knowledge Representation and Reasoning (KR’14). AAAI Press, 2014. 19. M. Gebser, T. Janhunen, and J. Rintanen. SAT modulo graphs: Acyclicity. In Ferm´e and Leite [16], pages 137–151. 20. M. Gebser, R. Kaminski, B. Kaufmann, M. Ostrowski, T. Schaub, and M. Schneider. Potassco: The Potsdam answer set solving collection. AI Communications, 24(2):107–124, 2011. 21. M. Gebser, B. Kaufmann, and T. Schaub. Solution enumeration for projected Boolean search problems. In W. van Hoeve and J. Hooker, editors, Proceedings of the Sixth International Conference on Integration of AI and OR Techniques in Constraint Programming for Combinatorial Optimization Problems (CPAIOR’09), volume 5547 of Lecture Notes in Computer Science, pages 71–86. Springer-Verlag, 2009. 22. M. Gebser, B. Kaufmann, and T. Schaub. Conflict-driven answer set solving: From theory to practice. Artificial Intelligence, 187-188:52–89, 2012.

23. M. Gebser, M. Ostrowski, and T. Schaub. Constraint answer set solving. In P. Hill and D. Warren, editors, Proceedings of the Twenty-fifth International Conference on Logic Programming (ICLP’09), volume 5649 of Lecture Notes in Computer Science, pages 235–249. Springer-Verlag, 2009. 24. T. Janhunen, I. Niemel¨a, and M. Sevalnev. Computing stable models via reductions to difference logic. In Erdem et al. [14], pages 142–154. 25. J. Lee and Y. Meng. Answer set programming modulo theories and reasoning about continuous changes. In F. Rossi, editor, Proceedings of the Twenty-third International Joint Conference on Artificial Intelligence (IJCAI’13), pages 990–996. IJCAI/AAAI Press, 2013. 26. G. Liu, T. Janhunen, and I. Niemel¨a. Answer set programming via mixed integer programming. In G. Brewka, T. Eiter, and S. McIlraith, editors, Proceedings of the Thirteenth International Conference on Principles of Knowledge Representation and Reasoning (KR’12), pages 32–42. AAAI Press, 2012. 27. P. Simons, I. Niemel¨a, and T. Soininen. Extending and implementing the stable model semantics. Artificial Intelligence, 138(1-2):181–234, 2002. 28. T. Soh, D. Le Berre, S. Roussel, M. Banbara, and N. Tamura. Incremental SAT-based method with native Boolean cardinality handling for the Hamiltonian cycle problem. In Ferm´e and Leite [16], pages 684–693. 29. A. Van Gelder, K. Ross, and J. Schlipf. The well-founded semantics for general logic programs. Journal of the ACM, 38(3):620–650, 1991.