Constraint (Logic) Programming

1
Constraint (Logic) Programming

• An overview
• Boolean Constraint Propagation
• Finite Domains and Constraint Networks
• Consistency Criteria
• Maintaning Node Consistency
• Maintaining Arc Consistency
• Dech04 Rina Dechter, Constraint Processing,

2
Boolean Satisfiability

• In most Boolean problems, the use of a complete
  solver is quite innefficient, since it maintains
  the set of all solutions in a solved form.
• Alternatively, a Boolean satisfiability problem
  may be solved, usually much more efficiently, by
  searching for a solution.
• In this case, two alternatives are available,
  with respect to the role of constraints
• Constraints are used passively. Once the variable
  appearing in the constraint are instantiated, the
  constraint is checked. If it is not satisfied,
  the search backtracks.
• Constraints are used actively, to reduce the
  domain of the variables still to instantiate.
• These alternatives are illustrated by modelling
  all constraints as clauses.

3
Boolean Clauses

• Syntatically,
• A literal ? variable or its negation
• Variables are denoted by upper case identifiers,
  and negation with ?.
• A clause ? set of literals.
• Clauses are represented with the disjunction
  operator, e.g. A ? ?B ? C
• A Boolean Satisfiabilty Problem ? set of
  clauses.
• Semantically,
• Boolean variables may take values True / False
  (or T / F or 1 / 0).
• A negation ? reverses, of course, this value.
• A clause is interpreted as a disjunction of
  literals. Hence, a clause is satisfied if at
  least one of its literals takes value True.
• Solving a problem corresponds to find values to
  the variables such that all clauses are
  satisfied.

4
Search Tree

• Every problem may be represented as a (search)
  tree, where each node has two children,
  corresponding to a variable and its negation not
  appearing in the path from the root to the node.
• A solution of the problem, a complete asignment
  of T/F values to all variables, corresponds to a
  path from the root to a leaf, that satisfies all
  constraints.
• The search process may be implemented by
  traversing the search tree.
• A complete search will visit (if necessary) all
  leafs.

5
Search Tree

• A generate and test approach to constraint
  solving will visit all leafs (generate potential
  solutions) and test the satisfiability of all
  clauses for the corresponding assignments of
  values to variables.
• Search may be improved by backtracking at each
  node (not only in the leafs) the clauses with
  variables defined are tested for satisfiability.
• In this form, by testing incomplete solutions,
  backtracking avoids the completion of many
  impossible partial solutions.

c1 ?A ? B c2 ?A ? C c3 ?B ? ?C
6
Search Tree

• Still, backtracking handles constraints
  passively. First values are assigned to
  variables, and then constraints (clauses) are
  tested.
• Alternatively, constraints are handled actively
  with constraint propagation.
• In the Boolean Constraint Propagation (BCP)
• when all literals but one of a clause are
  assigned False, then the clause becomes active
  and propagates the remaining literal is assigned
  True.

c1 ?A ? B c2 ?A ? C c3 ?B ? ?C
7
Boolean Constraint Propagation

• This propagation can be noticed in the 4-queens
  problem. Here are some examples
• Propagate a 0-assignment
• Propagate a 1

X21 ? X22 ? X23 ? X24 ? X24 ? 1
8
Boolean Constraint Propagation

• Here is the complete search process with
  constraint propagation
• Assign X11 Propagate X23 Propagate
• X24 Propagate Propagate
• X12 Propagate Propagate Propagate
  Propagate

Fail ! X31 ? X32 ? X33 ? X34 Backtrack X23
Fail ! X41 ? X42 ? X43 ? X44 Backtrack X24
9
Boolean Clauses in SICStus

• SICStus does not provide any constraint solver
  for the satisfiability of Boolean clauses (SAT).
• Nevertheless, it can be easily implemented as an
  instance of a finite domains solver, where the
  domain of the variables are 0,1.
• A clause is thus converted into an inequality
  constraint over an arithmetic expression. An
  example illustrates this modelling
• Clause X ? ?Y ? Z
• ? X (1-Y) Z ? 1 ? X Y Z ? 0
• Propagation 1 X 0, Y 1 ? 0-1Z ? 0
  ? Z ? 1 ? Z ? 1
• Propagation 2 X 0, Z 0 ? 0-Y0 ? 0
  ? Y ? 0 ? Y ? 0
• (see details in queens4_sat_fd.pl)

10
Why Finite Domains ?

• In most problems, and notwithstanding the
  theoretical and practical interest in SAT,
  problems are more naturally specified with
  variables whose domain is not restricted to 0/1
  values, but may take a finite set of values.
• In particular, the N queens problem is more
  easily programmed with n variables, one for
  each row, whose value denotes the column that the
  queen of that row must be in. The values allowed
  are, of course, the number of the column, i.e.
  integers from 1 to n.
• Such specification, not only is more natural, but
  it also may lead to a substantial increase in the
  efficiency of the solving process.
• Finite Domain encodings of problems where n
  variables can take k different values implement a
  search space with a substantially different size
  from the corresponding Boolean coding where each
  value is represented by a distinct Boolean
  variable.

11
Why Finite Domains ?

• To compare the search spaces of Boolean and
  Finite Domain encodings for problems where n
  variables can take k different values we note
  that
• Boolean Encodings - kn boolean variables (
  0/1).
• Search Space 2kn.
• Finite Domains - n variables each with k possible
  values
• Search Space kn
• Ratio of the Search Spaces
• r 2kn / 2log2kn 2 (k-log2(k))n
• For example, in the N-queens problem, we have
• n 8 ? k 8, and r2(8-3)8 240 ? 1012
• n 16 ? k 16, and r2(16-4)16 2192 ? 1058

12
Finite Domains

• Of course, the ratio of the search spaces that
  are actually searched is not so large, namely due
  to constraint propagation. Still, the differences
  may be quite significant.
• The efficiency of the CLP programs over finite
  domains (including the Boolean case) may still be
  improved by making use of
• Adequate Propagation Algorithms
• Appropriate Heuristics for selection of the
  Variable to label and the Value to assign
• Before investigating these issues, a number of
  concepts are introduced
• Constraints and Constraint Network
• Partial and Total Solutions
• Satisfaction and Consistency

13
Basic Concepts Domains

• Definition (Domain of a Variable)
• The domain of a variable is the (finite) set of
  values that can be assigned to that variable.
• Given some variable X, its domain will be usually
  referred to as dom(X) or, simply, Dx.
• Example The N queens problem may be modelled by
  means of N variables, X1 to Xn, all with the
  domain from 1 to n.
• Dom(Xi) 1,2, ..., n or
  Xi 1..n.

14
Basic Concepts Labels

• To formalise the notion of the state of a
  variable (i.e. its assignment with one of the
  values in its domain) we have the following
• Definition (Label)
• A label is a Variable-Value pair, where the Value
  is one of the elements of the domain of the
  Variable.
• The notion of a partial solution, in which some
  of the variables of the problem have already
  assigned values, is captured by the following
• Definition (Compound Label)
• A compound label is a set of labels with distinct
  variables.

15
Basic Concepts Constraints

• We come now to the formal definition of a
  constraint
• Definition (Constraint)
• Given a set of variables, a constraint is a set
  of compound labels on these variables.
• Alternatively, a constraint may be defined simply
  as a relation, i.e. a subset of the cartesian
  product of the domains of the variables involved
  in that constraint.
• For example, given a constraint Rijk involving
  variables Xi, Xj and Xk, then
• Rijk ? dom(Xi) x dom(Xj) x dom(Xk)

16
Basic Concepts Constraints

• Given a constraint C, the set of variables
  involved in that constraint is denoted by
  vars(C).
• Simetrically, the set of constraints in which
  variable X participates is denoted by cons(X).
• Notice that a constraint is a relation, not a
  function, so that it is always Cij Cji.
• In practice, constraints may be specified by
• Extension through an explicit enumeration of the
  allowed compound labels
• Intension through some predicate (or procedure)
  that determines the allowed compound labels.

17
Basic Concepts Constraint Definition

• For example, the constraint C13 involving X1 and
  X3 in the 4-queens problem, may be specified
• By extension (label form)
• C13 X1-1,X3-2,X1-1,X3-4,X1-2,X3-1,X1-2,
  X3-3,
• X1-3,X3-2,X1-3,X3-4,X1-4,X3-1,X1-4,X3-3
  .
• or, in tuple (relational) form, omitting the
  variables
• C13 lt1,2gt,lt1,4gt,lt2,1gt,lt2,3gt,lt3,2gt,lt3,4gt,lt4,1gt,
  lt4,3gt.
• By intension
• C13 (X1 ? X3) ? (1X1 ? 3X3) ? (3X1 ?
  1X3).

18
Basic Concepts Constraint Arity

• Definition (Constraint Arity)
• The constraint arity of some constraint C is the
  number of variables over which the constraint is
  defined, i.e. the cardinality of the set Vars(C).
• Despite the fact that constraints may have an
  arbitrary arity, an important subset of the
  constraints is the set of binary constraints.
• The importance of such constraints is two fold
• All constraints may be converted into binary
  constraints
• A number of concepts and algorithms are
  appropriate for these constraints.

19
Basic Concepts Binary Constraints

• Conversion to Binary Constraints
• An n-ary constraint, C, defined by k compound
  labels on its variables X1 to Xn, is equivalent
  to n binary constraints, C0i, through the
  addition of a new variable, X0, whose domain is
  the set 1 to k.
• In practice,
• The k n-ary labels may be sorted in some
  arbitrary order.
• Each of the n binary constraints C0i relates the
  new variable X0 with the variable Xi.
• The compound label Xi-vi, X0-j belongs to
  constraint C0i iff Xi-vi belongs to the j-th
  compound label that defines C.

20
Basic Concepts Binary Constraints

• Example
• Given variables X1 to X3, with domains 1..3, the
  following ternary constraint C is composed of 6
  labels..
• C(X1, X2, X3) lt1,2,3gt,lt1,3,2gt,lt2,1,3gt,lt2,3,1gt
  ,lt3,1,2gt,lt3,2,1gt
• Each of the labels may be associated to a value
  from 1 to 6
• 1 lt1,2,3gt, 2 lt1,3,2gt, ... , 6 lt3,2,1gt
• Now, the following binary constraints, C01 to
  C03, are equivalent to the initial ternary
  constraint C
• C01(X0, X1) lt1,1gt, lt2,1gt, lt3,2gt, lt4,2gt,
  lt5,3gt, lt6,3gt
• C02(X0, X2) lt1,2gt, lt2,3gt, lt3,1gt, lt4,3gt,
  lt5,1gt, lt6,2gt
• C03(X0, X3) lt1,3gt, lt2,2gt, lt3,3gt, lt4,1gt,
  lt5,2gt, lt6,1gt

21
Basic Concepts Constraint Satisfaction

• Definition (Constraint Satisfaction 1)
• A compound label satisfies a constraint if their
  variables are the same and if the compound label
  is a member of the constraint.
• In practice, it is convenient to generalise
  constraint satisfaction to compound labels that
  strictly contain the constraint variables.
• Definition (Constraint Satisfaction 2)
• A compound label satisfies a constraint if its
  variables contain the constraint variables and
  the projection of the compound label to these
  variables is a member of the constraint.

22
Basic Concepts Constraint Satisfaction Problem

• Definition (Constraint Satisfaction Problem)
• A constraint satisfaction problem is a triple
  ltV, D, Cgt where
• V is the set of variables of the problem
• D is the domain(s) of its variables
• C is the set of constraints of the problem
• Definition (Problem Solution)
• A solution to a Constraint Satisfaction Problem
  P ltV, D, Cgt, is a compound label over the
  variables V of the problem, which satisfies all
  constraints in C.

23
Basic Concepts Constraint Graph

• For convenience, the constraints of a problem may
  be considered as forming a special graph.
• Definition (Constraint Graph or Constraint
  Network)
• The Constraint Graph or Constraint Network of a
  binary constraint satisfaction problem is defined
  as follows
• There is a node for each of the variables of the
  problem.
• For each non-trivial constraint of the problem,
  involving one or two variables, the graph
  contains an arc linking the corresponding nodes.
• When the problems include constraints with
  arbitrary arity, the Constraint Network may be
  formed after converting these constraints on its
  binary equivalent.

24
Basic Concepts Constraint Hyper-Graph

• When it is not convenient to convert n-ary
  constraints to their binary equivalent, the
  problem may be represented by an hiper-graph.
• Definition (Constraint Hyper-Graph)
• Any constraint satisfaction problem with
  arbitrary n-ary constraints may be represented
  by a Constraints Hiper-Graph formed as follows
• There is a node for each of the variables of the
  problem.
• For each constraint of the problem, the graph
  contains an hiper-arc linking the corresponding
  nodes.
• Of course, when the problem has only binary
  constraints, the hiper-graph degenerates into the
  simpler graph.

25
Example 4-Queens

• Example
• The 4 queens problem may be specified by the
  following constraint network

C13 lt1,2gt, lt1,4gt, lt2,1gt, lt2,3gt, lt3,2gt, lt3,4gt,
lt4,1gt, lt4,3gt
26
Basic Definitions Graph Density

• Definition (Complete Constraint Network)
• A constraint netwok is complete, when there is
  an arc connecting any two nodes of the graph
  (i.e. when there is a constraint over any pair of
  variables).
• The 4 queens problem (in fact, any n queens
  problem) has a complete graph.
• However, this is often not the case most graphs
  are sparse. In this case, it is important to
  measure the density of the constraint network.
• Definition (Density of a Constraint Graph)
• The density of a constraint graph is the ratio
  between the number of its arcs and the number of
  arcs of a complete graph on the same number of
  nodes

27
Basic Definitions Problem Difficulty

• In principle, the difficulty of a constraint
  problem is related to the density of its graph.
• Intuitively, the denser the graph is, the more
  difficult the problem becomes, since there are
  more opportunities to invalidate a compound
  label.
• It is important to distinguish between the
  difficulty of a problem and the difficulty of
  solving the problem.
• In particular, a difficult problem may be so
  difficult that it is trivial to find it to be
  impossible!
• The difficulty of a problem is also related to
  the difficulty of satisfying each of its
  constraints. Such difficulty may be measured
  through its tightness.

28
Basic Definitions Constraint Tightness

• Definition (Tightness of a Constraint)
• Given a constraint C on variables X1 ... Xn,
  with domains D1 to Dn, the tightness of C is
  defined as the ratio between the number of labels
  that define the constraint and the size (i.e. the
  cardinality) of the cartesian product D1 x D2 x
  .. Dn.
• For example, the tightness of constraint C13 of
  the 4 queens problem, on variables X1 and X3 with
  domains 1..4
• C13 lt1,2gt, lt1,4gt, lt2,1gt, lt2,3gt, lt3,2gt,
  lt3,4gt, lt4,1gt, lt4,3gt
• is ½, since there are 8 tuples in the relation
  out of the possible 16 (44).
• The notion of tightness may be generalised for
  the whole problem.

29
Basic Definitions Problem Tightness

• Definition (Tightness of a Problem)
• The tightness of a constraint satisfaction
  problem with variables X1 ... Xn, is the ratio
  between the number of its solutions and the
  cardinality of the cartesian product
• D1 x D2 x .. Dn.
• For example, the 4 queens problem, that has only
  two solutions lt2,4,1,3gt and lt3,1,4,2gt
• has tightness 2/(4444) 1/128.

30
Basic Definitions Problem Solving Difficulty

• The difficulty in solving a constraint
  satisfaction problem is related both with the
• The density of its graph and
• Its tightness.
• As such, when testing algorithms to solve this
  type of problems, it is usual to generate random
  problem instances, parameterised not only by the
  number of variables and the size of their
  domains, but also by the density of its graph and
  the tightness of its constraints.
• The study of these issues has led to the
  conclusion that constraint satisfaction problems
  often exhibit a phase transition, which should be
  taken into account in the study of the
  algorithms.
• This phase transition typically contains the most
  difficult instances of the problem, and separates
  the instances that are trivially satisfied from
  those that are trivially insatisfiable.

31
Basic Definitions Problem Solving Difficulty

• For example, in SAT, it has been found that the
  phase transition occurs when the ration of
  clauses to variables is around 4.3.

32
Basic Definitions Redundancy

• Another issue to consider in the difficulty of
  solving a constraint satisfaction problem is the
  potential existence of redundant values and
  labels in its constraints.
• Definition (Redundant Value)
• A value in the domain of a variable is redundant,
  if it does not appear in any solution of the
  problem.
• Definition (Redundant Label)
• A compound label of a constraint is redundant if
  it is not the projection to the constraint
  variables of a solution to the whole problem.
• Redundant values and labels increase the search
  space useless, and should thus be avoided. There
  is no point in testing a value that does not
  appear in any solution !

33
Basic Definitions Redundancy

• Example
• The 4 queens problem only admits two solutions
  
• lt2,4,1,3gt and lt3,1,4,2gt.
• Hence, values 1 and 4 are redundant in the domain
  of variables X1 and X4, and values 2 and 3 are
  redundant in the domain of variables X2 and X3.
• Regarding redundant labels, labels lt2,3gt (shown
  in the figure) and lt3,2gt are redundant in
  constraint C13.

34
Basic Definitions Redundancy

• Example
• The 4 queens problem, which only admits the two
  solutions lt2,4,1,3gt and lt3,1,4,2gt may be
  simplified by elimination of the redundant
  values and labels.

C13 lt1,2gt, lt1,4gt, lt2,1gt, lt2,3gt, lt3,2gt, lt3,4gt,
lt4,1gt, lt4,3gt
35
Basic Definitions Equivalent Problems

• Of course, any problem should be equivalent to
  any of its simplified versions. Formally,
• Definition (Equivalent Problems)
• Two problems P1 ltV1, D1, C1gt and P2 ltV2, D2,
  C2gt are equivalent iff they have the same
  variables (i.e. V1 V2) and the same set of
  solutions.
• The simplification of a problem may also be
  formalised
• Definition (Reduced Problem)
• A problem PltV,D,Cgt is reduced to PltV, D,
  Cgt if
• P and P are equivalent
• The domains D are included in D and
• The constraints C are at least as restrictive as
  those in C.

36
Constraint Solving Methods

• As shown before, and independently of any problem
  reduction, a generate and test procedure to solve
  a Constraint Satisfaction Problem is usually very
  inneficient.
• Nevertheless, this is the approach taken in local
  search methods (simulated annealing or genetic
  algorithms) although mostly in an optimisation
  context !
• It is thus often preferable to use a solving
  method that is constructive and incremental,
  whereby a compound label is being completed
  (constructive), one variable at a time
  (incremental), until a solution is reached.
• However, one must check that at every step in the
  construction of a solution the resulting label
  has still the potential to reach a complete
  solution.

37
Constraint Solving Methods

• Ideally, a compound label should be the
  projection of some problem solution.
• Unfortunately, in the process of solving a
  problem, its solutions are not known yet!
• Hence, one must use a notion weaker than that of
  a (complete) solution, namely
• Definition (k-Partial Solution)
• A k-partial solution of a constraint solving
  problem P ltV,D,Cgt, is a compound label on a
  subset of k of its variables, Vk, that satisfies
  all the constraints in C whose variables are
  included in Vk.

38
Constructive Solving Methods

• This is of course, the basis of the solving
  methods that use some form of backtracking. If
  conveniently performed, backtracking may be
  regarded as a tree search, where the partial
  solutions correspond to the internal nodes of the
  tree and complete solutions to its leaves.

39
Problem Search Space

• Clearly, the more a problem is reduced, the
  easier it is, in principle, to solve it.
• Given a problem PltV,D,Cgt with n variables
  X1,..,Xn the potential search space where
  solutions can be found (i.e. the leaves of the
  search tree with compound labels ltX1-v1gt, ...,
  ltXn-vngt) has cardinality
• S D1 D2 ... Dn
• Assuming identical cardinality (or some kind of
  average of the domains size) for all the variable
  domains, (Di d) the search space has
  cardinality
• S dn
• which is exponential on the size n of the
  problem.

40
Problem Search Space

• If instead of the cardinality d of the initial
  problem, one solves a reduced problem whose
  domains have lower cardinality d (ltd) the size
  of the potential search space also decreases
  exponentially!
• S/S dn / dn (d/d)n
• Such exponential decrease may be very significant
  for reasonably large values of n, as shown in
  the table.

41
Reduction of the Search Space

• In practice, this potential narrowing of the
  search space has a cost involved in finding the
  redundant values (and labels).
• A detailed analysis of the costs and benefits in
  the general case is extremely complex, since the
  process depends highly on the instances of the
  problem to be solved.
• However, it is reasonable to assume that the
  computational effort spent on problem reduction
  is not proportional to the reduction achieved,
  becoming less and less efficient.
• After some point, the gain obtained by the
  reduction of the search space does not compensate
  the extra effort required to achieve such
  reduction.

42
Reduction of the Search Space

• Qualitatively, this process may be represented by
  means of the following graph

43
Reduction of the Search Space

• The effort in reducing the domains must be
  considered within the general scheme to solve the
  problem.
• In Constraint Logic Programming, the
  specification of the constraints usually precedes
  the enumeration of the variables.
• Problem(Vars)-
• Declaration of Variables and Domains,
• Specification of Constraints,
• Labelling of the Variables.
• In general, search is performed exclusively on
  the labelling of the variables.
• The execution model alternates enumeration with
  propagation, making it possible to reduce the
  problem at various stages of the solving process.

44
Reduction of the Search Space

• Hence, given a problem with n variables X1 to Xn
  the execuction model follows the following
  pattern
• Declaration of Variables and Domains,
• Specification of Constraints,
• indomain(X1), value selection with
  backtraking
• propagation, reduction of problem X2 to Xn
• indomain(X2),
• propagation, reduction of problem X3 to Xn
• ...
• indomain(Xn-1)
• propagation, reduction of problem Xn
• indomain(Xn)

45
Domain Reduction Consistency Criteria

• Once formally defined the notion of problem
  reduction, one must discuss the actual procedure
  that may be used to achieve it.
• First of all, one must ensure that whatever
  procedure is used, the reduction keeps the
  problem equivalent to the initial one.
• Here we have a small problem, since the
  definition of equivalence requires the solutions
  to be the same and we do not know in general what
  the solutions are!
• Nevertheless, the solutions will be the same if
  in the process of reduction we have the guarantee
  that no solutions are lost. Such guarantees are
  met by several criteria.

46
Domain Reduction Consistency Criteria

• Consistency criteria enable to establish
  redundant values in the variables domains in an
  indirect form, i.e. requiring no prior knowledge
  on the set of problem solutions.
• Hence, procedures that maintain these criteria
  during the propagation phases, will eliminate
  redundant values and so decrease the search space
  on the variables yet to be enumerated.
• For constraint satisfaction problems with binary
  constraints, the most usual criteria are, in
  increasingly complexity order,
• Node Consistency
• Arc Consistency
• Path Consistency

47
Domain Reduction Node Consistency

• Definition (Node Consistency)
• A constraint satisfaction problem is
  node-consistent if no value on the domain of its
  variables violates the unary constraints.
• This criterion may seem both obvious and useless.
  After all, who would specify a domain that
  violates the unary constraints ?!
• However, this criterion must be regarded within
  the context of the execution model that
  incrementally completes partial solutions.
  Constraints that were not unary in the initial
  problem become so when one (or more) variables
  are enumerated.

48
Domain Reduction Node Consistency

• Example
• After the initial posting of the constraints, the
  constraint network model at the right represents
  the 4-queens problem.
• After enumeration of variable X1, i.e. X11,
  constraints C12, C13 and C14 become unary !!

49
Domain Reduction Node Consistency

• An algorith that maintains node consistency
  should remove from the domains of the future
  variables the appropriate values.
• Maintaining node consistency achieves a domain
  reduction similar to what was achieved in
  propagation with the boolean formulation.

50
Maintaining Node Consistency

• Given the simplicity of the node consistency
  criterion, an algorithm to maintain it is very
  simple and with low complexity.
• A possible algorithm is NC-1, below.
• procedure NC-1(V, D, R)
• for X in V
• for v in Dx do
• for Cx in Cons(X) Vars(Cx) X do
• if not satisfy(X-v, Cx) then
• Dx lt- Dx \ v
• end for
• end for
• end for
• end procedure

51
Maintaining Node Consistency

• Space Complexity of NC-1 O(nd)
• Assuming n variables in the problem, each with d
  values in its domain, and assuming that the
  variables domains are represented by extension,
  a space nd is required to keep explicitely the
  domains of the variables.
• For example, the initial domain 1..4 of variables
  Xi in the 4 queens problem is represented by a
  boolean vector (where 1 means the value is in the
  domain)
• Xi 1,1,1,1 or 1111.
• After enumeration X11, node consistency prunes
  the domain of other variables to X1 1000, X2
  0011, X3 0101 and X4 0110
• Algorithm NC-1 does not require additional space,
  so its space complexity is
• O(nd).

52
Maintaining Node Consistency

• Time Complexity of NC-1 O(nd)
• Assuming n variables in the problem, each with d
  values in its domain, and taking into account
  that each value is evaluated one single time, it
  is easy to conclude that algorithm NC-1 has time
  complexity O(nd).
• The low complexity, both temporal and spatial, of
  algorithm NC-1, makes it suitable to be used in
  virtual all situations by a solver.
• However, node consistency is rather incomplete,
  not being able to detect many possible reductions.

53
Domain Reduction Arc Consistency

• A more demanding and complex criterion of
  consistency is that of arc-consistency
• Definition (Arc Consistency)
• A constraint satisfaction problem is
  arc-consistent if,
• It is node-consistent and
• For every label Xi-vi of every variable Xi, and
  for all constraints Cij, defined over variables
  Xi and Xj, there must exist a value vj that
  supports vi, i.e. such that the compound label
  Xi-vi, Xj-vj satisfies constraint Cij.

54
Domain Reduction Arc Consistency

• Example
• After enumeration of variable X11, and making
  the network node-consistent, the 4 queens problem
  has the following constraint network
• However, label X2-3 has no support in variable
  X3, since neither compound label X2-3 , X3-2
  nor X2-3 , X3-4 satisfy constraint C23.
• Therefore, value 3 can be safely removed from the
  domain of X2.

55
Domain Reduction Arc Consistency

• Example (cont.)
• In fact, none (!) of the values of X3 has support
  in variables X2 and X4., as shown below
• label X3-4 has no support in variable X2, since
  none of the compound labels X2-3, X3-4 and
  X2-4, X3-4 satisfy constraint C23.
• label X3-2 has no support in variable X4, since
  none of the compound labels X3-2, X4-2 and
  X3-2, X4-3 satisfy constraint C34.

56
Domain Reduction Arc Consistency

• Example (cont.)
• Since none of the values from the domain of X3
  has support in variables X2 and X4, maintenance
  of arc-consistency empties the domain of X3!
• Hence, maintenance of arc-consistency not only
  prunes the domain of the variables but also
  antecipates the detection of unsatisfiability in
  variable X3 ! In this case, backtracking of X11
  may be started even before the enumeration of
  variable X2.
• Given the good trade-of between pruning power and
  simplicity of arc-consistency, a number of
  algorithms have been proposed to maintain it.

57
Maintaining Arc Consistency AC-1

• AC-1, shown below, is a very simple algorithm to
  maintain Arc Consistency
• procedure AC-1(V, D, C)
• NC-1(V,D,C) node consistency
• Q aij Cij ? C ? Cji ? C see note
• repeat
• changed lt- false
• for aij in Q do
• changed lt- changed or revise_dom(aij,V,D,C)
  
• end for
• until not change
• end procedure
• Note for constraint Cij two directed arcs, aij
  and aji, are considered

58
Maintaining Arc Consistency AC-1

• Predicate rev_dom(aij,V,D,R) succeeds iff it
  prunes values from the domain of Xi
• predicate revise_dom(aij,V,D,C) Boolean
• success lt- false
• for vi in dom(Xi) do
• if there is no vj in dom(Xj) such that
• satisfies(Xi-vi,Xj-vj,Cij) then
• dom(Xi) lt- dom(Xi) \ vi
• success lt- true
• end if
• end for
• revise_dom lt- success
• end predicate

59
Time Complexity of AC-1

• Time Complexity of AC-1 O(nad3)
• Assuming n variables in the problem, each with d
  values in its domain, and a total of a arcs, in
  the worst case, predicate revise_dom, checks d2
  pairs of values.
• The number of arcs aij in queue Q is 2a (2
  directed arcs aij and aji are considered for each
  constraint Cij). For each value removed from one
  domain, revise_dom is called 2a times.
• In the worst case, only one value from one
  variable is removed in each cycle, and the cycle
  is executed nd times.
• Therefore, the worst-case time complexity of
  AC-1 is O( d2 2and), i.e.
• O(nad3)

60
Space Complexity of AC-1

• Space Complexity of AC-1 O(ad2) O(n2d2)
• AC-1 must maintain a queue Q, with maximum size
  2a. Hence the inherent spacial complexity of AC-1
  is O(a).
• To this space, one has to add the space required
  to represent the domains O(nd) and the
  constraints of the problem. Assuming a
  constraints and d values in each variable domain
  the space required is O(ad2), and a total space
  requirement of
• O(nd ad2)
• which dominates O(a).
• For dense constraint networks, a ? n2/2. This
  is then the dominant term, and the space
  complexity becomes
• O(ad2) O(n2d2)

61
Maintaining Arc Consistency From AC-1 to AC-3

• Inefficiency of AC-1
• Every time a value vi is removed from the domain
  of variable Xi by predicate revise_dom(aij,V,D,R),
  all arcs are reexamined.
• However, only the arcs aki (for k ? i and k ? j )
  should be reexamined.
• This is because the removal of vi may eliminate
  the support from some value vk of some variable
  Xk for which there is a constraint Cki (or Cik).
• Such inefficiency is eliminated in algorithm
  AC-3.

62
Maintaining Arc Consistency AC-3

• AC-3 only revisits arcs for which the domain of
  the leading variable has been revised
  (narrowed).
• procedure AC-3(V, D, C)
• NC-1(V,D,R) node consistency
• Q aij Rij ? C ? Cji ? C
• while Q ? ? do
• Q Q \ aij removes an element from Q
• if revise_dom(aij,V,D,C) then revised Xi
• Q Q ? aki Cki ? C ? k ? i ? k ? j
• end if
• end while
• end procedure
• Intuitively, AC-3 must have not only better
  worst-case, but also a better typical-case
  complexity than AC-1.

63
Time and Space Complexity of AC-3

• Time Complexity of AC-3 O(ad3)
• Each arc aki is only added to Q when some value
  vi is removed from the domain of Xi.
• In total, each of the 2a arcs may be added to Q
  (and removed from Q) d times.
• Every time that an arc is removed, predicate
  revise_dom is called, to check at most d2 pairs
  of values.
• All things considered, and in contrast with AC-1,
  with complexity O(nad3), the time complexity of
  AC-3, in the worst case, is O(2ad d2), i.e.
  O(ad3).
• Space Complexity of AC-3 O(ad2)
• As to space complexity AC-3 has the same
  requirements than AC-1, and the same worst-case
  space complexity of O(ad2) ? O(n2d2), due to the
  representation of constraints by extension.