Finite Domains

1

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 SICStus, they must be integers).

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.

2

Finite DomainsFinite Domain codings of problems such as the N queens problem, 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.

Booleans - K*n boolean variables ( 0/1).

Search Space = 2k*n.

Finite Domains - n variables each with K possible values

Search Space = kn

Ratio of the Search Spacesr= 2k*n / 2log2(k)*n = 2 (k-log2(k))*n

In the 8-queens problem, k=8 e n=8, and r=2(8-3)*8

=240

3

Finite Domains

Of course, the ratio of the search spaces that are actually searched is not so large.

As in N-queens, since a variable in the Finite Domain can only take one value in a particular solution, the boolean code will have exclusivity constraints of the type at_most_one([B1, B2, ...Bk]), e.g. queens in the same row. Efficient Boolean propagation imposes a 0 value to all the other variables, when one of the set takes value 1.

Still, the differences may be significant, as can be seen in the programs coded directly in finite domains

queens_sat_bk and queens_sat_fd

queens_bk and queens_fd

4

Finite Domains

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

• Value to assign

These variations may be found in program

queens_fd_xc

where a number of possibilities are parameterised.

5

Finite Domains

The changes in efficiency in the various versions of the N queens program were due to different

• Propagation Algorithms

• Heuristics for Variable Selection

Before investigating these issues, namely the Propagation Algorithms, we should formalise a number of concepts that will be used

• Constraints and Constraint Network

• Partial and Total Solutions

• Satisfaction and Consistency

6

Finite Domains - Basic Definitions

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, more 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.

7


To formalise the notion of assignment of a variable with one of the variable’s domain we have the following

Definition (Label):

A label is a pair Variable-Value, 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.

8


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.

Put in other terms, a constraint may be regarded as 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)

9


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 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.

10


For example, for variables X1 e X3 in the 4 queens problem, the constraint involving them, may be specified

By extension:

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 form, omitting the variables

C13 = {<1,2>, <1,4>, <2,1>, <2,3>, <3,2>, <3,4>, <4,1>, <4,3>}

By intension:

C13 = (X1 X3) (1+X1 3+X3) (3+X1 1+X3)

11


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

1.All constraints may be converted into binary constraints

2. A number of concepts and algorithms are appropriate for these constraints.

12


Conversion to Binary Constraints

An n-ary constraint, C, defined by k compound lables on its variables X1 a Xn, is equivalent to n binary constraints, Bi, through the addition of a new variable, Z, whose domain is the set 1 to k.

In fact, the k n-ary labels may be sorted in some arbitrary order.

Each of the n binary constraints Bi relates the new variable Z with the variable Xi.

The compound label {Xi-vi, Z-z} belongs to constraint Bi iff Xi-vi belongs to the n-th compound label that defines C.

13


Example: Given variables X1 to X3, with domains 1 to 3, the following ternary constraint C imposes different values for the three variables and is composed of 6 labels..

C(X1, X2, X3) = {<1,2,3>,<1,3,2>,<2,1,3>,<2,3,1> ,<3,1,2>,<3,2,1

>}

Each of the labels may be associated to a value from 1 to 6

1 : <1,2,3>, 2 : <1,3,2>, ... 6: <3,2,1>

The following binary constraints, B1 to B3, are equivalent to the initial ternary constraint C

B1(Z, X1) = {<1,1>, <2,1>, <3,2>, <4,2>, <5,3>, <6,3>}

B1(Z, X1) = {<1,2>, <2,3>, <3,1>, <4,3>, <5,1>, <6,2>}

B1(Z, X1) = {<1,3>, <2,2>, <3,3>, <4,1>, <5,2>, <6,1>}

14


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

15


Definition (Constraint Satisfaction Problem):

A constraint satisfaction problem is a triple <V,D,C> 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, defined as the tuple <V, D, C>, is a compound label over the variables V of the problem, which satisfies all the constraints in C.

16


For convenience, the constraints of a problem may be considered as forming a special graph.

Definition (Constraint Graph or Network):

The Constraint Graph or Network of a binary constraint satisfaction problem has 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.

17


When it is not convenient for some reason to convert constraints to their binary equivalent, the problem may be represented by an hiper-graph.

Definition (Constraint Hiper-Graph):

Any constraint satisfaction problem with arbitrary n-ary constraints may be represented by a Constraints Hiper-Graph whose nodes are 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, its constraints hiper-graph degenerates into a Constraints graph.

18


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

X1 in 1..4

X4 in 1..4

X3 in 1..4X2 in 1..4

C12

R23

R14

C24

C34

C13{<1,2>, <1,4>, <2,1>, <2,3>,

<3,2>, <3,4>, <4,1>, <4,3>}

19


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, for any n) has a complete graph. However, this is not always the case, and graphs may be 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.

20


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 trivially found 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”.

21


Definition (Tightness of a Constraint):

Given a constraint C on variables X1 ... Xn, with domains D1 a 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 = {<1,2>, <1,4>, <2,1>, <2,3>, <3,2>, <3,4>, <4,1>, <4,3>}

is 8/(4*4) = 1/2.

The notion of tightness may be generalised for the whole problem.

22


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 <2,4,1,3> e <3,1,4,2>

has tightness 2/4*4*4*4 = 1/128.

23


The difficulty in solving a constraint satisfaction problem is related both with 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 arcs, but also by the density of its graph and the tightness of its constraints.

As a remark, the study of these issues has led to the conclusion that constraint satisfaction problems often exhibit a phase transition, separating the problems trivially satisfied from those trivially insatisfiable, which should be taken into account in the study of the algorithms.

24


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.

Definição (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.

25


Example: The 4 queens problem only admits the two solutions <2,4,1,3> e <3,1,4,2>.

Hence, values 1 e 4 are redundant in the domain of variables X1 e X4, and values 2 and 3 are redundant in the domain of variables X2 e X3.

Regarding redundant labels, labels <2,3> e <3,2> are redundant in constraint C13.

26


Example: The 4 queens problem, which only admits the two solutions <2,4,1,3> e <3,1,4,2> may be “simplified” by elimination of the redundant values and labels.

X1 in 1,2,3,4

X4 in 1,2,3,4

X3 in 1,2,3,4X2 in 1,2,3,4

C12

R23

R14

C24

C34

C13

{<1,2>, <1,4>, <2,1>, <2,3>,

<3,2>, <3,4>, <4,1>, <4,3>}

27

Finite Domains - Basic DefinitionsOf course, any problem is equivalent to any of its simplified versions. Formally,

Definition (Equivalent Problems):

Two problems P1 = <V1, D1, C1> and P2 = <V2, D2, C2> 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 P=<V,D,C> is reduced to P’=<V’, D’, C’> ifa) P e P’ are equivalent;b) The domains D’x are included in Dx; and

c) The constraints C’ are at least as restrictive as those in C.

28

Construtive Solving Methods in Finite Domains

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) !!!

It is thus 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.

29


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!

Hence, one may use a notion weaker than that of a (complete) solution, namely

Definition (k-Partial Solution):

A k-partial solution of a constraint solving problem, defined as P = <V,D,C>, 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.

30


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.

2

4

1

3

31 4

1

4

2

31


Clearly, the more a problem is reduced, the easier it is, in principle, to solve it.

Given a problem P=<V,D,C> 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 {<X1-v1>, ..., <Xn-vn>}) 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 = d n

which is exponential on the “size” n of the problem.

32


If instead of the cardinality d of the initial problem, one solves a reduced problem whose domains have lower cardinality d’ (<d) the size of the potential search space also decreases exponentially!

S’/S = d’n / dn = (d’/d)n

Such exponential decreases may be very significant for “reasonably” large values of n, as shown in the table.

10 20 30 40 50 60 70 80 90 100

7 6 4.6716 21.824 101.95 476.29 2225 10395 48560 226852 1E+06 5E+06

6 5 6.1917 38.338 237.38 1469.8 9100.4 56348 348889 2E+06 1E+07 8E+07

5 4 9.3132 86.736 807.79 7523.2 70065 652530 6E+06 6E+07 5E+08 5E+09

4 3 17.758 315.34 5599.7 99437 2E+06 3E+07 6E+08 1E+10 2E+11 3E+12

3 2 57.665 3325.3 191751 1E+07 6E+08 4E+10 2E+12 1E+14 7E+15 4E+17

d d'

S/S'

n

33


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.

34

Construtive Solving Methods in Finite DomainsQualitatively, this process may be represented by means of the following graphic

Com

p uta

ti ona

l Co s

t

R - Reduction Cost

S- Search Cost

R+S Combined Cost

Effort spent in solving the problem

35


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.

However, the execution model alternates enumeration with propagation, making it possible to reduce the problem at various stages of the solving process.

36


Given a problem with n variables X1 a Xn the execuction model follows the following pattern:

Declaration of Variables and Domains,

Specification of Constraints,

indomain(X1), % value selection with backtraking

propagation, % reduction to problem X2 to Xn

indomain(X2),

propagation, % reduction to problem X3 to Xn

...

indomain(Xn-1)

propagation, % reduction to problem Xn

indomain(Xn)

37

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.

38

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.

In constraint satisfaction problems with binary constraints, the most usual criteria are, in increasingly complexity order,

• Node Consistency

• Arc Consistency

• Path Consistency

39

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.

40

Domain Reduction - Node ConsistencyExample: After the initial launching of the constraints, the 4 queens problem has thee following constraint network: X1 in 1..4

X4 in 1..4

X3 in 1..4X2 in 1..4

C12

C23

R14

C24

C34

R13

After enumerating variable X1, making X1=1, constraints C12, C13 e C14 become unary !!

X4 in 1..4

X3 in 1..4X2 in 1..4C23

C24

C34

X2 1,2

X3 1,3

X4 1,4

41

Domain Reduction - Node ConsistencyAn 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.

X4 1,4

1 1

1 1

1 1

X2 1,2X3 1,3

X4 in 2,3

X3 in 2,4X2 in 3,4C23

C24

C34

X2 1,2

X3 1,3

X4 1,4

42


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 <- Dx \ {v} end for end for end forend procedure

43


Space Complexity of NC-1

Assuming n variables in the problem, each with d values in its domain, and assuming that the variable’s 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 X1=1, node consistency will prune the domain of the other variables to X1 = 1000, X2 = 0011, X3 = 0101 e X4 = 0110

Algorithm NC-1 does not require additional space, so its space complexity is O(nd).

44


Time Complexity of NC-1

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 some possible reductions.

45

Domain Reduction - Arc Consistency

A more demanding and complex criterion of consistency is arc-consistency

Definition (Arc Consistency):

A constraint satisfaction problem is arc-consistent if,

1. It is node-consistent; and

2. For every label Xi-vi of every variable Xi, and for all constraints Cij, that involve 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.

46

Domain Reduction - Arc ConsistencyExample: After enumerating variable X1, X1=1, and making the network node-consistent, the 4 queens problem has the following constraint network:

However, the 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.

X4 in 2,3

X3 in 2,4X2 in 3,4C23

C24

C34

X2 1,2

X3 1,3

X4 1,4

X4 1,4

1 1

1 1

1 1

X2 1,2X3 1,3

47

Domain Reduction - Arc ConsistencyIn 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.

X4 1,4

1 1

1 1

1 1

X2 1,2X3 1,3

48

Domain Reduction - Arc ConsistencySince none of the values from the domain of X3 has support in variables X2 e X4, the maintenance of arc-consistency empties the domain of X3!

Hence, arc-consistency maintenance not only prunes the domain of the variables but also antecipates the detection of unsatisfiability in variable X3 !

In this case, backtracking of X1=1 may be started even before the enumeration of variable X2.

X4 1,4

1 1

1 1

1 1

X2 1,2X3 1,3

49

Maintaining Arc Consistency: AC-1Maintaining Arc Consistency

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 <- false; for aij in Q do

changed <- changed or revise_dom(aij,V,D,C)

end for until not changedend procedure

Note: for Cij two directed arcs aij e aji are considered

50

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 <- 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) <- dom(Xi) \ {vi};

success <- true; end if revise_dom <- success;end predicate

51

Maintaining Arc Consistency: AC-1Time Complexity of AC-1

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 given by O( d2 * 2a * nd), i.e.

O(nad3)

52


Space Complexity of AC-1

AC-1 must maintain a queue Q, with maximum size 2a. Hence the inherent spacial complexity of AC-1 é 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) (it dominates O(a)).

For “dense” constraint networks”, a n2/2. This is then the dominant term, and the space complexity becomes

O(ad2).

53


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.

54


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 whileend procedure

Intuitively, AC-3 must have not only better worst-case, but also a better typical-case complexity than AC-1.

55

Maintaining Arc Consistency: AC-3Time Complexity of AC-3

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 temporal complexity O(nad3), the time complexity of AC-3, in the worst case, is O(2ad * d2), i.e.

O(ad3)

56


Inefficiency of AC-3

Every time a value vi is removed from the domain of some variable Xi, by predicate revise_dom(aij,V,D,C),

all arcs leading to that variable are reexamimed.

Nevertheless, only some of these arcs aki (for k i e k j ) should be examined.

Although the removal of vi may eliminate support for some value vk of another variable Xk for which there is a constraint Cki (ou Cik), other values in the domain of Xi may maintain support in variable Xi for the pair Xk-vk!

This idea is exploited in algorithm AC-4.

57


Algorithm AC-4 (counters)

Algorithm AC-4 maintain data structures to account for the number of values in the domain of variable Xi that support value vk from another variable Xk, for which there is a constraint Cik.

For example, in the 4 queens problem, the counters that account for the support of value X1= 2 are initialised as follows

c(2,X1,X2) = 1 % X2-4 does not attack X1-1

c(2,X1,X3) = 2 % X3-1 and X3-3 do not attack X1-1

c(2,X1,X4) = 3 % X4-1, X4-3 and X4-4 do not attack X1-1

58


Algorithm AC-4 (supporting sets)

To update the counters when a value is eliminated, it is useful to maintain the set of Variable-Value pairs that are supported by each value of a variable.

AC-4 thus maintain for each Value-Variable pair the set of all Variable-Value pairs supported by the former pair.

sup(2,X1) = [X2-4,X3-1,X3-3,X4-1,X4-3,X4-4]

% X2-2 supports (does not attack)

X2-4,X3-1,...

sup(1,X1) = [X2-2, X2-3 , X3-2, X3-4, X4-2, X4-3]

sup(3,X1) = [X2-1, X3-2 , X3-4, X4-1, X4-2, X4-4]

sup(4,X1) = [X2-1, X2-2 , X3-1, X3-3, X4-2, X4-3]

59


Algorithm AC-4 (Propagation)

Every time that is detected that a value from a variable does not have support in another variable this value is removed from the domain of the variable and is addded to a list for subsequent propagation.

However, although the value may loose support several times, its removal may only be propagated, in a useful way, once.

To account for this situation, AC-4 maintains a Boolean matrix M. The 1/0 value of element M[X,v] represents whether value v is/is not present in the domains of variable X.

60


Algorithm AC-4 (Overall structure)

AC-4 makes use of the data structures presented in the predictable way.

In a first phase, executed only once, the algorithm initialises the data structures (counters, supporting sets, boolean matrix and removal list).

In the second phase, executed not only after the first phase, but also after each enumeration step, the algorithm performs the actual constraint propagation, updating the data structures as required.

61

Maintaining Arc Consistency: AC-4Algorithm AC-4 (Phase 1 - Initialisation)procedure inicialise_AC-4(V,D,C); M <- 1; sup <- ; List = ; for Cij in C do

for vi in dom(Xi) do ct <- 0; for vj in dom(Xj) do if satisfies({Xi-vi, Xj-vj}, Cij) then ct <- ct + 1; sup(vj,Xj)<- sup(vj,Xj) {Xi-vi} end if end for if ct = 0 then M[Xi,vi] <- 0; List <- List {Xi-vi} dom(Xi) <- dom(Xi)\{vi} else c(vi, Xi, Xj) <- ct; end if end for

end forend procedure

62

Maintaining Arc Consistency: AC-4Algorithm AC-4 (Phase 2 - Propagation)

procedure propagate_AC-4(V,D,R); while List do List <- List \ {Xi-vi} % remove element from List

for Xj-vj in sup(vi,Xi) do

c(vj,Xj,Xi) <- c(vj,Xj,Xi) - 1;

if c(vj,Xj,Xi) = 0 M[Xj,vj] = 1 then

List = List {Xj-vj};

M[Xi,vi] <- 0;

dom(Xj) <- dom(Xj) \ {vj}

end if end for end while

end procedure

63

Maintaining Arc Consistency: AC-4 4Time Complexity of AC-4 (Inicialisation)

Analysing the cycles executed in the procedure, i.e.

inicialize_AC-4, for Cij in C do

for vi in dom(Xi) do for vj in dom(Xj) do

and assuming that the number of constraints (arcs) is a, that the variables have all d values in their domains, the inner cycle of the procedure is executed 2ad2 times, which sets the time complexity of the initialisation phase of AC-4 to

O(ad2).

64

Maintaining Arc Consistency: AC-4Time Complexity of AC-4 (Propagation)

In the inner cycle of the propagation procedure a counter for pair Xj-vj is decremented

c(vj,Xj,Xi) <- c(vj,Xj,Xi) - 1;

Since there are 2a arcs and each variable has d values in its domain, there are 2ad counters. Each counter is initialise at most to d, as each pair Xj-vj may only have d supporting values in the domain of another variable Xi.

Hence, the inner cycle is executed at most 2ad2

times, which determines the time complexity of the propagation phase of AC-4 to be

O(ad2)

65

Maintaining Arc Consistency: AC-4Time Complexity of AC-4 (Propagation)

Therefore, the global time complexity of AC-4 is

O(ad2)

not only in the beginning (inicialisation + propagation) but also on its subsequent use after each enumeration (propagation alone).

This assymptotic worst-case complexity is better then that of algorithm AC-3, O(ad3).

Unfortunatelly, this improvement on the time complexity of AC-4 is obtained with a much less favourable space complexity than that of AC-3.

66

Maintaining Arc Consistency: AC-4Space Complexity of AC-4 (Propagation)

As a whole algorithm AC-4 maintainsCounters: As discussed, a total of 2adSuporting Sets: In the worst case, for each

constraint Rij, each of the d Xi-vi pairs supports d values vj from Xj (and vice-versa). The space to maintain the supporting sets is thus O(ad2).

List: Contains at most 2a arcsMatrix M: Maintains nd Boolean values.

The space required to maintain the supporting sets dominates. Compared with AC-3, with space complexity O(a), AC-4 has the much worse space complexity of

O(ad2)

67

Maintaining Arc Consistency: AC-4Is AC-4 an optimal algorithm?

The assymptotic complexity of AC-4, cannot be improved by any algorithm! In fact, to check an arc consistent problem it is necessary to test, for each constraint Cij, that the d2 pairs Xi-vi and Xj-vj satisfy Cij, and so ad2 tests are required, which is the assymptotic complexity of AC-4.

However, one should bear in mind that the worst case complexity is assymptotic. For “small” values of the parameters, the constants involved may have a non negligeable effect.

Moreover, in typical cases, most of the data structures used might be unnecessary. In practice (typically) AC-3 is more efficient than AC-4!

68

Maintaining Arc Consistency: AC-4Pitfalls of AC-4

Despite its assymptotical optimality, AC-4 presents a bad typical complexity. Its data structures, namely the counters that enable improving the support detection arer too demanding.

Also the initialisation of these structures is too heavy, namely when the domians have large cardinality, d.

The space required by AC-4 is also problematic, specially when the constraints are represented by intension, rather than by extension (in this case, the space required to represent the constraints is of the same order of magnitude...).

Documents

Finite Domains