1 Introduction
The popularity of Answer Set Programming (ASP; [Baral2003]) as a paradigm for knowledge representation and reasoning is mainly due to two factors: first, its rich modeling language and, second, the availability of highperformance ASP systems. In fact, modern ASP solvers, such as clasp [Gebser et al.2007a], cmodels [Giunchiglia, Lierler, & Maratea2006], and smodels [Ward & Schlipf2004], have meanwhile closed the gap to Boolean Satisfiability (SAT; [Mitchell2005]) solvers. In both fields, conflictdriven learning and related techniques have led to significant performance boosts [Bayardo & Schrag1997, MarquesSilva & Sakallah1999, Moskewicz et al.2001, Gebser et al.2007d]. The basic prerequisite for the application of such techniques is conflict analysis, that is, the extraction of nontrivial reasons for dead ends encountered during search. Even though ASP and SAT solvers exploit different inference patterns, their underlying search techniques are closely related to each other. For instance, the basic search strategy of SAT solver chaff [Moskewicz et al.2001], nowadays a quasi standard in SAT solving, is also exploited by ASP solver clasp, in particular, the principles of conflict analysis are similar. Vice versa, the solution enumeration approach implemented in clasp [Gebser et al.2007b] could also be applied by SAT solvers. Given these similarities, general search or, more specifically, conflict analysis techniques developed in one community can (almost) immediately be exploited in the other field too.
In this paper, we address the problem of identifying “good” reasons for conflicts to be recorded within an ASP solver. In fact, conflictdriven learning exhibits several degrees of freedom. For instance, several constraints may become violated simultaneously, in which case one can choose the conflict(s) to be analyzed. Furthermore, distinct schemes may be used for conflict analysis, such as the resolutionbased FirstUIP and LastUIP scheme
[Zhang et al.2001]. Finally, if conflict analysis is based on resolution, several constraints may be suitable resolvents, likewise permitting to eliminate some literal in a resolution step.For the feasibility of our study, it was necessary to prune dimensions of freedom in favor of predominant options. In the SAT area, the FirstUIP scheme [MarquesSilva & Sakallah1999] has empirically been shown to yield better performance than other known conflict resolution strategies [Zhang et al.2001]. We thus fix the conflict analysis strategy to conflict resolution according to the FirstUIP scheme. Furthermore, it seems reasonable to analyze the first conflict detected by a solver (although conflicts encountered later on may actually yield “better” reasons). This leaves to us the choice of the resolvents to be used for conflict resolution, and we investigate this issue with respect to different goals: reducing the size of reasons to be recorded, skipping greater portions of the search space by backjumping (explained below), reducing the number of conflict resolution steps, and reducing the overall number of encountered conflicts (roughly corresponding to runtime). To this end, we modified the conflict analysis procedure of our ASP solver clasp^{1}^{1}1http://www.cs.unipotsdam.de/clasp for accommodating a variety of heuristics for choosing resolvents. The developed heuristics and comprehensive empirical results for them are presented in this paper.
2 Logical Background
We assume basic familiarity with answer set semantics (see, for instance, [Baral2003]). This section briefly introduces notations and recalls a constraintbased characterization of answer set semantics according to [Gebser et al.2007c]
. We consider propositional (normal) logic programs over an alphabet
. A logic program is a finite set of rules(1) 
where and is an atom for . For a rule as in (1), let be the head of and be the body of . The set of atoms occurring in a logic program is denoted by , and the set of bodies in is . For regrouping bodies sharing the same head , define .
For characterizing the answer sets of a program , we consider Boolean assignments over domain . Formally, an assignment is a sequence of (signed) literals of the form or for and . Intuitively, expresses that is true and that it is false in . We denote the complement of a literal by , that is, and . Furthermore, we let denote the sequence obtained by concatenating two assignments and . We sometimes abuse notation and identify an assignment with the set of its contained literals. Given this, we access the true and false propositions in via and . Finally, we denote the prefix of up to a literal by
In our context, a nogood [Dechter2003] is a set of literals, expressing a constraint violated by any assignment containing . An assignment such that and is a solution for a set of nogoods if for all . Given a logic program , we below specify nogoods such that their solutions correspond to the answer sets of .
We start by describing nogoods capturing the models of the Clark’s completion [Clark1978] of a program . For , let
Observe that every solution for must assign body equivalent to the conjunction of its elements. Similarly, for an atom , the following nogoods stipulate to be equivalent to the disjunction of :
Combining the above nogoods for , we get
The solutions for correspond onetoone to the models of the completion of . If is tight [Fages1994, Erdem & Lifschitz2003], these models are guaranteed to match the answer sets of . This can be formally stated as follows.
Theorem 1 ([Gebser et al.2007c])
Let be a tight logic program. Then, is an answer set of iff for a (unique) solution for .
We proceed by considering nontight programs . As shown in [Lin & Zhao2004], loop formulas can be added to the completion of to establish full correspondence to the answer sets of . For , let be
Observe that contains the bodies of all rules in that can externally support [Lee2005] an atom in . Given and , the following nogoods capture the loop formula of :
Furthermore, we define
By augmenting with , Theorem 1 can be extended to nontight programs.
Theorem 2 ([Gebser et al.2007c])
Let be a logic program. Then, is an answer set of iff for a (unique) solution for .
By virtue of Theorem 2, the nogoods in provide us with a constraintbased characterization of the answer sets of . However, it is important to note that the size of is linear in , while contains exponentially many nogoods. As shown in [Lifschitz & Razborov2006], under current assumptions in complexity theory, the exponential number of elements in is inherent, that is, it cannot be reduced significantly in the worst case. Hence, ASP solvers do not determine the nogoods in a priori, but include mechanisms to determine them on demand. This is illustrated further in the next section.
3 Algorithmic Background
This section recalls the basic decision procedure of clasp [Gebser et al.2007c], abstracting ConflictDriven Clause Learning (CDCL; [Mitchell2005]) for SAT solving from clauses, that is, ConflictDriven Nogood Learning (CDNL).
3.1 ConflictDriven Nogood Learning
Algorithm 1 shows our main procedure for deciding whether a program has some answer set. The algorithm starts with an empty assignment and an empty set of recorded nogoods (Lines 1–2). Note that dynamic nogoods added to in Line 5 are elements of , while those added in Line 9 result from conflict analysis (Line 8). In addition to conflictdriven learning, the procedure performs backjumping (Lines 10–11), guided by a decision level determined by conflict analysis. Via decision level , we count decision literals, that is, literals in that have been heuristically selected in Line 15. The initial value of is (Line 3), and it is incremented in Line 16 before a decision literal is added to (Line 17). All literals in that are not decision literals have been derived by propagation in Line 5, and we call them implied literals. For any literal in , we write to refer to the decision level of , that is, the value had when was added to . After propagation, the main loop (Lines 4–17) distinguishes three cases: a conflict detected via a violated nogood (Lines 6–11), a solution (Lines 12–13), or a heuristic selection with respect to a partial assignment (Lines 14–17). Finally, note that a conflict at decision level signals that has no answer set (Line 7).
10
10
10
10
10
10
10
10
10
3.2 Propagation
Our propagation procedure, shown in Algorithm 2, derives implied literals and adds them to . Lines 3–9 describe unit propagation (cf. [Mitchell2005]) on . If a conflict is detected in Line 4, unit propagation terminates immediately (Line 5). Otherwise, in Line 6, we determine all nogoods that are unitresulting wrt , that is, the complement of some literal must be added to because all other literals of are already true in . If there is some unitresulting nogood (Line 7), is augmented with in Line 8. Observe that is chosen nondeterministically, and several distinct nogoods may imply wrt . This nondeterminism gives rise to our study of heuristics for conflict resolution, selecting a resolvent among the nogoods that imply .
The second part of Algorithm 2 (Lines 10–14) checks for unitresulting or violated nogoods in . If is tight (Line 10), sophisticated checks are unnecessary (cf. Theorem 1). Otherwise, we consider sets such that , called unfounded sets [Van Gelder, Ross, & Schlipf1991]. An unfounded set is determined in Line 12 by a dedicated algorithm, where . If such a nonempty unfounded set exists, each nogood is either unitresulting or violated wrt , and an arbitrary is recorded in Line 14 for triggering unit propagation. Note that all atoms in must be falsified before another unfounded set is determined (cf. Lines 11–12). Eventually, propagation terminates in Line 13 if no nonempty unfounded set has been detected in Line 12.
10
10
10
10
10
10
10
10
10
4
4
4
3.3 Conflict Analysis
Algorithm 3 shows our conflict analysis procedure, which is based on resolution. Given a nogood that is violated wrt , we determine in Line 2 the literal added last to . If is the single literal of its decision level in (cf. Line 3), it is called a unique implication point (UIP; [MarquesSilva & Sakallah1999]). Among a number of conflict resolution schemes, the FirstUIP scheme, stopping conflict resolution as soon as the first UIP is reached, has turned out to be the most efficient and most robust strategy [Zhang et al.2001]. Our conflict analysis procedure follows the FirstUIP scheme by performing conflict resolution only if is not a UIP (tested in Line 4) and, otherwise, returning along with the smallest decision level at which is implied by after backjumping (Line 8).
Let us take a closer look at conflict resolution steps in Lines 5–7. It is important to note that, if is not a UIP, it cannot be the decision literal of . Rather, it must have been implied by some nogood . As a consequence, the set determined in Line 5 cannot be empty, and we call its elements antecedents of . Note that each antecedent contains and had been unitresulting immediately before was added to ; we thus call a reason for . Knowing that may have more than one antecedent, a nondeterministic choice among them is made in Line 6. Exactly this choice is subject to the heuristics studied below. Furthermore, as is the literal of added last to , is also a reason for . Since they imply complementary literals, no solution can jointly contain both reasons, viz., and . Hence, combining them in Line 7 gives again a nogood violated wrt . Finally, note that conflict resolution is guaranteed to terminate at some UIP, but different heuristic choices in Line 6 may result in different UIPs.
4 Implication Graphs and Conflict Graphs
To portray the matter of choosing among several distinct antecedents, we modify the notion of an implication graph [Beame, Kautz, & Sabharwal2004]. At a given state of CDNL, the implication graph contains a node for each literal in assignment and, for a violated nogood , a node is included, where is the literal of added last to , that is, . Furthermore, for each antecedent of an implied literal , the implication graph contains directed edges labeled with from all literals in the reason to . Different from [Beame, Kautz, & Sabharwal2004], where implication graphs reflect exactly one reason per implied literal, our implication graph thus includes all of them. If the implication graph contains both and , we call them conflicting literals. Note that an implication graph contains at most one such pair , called conflicting assignment, because our propagation procedure in Algorithm 2 stops as soon as a nogood becomes violated (cf. Lines 4–5).
An exemplary implication graph is shown in Figure 1. Each of its nodes (except for one among the two conflicting literals) corresponds to a literal that is true in assignment
The three decision literals in are underlined, and all other literals are implied. For each literal , its decision level is also provided in Figure 1 in parentheses. Every edge is labeled with at least one antecedent of its target, that is, the edges represent the following nogoods:
Furthermore, nogood is unitresulting wrt the empty assignment, thus, implied literal (whose decision level is ) does not have any incoming edge. Observe that the implication graph contains conflicting assignment , where has been implied by nogood and likewise by . It is also the last literal in belonging to violated nogood , so that its complement is the second conflicting literal in the implication graph. Besides , literal has multiple antecedents, namely, and , which can be read off the labels of the incoming edges of .
The conflict resolution done in Algorithm 3, in particular, the heuristic choice of antecedents in Line 6, can now be viewed as an iterative projection of the implication graph. In fact, if an implied literal has incoming edges with distinct labels, all edges with a particular label are taken into account, while the edges with different labels only are dropped. This observation motivates the following definition: a subgraph of an implication graph is a conflict graph if it contains a conflicting assignment and, for each implied literal in the subgraph, the set of predecessors of is a reason for . Note that this definition allows us to drop all literals that do not have a path to any conflicting literal, such as and in Figure 1. Furthermore, the requirement that the predecessors of an implied literal form a reason corresponds to the selection of an antecedent, where only the incoming edges with a particular label are traced via conflict resolution.
The next definition accounts for a particularity of ASP solving related to unfounded set handling: a conflict graph is levelaware if each conflicting literal has some predecessor such that . In fact, propagation in Algorithm 2 is limited to falsifying unfounded atoms, thus, unit propagation on nogoods in is performed only partially and may miss implied literals corresponding to external bodies (cf. [Gebser et al.2007c]). If a conflict graph is not levelaware, the violated nogood provided as input to Algorithm 3 already contains a UIP, thus, itself is returned without performing any conflict resolution inbetween. Given that we are interested in conflict resolution, we below consider levelaware conflict graphs only.
Finally, we characterize nogoods derived by Algorithm 3 by cuts in conflict graphs (cf. [Zhang et al.2001, Beame, Kautz, & Sabharwal2004]). A conflict cut in a conflict graph is a bipartition of the nodes such that all decision literals belong to one side, called reason side, and the conflicting assignment is contained in the other side, called conflict side. The set of nodes on the reason side that have some edge into the conflict side form the conflict nogood associated with a particular conflict cut. For illustration, a FirstNewCut [Beame, Kautz, & Sabharwal2004] is shown in Figure 2. For the underlying conflict graph, we can choose among the incoming edges of whether to include the edges labeled with or the ones labeled with . With , we get conflict nogood , while yields .
Different conflict cuts correspond to different resolution schemes, where we are particularly interested in the FirstUIP scheme. Given a conflict graph and conflicting assignment , a UIP can be identified as a node such that all paths from , the decision literal of decision level , to either or go through (cf. [Zhang et al.2001]). In view of this alternative definition of a UIP, it becomes even more obvious than before that is indeed a UIP, also called the LastUIP. In contrast, a literal is the FirstUIP if it is the UIP “closest” to the conflicting literals, that is, if no other UIP is reachable from . The FirstUIPCut is then given by the conflict cut that has all literals lying on some path from the FirstUIP to a conflicting literal, except for the FirstUIP itself, on the conflict side and all other literals (including the FirstUIP) on the reason side. The FirstUIPNogood, that is, the conflict nogood associated with the FirstUIPCut, is exactly the nogood derived by conflict resolution in Algorithm 3 when antecedents that contribute edges to the conflict graph are selected for conflict resolution. Also note that the FirstUIPCut for a conflict graph is unique, thus, by projecting an implication graph to a conflict graph, we implicitly fix the FirstUIPNogood. With this is mind, the next section deals with heuristics for extracting conflict graphs from implication graphs.
5 Heuristics
In this section, we propose several heuristics for conflict resolution striving for different goals.
5.1 Recording Short Nogoods
Under the assumption that short nogoods prune larger portions of the search space than longer ones, a FirstUIPNogood looks the more attractive the less literals it contains. In addition, unit propagation on shorter nogoods is usually faster and might even be enabled to use particularly optimized data structures, for instance, specialized to binary or ternary nogoods [Ryan2004]. As noticed in [Mahajan, Fu, & Malik2005], a conflict nogood stays short when the resolvents are short, when the number of resolvents is small, or when the resolvents have many literals in common. In the SAT area, it has been observed that preferring short nogoods in conflict resolution may lead to resolution sequences involving mostly binary and ternary nogoods, so that derived conflict nogoods are not much longer than the originally violated nogoods [Mitchell2005]. Our first heuristics, , thus selects an antecedent containing the smallest number of literals among the available antecedents of a literal. Given the same implication graph as in Figure 1 and 2, may yield the conflict graph shown in Figure 3 by preferring antecedent of over and antecedent of over during conflict resolution. The corresponding FirstUIPNogood, , is indeed short and enables CDNL to after backjumping derive by unit propagation at decision level . However, the antecedents and of are of the same size, thus, may likewise pick , in which case the FirstUIPCut in Figure 4 is obtained. The corresponding FirstUIPNogood, , is longer. Nonetheless, our experiments below empirically confirm that tends to reduce the size of FirstUIPNogoods. But before, we describe further heuristics focusing also on other aspects.
5.2 Performing Long Backjumps
By backjumping, CDNL may skip the exhaustive exploration of regions of the search space, possibly escaping spare regions not containing any solution. Thus, it seems reasonable to aim at FirstUIPNogoods such that their literals belong to small decision levels, as they are the determining factor for the lengths of backjumps. Our second heuristics, , thus uses a lexicographic order to rank antecedents according to the decision levels of their literals. Given an antecedent of a literal , we arrange the literals in the reason for in descending order of their decision levels. The so obtained sequence , where , induces a descending list of decision levels. An antecedent is then considered to be smaller than another antecedent , viz., , if the first element that differs in and is smaller in or if is a prefix of and shorter than . Due to the last condition, also prefers an antecedent that is shorter than , provided that literals of the same decision levels as in are also found in . Reconsidering the implication graph in Figure 1 and 2, we obtain for antecedents and of , and we have for antecedents and of . By selecting antecedents that are lexicographically smallest, leads us to the conflict graph shown in Figure 4. In this example, the corresponding FirstUIPNogood, , is weaker than , which may be obtained with (cf. Figure 3).
Given that lexicographic comparisons are computationally expensive, we also consider a lightweight variant of ranking antecedents according to decision levels. Our third heuristics, , prefers an antecedent over if the average of is smaller than the average of . In our example, we get and , yielding the conflict graph shown in Figure 5. Unfortunately, the corresponding FirstUIPNogood, , does not match the goal of as backjumping only returns to decision level , where is then flipped to . Note that this behavior is similar to chronological backtracking, which can be regarded as the most trivial form of backjumping.
5.3 Shortening Conflict Resolution
Our fourth heuristics, , aims at speeding up conflict resolution itself by shortening resolution sequences. In order to earlier encounter a UIP, prefers antecedents such that the number of literals at the current decision level is smallest. In our running example, prefers over as it contains fewer literals whose decision level is . However, antecedents and of are indifferent, thus, may yield either one of the conflict graphs in Figure 4 and 5.
5.4 Search Space Pruning
The heuristics presented above rank antecedents merely by structural properties, thus disregarding their contribution in the past to solving the actual problem. The latter is estimated by nogood deletion heuristics of SAT solvers
[Goldberg & Novikov2002, Mahajan, Fu, & Malik2005], and clasp also maintains activity scores for nogoods [Gebser et al.2007a]. Our fifth heuristics, , makes use of them and ranks antecedents according to their activities.Finally, we investigate a heuristics, , that stores (and prefers) the smallest decision level at which a nogood has ever been unitresulting. The intuition underlying is that the number of implied literals at small decision levels can be viewed as a measure for the progress of CDNL, in particular, as attesting unsatisfiability requires a conflict at decision level . Thus, it might be a good idea to prefer nogoods that gave rise to implications at small decision levels.
6 Experiments
For their empirical assessment, we have implemented the heuristics proposed above in a prototypical extension of our ASP solver clasp version 1.0.2. (Even though there are newer versions of clasp, a common testbed, omitting some optimizations, is sufficient for a representative comparison.) Note that clasp [Gebser et al.2007a] incorporates various advanced Boolean constraint solving techniques, e.g.:

lookbackbased decision heuristics [Goldberg & Novikov2002],

restart and nogood deletion policies [Eén & Sörensson2003],

watched literals for unit propagation on “long” nogoods [Moskewicz et al.2001],

dedicated treatment of binary and ternary nogoods [Ryan2004], and

early conflict detection [Mahajan, Fu, & Malik2005].
Due to this variety, the solving process of clasp is a complex interplay of different features. Thus, it is almost impossible to observe the impact of a certain feature, such as our conflict resolution heuristics, in isolation. However, we below use a considerable number of benchmark classes with different characteristics and shuffled instances, so that noise effects should be compensated at large.
For accommodating conflict resolution heuristics considering several antecedents per literal, the lowlevel implementation of clasp had to be modified. These modifications are less optimized than the original implementation, so that our prototype incurs some disadvantages in raw speed that can potentially be reduced by optimizing the implementation. However, for comparison, we include unmodified clasp version 1.0.2, not applying any particular heuristics in conflict resolution. Given that unit propagation in clasp privileges binary and ternary nogoods, they are more likely to be used as antecedents than longer nogoods, as original clasp simply stores the first antecedent it encounters and ignores others. In view of this, unit propagation of original clasp leads conflict resolution into the same direction as , though in a less exact way. The next table summarizes all clasp variants and conflict resolution heuristics under consideration, denoting the unmodified version simply by clasp:
Label  Heuristics  Goal 

clasp  —  speeding up unit propagation 
clasp  recording short nogoods  
clasp  performing long backjumps  
clasp  performing long backjumps  
clasp  shortening conflict resolution  
clasp  search space pruning  
clasp  search space pruning 
Note that all clasp variants perform early conflict detection, that is, they encounter a unique conflicting assignment before beginning with conflict resolution. Furthermore, all of them perform conflict resolution according to the FirstUIP scheme. Thus, we do not explore the first two among the three degrees of freedom mentioned in the introductory section and concentrate fully on the choice of resolvents.
We conducted experiments on the benchmarks used in categories SCore and SLparse of the first ASP system competition [Gebser et al.2007d]. Tables 1–4 group benchmark instances by their classes, viz., Classes 1–11. Via superscripts and in the first column, we indicate whether the
instances belonging to a class are structured (e.g., 15Puzzle) or randomly generated (e.g., BlockedNQueens). We omit classifying Factoring, which is a worstcase problem where an efficient algorithm would yield a cryptographic attack. Furthermore, Tables
1–4 show results for computing one answer set or deciding that an instance has no answer set. For each benchmark instance, we performed five runs on different shuffles, resulting in runs per benchmark class. All experiments were run on a 3.4GHz PC under Linux; each run was limited to 600s time and 1GB RAM. Note that, in Tables 1–3, we consider only the instances on which runs were completed by all considered clasp variants.Table 1 shows the average lengths of FirstUIPNogoods for the heuristics aiming at short nogoods, implemented by clasp and clasp, among which the latter uses the lengths of antecedents as a tie breaker. For comparison, we also include original clasp. On most benchmark classes, we observe that clasp as well as clasp tend to reduce the lengths of FirstUIPNogoods, up to percent shorter than the ones of clasp on BlockedNQueens. But there remains only a slight reduction of about percent shorter FirstUIPNogoods of clasp in the summary of all benchmark classes (weighted equally). We also observe that clasp, more straightly preferring short antecedents than clasp, does not reduce FirstUIPNogood lengths any further. Interestingly, there is no clear distinction between structured and randomly generated instances, neither regarding magnitudes nor reduction rates of FirstUIPNogood lengths.
No.  Class  clasp  clasp  clasp  

15Puzzle  22.33  22.35  23.03  
BlockedNQueens  27.32  28.23  31.85  
EqTest  172.12  178.27  189.12  
Factoring  134.95  130.67  141.34  
HamiltonianPath  12.96  11.73  12.04  
RandomNonTight  31.82  32.07  32.74  
BoundedSpanningTree  35.06  36.68  33.95  
Solitaire  24.55  22.02  25.03  
SuDoku  16.22  15.09  13.99  
TowersOfHanoi  52.89  52.31  58.29  
TravelingSalesperson  101.37  90.35  99.26  
Average FirstUIPNogood Length  45.15  44.46  47.21 
Table 2 shows the average backjump lengths in terms of decision levels for the clasp variants aiming at long backjumps, viz., clasp and clasp. We note that average backjump lengths of more than decision levels indicate structured instances, except for BoundedSpanningTree. Regarding the increase of backjump lengths, clasp does not exhibit significant improvements, and the polarity of differences to original clasp varies. Only the more sophisticated heuristics of clasp almost consistently leads to increased backjump lengths (except for HamiltonianPath), but the amounts of improvements are rather small.
No.  Class  clasp  clasp  clasp  

15Puzzle  2.12  2.14  2.10  
BlockedNQueens  1.07  1.08  1.07  
EqTest  1.03  1.04  1.03  
Factoring  1.20  1.21  1.20  
HamiltonianPath  2.53  2.58  2.62  
RandomNonTight  1.15  1.16  1.15  
BoundedSpanningTree  3.12  3.47  3.06  
Solitaire  3.34  3.28  2.92  
SuDoku  2.55  3.01  2.76  
TowersOfHanoi  1.46  1.46  1.40  
TravelingSalesperson  1.27  1.51  1.43  
Average Backjump Length  1.89  1.99  1.89 
Table 3 shows the average numbers of conflict resolution steps for clasp and clasp, among which the former particularly aims at their reduction. Somewhat surprisingly, clasp in all performs more conflict resolution steps even than original clasp, while clasp almost consistently exhibits a reduction of conflict resolution steps (except for SuDoku). This negative result for clasp suggests that trimming conflict resolution regardless of its outcome is not advisable. The quality of recorded nogoods certainly is a key factor for the performance of conflictdriven learning solvers for ASP and SAT, thus, shallow savings in their retrieval are not worth it and might even be counterproductive globally.
No.  Class  clasp  clasp  clasp  

15Puzzle  102.95  103.45  103.77  
BlockedNQueens  18.17  17.61  17.74  
EqTest  86.94  84.78  85.76  
Factoring  325.54  290.36  296.07  
HamiltonianPath  11.87  12.03  12.14  
RandomNonTight  16.41  16.47  32.74  
BoundedSpanningTree  20.11  20.27  20.66  
Solitaire  79.05  67.70  79.89  
SuDoku  21.48  20.86  19.73  
TowersOfHanoi  41.60  40.36  42.69  
TravelingSalesperson  141.68  96.06  122.98  
Average Number of Resolution Steps  78.71  70.00  75.83 
Finally, Table 4 provides average numbers of conflicts and average runtimes in seconds for all clasp variants. For each benchmark class, the first line provides the average numbers of conflicts encountered on instances where runs were completed by all clasp variants, while the second line gives the average times of completed runs and numbers of timeouts in parentheses. (Recall that all clasp variants were run on shuffles of the instances per class, leading to more than timeouts on BlockedNQueens and, with some clasp variants, also on Solitaire.) At the bottom of Table 4, we summarize average numbers of conflicts and average runtimes over all benchmark classes (weighted equally). Note that the last but one line provides the sums of timeouts in parentheses, while the last line penalizes timeouts with maximum time, viz., 600 seconds. As mentioned above, original clasp is highly optimized and does not suffer from the overhead incurred by the extended infrastructure for applying heuristics in conflict resolution. As a consequence, we observe that original clasp outperforms its variants on most benchmark classes as regards runtime. Among the variants of clasp, clasp in all exhibits the best average number of conflicts and runtime. However, it also times out most often and behaves unstable, as the poor performance on Classes 2 and 11 shows. In contrast, clasp and clasp lead to fewest timeouts (in fact, as many timeouts as clasp), and clasp encounters fewer conflicts than clasp. Variant clasp, preferring “critical” antecedents, exhibits a comparable performance, while clasp and clasp yield more timeouts and also encounter relatively many conflicts. Overall, we notice that some clasp variants perform reasonably well, but without significantly decreasing the number of conflicts in comparison to original clasp. As there is no clear winner among our clasp variants, unfortunately, they do not suggest any “universal” conflict resolution heuristics.
No.  Class  clasp  clasp  clasp  clasp  clasp  clasp  clasp  
15Puzzle  195.00  203.96  203.54  248.00  261.44  226.96  241.18  
0.13  0.14  0.14  0.15  0.16  0.15  0.14  
BlockedNQueens  27289.06  26989.57  28176.00  27553.63  30240.71  29119.60  28588.34  
116.87 (24)  122.04 (21)  39.70 (27)  86.24 (24)  138.01 (22)  68.10 (25)  24.52 (22)  
EqTest  62430.92  62648.96  59330.52  62705.00  62374.84  63303.44  62290.76  
19.47  21.66  19.41  19.98  20.03  21.30  15.66  
Factoring  15468.44  14838.64  14985.72  16016.56  16365.52  15404.64  16920.68  
6.30  5.85  6.27  6.55  6.36  6.36  5.11  
HamiltonianPath  703.70  683.29  653.19  564.83  764.16  694.33  650.70  
0.05  0.05  0.05  0.04  0.06  0.05  0.05  
RandomNonTight  427031.71  411024.73  402846.21  429955.23  423332.74  405476.81  406007.41  
53.85  55.17  51.53  54.92  53.33  52.78  41.79  
BoundedSpanningTree  879.92  640.88  801.76  634.96  662.22  940.92  949.84  
4.51  4.37  4.38  4.36  4.27  4.98  4.42  
Solitaire  193.85  145.85  103.40  134.75  103.40  95.90  134.00  
66.14 (2)  0.22 (5)  30.81 (4)  0.22 (5)  0.21 (5)  0.21 (5)  0.23 (4)  
SuDoku  123.40  127.80  164.60  111.93  108.67  119.87  123.93  
.  18.89  19.85  19.75  19.10  19.39  19.77  19.96  
TowersOfHanoi  145064.20  124222.96  71220.52  140386.64  97411.80  134192.96  133760.48  
62.43  46.69  21.86  52.19  32.76  47.63  37.60  
TravelingSalesperson  2512.20  1018.80  3243.16  2535.40  1334.32  2500.16  947.56  
34.06  21.63  42.22  36.77  25.70  34.42  20.89  
Average Number of Conflicts  56824.37  53545.45  48477.39  56737.24  52748.20  54339.63  54217.91  
Average Time (Sum Timeouts)  31.89 (26)  24.81 (26)  19.68 (31)  23.38 (29)  25.02 (27)  21.31 (30)  14.20 (26)  
Average Penalized Time  49.25  46.75  45.28  48.05  47.12  47.14  37.27  
7 Discussion
We have proposed a number of heuristics for conflict resolution and conducted a systematic empirical study in the context of our ASP solver clasp. However, it is too early to conclude any dominant approach or to make general recommendations. As has also been noted in [Mitchell2005], conflict resolution strategies are almost certainly important but have received little attention in the literature so far. In fact, dedicated approaches in the SAT area [Ryan2004, Mahajan, Fu, & Malik2005] merely aim at reducing the size of recorded nogoods. Though this might work reasonably well in practice, it is unsatisfactory when compared to sophisticated decision heuristics [Goldberg & Novikov2002, Ryan2004, Mahajan, Fu, & Malik2005, Dershowitz, Hanna, & Nadel2005] resulting from more profound considerations. We thus believe that heuristics in conflict resolution deserve further attention. Future lines of research may include developing more sophisticated scoring mechanisms than the ones proposed here, combining several scoring criterions, or even determining and possibly recording multiple reasons for a conflict (corresponding to different conflict graphs). Any future improvements in these directions may significantly boost the stateoftheart in both ASP and SAT solving.
References
 [Baral, Brewka, & Schlipf2007] Baral, C.; Brewka, G.; and Schlipf, J., eds. 2007. Proceedings of the Ninth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR’07). SpringerVerlag.
 [Baral2003] Baral, C. 2003. Knowledge Representation, Reasoning and Declarative Problem Solving. Cambridge University Press.

[Bayardo & Schrag1997]
Bayardo, R., and Schrag, R.
1997.
Using CSP lookback techniques to solve realworld SAT instances.
In
Proceedings of the Fourteenth National Conference on Artificial Intelligence (AAAI’97)
, 203–208. AAAI Press/MIT Press.  [Beame, Kautz, & Sabharwal2004] Beame, P.; Kautz, H.; and Sabharwal, A. 2004. Towards understanding and harnessing the potential of clause learning. Journal of Artificial Intelligence Research 22:319–351.
 [Clark1978] Clark, K. 1978. Negation as failure. In Gallaire, H., and Minker, J., eds., Logic and Data Bases, 293–322. Plenum Press.
 [Dechter2003] Dechter, R. 2003. Constraint Processing. Morgan Kaufmann Publishers.
 [Dershowitz, Hanna, & Nadel2005] Dershowitz, N.; Hanna, Z.; and Nadel, A. 2005. A clausebased heuristic for SAT solvers. In Bacchus, F., and Walsh, T., eds., Proceedings of the Eigth International Conference on Theory and Applications of Satisfiability Testing (SAT’05), 46–60. SpringerVerlag.
 [Eén & Sörensson2003] Eén, N., and Sörensson, N. 2003. An extensible SATsolver. In Proceedings of the Sixth International Conference on Theory and Applications of Satisfiability Testing (SAT’03), 502–518.
 [Erdem & Lifschitz2003] Erdem, E., and Lifschitz, V. 2003. Tight logic programs. Theory and Practice of Logic Programming 3(45):499–518.
 [Fages1994] Fages, F. 1994. Consistency of Clark’s completion and the existence of stable models. Journal of Methods of Logic in Computer Science 1:51–60.
 [Gebser et al.2007a] Gebser, M.; Kaufmann, B.; Neumann, A.; and Schaub, T. 2007a. clasp: A conflictdriven answer set solver. In Baral et al. lpnmr07, 260–265.
 [Gebser et al.2007b] Gebser, M.; Kaufmann, B.; Neumann, A.; and Schaub, T. 2007b. Conflictdriven answer set enumeration. In Baral et al. lpnmr07, 136–148.
 [Gebser et al.2007c] Gebser, M.; Kaufmann, B.; Neumann, A.; and Schaub, T. 2007c. Conflictdriven answer set solving. In Veloso, M., ed., Proceedings of the Twentieth International Joint Conference on Artificial Intelligence (IJCAI’07), 386–392. AAAI Press/MIT Press.
 [Gebser et al.2007d] Gebser, M.; Liu, L.; Namasivayam, G.; Neumann, A.; Schaub, T.; and Truszczyński, M. 2007d. The first answer set programming system competition. In Baral et al. lpnmr07, 3–17.

[Giunchiglia, Lierler, &
Maratea2006]
Giunchiglia, E.; Lierler, Y.; and Maratea, M.
2006.
Answer set programming based on propositional satisfiability.
Journal of Automated Reasoning
36(4):345–377.  [Goldberg & Novikov2002] Goldberg, E., and Novikov, Y. 2002. BerkMin: A fast and robust SAT solver. In Proceedings of the Fifth Conference on Design, Automation and Test in Europe (DATE’02), 142–149. IEEE Press.
 [Lee2005] Lee, J. 2005. A modeltheoretic counterpart of loop formulas. In Kaelbling, L., and Saffiotti, A., eds., Proceedings of the Nineteenth International Joint Conference on Artificial Intelligence (IJCAI’05), 503–508. Professional Book Center.
 [Lifschitz & Razborov2006] Lifschitz, V., and Razborov, A. 2006. Why are there so many loop formulas? ACM Transactions on Computational Logic 7(2):261–268.
 [Lin & Zhao2004] Lin, F., and Zhao, Y. 2004. ASSAT: computing answer sets of a logic program by SAT solvers. Artificial Intelligence 157(12):115–137.
 [Mahajan, Fu, & Malik2005] Mahajan, Y.; Fu, Z.; and Malik, S. 2005. Zchaff2004: An efficient SAT solver. In Hoos, H., and Mitchell, D., eds., Proceedings of the Seventh International Conference on Theory and Applications of Satisfiability Testing (SAT’04), 360–375. SpringerVerlag.
 [MarquesSilva & Sakallah1999] MarquesSilva, J., and Sakallah, K. 1999. GRASP: A search algorithm for propositional satisfiability. IEEE Transactions on Computers 48(5):506–521.
 [Mitchell2005] Mitchell, D. 2005. A SAT solver primer. Bulletin of the European Association for Theoretical Computer Science 85:112–133.
 [Moskewicz et al.2001] Moskewicz, M.; Madigan, C.; Zhao, Y.; Zhang, L.; and Malik, S. 2001. Chaff: Engineering an efficient SAT solver. In Proceedings of the Thirtyeighth Conference on Design Automation (DAC’01), 530–535. ACM Press.
 [Ryan2004] Ryan, L. 2004. Efficient algorithms for clauselearning SAT solvers. Master’s thesis, Simon Fraser University.
 [Van Gelder, Ross, & Schlipf1991] Van Gelder, A.; Ross, K.; and Schlipf, J. 1991. The wellfounded semantics for general logic programs. Journal of the ACM 38(3):620–650.
 [Ward & Schlipf2004] Ward, J., and Schlipf, J. 2004. Answer set programming with clause learning. In Lifschitz, V., and Niemelä, I., eds., Proceedings of the Seventh International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR’04), 302–313. SpringerVerlag.
 [Zhang et al.2001] Zhang, L.; Madigan, C.; Moskewicz, M.; and Malik, S. 2001. Efficient conflict driven learning in a Boolean satisfiability solver. In Proceedings of the International Conference on ComputerAided Design (ICCAD’01), 279–285.
Comments
There are no comments yet.