Constraint Propagation

influenced by Dr. Rina Dechter, “Constraint Processing”

why propagate constraints? tightens networks leaves fewer choices for search by

eliminating dead endsBUT propagating can be costly in resources tradeoff between constraint propagation and

search “bounded constraint propagation algorithms”

how constraints improve search used in partial solution searches

where the start state is root of search tree

(no variables have assigned values) at any level of tree, some variables are

assigned, some are not constraints reduce choice for next variable

assigned

how constraints improve search

-

v1

v2

v3

v4

choosing v4

satisfy constraints on scopes containing v4 with v1, v2, v3

example - red/green graph

redgreen

redgreen

redgreen

v1

v2 v3

-

v1

v2

v3

arc-consistency local consistency property

involves binary constraint and its two variables

any value in the domain of one variable can be extended by a value of the other variable consistent with the constraint

arc-consistency example

x1, D1 = {1,2,4} {1,2}

x2, D2 = {1,2,4} {2,4}

C12: {(x1,x2) | x1 < x2 } = {(1,2),(1,4),(2,4)}x1

124

x2

124

x1

12.

x2

.24

arc-inconsistent arc-consistent

enforcing arc-consistency reduces domains

algorithm to make xi arc-consistent w.r.t. xj

Revise(Di) w.r.t. Cij on Sij={xi,xj}for each ai Di

if no aj Dj such that (ai,aj) Cij

delete ai from Di

performance O(k2) in domain size

reducing search spaces apply arc-consistency to all constraints in

problem space removes infeasible solutions focuses search

arc consistency may be applied repeatedly to same constraints

interaction of constraints: example

x1, D1 = {1,2,4}

C12: {x1 = x2}

x2, D2 = {1,2,4}

C23: {x2 = x3}

x3, D2 = {1,2,4}

C31: {x1 = 2*x3}

x1

124

x2

124

x3

124

AC-3 arc-consistency algorithmproblem: R =(X,D,C)AC-3(R)q = new Queue()for every constraint Cij C

q.add((xi,xj)); q.add((xj,xi));while !q.empty()

(xi,xj) = q.get();Revise(Di) wrt Cijif(Di changed)for all k ≠i or jq.add( (xk,xi)

performance O(c.k3) c binary constraints, k domain size

arc-consistency automated version of problem-solving

activity by people - propagating constraints

loopholes in arc-consistency

x1, D1 = {1,2}

C12: {x1 ≠ x2}

x2, D2 = {1,2}

C23: {x2 ≠ x3}

x3, D2 = {1,2}

C31: {x1 ≠ x3}

x1

12

x2

12

x2

12

≠ ≠

≠

stronger constraint checking path-consistency extends arc-consistency

to three variables at once (tightening) global constraints -specialized consistency

for set of variables e.g., alldifferent(x1, …, xm) - equivalent of

permutation set who owns the zebra? problem

fixed sum, cumulative maximum

constraints in partial solution search space

example problem:V = {x,y,l,z},D = {Dx, Dy, Dl, Dz}

Dx={2,3,4}, Dy={2,3,4}, Dl={2,5,6}, Dz={2,3,5}

C = {Czx, Czy, Czl}: z must divide other variables

2,3,4y

2,5,6l

2,3,4x

2,3,5z

reducing search space size

1. variable ordering2. arc-consistency (or path-consistency, etc)

i. pre-search check to reduce domainsii. during search check for consistency with

values already assigned

reducing space size1. variable ordering

reducing space size

2. arc-consistency

reducing space size2. path-consistency (tightening)

• Cxl, Cxy, Cyl (slashed subtrees)

dfs with constraints - detail

extending a partial solution

xk-1

xk

xk+1

4

2

?

D`k+1 = {1,2,3,4}

SELECT-VALUE(D`k+1)

while (! D`k+1 .empty())

a = D`k+1 .pop()

if (CONSISTENT(xk+1=a)) return areturn null // dead end

dfs algorithm with constraints dfs(X,D,C) returns consistent solutioni=1, D`i = Di

while (1≤ i ≤ n) // n=|X| xi = SELECT-VALUE(D`i) if(xi == null) // dead end i-- // backtrack else i++ D`i = Di

if (i==0) return “no solution”return (x1, x2, …, xn)

improving search performance changing the resource balance between

constraint propagation and search

do more pruning by consistency checking many strategies e.g., look-ahead algorithms

look-aheadconsistency

SELECT-FORWARD(D`k+1)while (!D`k+1.empty()) a = D`k+1 .pop() if (CONSISTENT(xk+1=a)) for (i; k+1 < i ≤ n) for all bD`i

if(!CONSISTENT(xi=b)) remove b from D`i

if(D`i.empty()) // xk+1=a is dead end reset all D`j, j>k+1 else return areturn null

SELECT-VALUE(D`k+1)

while (!D`k+1.empty())

a = D`k+1 .pop()

if (CONSISTENT(xk+1=a)) return areturn null

optimization algorithms same strategies can be used in other

search algorithms greedy, etc

example problem - sudoku