Constraint Manipulation using Rewrite Rules and
Strategies
Carlos Castro
INRIA Lorraine & CRIN
615, rue du Jardin Botanique, BP 101,
54602 Villers-les-Nancy Cedex, France
e-mail: Carlos.Castro@loria.fr
Abstract
1 Introduction
In the last twenty years many work has been
done on solving Constraint Satisfaction Problems
(CSP). Several languages and libraries are now
available to deal with CSP and they have been
successfully applied for solving real life problems.
These tools are mainly based on procedural or
Prolog-like languages. We are interested in constraint manipulation using rule-based algorithms
because of the explicit distinction made in this approach between deduction rules and control. We
associate actions with rewrite rules and control
with strategies that establish the order of application of the inferences. This framework allows
us to describe constraint handling in a very abstract way, prototype new heuristics almost only
modifying the choice of rules, prove termination
in a easier way and possibly partly automated,
and combine constraint solving with other computational systems. Prototype new heuristics and
prove termination are not obvious tasks in black
box like algorithms. Our rst goal is to improve
our understanding of the algorithms developed for
solving CSP once, they are expressed as rewrite
rules coordinated by strategies, and then to be
able to propose new ones. Extending the domain
of application of Rewriting Logic to CSP is another motivation for our work. This leads the way
to the design of a formalism that allows the application of the knowledge already developed in
the domain of Automated Deduction, to the constraint solving process. To verify our approach we
have implemented a prototype which is currently
executable in the system ELAN [11], an interpreter
of computational systems.
This paper is organised as follows: Section 2
We are interested in constraint manipulation using rule-based algorithms because of the explicit
distinction made in this approach between deduction rules and control. We associate actions with
rewrite rules and control with strategies that establish the order of application of the inferences.
This framework allows us to describe constraint
handling in a very abstract way, prototype new
heuristics almost by modifying only the choice of
rules, prove termination in an easier and possibly partially automated way, and combine constraint solving with other computational systems.
Our rst goal is to improve our understanding of
the algorithms developed for handling Constraint
Satisfaction Problems, once they are expressed as
rewrite rules coordinated by strategies, and then
to be able to propose new ones. Extending the
domain of application of Rewriting Logic to constraint solving is another motivation for our work.
In this paper, we formalise constraint solving as an
inference process and we present a new technique
for handling disjunctive constraints. We hope that
this work leads the way to the design of a formalism that allows the application of the knowledge
already developed in the domain of Automated
Deduction, to the constraint solving process. To
verify our approach we have implemented a prototype which is currently executable in the system
ELAN, an interpreter of computational systems.
Keywords:
Constraint Satisfaction Problems,
Rewriting Logic, Computational Systems.
1
contains some denitions and an overview about
CSP solving, in section 3 we briey present a
computational system for CSP solving, section 4
presents a new technique to deal with CSPs involving disjunctive constraints and section 5 concludes the paper, presents the work we are currently developing and further ideas.
variables, by e the number of binary constraints
and by a the number of elements in the domain
D (a = C ard(D)).
Typical tasks dened in connection with CSP
are to determine whether a solution exists, and to
nd one or all the solutions. In this section we
present three categories of techniques used in processing CSP: Searching Techniques, Problem Reduction, and Hybrid Techniques. Kumar's work
[12] is an excellent survey on this topic.
2 CSP
Formally, an elementary constraint c? is an atomic
formula built on a signature = (F ; P ), where
F is a set of ranked function symbols and P a
set of ranked predicate symbols, and a denumerable set X of variable symbols 1 . Elementary constraints are combined with usual rst-order connectives. We denote the set of constraints built
from and X by C (; X ). Given a structure
D = (D; I ), where I is an interpretation function and D the domain of this interpretation, a
h; X ; Di-CSP is any set C = (c?1 ^ : : : ^ c?n) such
that c?i 2 C (; X ) 8i = 1; : : :; n. A solution of c?
is a mapping from X to D that associates to each
variable x 2 X an element in D such that c? is
satisable in D. The solution set of c? is given by:
Searching Techniques in CSP Searching
consists of techniques for systematic exploration
of the space of all solutions. The simplest algorithm generate-and-test, also called trial-anderror search, is based on the idea of testing every possible combination of values to obtain a solution of a CSP. Intending to avoid the obvious
combinatorial explosion of generate-and-test the
basic algorithm commonly used for solving CSPs
is the simple backtracking search algorithm, also
called standard backtracking or depth-rst search
with chronological backtracking [4]. The time complexity of backtracking is O(an e), i.e., the time
taken to nd a solution tends to be exponential
in the number of variables [14]. In order to avoid
the exploration of subtrees of the backtrack search
SolD (c? ) = f 2 XD j(c?) = Tg:
tree that dier only in inessential features (thrashA solution of C is a mapping such that all con- ing,) such as the assignments to variables irrelestraints c?i 2 C are satisable in D. The solution vant to the failure of the subtrees, the notion of
set of C is given by:
problem reduction has been developed.
Problem Reduction in CSP Problem reduc-
SolD (C ) = f 2 XD j(c?i ) = T 8i = 1; : : :; ng:
tion techniques transform a CSP to an equivalent
problem by reducing the values that the variables
can take. Given the CSPs P and P 0 whose solution set are Sol(P ) and Sol(P 0 ), respectively, we
say that they are equivalent if Sol(P ) = Sol(P 0 ):
A CSP P is reduced to P 0 if P and P 0 are equivalent, the set Dx 0 associated to each membership constraint x 2? Dx 0 in P 0 is a subset of the
set Dx associated to each membership constraint
x 2? Dx in P , and the set of constraints C 0 in P 0
is more restrictive than, or as restrictive as, the
set of constraints C in P . Problem reduction is
often refered to as consistency maintenance [17].
Consistency concepts have been dened in order
to eliminate combinations of values which could
not appear together in any set of values satisfying
1 For clarity, constraints are syntactically distinguished the set of constraints and obtaining in this way
from formulae by a question mark exponent on their pred- a reduced problem. Mackworth [13] establishes
icate symbols.
three levels of consistency: node, arc and pathGiven a variable x 2 X and a non-empty set
Dx D, the membership constraint of x is a relation given by x 2? Dx : We use these membership constraints to make explicit the domain reduction process during the constraint solving. In
practice, the sets Dx have to be set up to D at
the beginning of the constraint solving process,
and constraint propagation will eventually reduce
them. We consider CSPs in which the carrier of
the structure is a nite set and the constraints are
only unary or binary. This class of CSP is known
as Binary Constraint Satisfaction Problems. To
represent Binary CSPs graphs are generally used,
that is why a CSP is also called a Constraint Network. In this work, we denote by n the number of
2
consistency. These names come from the fact that
general graphs have been used to represent Binary
CSP. A general notion of k-consistency was introduced in [9], where 1-consistency, 2-consistency
and 3-consistency correspond to node, arc and
path-consistency, respectively. The varying forms
of consistency algorithms can be seen as approximation algorithms, in that they impose necessary
but not always sucient conditions for the existence of a solution on a CSP. We now give the
standard denitions of node and arc-consistency
for a binary network of constraints 2 .
[8] use complex data structures to keep the optimal worst-case time complexity of AC-4 while
working out the drawback of space complexity of
AC-4. As our aim in this work is only to introduce a new framework to model CSP, we use AC-3
because we need a very simple data structure to
implement it.
Hybrid Techniques As backtracking suers
from thrashing and consistency algorithms can
only eliminate local inconsistencies, hybrid techniques have been developed. In this way we obtain a complete algorithm that can solve all problems and where thrashing can be reduced. Hybrid techniques integrate constraint propagation
algorithms into backtracking in the following way:
whenever a variable is instantiated, a new CSP
is created; then a constraint propagation algorithm is applied to remove local inconsistencies
of these new CSPs [23]. Embedding consistency
techniques inside backtracking algorithms is called
Hybrid Techniques. A lot of algorithms that essentially t the previous format have been proposed. Forward Checking, Partial Lookahead, Full
Lookahead, and Really Full Lookahead, for example, primarily dier in the degrees of arc consistency performed at the nodes of the search tree.
Denition 1 (Node consistency) Given a
variable x 2 X and a unary constraint c? (x) 2 C ,
the node associated to x is consistent if
8 2 XD : 2 SolD (x 2? Dx ) ) 2 SolD (c? (x)):
A network of constraints is node-consistent if all
its nodes are consistent.
Verication of node consistency is obvious, the
algorithm NC-1 proposed by Mackworth [13] carries out this task and its time complexity is O(an)
[14].
Denition 2 (Arc consistency) Given the
variables xi ; xj 2 X and the constraints
c?i (xi ); c?j (xj ); c?k (xi; xj ) 2 C , the arc associ-
3 A Computational System
for Solving CSP
ated to c?k (xi ; xj ) is consistent if
8 2 XD 90 2 XD : 2 SolD (xi 2? Dx ^ c?i (xi ))
i
) 0 2 SolD (xj 2? Dx
j
The idea of solving constraint systems using com-
systems was rstly proposed by Kirch^ c?j (xj ) ^ c?k ((xi); xj )): putational
ner, Kirchner and Vittek in [10] where they de-
A network of constraints is arc-consistent if all ne the concept of computational systems and
describe how a constraint solver for symbolic conits arcs are consistent.
straints can be viewed as a computational system aimed at computing solved forms for a class
of considered formulas called constraints. They
point out some advantages of describing constraint solving processes as computational systems over constraint solving systems where solvers
are encapsulated in black boxes, such as reaching
solved forms more eciently with smart choices
of rules, easier termination proofs and possibly
partly automated, description of constraint handling in a very abstract way, and easy combination of constraint solving with other computa2 In this work, we do not use the concept of path- tional systems. Following [10], a computational
consistency because it has been proved that algorithms for system is given by a signature providing the synachieving path-consistency do not pay-o their cost.
tax, a set of conditional rewrite rules describing
Several algorithms have been proposed for
achieving arc consistency. In [13], Mackworth
proposes AC-3 whose time complexity is O(a3 e)
[14]. In [16] Mohr and Henderson propose the algorithm AC-4 whose worst-case time complexity
is O(ea2 ) and they prove its optimality in terms
of time. But, in problems with many solutions,
where constraints are large and arc-consistency
removes few values, AC-3 runs often faster than
AC-4 despite its non-optimal time complexity [21].
Algorithms like AC-6 [1], AC-6++ [2] and AC-7
3
the deduction mechanism, and a strategy to guide
application of rewrite rules. Formally, this is the
combination of a rewrite theory in rewriting logic
[15], together with a notion of strategy to eciently compute with given rewrite rules. Computation is exactly application of rewrite rules on
a term and strategies describe the intented set of
computations, or equivalently in rewriting logic, a
subset of proofs terms.
of consistency we are imposing on the constraint
set. So, a CSP P in unary solved form is a system in basic form whose set of constraints is node
consistent, and a CSP P in binary solved form is
a system in basic form whose set of constraints is
arc consistent.
Denition 4 (Solved form) A solved form for
a CSP P is a conjunction of formulae in basic
form equivalent to P and such that all basic assignments satisfy all constraints. A basic assignment of a CSP P in solved form is called solution.
3.1 Solved Forms
Term rewriting repeatedly transforms a term into
an equivalent one, using a set of rewrite rules, until
a normal form is eventually obtained. The solved 3.2 Rewrite Rules
form we use is dened with the notion of basic In [5] we propose ConstraintSolving a set of
rewrite rules for solving CSP, which is presented
form.
in gure 1.
Denition 3 (Basic form) A basic form for a We use a constant F to denote a unsatisCSP P is any conjunction of formulae of the form able CSP. The rule Node-Consistency, where
RD(x 2? Dx ; c?(x)) stands for the set Dx0 =
^
^
^ ?
fv 2 Dx j c?(v)g, veries node consistency
(xi 2 Dxi ) ^ (xj =? vj ) ^ (c?k )
and it is based on NC-1 algorithm. The rule
j 2J
i2I
k2K
Arc-Consistency, where RD(x1 2? Dx1 ; x2 2?
Dx2 ; c?(x1 ; x2)) stands for the set Dx0 1 = fv 2
equivalent to P such that
Dx1 j (9w 2 Dx2 ) c? (v; w)g, veries arc consistency and it is based on AC-3 algorithm. Rule
8i1 ; i2 2 I; i1 6= i2 ) xi 1 6= xi 2
Instantiation corresponds to a variable assign 8i 2 I; Dxi 6= ;
ment. Elimination expresses the fact that once
a variable has been instantiated, we can propagate
8j1; j2 2 J; j1 6= j2 ) xj 1 6= xj 2
its value through all constraints where the variable
is involved in. C fx 7! vg denotes the conjunction
8i 2 I 8j 2 J xi 6= xj
of constraints obtained from C by replacing all
8k 2 K 9i 2 I 9j 2 J; xk = xi _ xk = xj occurrences of the variable x by the value v. The
rule Falsity expresses the obvious fact of unsatisThe constraints in the rst, second, and third ability.
The rule Generate expresses the simple
conjunction are called membership, equality, and fact of branching
to carry out exhaustive search.
functional constraints, respectively. For each variable we have associated a membership constraint Lemma 1 The set of rules ConstraintSolving
or an equality constraint, the set associated to is correct and complete.
each variable in the membership constraints must
not be empty, and for each variable appearing Proof: See [5].
in the functional constraints there must be associated a membership constraint or an equality Theorem 1 Starting with a CSP P and applying
constraint. Variables which are only involved in repeatedly the rules in ConstraintSolving until
equality constraints are called solved variables and no rule applies anymore results in F i P has no
the others non-solved variables.
solution or else it results in a solved form of P .
A CSP P in basic form can be associated with a
basic assignment obtained by assigning each vari- Proof: See [5].
able in the equality constraints to the associated
value v and each variable x in the membership ConstraintSolving was designed to deal with
constraints to any value in the set Dx . In this way elementary constraints. In order to combine them
we can dene several forms depending on the level with rst-order connectives we add a new rule
4
[Node ? Consistency] x 2? Dx ^ c? (x) ^ C
) x 2? RD(x 2? Dx ; c?(x)) ^ C
[Arc ? Consistency] x1 2? Dx1 ^ x2 2? Dx2 ^ c?(x1 ; x2) ^ C
) x1 2? RD(x1 2? Dx1 ; x2 2? Dx2 ; c?(x1; x2)) ^
x2 2? Dx2 ^ c? (x1; x2) ^ C
if RD(x1 2? Dx1 ; x2 2? Dx2 ; c?(x1; x2)) 6= Dx1
[Instantiation]
x 2? Dx ^ C
) x =? (x) ^ C
if fg = SolD (x 2? Dx )
[Elimination]
x =? v ^ C
) x =? v ^ C fx 7! vg
if x 2 V ar(C )
[Falsity]
x 2? ; ^ C
[Generate]
) F
x 2? Dx ^ C
) x =? (x) ^ C or x 2? Dx n(x) ^ C
if 2 SolD (x 2? Dx )
Figure 1: ConstraintSolving: Rewrite rules for solving Binary CSP
[CreateChoicePoint] (c?1 _ c?2) ^ C
) c?1 ^ C or c?2 ^ C
Figure 2: CreateChoicePoint: Rewrite rule for creating a choice point
CreateChoicePoint that creates a choice point, 3.3 Strategies
i.e., posts the disjuncts of a disjunctive constraint. As we have mention there are several heuristics
This rule is presented in gure 2.
to search for a solution in CSP, starting from the
brute force generate and test algorithm until elaborated versions of backtracking. The expressive
power of computational systems allows to express
these dierent heuristics through the notion of
As all rst-order connectives can de expressed strategy. In this way, for example, a unary solved
using conjunctions and disjunctions we can now form can be obtained by applying
deal with all of them, we just have to put the
j
set of constraints in a conjunctive normal form. [Node-Consistency j CreateChoicePoint
Falsity
]
The right hand side of rule CreateChoicePoint
is equivalent to (c?1 or c?2) ^ C . This expression A binary solved form can be obtained by applyis equivalent to (c?1 _ c?2 ) ^ C , the left hand side of ing
the rule, so rule CreateChoicePoint is correct
j CreateChoicePoint j
and complete. As CreateChoicePoint creates [Arc-Consistency
Falsity
]
a new subproblem for each disjunct involved in a
disjunctive constraint, the solution for the origi- And a solved form for a set of elementary connal problem is in the union of the solution to each straints can be obtained using the strategy
subproblem, and as nally each subproblem is a
[[Generate; Elimination] j Falsity]
conjunction of elementary constraints theorem 1
is still valid when we consider together the set of which implements exhaustive search 3.
rules ConstraintSolving and the rule Create- 3 The symbol means applying a given rule zero or N
times over the constraint system.
ChoicePoint.
5
We can integrate constraint propagation and
search in order to get a solved form more eciently than the force brute approach. Let us dene the following strategies:
NodeC :: [Node-Consistency;
[Instantiation; EliminationjFalsity]]
ArcC :: [Arc-Consistency;
[Instantiation; EliminationjFalsity]]
Considering only elementary constraints, the
strategy
[NodeC j ArcC] ;
[Generate; EliminationjFalsity]
implements a preprocessing which veries node
and arc consistency and then carries out an exhaustive search in the reduced problem. Considering disjunctive constraints, the strategy
[NodeC j ArcC] ; [CreateChoicePoint;
[NodeC j ArcC] ; Generate; Elimination;
NodeC]
implements an heuristic which, once node and
arc consistency have been veried, carries out a
loop which rstly creates a choice point, then veries node and arc consistency, then carries out an
enumeration step, and nally veries node consistency. This last one is a particular version of Forward Checking an heuristic widely used in CSP.
all constraints in store are k-consistent and all
the variables in the membership constraints have
associated a non-empty set.
ELAN is a system for prototyping nondeterministic computations thanks to rules and
strategies. Strategies is one of the main originalities of ELAN compared to other algebraic specication languages based on rewriting. A strategy is a way to describe which computations the
user is interested in, and species where a given
rule should be applied in the term to be reduced. We describe informally here how ELAN
deals with rewrite rules and strategies and we
present an overview of our prototype. A full description of the language can be found in [3]. All
details about the prototype can be obtained at
http://www.loria.fr/~castro/CSP/csp.html.
3.4.1 Rewrite Rules
Rules are labelled conditional rewrite rules with
local variable assignments
[`] : l ) r if v where y := [S ]u
` is the rule label, l and r the respective left and
right-hand sides, v the condition and y := [S ]u a
local assignment, assigning to the local variable y
the result of the strategy S applied to the term u.
For applying such a rule on a term t, say at top
position, rst l is matched against t. Then the expressions in where and if parts, instantiated with
the matching substitution, are evaluated in order.
When there is no failure, this usually instantiates
the local variables (such as y) in where expressions, and this extends the matching substitution.
When every condition is satised, the replacement
by the instantiated left-hand side is performed.
As an example, gure 3 presents the implementation of Node-Consistency using ELAN.
This rule establishes that if the rst constraint,
c, in the list of constraints has arity equals to
1, the operator Verify NC will be applied, this
result will be assigned to Q and nally the left
hand side will be rewritten to Q. The rule Node
Consistency corresponds to the high level of the
verication of local consistency following the idea
of algorithm NC-1. The actual verication of values is carried out by the operator Verify NC which
is presented in a general way in gure 4.
The operator Verify NC manipulates the data
structure using two kinds of basic operators.
3.4 Implementation
We have implemented a prototype which is currently executable in the system ELAN [11], an interpreter of computational systems4 . We use a 4tuple CSP[lmc,lec,C,store] to represent a CSP,
where lmc is a list with the membership constraints, lec is a list with the equality constraints,
C is a list with the set of constraints to solve
and store is a list with the constraints already
veried. Our implementation for achieving local
consistency is mainly based on algorithm AC-3,
the constraints in C are veried and stored in the
store, once a variable's domain is modied we extract all constraints in the store where the variable is involved in and add them to C. So, a kconsistent CSP is obtained once the list C is empty,
4 ELAN is available via anonymous ftp at ftp.loria.fr
in the directory /pub/loria/protheo/softwares/Elan.
Further information can be obtained at
http://www.loria.fr/equipe/protheo.html
6
csp
c : formula ; lmc , l e c ,C , st ore : l i s t [ formula ] ; Q: csp ;
rules for
global
[ NodeConsistency ]
end
CSP [ lmc , l e c , c . C, s tor e ]
=>
Q
i f ArityOfC onstr aint ( c ) == 1
where
Q := ( ) Verify ? NC (CSP [ lmc , l e c , c . C, s to re ] )
Figure 3: Rule Node-Consistency: Verication of Node-Consistency
tional matching and second to the where assignment, since it may itself return several possible
assignments for variables, due to the use of strategies. When a rewrite rule or a strategy returns an
empty set of terms, we say that it fails. Thus
the language provides a way to handle this nondeterminism. This is done using three basic strategy operators: dc, standing for dont care choose,
dk, standing for dont know choose, and rst. For
a rewrite rule [`] : l ) r the strategy dc(`) returns at most one result which is undeterministically taken among the possible results of the application of the rule. rst is a 'sequential version' of dont care choose, which takes always the
rst, in textual order, successful branch. On the
contrary, if the ` rule is applied using the dk(`)
strategy, then all possible results are computed
and returned by the strategy. The implementation handles these several results by an appropriate back-chaining operation. This is extended to
the application of several rules: the dk strategy
results in the application of all sub-strategies and
yields the concatenation of all results; the application of the dc strategy returns the set of results
of one (the rst) non-failing rule application. If all
sub-strategies fail, then it fails too, i.e. it yields
the empty set. The strategy constants id and fail
respectively represent identity and failure.
The current implementation of our system
includes strategies that implement exhaustive
search, local consistency and hybrid techniques.
As a basic example, gure 6 presents the implementation of local consistency for a set of elementary constraints.
More interesting heuristics as Forward Check3.4.2 Strategies
ing, and Full Lookahead can be easily impleApplication of a rewrite rule in ELAN yields, in mented using the powerful of strategies in ELAN.
general, several results. This is rst due to equa- Figure 7 presents a simple version of Forward
The basic operator GetVarOfFormule(c), returns the list of variables involved in the constraint c, GetVarInHead(x,l,nil) returns a list
of constraints where the rst element corresponds
to the membership constraint associated to
x, and GetConstraintOnVar(x,store,nil,nil)
returns two lists, the rst one with the constraints
in store where x is involved in and the second
one with the rest of the store. All these operators are domain independent. The operators
EvaluateGroundFormule(c) evaluate the truth
value of a ground formula according to the interpretation I, and ReviseDxWRTc return the set
of values in Dx that satisfy c, i.e., this operator implements RD of rule Node-Consistency
in gure 1.
Figure 5 describes the specication of the operator ReviseDxWRTc in the particular case of an
integer signature. ReviseDxWRTc makes use of a
canonical form for the constraints because of efciency reasons. This canonical form is obtained
applying a preprocessing step on the input term.
Once we realise that there are rules that depend on the general process of constraint solving
and rules that depend on the specic structure
over which we want to solve Binary CSPs, it is
natural to think about a general solver for solving
CSP. Using this idea we have designed a general
framework for constraint solving and implemented
a computational system for solving Binary CSP
over two discrete domains, the integer numbers
and the nite domains. In this way, solving Binary CSP(X ) needs only to specify a module for
the particular signature associated to X .
7
csp
x , y : var ; lv : l i s t [ var ] ; v : Type ; n : int ; F : bool ;
D,RD: domain ; c : formula ; lmc , l e c ,C , st or e , l1 : l i s t [ formula ] ;
t w o l i s t s : tuple [ l i s t [ formula ] , l i s t [ formula ] ] ;
rules for
global
[]
Verify ? NC (CSP [ lmc , l e c , c . C, s to re ] )
=>
where
( l i s t [ var ] ) y . lv := ( ) GetVarOfAtomicFormula ( c )
switch
case
occurs y in l e c then
where
( l i s t [ formula ] ) x = v . l1 := ( ) GetVarInHead ( y , l e c
switch
case
EvaluateGroundFormula ( r ep la ce ( x , v , c ) )
then
, nil )
CSP [ lmc , x=v . l1 , C, s to re ]
otherwise
CSP [ x in ? empty . lmc , l1 ,C , s tor e ]
end
otherwise
where
where
switch
case
( l i s t [ formula ] ) x in ? D. l1 := ( ) GetVarInHead ( y , lmc , n il )
RD := ( ) ReviseDxWRTc ( x in ? D, c )
RD != D then
CSP [ x in ? RD. l1 , l e c , append ( 1?th ( t w o l i s t s ) ,C) , 2?th ( t w o l i s t s ) ]
where ( tuple [ l i s t [ formula ] , l i s t [ formula ] ] )
t w o l i s t s := ( ) GetConstraintsOnVar ( x , st or e , ni l , n i l )
otherwise
end
end
end
CSP [ x in ? D. l1 , l e c , C, s to re ]
Figure 4: Operator Verify NC: Verication of Node-Consistency
Checking and a version of Full Lookahead including the First Fail Principle to select the next variable to instantiate5.
It is important to note that rewrite rules and
strategies allow an easy formalisation of this kind
of strategies, but it is dicult to implement
heuristics like Backjumping. The basic strategy operator dk, dont know choose, is powerful
enough to implement choice point like heuristics,
but it does not allow to jump in the search tree.
Concerning the same operator, global variables
are not available, so implementation of branch
and bound techniques, widely used for optimisation problems, are not evident.
constraint. A lot of combinatorial problems involve this kind of constraints. For example, in
scheduling problems these constraints come from
the fact that several tasks must use the same resource and the limited capacity of that resource
does not allow to perform all tasks at a same time
[20]. Let T askij the start time of task i of job
j and dij the duration of task i of job j . On a
machine performing a simple task at a time, the
capacity constraints enforce the mutual exclusion
for each pair of tasks assigned to the same machine. If we consider task k of jobs i and j , the
fact that on machine k job i runs before job j or
vice versa can be expressed by the following disjunctive constraint
4 Handling Disjunctive Constraints
T askkj ? T askki + dki _ T askki ? T askkj + dkj
In order to perform all tasks using the same
The combination of two elementary constraints resource
a sequential order must be established,
with a disjunction operator is called a disjunctive these precedence
relations that are not known
5 The First Fail Principle is also known as Minimum a priori are determinated by the solution to a
Domain.
scheduling problem. This feature changes the
8
domain
x : var ; D: domain ; k1 , k2 , lowbound : int ;
rules for
global
[]
ReviseDxWRTc ( x in ? D, k1 ( ) x (+) k2 >=? 0 )
=>
where
lowbound :=( ) ?k2 /k1
switch
case
lowbound <= MaxOfDomain(D)
UpdateMinOfDomain (D, lowbound )
then
otherwise
empty
end
end
Figure 5: Operator ReviseDxWRTc: Revise Domain for integers
csp
implicit
[ ] L oc alC ons is te nc yF orE l eme nta ryC ons tr ai nts =>
repeat + ( f i r s t ( NodeConsistency j j ArcConsistency ) ;
f irst ( fi rs t ( Ins ta ntia tio n ) ;
f i r s t ( Elimination j j id )
s t r a t e g i e s for
jj
f i r s t ( F a l s i ty )
jj
end
)
id
)
Figure 6: Strategy for implementing Local Consistency
nature of the problem, and no ecient polynomial algorithm can be exhibited for solving all
problems involving disjunctive constraints. Some
techniques to deal with this kind of problems are
Choice Point [18], introduction of (0/1) Binary
Variables [22], and Constructive Disjunction [19].
Figure 8 presents ConstructiveDisjunction a
set of rules to deal with CSPs involving
T disjunctive
constraints, where D0 x = Dx n fv 2 Dx j (8i =
1; ::; k; j = 1; ::; ni) c?ij jx=v = Fg.
Rule Post-Constraint establishes that if a disjunctive constraint is composed of only one disjunct then this disjunct is posted as an elementary
constraint and the original disjunctive constraint
is eliminated. Rule Eliminate-Disjunct express
the fact that when a disjunct is inconsistent with
respect to the membership constraints associated
to the variables in the disjunct, this disjunct is
eliminated from the disjunctive constraint. If a
disjunct is a ground formula and its truth value
is true then the whole disjunctive constraint is
eliminated, that is the idea of rule EliminateDisjunction. Rule Split-Disjunctions splits
the set of disjunctive constraints in two subsets
whose set of variables are disjoints. The idea
behind this rule is to obtain a set of connected
graphs when it is applied repeatedly on the set
of disjunctive constraints. Finally, rule DomainReduction veries local consistency using a constructive disjunction approach, impossible combinations of values that are common to all alternatives of a set of disjunctive constraints are eliminated.
The rules in ConstructiveDisjunction can
be used to carry out a preprocessing step in order to eliminate some values, before any a priori choice between the disjuncts of the disjunctive
constraints, as is expressed by the following strategies. Let
CD :: [Split-Disjunctions;
Domain-Reduction; [Post-Constraint j
Eliminate-Disjunct j
Eliminate-Disjunction]]
So, the strategy
9
s t r a t e g i e s for
implicit
csp
[ ] Forward ? Checking =>
L oca lC o ns is te ncy Fo rE l emen ta ryC ons tr ai nts ;
repeat (
f i r s t ( GetDisjunctiveNormalForm ) ;
f i r s t ( dk ( P os t F i r s t C o n s tr a i nt j j PostSecondConstraint ) j j f i r s t ( PostConstraint ) ) ;
L oca lC o ns is te ncy Fo rE le men tar yC o ns tr ain ts ;
dk (
f i r s t ( Enumerate1 ) ;
f i r s t ( Elimination j j id ) ;
f i r s t ( Node ? Consistency ? for ? Elementary ? Constraints j j id )
jj
first
)
)
( Enumerate2 )
end
[ ] Full ? Lookahead ? With ? Minimum ? Domain =>
L oca lC o ns is te ncy Fo rE l emen ta ryC ons tr ai nts ;
repeat (
f i r s t ( GetDisjunctiveNormalForm ) ;
f i r s t ( dk ( P os t F i r s t C o n s tr a i nt j j PostSecondConstraint ) j j
L oca lC o ns is te ncy Fo rE le men tar yC o ns tr ain ts ;
f i r s t ( GetVarWithMinimumDomain ) ;
dk (
f i r s t ( Enumerate1 ) ;
f i r s t ( Elimination j j id ) ;
Lo cal C o nsi s ten cyF o rE le ment ar yC o nst ra in ts
jj
first
)
)
first
( PostConstraint ) ) ;
( Enumerate2 )
end
Figure 7: Strategies for implementing Hybrid Techniques
variables- are communicated through membership
[LocalConsistencyForElementaryConstraints;constraints. The algorithm stops when there are
CD]
no more changes in these constraints.
veries local consistency for a set of elementary Theorem 2 If we can decompose a set of disjuncand disjunctive constraints using a constructive tive constraints in M subgraphs, the worst case
disjunction and a graph decomposition approach. time complexity of our algorithm is bounded by
In [6] we propose an approach for systematic M 2ND?M +1 , where ND is the total number of
manipulation of disjunctive constraints. We rstly disjunctive constraints.
decompose a set of constraints in two subproblems, the rst one with all the elementary con- Proof: See [6].
straints and the second one with all the disjunctive
constraints. A graph decomposition algorithm is This theorem means that if we can decompose
applied to the set of disjunctive constraints in the set of disjunctive constraints in several suborder to obtain the maximum number of sub- problems we can do better than the existing apsets whose sets of variables are disjoints. Then proaches, like choice point. This approach can
arc consistency is veried for the set of elemen- be used for solving scheduling problems where
tary constraints and we use constructive disjunc- disjunctive constraints are the main complexity.
tion to deal with the subsets of disjunctive con- In [7] we show how we can reduce the search
straints in order to prune the search space. The space and eliminate some disjunctions when our
results -elimination of impossible values for the approach is used as a preprocessing step.
10
[Post ? Constraint]
V
W
C ^ i=1;::;m Vj =1;::;ni c?ij W
) C ^ c?k1 ^ i=1;::;m;i6=k j =1;::;ni c?ij
Vif nk =(x12? D ) ^ C ^ V
W
?
[Eliminate ? Disjunct]
x
xV
2X
i=1;::;m j =1;::;ni cij
?
) Vx2X (x 2 DWx ) ^ C ^ W
?
?
i=1;::;m
;i=6 k j =1;::;ni cij ^ j =1;::;nk;j 6=l ckj
V
?
?
if SolDV( x2X (xW2 Dx ) ^ ckl ) = ;
[Eliminate ? Disjunction] C ^ i=1
c?
;::;m j =1;::;n
i ij
V
W
) C ^ i=1;::;m;i=6 k j =1;::;ni c?ij
if 9 l 2V[1; ::; nkW] : c?kl = T
?
[Split ? Disjunctions]
C ^ i=1
;::;m jW
=1;::;ni cij
V
c? ^
) VC ^ i=1;::;k
i ij
W j=1;::;n
?
i=k+1;::;m j =1;::;ni cij
if SSi=1;::;k;j=1;::;ni V ar(c?ij ) \
V ar(cW?ij ) = ;
i=k+1;::;m;j =1;::;n
i
V
?
[Domain ? Reduction]
x 2V Dx ^ C W^ i=1;::;k j =1;::;ni c?ij ^
c?
i=k+1;::;m j =1;::;nV
i ij
?
0
) Vx 2 D x ^WC ^ i=1;::;k Wj =1;::;ni c?ij ^
?
i=k+1
;::;m j =1;::;ni cij
S
if x 2 i=1;::;k;j=1;::;ni V ar(c?ij )
and Dx 6= D0 x
Figure 8: ConstructiveDisjunction: Rewrite rules for constructive disjunction in Binary CSP
5 Conclusion
tected problems concerning the implementation of
heuristics that require to jump in the search tree,
and we are also working on the implementation of
branch and bound techniques.
As our aim in this work was only to apply the
expressive power of computational systems to better understand constraint solving we did not care
about eciency, so as future work we are interested in eciency considerations related to our
implementation. We are also interested in the development of the prototype in order to validate it
solving real life problems. From a more theoretical point of view we are interested in detection
and elimination of redundancy in CSP using syntactical methods.
We have implemented a prototype of a computational system for solving Binary CSPs. We
have veried how computational systems are an
easy and natural way to describe and manipulate
Binary CSPs. Using this approach we have investigated the description of specic techniques
for constraint manipulation. We have proposed
an approach for systematic manipulation of disjunctive constraints, useful to solve, for example,
scheduling problems where disjunctive constraints
are the main complexity.
The main contribution of this work can be seen
from two points of view. First, we have formalised
algorithms to solve Binary CSPs in a way that
makes explicit dierence between actions and control, allowing us to better understand the algo- References
rithms that we have used for constraint solving. [1] Christian Bessiere. Arc-consistency and arcconsistency again. Articial Intelligence, 65:179{190,
This framework makes easier to prototype new
1994.
heuristics and prove termination, tasks that until now were not obvious in black box like algo- [2] Christian Bessiere and Jean-Charles Regin. An arcconsistency algorithm optimal in the number of conrithms. Second, we have extended the domain of
straint checks. In Proceedings of the Workshop on
application of Rewriting Logic.
Constraint Processing, ECAI'94, Amsterdam, The
We are currently working to solve the deNetherlands, pages 9{16, 1994.
11
[3] Peter Borovansky, Claude Kirchner, and Helene
Kirchner. Strategies and Rewriting in ELAN. In
Bernard Gramlich and Helene Kirchner, editors, Proceedings CADE-14 Workshop on Strategies in Automated Deduction, pages 13{24, Townsville, Australia,
July 1997.
[4] Maurice Bruynooghe and Raf Venken. Backtracking.
In Stuart C. Shapiro, editor, Encyclopedia of Articial Intelligence, volume 1. Addison-Wesley Publishing Company, 1992. Second Edition.
[5] Carlos Castro. Solving Binary CSP Using Computational Systems. In Jose Meseguer, editor, Proceedings of the First International Workshop on
Rewriting Logic and its Applications, RWLW'96, volume 5, pages 245{264, Asilomar, Pacic Grove, CA,
USA, September 1996. Electronic Notes in Theoretical Computer Science.
[6] Carlos Castro. An Approach for Achieving Local Consistency in Binary CSP Involving Disjunctive Constraints. In XXIII Conferencia Latinoamericana de
Informatica, CLEI'97, Valparaso, Chile, November
1997. To appear.
[7] Carlos Castro. An Approach for Systematic Manipulation of Disjunctive Constraints in CSP: An Application to Scheduling Problems. To be submitted, 1997.
[8] E. C. Freuder. Using Metalevel Constraint Knowledge to Reduce Constraint Checking. In Proceedings
of the Workshop on Constraint Processing, ECAI'94,
Amsterdam, The Netherlands, pages 27{33, 1994.
[9] Eugene C. Freuder. Synthesizing Constraint Expressions. Communications of the ACM, 21(11):958{966,
November 1978.
[10] Claude Kirchner, Helene Kirchner, and Marian Vittek. Designing Constraint Logic Programming Languages using Computational Systems. In Pascal Van
Hentenryck and Vijay Saraswat, editors, Principles
and Practice of Constraint Programming. The Newport Papers, pages 131{158. The MIT press, 1995.
[11] Claude Kirchner, Helene Kirchner, and Marian Vittek. ELAN, User Manual. INRIA Lorraine &
CRIN, Campus scientique, 615, rue du Jardin
Botanique, BP-101, 54602 Villers-les-Nancy Cedex,
France, November 1995.
[12] Vipin Kumar. Algorithms for Constraint-Satisfaction
Problems: A Survey. Articial Intelligence Magazine,
13(1):32{44, Spring 1992.
[13] Alan K. Mackworth. Consistency in Networks of Relations. Articial Intelligence, 8:99{118, 1977.
[14] Alan K. Mackworth and Eugene C. Freuder. The
Complexity of Some Polynomial Network Consistency
Algorithms for Constraint Satisfaction Problems. Articial Intelligence, 25:65{74, 1985.
[15] Jose Meseguer. Conditional rewriting logic as a unied model of concurrency. Theoretical Computer Science, 96(1):73{155, 1992.
[16] Roger Mohr and Thomas C. Henderson. Arc and Path
Consistency Revisited. Articial Intelligence, 28:225{
233, 1986.
[17] Edward Tsang. Foundations of Constraint Satisfaction. Academic Press, 1993.
[18] Pascal van Hentenryck. Constraint Satisfaction in
Logic Programming. The MIT press, 1989.
[19] Pascal van Hentenryck, Vijay Saraswat, and Yves
Deville. Design, Implementation, and Evaluation of
the Constraint Language cc(FD). In Constraint Programming: Basic and Trends. Selected Papers of the
22nd Spring School in Theoretical Computer Sciences. Springer-Verlag, Ch^atillon-sur-Seine, France,
May 1994.
[20] Mark G. Wallace. Applying Constraints For Scheduling. In Mayoh B and Penjaam J, editors, Constraint Programming, NATO ASI Series. SpringerVerlag, 1994.
[21] Richard J. Wallace. Why AC-3 is almost always better
than AC-4 for establishing arc concsistency in CSPs.
In Proceedings 13th International Joint Conference
on Articial Intelligence, Chambery (France), pages
239{245, 1993.
[22] H.P. Williams. Model Building in Mathematical Programming. J. Wiley and Sons, New York, 1978.
[23] Martin Zahn and Walter Hower. Backtracking along
with constraint processing and their time complexities. Journal of Experimental and Theoretical Articial Intelligence, 8:63{74, 1996.
12