2-C3OP: An Improved Version of 2-Consistency

Transcription

1 -COP: An Improved Version of -Consistency Marlene Arangú, Miguel A. Salido, Federico Barber Instituto de Automática e Informática Industrial Universidad Politécnica de Valencia. Valencia, Spain Abstract Nowadays, many real problems can be modeled as constraint satisfaction problems. Arc consistency algorithms are widely used to prune the search space of Constraint Satisfaction. In this paper we present a new algorithm, called -COP, that achieves in binary and non-normalized CSPs. This algorithm is a reformulation of -C algorithm and it performs the constraint checks bidirectionally using inference. The evaluation section shows that -COP achieve like -C and it is 0 % faster. Furthermore, -COP performs less number of constraint checks than both AC and -C. 1 Introduction Constraint propagation is a process that uses a set of constraints of a problem to reduce domains by pruning values that cannot take part in any solution. It is an essential part of many constraint programming systems due to the fact that the benefit of efficient propagation is immediate. Constraint propagation is also called consistency technics, domain filtering or pruning. Proposing efficient algorithms for enforcing arc-consistency has always been considered as a central question in the constraint reasoning community. Thus, there are many arc-consistency algorithms such as AC1, AC, and AC [1];...; AC []; AC []; AC001, AC.1 []; and more. Algorithms that perform arc-consistency have focused their improvements on time-complexity and spacecomplexity. Main improvements have been achieved by: changing the way of propagation: from arcs (AC [1] ) to values (AC [1] ), (i.e., changing the granularity: from coarse-grained to fine-grained); apping new structures; performing bidirectional searches (AC []); changing the support search: searching for all supports (AC) or searching for only the necessary supports (AC [], AC, AC [] and AC001.1 []); improving the propagation (i.e., it performs propagation only when necessary, AC and AC001); etc. However, little work has been done for developing algorithms to achieve in binary CSPs (binary: all constraints involves only two variables). The concept of consistency was generalized to k- consistency by [] and an optimal algorithm k-consistency for labeling problem was proposed by [] but it is based on normalized CSPs. If the constraints have two variables in k-consistency (k=) then we talking about to. Also, many works on arc-consistency made the simplifying assumptions that CSPs are binary and normalized (two different constraints do not involve exactly the same variables), because of those notations are much simpler and new concepts are easier to present. But in [1] shows a strange effect of associating arc-consistency with binary normalized CSPs. It is the confusion between the notions of arc-consistency and ( guarantees that any instantiation of a value to a variable can be consistently exted to any second variable). On binary CSPs, is at least as strong as arc-consistency. When the CSP is binary and normalized, arc-consistency and perform same pruning. For more detail see [1]. Besides, a non-normalized CSP can be transformed into a normalized one by using the intersection of valid tuples [], but it can be very costly in large domains. Figure 1. Example of Binary CSP. We will focus our attention on binary and nonnormalized CSPs. Figure 1 left shows a binary CSP (pre-

2 sented in [1]) with two variables X 1 and X, D 1 = D = {1,, } and two constraints R 1 : X 1 X, R 1 : X 1 X. It can be observed that this CSP is arc-consistent due to the fact that every value of every variable has a support for constraints R 1 and R 1. In this case, arc-consistency does not prune any value of the domain of variables X 1 and X. However, as it is shown in [1], this CSP is not -consistent because the instantiation X 1 = can not be exted to X and the instantiation X = 1 can not be exted to X 1. Thus, Figure 1 right presents the resultant CSP filtered by arc-consistency and. It can be observed that is at least as strong as arc-consistency. Definitions By following standard notations and definitions in the literature [,, ]; we have summarized the basic definitions that we will use in this rest of the paper. Constraint Satisfaction Problem (CSP) is a triple P = X, D, R where, X is the finite set of variables {X 1, X,..., X n }. D is a set of domains D = D 1, D,..., D n such that for each variable X i X there is a finite set of values that the variable can take. R is a finite set of constraints R = {R 1, R,..., R m } which restrict the values that the variables can simultaneously take. A constraint is binary if it involves only two variables. A CSP is binary iff all constraints are binary. We denote R ij (R ij, 1) (R ij, ) as the direct constraint defined over the variables X i and X j and R ji (R ij, ) as the same constraint in the inverse direction over the variables X i and X j (inverse constraint). A block of constraints C ij is a set of binary constraints that involve the same variables X i and X j. Thus, we denote (C ij, t) : t = {1, } as the block of direct constraints defined over the variables X i and X j and (C ji, ) as the same block of constraints in the inverse direction over the variables X i and X j (block of inverse constraints) A CSP is normalized iff two different constraints do not involve exactly the same variables. Instantiation is a pair X i, a, that represents an assignment of the value a to the variable X i, and a is in the domain of X i. We can use (X i = a) X i, a. A constraint R ij is satisfied if the instantiation of X i, a and X j, b is legal for this constraint ( X i, a, X j, b ) R ij. Constraint Checks is the number of times that it asking whether if the constraint R ij is satisfied. i.e. it is the number of times that a constraint R ij R is checked to reach arc-consistency. Symmetry of the constraint: If the value b D j supports a value a D i, then a supports b as well. A value a D i is arc-consistent relative to X j, iff there exists a value b D j such that (X i, a) and (X j, b) satisfies the constraint R ij ((X i = a, X j = b) R ij ). A variable X i is arc-consistent relative to X j iff all values in D i are arc-consistent. A CSP is arc-consistent iff all the variables are arc-consistent, e.g., all the constraints R ij and R ji are arc-consistent. : A value a D i is -consistent relative to X j, iff there exists a value b D j such that (X i, a) and (X j, b) satisfies all the constraints R k ij ( k : (X i = a, X j = b) R k ij ). A variablex i is -consistent relative to X j iff all values in D i are -consistent. A CSP is -consistent iff all the variables are -consistent, e.g., any instantiation of a value to a variable can be consistently exted to any second variable. -COP -COP is new coarse grained algorithm that achieves in binary and non-normalized CSPs (see Algorithm 1). This algorithm deals with block of constraints as -C [1] but only requires keeps half block of constraints in Q and call two procedures: Revise and AddQ. -COP performs bidirectional checks (as AC) and performs inference to avoid unnecessary checks. However, it is done by using structures that are shared by all the constraints: suppinv: it is a vector whose size is the maximum size of all domains (maxd) and it stores the value X i that supports the value of X j. minsupp: it is an integer variable that stores the first value b D j that supports any a D i. By using minsupport inference is carried out to avoiding unnecessary checks because all b D j < minsupport are pruned without any check once suppinv is evaluated. t: is an integer parameter an it takes values t = {1,, }. This value is used to guide to the Revise procedure to check or not a constraint C ij (direct or inverse order) and to impose bidirectionally or not in the search. Initially -COP procedure stores in queue Q the constraint blocks (C ij, t) : t = 1. Then, a simple loop is performed to select and revise the block of constraints stored in Q, until no change occurs (Q is empty), or the domain of a variable remains empty. The first case ensures that every value of every domain is -consistent and the second case returns that the problem is not consistent. The Revise procedure (see Algorithm ) requires two internal variables change i and change j. They are initialized to zero and are used to remember which domains were pruned. For instance, if D i was pruned then change i = 1 and if D j was pruned then change j =. However, if both D i and D j were pruned then change = (because change = change i + change j ). During the loop of steps

3 -, each value in D i is checked 1. If the value b D j supports the value a D i then suppinv[b] = a, due to the fact that it is based on symmetry of the constraint (the support is bidirectional). Furthermore the first value b D j (which supports a value in D i ) is stored in minsupp. The second part of Algorithm is carried out in function of values t and change i. If t = or t =, and change i = 0 then C ij is not needed to be checked due to the fact that the constraint, in the previous loop, has not generated any prune. However, if t = 1 then C ij requires full bidirectional evaluation. If t = or t =, and change i = 1 then C ij also requires full bidirectional evaluation. In both cases, the processing of suppinv can be done in three different ways: 1) the values b D j : b < minsupp are pruned without performs any checking. Furthermore, variable change j is updated to change j = to indicate that a change in the second loop occurs. ) the values of b with suppinv[b] > 0 will not be checked due to the fact that they are supported in D i. Thus, they are initialized to 0 for further use of this vector. ) the values of b with b > minsupp and suppinv[b] = 0 will be checked until a support a is founded or they will be removed in other case. In this last case change j = in order to indicate that a change in the second loop occurs. 1 Algorithm : Procedure AddQ Data: Integer variable change, tuple (C ij, t) and queue Q. Result: Queue Q updated if ((change = 1 t = ) (change = t = 1)) then c = j if ((change = t = ) (change = 1 t = 1)) then c = i if (change = ) then c = j and o = j for each C kl with C kl C ij do if change = then Q Q {(C kl, 1) (c = l o = k) (c = k o l) (c k o = l)} if ((t = c = k) (t = 1 c = l)) then Q Q {(C kl, ) [(C kl, 1) (C kl, )] / Q} if ((t = c = l) (t = 1 c = k)) then Q Q {(C kl, ) [(C kl, 1) (C kl, ) (C kl, )] / Q} Algorithm 1: Procedure -COP Data: A CSP, P = X, D, R Result: true and P (which is -consistent) or false and P (which is -inconsistent because some domain remains empty) 1 for every i, j do C ij = for every arc R ij R do C ij C ij R ij for every set C ij do Q Q {(C ij, t) : t = 1} for each d D max do suppinv[d] = 0 while Q do select and delete (C ij, t) from queue Q with t = {1,, } change = Revise((C ij, t)) if change > 0 then if change 1 change then Q Q AddQ(change, (C ij, t)) return false /*empty domain*/ 1 return true The AddQ procedure (see Algorithm ) would add tuples to be evaluated again. The added tuples will dep on the tuples stored in Q and the variable change. Deping on the value t, generated by AddQ, the Revise procedure will guide the search. If t = 1 the search is full bidirectional (directed and inverse); if t = the search is inverse and the search is also directed if and only if some pruning is carried Algorithm : Procedure Revise Data: A CSP P defined by two variables X = (X i, X j ), domains D i and D j, and tuple (C ij, t) and vector suppinv. Result: D i, such that X i is -consistent relative X j and D j, such that X j is -consistent relative X i and integer variable change change i = 0; change j = 0 minsupp =dummyvalue for each a D i do if b D j such that (X i = a, X j = b) (C ij, t) then remove a from D i change i = 1 suppinv[b] = 1 if minsupp =dummyvalue then minsupp = b if ([(t = t = ) change i = 1] t = 1) then for each b D j do if b < minsupp then remove b from D j change j = if suppinv[b] > 0 then suppinv[b] = 0 change = change i + change j return change if a D i such that (X i = a, X j = b) (C ij, t) then remove b from D j change j = 1 if t= the inverse operator is used

4 Table 1. Number of pruning and constraint COP in problems 0% non-normalized < n, 0, 00, >. Table. Number of pruning and constraint COP in problems 0% non-normalized < n, 0, 00, >. n prune time checks prune time checks time checks n prune time checks prune time checks time checks Table. Number of pruning and constraint COP in problems 0% non-normalized < 0, 0, m, >. m prune time checks prune time checks time checks out; finally if t = the search is directed and the search is also inverse if and only if some pruning is carried out. Experimental Results In this section, we compare the behavior of arcconsistency algorithm AC and algorithms - C and -COP. The experiments were performed on random instances. A random CSP instance is characterized by the -tuple < n, d, m, c >, where n was the number of variables, d the domain size, m the total number of binary constraints and c the number of constraints in each block. The constraints were in the form ±X i op ± k ± X j, where X i, X j X, op {<,, =,, >, } and k N. We randomly generated binary non-normalized problems. All the variables maintained the same domain size. The problems were randomly generated by modifying these parameters. We evaluated 0 test cases for each type of problem. Thus, we set three of the parameters and varied the other one in order to evaluate the algorithm performance when this parameter increased. Performance was measured in terms of number of values pruned, constraint checks and time compute. All algorithms were written in C. The experiments were conducted on a PC Pentium IV (.0 GHz processor and 1 GB RAM). Table 1 shows the number of constraint checks and propagations in consistent instances 0% non-normalized, where the number of variables was increased from 0 to 10; the domain size was set to 0; the number of constraints and the number of non-normalized constraints were set at 00 and respectively (< n, 0, 00, >). Results show that the number of prunes was lower in all cases using AC than using both -C or -COP (AC: % less pruning). This is due to the fact that all problems started with same domain size and they had constraints with operators (=,,, or ), so that AC could not prune any value by analyzing the constraints individually. However, -C and -COP analyzed the blocks of constraints which had a mix of these operators and they were able to prune more search space. Furthermore, -COP performed 0 % and 1% less constraints checks than both AC and -C respectively. Finally, -COP was 0% faster than -C. Table shows the number of constraint checks and propagations in consistent instances 0% non-normalized. The number of variables was set to 0. The domain size was set to 0. The number of constraints was increased from 0 to 00 and the number of non-normalized constraints was set to (< 0, 0, m, >). Again, results show how the number of constraints checks was % lower using -C-OP than using AC. Also, the number of constraints checks was an % lower using -COP than - C. Both -COP and -C performed the same pruning (0% more than AC). AC performs slightly faster than -COP, although -COP carries out more pruning. -C performs 0% slower than -COP, despite performing the same pruning. It can also be observed that the number of constraint checks increases with the number of constraints increases. This is because, as the number of constraints increased, also increases the tightness of the problems. Tables and show results for 0% non-normalized consistent instances, increasing the number of variables (n) and the constraints (m) respectively. Results show that - COP and -C performed % more pruning than AC. - COP was 0% faster than -C but while it was slower than AC. However, despite being slower, -COP performs % more pruning and % less constraints checks than AC. Finally, -COP performed 0% faster and car-

5 Table. Number of pruning and constraint COP in problems 0% non-normalized < 0, 0, m, >. m prune time checks prune time checks time checks Table. Number of pruning and constraint checks by using AC, AC and -C in inconsistent problems < n, 0, 100, >. n prune time checks prune time checks prune time checks ried out % less constraint checks than -C. Tables and show the number of pruned, time and number of constraint checks in inconsistent instances 0% non-normalized, increasing the number of variables (n) and the constraints (m) respectively. -COP was faster and performed less pruning and less constraint checks than both AC and -C, showing that -COP is more efficient when detecting inconsistencies. Conclusions and Further Works Filtering techniques are widely used to prune the search space of CSPs. Many researchers associate Arc Consistency with binary normalized CSPs, so that there is a confusion between the notion of arc consistency and. In Table. Number of pruning and constraint checks by using AC, AC and -C in inconsistent problems < 0, 0, m, >. m prune time checks prune time checks prune time checks this paper, we have presented -COP algorithm a reformulation of -C algorithm to achieve in binary and non-normalized CSPs. -COP uses bidirectionally and inference to avoid performs ineffective checks. The evaluation section shows that -COP achieves and it is able to prune more search space than AC. Furthermore -COP performs less constraints checks than both AC and -C and its time-compute is close to AC and better than -C by 0%. This filtering algorithm could be very appropriate in search tools to manage non-normalized problems. In further works, we will focus our attention to an improved version of -COP to avoid redundant checks by using the Last value support (like was done in AC-001 []). Acknowledgment This work is partially supported by the research projects TIN00--C0-01 (Min. de Educación y Ciencia, Spain-FEDER), P1/0 (Min. de Fomento, Spain- FEDER), ACOMP/00/1 Generalitat Valenciana, and by the Technical University of Valencia. References [1] M. Arangú, M. Salido, and F. Barber. -c: From arcconsistency to. In SARA 00, 00. [] M. Arangú, M. Salido, and F. Barber. Exting arcconsistency algorithms for non-normalized csps. Technical Report, AI. 00. [] R. Barták. Theory and practice of constraint propagation. In J. Figwer, editor, Proc. of the rd WCPDC, 001. [] C. Bessiere. Constraint propagation. Technical report, CNRS/University of Montpellier, 00. [] C. Bessiere and M. Cordier. and arcconsistency again. In Proc. of the AAAI, pages, Washington, USA, July 1. [] C. Bessiere, E. Freuder, and J. C. Régin. Using constraint metaknowledge to reduce arc consistency computation. AI, :1 1, 1. [] C. Bessiere, J. C. Régin, R. Yap, and Y. Zhang. An optimal coarse-grained arc-consistency algorithm. AI, 1:1 1, 00. [] A. Chmeiss and P. Jegou. Efficient path-consistency propagation. IJAIT, :11 1, 1. [] M. Cooper. An optimal k-consistency algorithm. AI, 1:, 1. [] R. Dechter. Constraint Processing. MK, 00. [] E. Freuder. Synthesizing constraint expressions. Commun ACM, 1:, 1. [1] A. K. Mackworth. Consistency in networks of relations. AI, :, 1. [1] R. Mohr and T. Herson. Arc and path consistency revised. AI, :, 1. [1] F. Rossi, P. Van Beek, and T. Walsh. Handbook of constraint programming. Elsevier, 00.