Watching Clauses in Quantified Boolean Formulae

Transcription

1 Watching Clauses in Quantified Boolean Formulae Andrew G D Rowley University of St. Andrews, Fife, Scotland agdr@dcs.st-and.ac.uk Abstract. I present a way to speed up the detection of pure literals and deleted variables in Quantified Boolean Formulae (QBFs) using a method similar to watching literals in SAT. Pure literal detection and variable deletion is crucial in QBF search, unlike SAT search where only satisfiability is to be determined. I find that the watched clause method improves the efficiency of my implementation backjumping by up to 8825 times and rarely performs worse, despite an increase in the worst case complexity of the algorithm. Introduction The introduction of watched literals [], a lazy data structure for satisfiability (SAT) search algorithms, has resulted in great improvements in the run-time of SAT solvers. Watched literals keeps track of two literals remaining in a clause so as to detect when a clause becomes unit or empty. Watched literals is non-trivial to implement in QBF search. Quantified Boolean Formulae (QBFs) are SAT formulae with some variables universally quantified. This changes the semantics of unit and false clauses. The issue of watching literals in QBF is addressed in [2]. In this paper, I show that the use of lazy data structures need not be restricted to literals in clauses. In SAT, the detection of pure literals and deleted variables appears to be unimportant [3], and so watched literals has so far been the only implemented lazy data structure. In search for QBF satisfiability, this is not the case; the detection of universal pure literals and deleted variables in particular is critical [4]. This is due to the fact that finding a solution to the CNF formula part of a QBF does not necessarily mean that search is finished. Without pure literal and deleted variable detection, unnecessary variable backtracks can be made. One important fact that helps to make watched literals efficient is that no work is required to be done when unassigning a variable. This allows the computer s cache memory to be used more efficiently []. This was an additional goal when designing the data structure described here. 2 Background A Quantified Boolean Formula is of the form QB where Q is a sequence of quantifiers Q v...q nv n, where each Q i quantifies ( or ) a variable v i and each variable occurs exactly once in the sequence Q. B is a Boolean formula in conjunctive normal form (CNF), a conjunction of clauses where each clause is a disjunction of literals. Each literal is a variable and a sign. The literal is said to be negative if negated and positive otherwise. Universals and existentials are those variables quantified by a universal or existential quantifier respectively. A QBF of the form v Q 2v 2...Q nv nb is true if either Q 2v 2...Q nv nb[v :=

2 T] or Q 2v 2...Q nv nb[v := F] is true, where T represents true and F represents false. Similarly, a QBF of the form v Q 2v 2...Q nv nb is true if both Q 2v 2...Q nv nb[v := T] and Q 2v 2...Q nv nb[v := F] are true. The assignment of a value to a variable is equivalent to assigning a positive value to either the positive or negative literal of the variable. When a literal has been assigned true, clauses containing positive occurrences of the literal can be removed from B, and negative occurrences of the literal can be removed from the clauses of B. A QBF is vacuously true when B is satisfied by the current assignment to the variables i.e. B is the empty set of clauses. A QBF is vacuously false when B contains an empty clause. A pure literal is a literal such that every occurrence of its variable within the formula B has the same sign. These are handled differently, depending on the quantification of the variable. If the variable is universal, the literal can be assigned the value F. We do not need to assign the literal T since we can guarantee that the variable was not used to satisfy the formula i.e. we can do no worse than assigning the variable F. Similarly, an existential pure literal can be assigned T, since we can do no better than this. When a variable no longer occurs in any clause, the variable is said to be deleted. This most obviously occurs when the variable is assigned, but can also happen due to other variable assignments causing clauses to be removed. The detection of these events is important to avoid assigning deleted variables and unnecessary backtracks. Backtracking search for QBF [4] proceeds using the recursive definition of the truth of a QBF given above. Since each variable can only be assigned one value at any one time, if the QBF is of the form v Q 2v 2...Q nv nb, and Q 2v 2...Q nv nb[v := T] is false, then v is instead assigned F. Similarly, if the QBF is of the form v Q 2v 2...Q nv nb, and Q 2v 2...Q nv nb[v := T] is true, then v is instead assigned F. Backjumping for QBF [5] attempts to determine the variables responsible for the vacuously false or vacuously true QBF. Once this set is determined, only variables in the set are backtracked on. The solution set, found when the vacuously true QBF is found, is not unique for a given set of assignments. It is important to find a small solution set; the less variables assigned when determining the solution set, the more likely it is to be possible to find a small solution set. Watched literals [] for SAT efficiently detect unit and false clauses. Two literals are chosen in each clause. When either of these literals are removed, the clause is searched for another literal that can be watched i.e. one that has not been assigned. If no such literal can be found, the clause must be unit or false. The idea is that since two literals are watched, the clause cannot become unit or empty without removing one of the watched literals i.e. the data structure is detecting the key events of the clause. 3 Unwatched Data Structure To detect pure literals, one must know how many literals of each sign of a variable occur in the formula. A simple way of doing this is to keep track of which literal is in which clause for each variable. This may or may not be how this is done in other QBF solvers; this has so far gone undocumented and source code is as yet unavailable. This tracking of literals is done using a data type called the c- literal (short for Clause Literal). Each c-literal holds a clause and a sign. The sign

3 is the sign of the corresponding literal in the clause. Two sets of c-literals are kept for each variable, one for each sign. When the clause containing the literal is removed, the corresponding c-literal is removed from the variable. Since the positive and negative occurrences of the c-literals of a variable are kept distinct, it becomes trivial to detect pure literals and deleted variables. Upon backtracking the c-literal removed from a set must be restored. Each c-literal removal can be done in constant time, provided a doubly linked list data structure is used to store the c-literals. To remove all c-literals of a single sign from the variable therefore has complexity O(n) where n is the number of c-literals of a single sign of a variable. Of course, this may never occur since only some c-literals may be removed, and so this is a worst case. 4 Watched Data Structure We can apply the same methods to watch c-literals in sets as are used to watch literals in clauses. In detecting pure literals or deleted variables, the key events are the c-literal set of one of the signs of the variable becoming empty for a pure literal and both signs of c-literal set becoming empty for a deleted variable. In watching literals in SAT, we keep two watched literal pointers in every clause. Similarly in QBF, we keep two watched c-literal pointers in every pair of sets. The meaning of these pointers is that one of the following holds:. There is one watched unremoved c-literal for each sign of the variable. 2. The variable has a pure literal. 3. The variable is deleted. If the clause is removed, the watched c-literals of the literals in the clause are enumerated. No c-literal is actually ever removed from the sets, but instead the watched c-literal pointers are updated as per the above invariants. A c-literal is labelled removed if the clause representing the c-literal has been removed. It is otherwise labelled unremoved. The main aim of this updating is that no work should be required upon backtracking. When a watched c-literal c old is examined, the rules are as follows:. Search for an unremoved c-literal of the same sign as c old, c new. (a) If c new exists, watch it. (b) If c new does not exist, search for an unremoved c-literal of the opposite sign to c old, c o. i. If c o exists, the variable is pure in the sign of c o. ii. If c o does not exist, the variable is removed. At first sight, watching clauses appears to look bad. To detect a pure literal, we must scan the entire set of c-literals. However, since this is a lazy data structure, we are only doing this work when necessary. In the best case for removing all c- literals, this scan is only performed once when the last clause removed for a literal corresponds to the watched c-literal in a set, giving best case complexity O(n) where n is the number of c-literals of a single sign in the variable. The worst case is when the c-literal examined is always the watched c-literal in a variable, and we always scan over previously removed c-literals. In this case the number of n examinations is i = O(n 2 ). Even in the worst case, we are still doing all the i= work during variable assignment and no work during backtracking, improving the use of the computer cache. Additionally, the best case complexity is when the watched c-literal is never removed, and so the variable never becomes pure or deleted. In this case, watched clauses does no work.

4 Median Run Time for 00 Runs (s) CSBJ CSBJWC Percentage Satisfiable Fraction Satisfiable Number of Clauses per Problem Fig.. Phase transition for CSBJ and CSBJWC on random problems from Model A (n=20 per quantifier,h=5,outermost quantifier universal,4 quantifier alternations,l= in steps of Experimental Evaluation To judge the efficiency of the watched clause implementation, I compared it to my own implementation of a backjumping algorithm, called CSBJ. The implementation of watched clauses is based on my implementation, and is known as CSBJWC; the only difference is in how the implementation handles pure literals and deleted variables. Run time comparisons are then valid since run time differences can only be due to this change. To verify this, I checked the number of existential and universal backtracks performed by each implementation. The backtracks for CSBJ and CSBJWC were identical on all runs. All experiments were performed on a cluster of PIII Ghz machines with 52MB RAM. For structured instances, I used all benchmark instances available from QBFLib ( except the robot problems. Random instances were generated using Gent and Walsh s Model A [6]. The parameters used were 20 variables per quantifier, 4 quantifier alternations with the universal outermost, 5 variables per clause and a number of clauses from 25 to 450 in steps of 25. A time out of 3600 seconds was used on all instances. Figure shows the standard phase transition for CSBJ and CSBJWC. We see here that CSBJWC outperforms CSBJ on all but a few data sets. At the peak, CSBJWC beats CSBJ by 23%. This shows that the performance of watched clauses on random problems is mostly better than that without watched clauses, although not by a lot. Figure 2 compares the run times of CSBJ and CSBJWC on structured instances. Where a point occurs below the diagonal, CSBJWC outperforms CSBJ. The further the point is below the line, the better for watching clauses. Here we see that all the points are either below or on the diagonal line. Many points lie very far below the line, suggesting that watching clauses greatly increases the efficiency on many problems, in the best cases up to 8825 times. These results suggest that the increase in worst case time complexity in removing a c-literal from a variable is significantly less important than the gains involved in implementing the lazy data structure.

5 000 CSBJWC Run Time (s) CSBJ Run Time (s) Fig. 2. Performance of CSBJ and CSBJWC on structured problems. The diagonal line represents the point where CSBJ and CSBJWC have the same run time on a problem. Points above this line are where CSBJ beats CSBJWC and points below the line are where CSBJWC beats CSBJ. Even when there are no pure literals to detect, watched clauses may not perform optimally due to the worst case complexity. Where run times of CSBJ and CSBJWC are observed to be similar, it is likely that the watched c-literal is being removed more often than those instances in which CSBJWC performs well, where it could be that the watched c-literal is never be removed from some sets. 6 Conclusions In this paper I have presented a new method based on lazy data structures for implementing pure literal detection and variable deletion detection in QBF search. I have shown how this method is similar to watched literals in SAT search. The experimental evaluation shows how this method provides significant improvements in run-time over previous methods, with watched clauses providing run time improvements of up to 8825 times, despite an increase in worst case complexity when removing a c-literal from a variable. References. Moskewicz, M., Madigan, C., Zhao, Y., Zhang, L., Malik, S.: Chaff: Engineering an Efficient SAT Solver. In: DAC. (200) 2. Gent, I., Giunchiglia, E., Narizzano, M., Rowley, A., Tacchella, A.: Efficient data structures for QBF solvers. In: SAT. (2003) To appear 3. Zhang, L., Malik, S.: The quest for efficient Boolean satisfiability solvers. In: CADE. (2002) Cadoli, M., Schaerf, M., Giovanardi, A., Giovanardi, M.: An algorithm to evaluate quantified boolean formulae and its experimental evaluation. Journal of Automated Reasoning 28 (2002) Giunchiglia, E., Narizzano, M., Tacchella, A.: Backjumping for quantified boolean logic satisfiability. In: IJCAI. (200) Gent, I., Walsh, T.: Beyond NP: the QSAT phase transition. In: AAAI. (999)