A Hybrid Algorithm for Compiling Equality. Constraints and its Implementation. Department of Computer and Information Science

Transcription

1 URL: 9 pages A Hybrid Algorithm for Compiling Equality Constraints and its Implementation Neng-Fa Zhou Department of Computer and Information Science Brooklyn College, The City University of New York New York, NY , USA Sosuke Kaneko Graduate School of Computer Science and Systems Engineering Kyushu Institute of Technology Kawazu, Iizuka, Fukuoka , Japan Abstract In this paper, we extend the language we proposed in [11] to make it possible to program arc-consistency algorithms. We also propose a hybrid algorithm that integrates the interval-consistency (IC) and arc-consistency (AC) algorithms. For a constraint, the algorithm checks IC when it is non-binary and checks AC when the constraint turns into binary. The algorithm is well-balanced. Its reduction cost is close to the IC checking algorithm, while its reduction power is close to the AC checking algorithm for most problems. The experimental results show that the hybrid algorithm may be a little slower than the IC checking algorithm for programs that do not require strong reduction power, but may be an order of magnitude faster than IC for other programs. 1 Introduction Constraint propagation is a method that has been widely used to solve constraint satisfaction problems [9]. The basic idea of constraint propagation is to trigger a domain reduction procedure, called domain-reducer, whenever some update occurs to a variable. Many propagation algorithms can be derived from this idea depending on what kind of domain reducer to use and when to trigger it. There is a trade-of involved in deciding which algorithm is better. In general, the stronger the reduction power of an algorithm is, the less the number of backtracks will be in search and the stronger the reduction power is, the greater the cost of reduction itself will be. Most nite-domain constraint systems only maintain interval-consistency (IC) for constraints and trigger the domain-reducer only when the low and/or c2000 Published by Elsevier Science B. V. Open access under CC BY-NC-ND license.

2 upper bound of a domain is updated. The CHIP system maintains arcconsistency (AC) for binary equality constraints and triggers the domain reducer when whatever elements are excluded from a domain. For complex constraints, the IC checking algorithm is used. In [11], we proposed an intermediate language, called delay clauses, for compiling constraints and showed four dierent schemes for compiling arithmetic constraints. As an implementation language for constraints, delay clauses are much morepowerful than indexicals [2,5]. Many propagation algorithms that are impossible to describe in indexicals can be implemented straightforwardly in delay clauses. Constraint handling rules (CHRs) [3] are avery high-level language for implementing constraint reasoning and propagation. The high description power is not oered without cost [6]. Constraint solvers implemented in CHRs are an order of magnitude slower than those implemented in indexicals and delay clauses. In this paper, we extend delay clauses and make it possible to implement arc-consistency algorithms. We also propose a hybrid algorithm that integrates the IC and AC algorithms. For a constraint, the algorithm checks IC when it is non-binary and checks AC when the constraint turns into binary. The algorithm is well-balanced. Its reduction cost is close to the IC checking algorithm, while its reduction power is close to the AC checking algorithm for most problems. The experimental results show that the hybrid algorithm is an order of magnitude faster than the IC checking algorithm for many problems. 2 Preliminaries 2.1 Domain variables A domain variable is variable that has a nite domain associated with it. When the domain of a variable becomes a singleton, then the variable will be boundtothevalue. A failure occurs when the domain of a variable becomes empty. There are several primitive operations available on domain variables. For example, the primitive dvar(x) succeeds if X is a domain variable the primitive fd min(x,min) says that the minimum element in the domain of X is Min and the primitive fd max(x,max) says that the maximum element in the domain of X is Min. 2.2 Delay clauses Adelay clause takes the following form : delay Head:-Condition:{Triggers} Action. where Condition is a sequence of in-line tests, Triggers is a sequence of trigger declarations, and Action is a sequence of arbitrary calls. For any call to the predicate of Head, ifitmatches Head and Condition is satised, then the call delays and Action is executed. Triggers species the 2

3 events that will trigger the execution of the delayed calls. There are four kinds of triggers: ins(x) is on when X is instantiated min(x) is on when the low bound of X is updated max(x) is on when the upper bound of X is updated and dom(x) is on when any inner elementofthe domain of X is excluded. A delay clause is executed in an event-driven manner. At the entry and exit points of every predicate, the system checks to see whether there is a trigger that has been turned on. If so, then the current procedure is interrupted and control is moved to the delayed calls associated with the trigger. 2.3 The AC-5 algorithm In the AC-5 algorithm, constraints are classied into three dierent classes: functional (for instance, X=2Y+1), anti-functional (for instance, Xn=Y), and monotonic (for instance, X>2X+1). For anti-functional constraints, AC- 5delays until constraints become unary. For monotonic constraints, AC-5 maintains IC of constraints and examines only the upper and low bounds of domains. For equality (functional) constraints, AC-5 maintains AC ofcon- straints. Consider a binary functional constraint p(x,y). Whenever an element x is excluded from the domain of X, then the corresponding element y in the domain of Y that satises p(x,y) will be excluded from the domain of Y. 3 Extending Domain Variables In order to implement AC-5, we need to know what elements have been excluded from a domain since the last time we examined the domain. For each domain variable, we add a new eld to it that stores the list of inner elements that have been excluded from the domain. Note that the low andupper bounds are not recorded on the list when they are excluded. We do not lose any reduction power by doing so as long as we lettheacchecking algorithm check IC. We introduce the following two new primitives on domain variables: fd delta(+x,-deltax) X is a domain variable and DeltaX is an internal number associated with the list of excluded elements of X. fd delta elms(+deltax,-elms) Elms is bound to the list of elements that have been excluded from X since the last time fd delta elms(deltax, ) is executed or since DeltaX was generated if no other fd delta elms(deltax, ) has been executed. For example, consider the following program: testdelta:- X in 1..10, fd_delta(x,deltax), 3

4 X #\= 4, fd_delta_elms(deltax,a), X #\= 5, X #\= 10, fd_delta_elms(deltax,b), write(a,b). At the end of the clause, the variable A will be bound to [4] and B to [5]. The excluded element 10 is not included in B since it was the upper bound when it was excluded. 4 Propagators for Binary Equality Constraints With the new primitives, fd delta and fd delta elms, on domain variables, it becomes now possible to implement the AC-5 algorithm for binary equality constraints. In this section, we show how to implement the propagator for the binary constraint ax=by+c where X and Y are domain variables, a and b are non-negative integers, and c is an arbitrary integer. More specic and ecient propagators can be derived from this general propagator by taking special coecients into account. The following shows the propagator: 'ax=by+c'(a,x,b,y,c):- (1)'arc_consistent_aX=bY+c'(A,X,B,Y,C), (2)fd_delta(X,DeltaX), (3)fd_delta(Y,DeltaY), (4)'aX=bY+c_prop'(A,X,B,Y,C,DeltaX), % reduce Y when X is updated C1 is -C, (5)'aX=bY+c_prop'(B,Y,A,X,C1,DeltaY). % reduce X when Y is updated The call on line (1) preprocesses the constraint to make the constraint arcconsistent: for each element x in the domain of X, there is an element y in the domain of Y such that A x = B y + c. The same thing is guaranteed for each element in Y. The calls on lines (2) and (3) tell the system to start memorizing excluded elements from the domains of X and Y, respectively. The predicate call 'ax=by+c prop'(a,x,b,y,c,deltax),which is dened as follows, reduces the domain of Y when X is updated. delay 'ax=by+c_prop'(a,x,b,y,c,deltax):- dvar(x),dvar(y) : {ins(x),min(x),max(x),dom(x)}, Y in (A*min(X)-C)/>B..(A*max(X)-C)/<B, fd_delta_elms(deltax,elmsx), reduce the domain of Y for each element in ElmsX. 4

5 'ax=by+c_prop'(a,x,b,y,c,deltax):- dvar(x) : X is (B*Y-C)//A. 'ax=by+c_prop'(a,x,b,y,c,deltax):- true : Y is -(A*X+C)//B. When whatever update is made to the variable X, the predicate will be reexecuted. The action in the delay clause, which is executed when both X and Y are variables, reduces the domain of Y to make the constraint arc-consistent with respect to X: for each x in the domain of X, there exists an element y in the domain of Y such that Ax=By+C. When either X or Y is instantiated, then the constraint becomes an assignment or a test. The remaining two clauses take care of these cases. 5 A Hybrid Algorithm for Compiling Equality Constraints In the current version of B-Prolog, a constraint with n variables is compiled to a call to the following predicate: delay c(c,a1,a2,...,an,x1,x2,..,xn):- no_vars_gt(n,0) : {Triggers}, reduce domains of X1,..,Xn. c(c,a1,a2,...,an,x1,x2,..,xn):- true : test the constraint. where the in-line call no vars gt(n,m) succeeds if there are more than m variables occurring in the last n arguments. The predicate uses the same code to reduce the domains of the variables to achieve ICuntil the constraint becomes ground. For a constraint, the hybrid algorithm maintains IC when there are multiple variables involved in the constraint and start to maintain AC when the constraint becomes binary. The propagator for an n-ary constraint looks as follows: delay c(c,a1,a2,...,an,x1,x2,..,xn):- no_vars_gt(n,2) : {Triggers}, reduce domains of X1,..,Xn. c(c,a1,a2,...,an,x1,x2,..,xn):- true : nary_to_binary(n,newc,b1,y1,b2,y2), call_bc_propagator(newc,b1,y1,b2,y2). When there are more than two variables in the constraint, the domains are reduced to make the constraint interval-consistent. When the number of variables becomes two or less, the call nary to binary(n,newc,b1, Y1,B2,Y2), which is a built-in 1, transforms the constraintinto a binary one: B1*Y1+B2*Y2+NewC 1 We use a trick here. Instead of passing the coecients and the variables of the constraint to nary to binary, we let it get the information from its parent call. 5

6 =0, and the next call invokes an appropriate propagator for the binary constraint. 6 Performance Evaluation Table 1 compares the CPU times required by two versions of B-Prolog to run several programs. bp interval is the current B-Prolog (version 3.5) that checks only IC of constraints, and bp hybrid is a version of B-Prolog that adopts the hybrid algorithm described in this paper. bp hybrid is nearly twice as fast as bp interval for alpha and is explosively faster than bp interval for the linear-space N-queen program [8]. For the remaining programs, bp hybrid has similar performance to that of bp interval. We understand from this results that the overhead of keeping record of excluded elements is actually very low. The following two facts tell the reason: First, bp hybrid starts to memorize the updates of the domain of a variable only after the variable appears in some binary constraints and second only inner elements that are excluded from a domain are memorized. Table 1 Execution Times (SPARC-10, milliseconds) Program bp interval bp hybrid alpha alpha crypta eq magic queens queens queens queens queens queens Table 2 compares the numbers of backtracks made in the two versions for the programs. We can understand from this table that the speed-ups of bp hybrid come from the reduction of the number of backtracks. Table 3 compares the CPU times required by the two versions to run the DJ system [13]. DJ is an extension of Java that supports constraint programming. DJ runs on B-Prolog and relies on the constraint propagators of B-Prolog 6

7 Table 2 Numbers of Backtracks Program bp interval bp hybrid alpha alpha crypta eq magic queens queens queens queens queens queens Table 3 Execution Times of DJ Programs (SPARC-10, milliseconds) Program bp interval bp hybrid Circles Circles Japan UK USA Marriage SendMoreMoney to solve constraints. bp hybrid is signicantly faster than bp interval. For instance, for the Marriage program, bp hybrid is nearly 20 times faster than bp interval. Most of the DJ programs have some constraints on the layout of graphical components. The hybrid algorithm proves very useful for solving geometric constraints. 7

8 7 Conclusion The AC and IC checking algorithms are two well known propagation algorithms for solving CSPs. The AC checking algorithm has a good reduction power but has to spend a lot of time reducing domains. On the other hand, the IC checking algorithm spend less time than IC in reducing domains but has a reduction power that may be too weak for big search problems. We proposed a hybrid algorithm that checks IC of constraints when there are multiple variables involved and checks AC of constraints when the constraints become binary. The experimental results show that the hybrid algorithm may be a little slower than the IC checking algorithm for programs that do not require strong reduction power, but may be an order of magnitude faster than IC for other programs. We demonstrated once again that delay clause is a powerful and ecient language for programming and compiling constraints. References [1] Abderrahmane Aggoun and Nicolas Beldiceanu. Overview of the CHIP compiler System, Proc. the 8th International Conference on Logic Programming, pp , MIT Press, [2] Philippe Codognet and Daniel Diaz. Compiling Constraints in clp(fd), Journal of Logic Programming, pp , [3] Thom W. Fruhwirth: Theory and Practice of Constraint Handling Rules, Journal of Logic Programming, Vol.37, , [4] Pascal Van Hentenryck, Yves Deville, and Choh-Man Teng. A generic arcconsistency algorithm and its specializations, Articial Intelligence 57(1992) [5] Pascal Van Hentenryck, Vijay A. Saraswat, Yves Deville: Design, Implementation, and Evaluation of the Constraint Language cc(fd), Journal of Logic Programming, Vol.37, pp , [6] C. Holzbaur and T. Fruhwirth: Compiling Constraint Handling Rules into Prolog iwth Attributed Variables, International Conference on Principles and Practice of Declarative Programming, [7] Micha Meier. Better Late Than Never, Implementations of Logic Programming Systems, E.Tick and G.Succi, Eds., Kluwer Academic Publishers, [8] Jean-Francois Puget and Michel Leconte. Beyond the Glass Box: Constraints as Objects, Proc International Symposium on Logic Programming, pp , MIT Press, [9] Edward Tsang. FOUNDATIONS of CONSTRAINT SATISFACTION, ACADEMIC PRESS,

9 [10] Neng-Fa Zhou: A Novel Implementation Method of Delay. In Proceedings of Joint International Conference and Symposium on Logic Programming, pp , MIT Press, [11] Neng-Fa Zhou. A High-Level Intermediate Language and Algorithm for Compiling Finite-Domain Constraints, Proc. Joint International Conference and Symposium on Logic Programming, pp.70-84, MIT Press, [12] Neng-Fa Zhou. B-Prolog User's Manual (Version 3.5), [13] Neng-Fa Zhou. DJ User's Manual (Version 0.5), 9