2.1 Answer Set Programming

Answer Set Programming (ASP) is a declarative programming paradigm based on nonmonotonic reasoning and the stable model semantics (Gelfond and Lifschitz Reference Gelfond and Lifschitz1991). Over the past decades, ASP has attracted considerable interest thanks to its elegant syntax, expressiveness, and efficient system implementations, successfully adopted in numerous domains like, for example, configuration, robotics, or biomedical applications (Erdem et al. Reference Erdem, Gelfond and Leone2016; Falkner et al. Reference Falkner, Friedrich, Schekotihin, Taupe and Teppan2018). We briefly present the syntax and semantics of ASP, and refer the reader to textbooks (Gebser et al. Reference Gebser, Kaminski, Kaufmann and Schaub2012; Lifschitz Reference Lifschitz2019) for more in-depth introductions.

Syntax.

An ASP program P is a set of rules r of the form:

\begin{equation*} a_0 \gets a_1, \dots, a_m, {\mathit{not}\,} a_{m+1}, \dots, {\mathit{not}\,} a_n,\end{equation*}

where $\mathit{not}$ stands for default negation and $a_i$ , for $0\leq i \leq n$ , are atoms. An atom is an expression of the form $p(\overline{t})$ , where p is a predicate, $\overline{t}$ is a possibly empty vector of terms, and the predicate $\bot$ (with an empty vector of terms) represents the constant false. Each term t in $\overline{t}$ is either a variable or a constant. A literal l is an atom $a_i$ (positive) or its negation ${\mathit{not}\,} a_i$ (negative). The atom $a_0$ is the head of a rule r, denoted by $H(r)=a_0$ , and the body of r includes the positive or negative, respectively, body atoms $B^+(r) = \{a_1, \dots, a_m\}$ and $B^-(r) = \{a_{m+1}, \dots, a_n\}$ . A rule r is called a fact if $B^+(r)\cup B^-(r)=\emptyset$ , and a constraint if $H(r) = \bot$ .

Semantics.

The semantics of an ASP program P is given in terms of its ground instantiation $P_{\mathit{grd}}$ , which is obtained by replacing each rule $r\in P$ with its instances obtained by substituting the variables in r by constants occurring in P. Then, an interpretation $\mathcal{I}$ is a set of (true) ground atoms occurring in $P_{\mathit{grd}}$ that does not contain $\bot$ . An interpretation $\mathcal{I}$ satisfies a rule $r \in P_{\mathit{grd}}$ if $B^+(r) \subseteq \mathcal{I}$ and $B^-(r) \cap \mathcal{I}=\emptyset$ imply $H(r) \in \mathcal{I}$ , and $\mathcal{I}$ is a model of P if it satisfies all rules $r\in P_{\mathit{grd}}$ . A model $\mathcal{I}$ of P is stable if it is a subset-minimal model of the reduct $\{H(r) \gets B^+(r) \mid r \in P_{\mathit{grd}}, B^-(r) \cap \mathcal{I} = \emptyset\}$ , and we denote the set of all stable models, also called answer sets, of P by $\mathit{AS}(P)$ .

2.2 Inductive Logic Programming

Inductive Logic Programming (ILP) is a form of machine learning whose goal is to learn a logic program that explains a set of observations in the context of some pre-existing knowledge (Cropper et al. Reference Cropper, Dumančić and Muggleton2020). Since its foundation, the majority of research in the field has addressed Prolog semantics although applications in other paradigms appeared in the last years. The most expressive ILP system for ASP is Inductive Learning of Answer Set Programs (ilasp), which can solve a variety of ILP tasks (Law et al. Reference Law, Russo and Broda2014; Law et al. Reference Law, Russo and Broda2021).

Learning from Answer Sets.

A learning task for ilasp is given by a triple $\langle B,E,H_M \rangle$ , where an ASP program B defines the background knowledge, the set E comprises two disjoint subsets $E^+$ and $E^-$ of positive and negative examples, and the hypothesis space $H_M$ is defined by a language bias M, which limits the potentially learnable rules (Law et al. Reference Law, Russo and Broda2014). Each example $e \in E$ is a pair $\langle e_{\mathit{pi}}, C\rangle$ called Context Dependent Partial Interpretation (CDPI), where (i) $e_{\mathit{pi}}$ is a Partial Interpretation (PI) defined as pair of sets of atoms $\langle T, F\rangle$ , called inclusions (T) and exclusions (F), respectively, and (ii) C is an ASP program defining the context of PI $e_{\mathit{pi}}$ .

Given a (total) interpretation $\mathcal{I}$ of a program P and a PI $e_{\mathit{pi}}$ , we say that $\mathcal{I}$ extends $e_{\mathit{pi}}$ if $ T \subseteq \mathcal{I}$ and $F \cap \mathcal{I} = \emptyset$ . Given an ASP program P, an interpretation $\mathcal{I}$ , and a CDPI $e=\langle e_{\mathit{pi}}, C\rangle$ , we say that $\mathcal{I}$ is an accepting answer set of e with respect to P if $\mathcal{I} \in \mathit{AS}(P \cup C)$ such that $\mathcal{I}$ extends $e_{\mathit{pi}}$ .

Each hypothesis $H \subseteq H_M$ learned by ilasp must respect the following criteria: (i) for each positive example $e \in E^+$ , there is some accepting answer set of e with respect to $B\cup H$ ; and (ii) for any negative example $e \in E^-$ , there is no accepting answer set of e with respect to $B\cup H$ . If multiple hypotheses satisfy the conditions, the system returns one of those with the lowest cost. By default, the cost $c_{r}$ of each rule $r \in H_M$ corresponds to its number of literals (Law et al. Reference Law, Russo and Broda2014); however, the user can define a custom scoring function for defining the rule costs. Law et al. (Reference Law, Russo and Broda2018) extend the expressiveness of ilasp by allowing noisy examples. With this setting, if an example e is not covered, that is, there is an accepting answer set for e if it is negative, or none if e is positive, the corresponding weight is counted as a penalty. If no dedicated weight is specified, the example’s weight is infinite, thus forcing the system to cover the example. Therefore, the learning task becomes an optimization problem with two goals: minimize the cost of H and minimize the total penalties for the uncovered examples.

The language bias M for the ilasp learning task is specified using mode declarations. Constraint learning, that is, when the search space exclusively consists of rules r with $H(r) = \bot$ , requires only mode declarations for the body of a rule: #modeb(R,P,(E)). In this definition, the optional element R is a positive integer, called recall, which sets the upper bound on the number of mode declaration applications in each rule. P is a ground atom whose arguments are placeholders of type var(t) for some constant term t. In the learned rules, the placeholders will be replaced by variables of type t. For each rule, there are at most $V_{{\max}}$ variables and $B_{{\max}}$ literals in the body, which are both equal to 3 by default. Finally, E is an optional modifier that restricts the hypothesis space further, limited in our paper to the anti_reflexive and symmetric options that both work with predicates of arity 2. When using the former, the atoms of the predicate P should be generated with two distinguished argument values, while rules generated with the latter take into account that the predicate P is symmetric.

In a constraint learning task, just as in other ILP applications (Cropper and Dumani Reference Cropper and Dumani2020), the language bias must be defined manually for each ASP program P. A careful selection of the bias is essential since a too weak bias might not provide enough limitations for a learner to converge. In contrast, a too strong bias may exclude solutions from the search space, thus resulting in suboptimal learned constraints.

Conflict Driven Inductive Logic Programming (CDILP).

Several ilasp releases have been developed in the last years, extending its learning expressiveness and applying more efficient search techniques (Law et al. Reference Law, Russo and Broda2020). Recently, Law (Reference Law2022) introduced CDILP – a new search approach that overcomes the limitation of previous ilasp versions regarding scalability with respect to the number of examples and further aims at efficiently addressing tasks with noisy examples. The approach exploits a set $\mathit{CC}$ of coverage constraints, each defined by a pair $\langle e, F \rangle$ , where $e \in E$ is a CDPI and F is a propositional formula over identifiers for the rules in $H_M$ . The formula is defined such that, for any $H \subseteq H_M$ , if H does not respect F, then H does not cover e. CDILP interleaves the search for an optimal hypothesis H (for the current $\mathit{CC}$ ) with a “conflict analysis” phase. In this phase, ilasp identifies (at least) one example e not covered by H, which was not determined by the current $\mathit{CC}$ ; then, it creates a new conflict for e and adds it to $\mathit{CC}$ . If such an example does not exist, ilasp returns the current H as an optimal solution. Otherwise, the system repeats the procedure with the updated set of conflicts. Using the Python interface, PyLASP, one can apply different conflict analysis methods as long as they are proven to be valid, that is, a method must terminate and compute formulas F such that the current hypothesis H does not respect them. This requirement guarantees that the CDILP procedure terminates and returns an optimal hypothesis for the learning task.

There are currently three built-in methods for conflict analysis in ilasp, denoted by $\alpha$ , $\beta$ , and $\gamma$ , each of which determines a coverage constraint for an example e that is not covered by a given hypothesis H. In the most stringent case, $\gamma$ , ilasp computes a coverage constraint that is satisfied by exactly those hypotheses that cover e. Identifying such a comprehensive coverage formula has the advantage that any example will be analyzed in at most one iteration, so that ilasp with $\gamma$ for conflict analysis usually requires a small number of iterations only. On the other hand, computing such a precise coverage formula is complex, meaning that an iteration can take long time. For this reason, $\alpha$ and $\beta$ were introduced. Both methods yield smaller formulas that can be computed in less time. While this can lead to more iterations of CDILP, in some domains, the overall runtime benefits from significantly shorter iterations. However, our preliminary investigations showed that, for highly combinatorial PUP instances, even $\alpha$ and $\beta$ struggle to compute coverage constraints in acceptable time. In this work, we thus introduce a new conflict analysis method that brings significant improvements over $\alpha$ , $\beta$ , and $\gamma$ on PUP instances.

2.3 Lifting SBCs for ASP

Tarzariol et al. (Reference Tarzariol, Gebser and Schekotihin2021) presented an approach to lift ground SBCs for ASP programs using ILP. Their system takes four kinds of inputs: (i) an ASP program P modeling a combinatorial problem; (ii) two sets S and $\mathit{Gen}$ of small satisfiable instances representative for a practical problem solved using P; (iii) the hypothesis space $H_M$ ; and (iv) the Active Background Knowledge $\mathit{ABK}$ as an ASP program comprising auxiliary predicate definitions and constraints learned so far. The generalization set $\mathit{Gen}$ contains instances used to generate positive examples that the set of learned constraints must preserve. As a result, we increase the likelihood for the learned constraints to generalize beyond the training examples. The instances of the training set S are passed to the instance-specific symmetry breaking system sbass (Drescher et al. Reference Drescher, Tifrea and Walsh2011) to identify the symmetries of each instance in S. The output of sbass, $\Pi$ , is a set of permutation group generators (also called permutations) subsuming groups of symmetric answer sets for the analyzed ground program. The framework by Tarzariol et al. (Reference Tarzariol, Gebser and Schekotihin2021) uses this information to define the positive and negative examples for an ILP task and applies ilasp to solve it. The negative examples are associated with a weight, as the system aims at constraints that remove as many symmetric answer sets as possible but does not require eliminating all of them.

In their subsequent work, Tarzariol et al. (Reference Tarzariol, Gebser and Schekotihin2022b) discuss four approaches for creating training examples with sbass for ground programs $P_i$ , obtained by grounding P with the instances $i \in S$ . In particular, enum enumerates all answer sets of $P_i$ and classifies each solution as a positive or negative example, according to the common lex-leader approach. That is, if an answer set $\mathcal{I}$ can be mapped to a lexicographically smaller, symmetric answer set using the permutations $\Pi$ , that is, if $\mathcal{I}$ is dominated, it will produce a negative example. Otherwise, $\mathcal{I}$ yields a positive example. In both cases, the inclusions are $\mathcal{I} \cap atoms(\Pi)$ , where $atoms(\Pi)$ denotes the set of atoms occurring in $\Pi$ , the exclusions are $atoms(\Pi) \setminus \mathcal{I}$ , and the context is i. On the other hand, the fullSBCs approach exploits the clingo API to interleave the solving phase, which returns a candidate answer set $\mathcal{I}$ , with the analysis of all its symmetric solutions. Thanks to the properties of permutation groups (Sakallah Reference Sakallah2009), fullSBCs can determine all symmetric answer sets by repeatedly applying the permutations $\Pi$ to $\mathcal{I}$ until no new solutions can be obtained. This approach leads to a partition of the answer sets for an instance, where every partition cell consists of symmetric solutions. For each obtained cell, the system labels the smallest answer set as a positive example and all remaining ones as negative examples, thus achieving full rather than partial symmetry breaking, while the enum approach yields the latter only.

Tarzariol et al. (Reference Tarzariol, Gebser and Schekotihin2022b) evaluate the performance of their methods on three versions of the pigeon-hole problem and the house-configuration problem (Friedrich et al. 2011). The $\mathit{ABK}$ they use contains predicates emulating arithmetic built-ins, and the search space is split to apply the learning framework iteratively and thus increase the learning efficiency. Given that the considered problem instances are defined in terms of unary predicates and those in the training set S have a small number of solutions (from about a dozen up to a few hundred), the suggested formulation of the ILP task admits a fast learning of first-order constraints speeding up the solving of (unsatisfiable) instances. However, instances of complex application problems lack the presupposed characteristics, rendering the previously proposed approaches inapplicable and calling for a more scalable handling of training instances.

3.1 Revised ILP task

Training Examples. Tarzariol et al. (Reference Tarzariol, Gebser and Schekotihin2021) propose approaches to the example generation for an ILP learning task, which yield a number of examples proportional to the number of solutions for each problem instance in S. However, for difficult problems with many symmetries, even the simplest instances might yield a large number of answer sets. Their enumeration might thus take unacceptably long time. Moreover, even if the enumeration succeeds, the number of obtained examples is often too large to be handled by ilasp. To overcome these issues, we propose two scalable approaches to the generation of examples for each instance in S based on the enum and fullSBCs strategies by Tarzariol et al. (Reference Tarzariol, Gebser and Schekotihin2021). The scalable enum strategy generates examples from a portion of solutions, which are sampled from at most n random answer sets. For each candidate solution, the lex-leader criterion is applied to determine whether another symmetric answer set dominates it. This approach does not guarantee a fixed ratio between positive and negative examples, and it might fail to identify symmetric answer sets, as inspecting single applications of permutation group generators does not achieve full symmetry breaking (Sakallah Reference Sakallah2009). Nevertheless, the fixed number of considered answer sets provides means to limit the time required for the definition of a learning task. The scalable fullSBCs approach creates a set of examples configured by two parameters: (i) cells defines the number of cells of symmetric solutions to analyze and (ii) max_cell_size limits the maximal number of negative examples generated per cell. For each cell, the approach adds the first max_cell_size symmetric answer sets as negative examples. Next, it explores the whole cell of symmetric solutions and takes the smallest one as a positive example. As a result, this method generates a controlled number of positive and negative examples, regardless of how many solutions there may be for a given instance. In fact, at most cells many positive and ${cells} \times {max\_cell\_size}$ many negative examples can be obtained in total.

Background Knowledge.

Learning SBCs that improve the grounding and solving efficiency is crucial for difficult combinatorial problems. Therefore, the background knowledge $\mathit{ABK}$ should provide necessary auxiliary predicates that allow an ILP system to incorporate such constraints in the search space. Previous formulations of $\mathit{ABK}$ for learning SBCs have issues with expressing appropriate constraints since the provided predicates do not take the structure of problem instances into account. In this paper, we propose a new version of $\mathit{ABK}$ comprising two new types of auxiliary predicates. The first type encodes local properties of nodes in an input graph, while the second enables a more efficient constraint representation. That is, for two different nodes N and M, the predicate close(N,M) holds if these nodes share a common neighbor. In case of bipartite graphs containing two types of nodes, A and B (standing for sensors and zones in case of PUP instances), we define two versions of this auxiliary predicate, distinguishing the two types by closeA/2 and closeB/2. The second auxiliary predicate introduces an ordering on value assignments as follows: let $[1..{\max}_x]$ and $[1..{\max}_y]$ be the domains of two variables X and Y, and p(X,Y) be a binary predicate that holds for at most one value ${\rm{X}} \in [1..{\max}_x]$ per ${\rm{Y}} \in [1..{\max}_y]$ in each answer set. Then, we define the following auxiliary predicate:

pGEQ(X,Y) :- p(X,Y).

pGEQ(X,Y) :- pGEQ(X+1,Y), 0 < X.

If pGEQ(X,Y) is true, we know that p(X’,Y) holds for some value X’ equal to X or greater. A constraint may then contain pGEQ(Y,Y) instead of the equivalent test p(X,Y),Y <=X, thus reducing the ground instantiation size. Moreover, this encoding can bring benefits for solving as well, as we obtain a more powerful propagation (Crawford and Baker Reference Crawford and Baker1994).

From a technical perspective, the framework presented by Tarzariol et al. (Reference Tarzariol, Gebser and Schekotihin2021) runs sbass on a ground program resulting from the union of P, an instance $i \in S$ , and $\mathit{ABK}$ . The inclusion of $\mathit{ABK}$ caused no difference in the symmetries for their approach (without iterative constraint learning), given that the introduced auxiliary predicates do not affect atoms occurring in P. On the other hand, the predicate pGEQ/2 alters the identification of symmetries for atoms over the predicate p/2 contained in P. Hence, we do not necessitate $\mathit{ABK}$ to contribute to a ground program passed to sbass, as indicated in Figure 2.

Language Bias.

To address difficult combinatorial problems, we suggest the following set of mode declarations to define the search space $H_M$ :

#modeb(1,r(var(t),var(t))).

#modeb(1,close(var(t),var(t)),(symmetric,anti_reflexive)).

#modeb(2,pGEQ(var(t),var(t))).

#modeb(1,q(var(t),var(t))).

Assuming that the predicate r/2 specifies the graph provided by an instance, the mode declaration in the first line expresses that one such atom can occur per constraint. Then, for each close/2 or pGEQ/2 predicate in $\mathit{ABK}$ , we include a respective mode declaration as in the second and third lines. Moreover, if atoms over another predicate q/2 occur in P, but not in $\mathit{ABK}$ , we supply a mode declaration of the last kind, where considering binary predicates is sufficient for PUP instances. Let us notice that only one type t of variables is used for all mode declarations. In this way, there is no restriction on the variable replacements, and we may explore inherent yet hidden properties of the input labels. Furthermore, we introduce an alternative scoring function assigning the cost $c_{\mathit{id}}$ to each rule $r_{\mathit{id}} \in H_M$ . For every literal obtainable from the mode declarations, we overwrite its default cost 1 with a custom cost, except for literals over domain predicates like, for example, r/2. For literals over other predicates, in case the same variable is used for both of the contained arguments, the cost is 2, and 3 otherwise. For example, the cost of the constraint :- pGEQ(V1,V1), close(V1,V2), q(V2,V3). would be equal to $1+1+1=3$ with the default scoring function but $2+1+3=6$ with our custom costs.

3.2 Conflict analysis

As discussed in Section, ilasp’s Conflict Driven ILP (CDILP) approach requires a conflict analysis method that, given a hypothesis H and an example e that H does not cover, returns a coverage formula F. For ilasp to function correctly, this formula must (i) not be satisfied by H, and (ii) be satisfied by every hypothesis $H'\subseteq H_M$ covering e.

Ilasp has several built-in methods for conflict analysis, some of which are described by Law (Reference Law2022). However, for learning tasks with hypothesis spaces that consist of constraints only, these methods all behave equivalently when processing positive examples. For positive examples $e=\langle e_{\mathit{pi}}, C\rangle$ such that $B\cup C$ has many answer sets, the built-in methods can return extremely long coverage formulas that also take long time to compute. For this reason, we define a new conflict analysis method leading to shorter coverage constraints that can be computed much faster.

Let $r^1$ be the first rule in H and $r^2,\ldots, r^{16}$ be the rules that subsume the second rule. In this case, for any positive example e that is not covered by H, we obtain the coverage constraint $\mathit{sbca}(e, H, T) = (\lnot r^1_{\mathit{id}}) \lor ((\lnot r^2_{\mathit{id}})\land\ldots\land (\lnot r^{16}_{\mathit{id}}))$ .

The following theorem shows that $\mathit{sbca}$ is a valid method for conflict analysis for positive examples, provided that the hypothesis space contains constraints only. This means that in our application domain, when using the $\mathit{sbca}$ method for some or all of the positive examples, ilasp is guaranteed to return an optimal solution for any learning task.

1. 1. H does not satisfy $\mathit{sbca}(e, H, T)$ .

2. 2. Every $H'\subseteq H_M$ that covers e satisfies $\mathit{sbca}(e, H, T)$ .

Proof.

1. 1. For each $r \in H$ , $r\subseteq_{\theta} r$ implies that $\bigwedge\limits_{r' \subseteq_{\theta} r} \lnot r'_{\mathit{id}}$ is not satisfied by H. Thus, H cannot satisfy any of the disjuncts of $\mathit{sbca}(e, H, T)$ , that is, it does not satisfy $\mathit{sbca}(e, H, T)$ .

2. 2. Assume for contradiction that some $H'\subseteq H_M$ covers $e = \langle e_{\mathit{pi}}, C\rangle$ but does not satisfy $\mathit{sbca}(e, H, T)$ . Then, by the definition of covering e, there is some answer set $\mathcal{I} \in \mathit{AS}(B\cup C\cup H')$ that extends $e_{\mathit{pi}}$ . As H’ does not satisfy $\mathit{sbca}(e, H, T)$ , H’ must include constraints that subsume each of the constraints in H. This means that $\mathit{AS}(B\cup C\cup H') \subseteq \mathit{AS}(B \cup C \cup H)$ . Hence, $\mathcal{I} \in AS(B \cup C \cup H)$ contradicts the condition that H does not cover e.

The advantage of the $\mathit{sbca}$ method for conflict analysis, over the methods that are already built-in to ilasp, is that this method does not need to compute answer sets of $B \cup C \cup H$ (for an uncovered example with context C). In other words, it does not need to consider the semantics of the current hypothesis H and can instead focus on purely syntactic properties. In combinatorial problem domains, where finding answer sets can be computationally intensive, our preliminary experiments showed that $\mathit{sbca}$ is much faster than the existing conflict analysis methods of ilasp. On the other hand, the syntactic coverage constraints generated by $\mathit{sbca}$ tend to be more specific than the semantic constraints computed by ilasp’s built-in methods. That is, the formulas determined by $\mathit{sbca}$ apply to fewer hypotheses and cut out fewer solution candidates, which in turn means that more (yet considerably faster) iterations of the CDILP procedure are required.

The $\mathit{sbca}$ method is closely related to the ILP system Popper (Cropper and Morel Reference Cropper and Morel2021), which also identifies syntactically determined constraints based on subsumption. Specifically, when Popper encounters a hypothesis H entailing an atom that should not be entailed (a negative example for Popper), all hypotheses subsuming H are discarded (as these would also entail the atom). Just like $\mathit{sbca}$ , since Popper uses syntactically determined constraints, it can compute these very quickly but may need many more iterations (compared to the semantic conflict analysis methods of Ilasp). While both approaches are closely linked, Popper learns under Prolog semantics. Therefore, Popper cannot reason about logic programs with multiple answer sets and is inapplicable for learning ASP constraints in the combinatorial problem domains we address.

PyLASP Script.

The $\mathit{sbca}$ method is essential to compute coverage formulas for positive examples obtained from the generalization set $\mathit{Gen}$ , including instances with a large number of answer sets, in acceptable time. However, for other examples, the existing conflict analysis methods of ilasp are better suited, as the obtained formulas are more informative. Hence, we extended the default PyLASP script of ilasp with means to specify examples requiring $\mathit{sbca}$ usage by dedicated identifiers, associated with instances in $\mathit{Gen}$ on which clingo takes more than 5 s for enumerating the answer sets.