# PowerPoint Presentation

Document Sample

```					Constraint Satisfaction
Problems
Contents

 Representations
 Solving with Tree Search and Heuristics
 Constraint Propagation
 Tree Clustering
Posing a CSP
 A set of variables V1, …, Vn
 A domain over each variable D1,…,Dn
 A set of constraint relations C1,…,Cm
between variables which indicate permitted
combinations

   Goal is to find an assignment to each
variable such than none of the constraints
are violated
Constraint Graphs
 Nodes = variables
 Edges = constraints

   Example: map coloring

A                       A
B
B       C
C
D              D
N-ary Constraint Graphs
   Example:
– Variables: X=[1,2] Y=[3,4] Z=[5,6]
– Constraints: X + Y = Z

X                             X

Y                 Z          Y                Z

Hyper graph            Primal constraint graph

(Roman Barták, 1998 )
Making a Binary CSP
   Can convert n-ary constraint C into a unary
constraint on new variable Vc
– Dc = cartesian product of vars in C

   Can convert n-ary CSP into a binary CSP
– Create var Vc for each constraint C (as above)
– Domain Dc = cartesian product – tuples that violate C
– Add binary equivalence constraints between new
variables Vc, Vc’:C,C’ share var X  Vc,Vc’ must agree
on X
Making a Unary Constraint
 Variables: X=[1,2] Y=[3,4] Z=[5,6]
 Constraints: X + Y = Z

X

XYZ

Y            Z        XYZ= [(1,3,5),(1,3,6),
(1,4,5),(1,4,6),
(2,3,5),(2,3,6)
(2,4,5),(2,4,6)]

(Roman Barták, 1998 )
Making a Unary Constraint
 Variables: X=[1,2] Y=[3,4] Z=[5,6]
 Constraints: X + Y = Z

X

XYZ

Y            Z        XYZ= [(1,4,5),
(2,3,5),
(2,4,6)]

(Roman Barták, 1998 )
Making a Binary CSP
 Variables: X=[1,2] Y=[3,4] Z=[5,6] W=[1,3]
 Constraints: X + Y = Z, W<Y

X
XYZ

Y
Y         Z
WY

Dual constraint graph
W
(Roman Barták, 1998 )
Making a Binary CSP
 Variables: X=[1,2] Y=[3,4] Z=[5,6] W=[1,3]
 Constraints: X + Y = Z, W<Y

X
XYZ

Y
Y         Z
WY

Dual constraint graph
W
(Roman Barták, 1998 )
Contents

 Representations
 Solving with Tree Search and Heuristics
 Constraint Propagation
 Tree Clustering
Generate and Test
   Generate each possible assignment to the
variables and test if constraints are satisfied
– Exponential possibilities: O(d n)
– Simple but extremely wasteful!
DFS and Backtracking
   Depth first search
– Levels represent variables
– Branches off nodes represent a possible instantiations
of variables

   Test against constraints after every variable
instantiation and backtrack if violation
– Incrementally attempts to extend partial solution
– Whole subtrees eliminated at once
Example
V1
red green blue

V2                  V3
red                 red green

(*,*,*)
Example
V1
red green blue

V2                     V3
red                    red green

(*,*,*)

(r,*,*)
Example
V1
red green blue

V2                     V3
red                    red green

(*,*,*)

(r,*,*)

(r,r,*)
Example
V1
red green blue

V2                     V3
red                    red green

(*,*,*)

(r,*,*)      (g,*,*)

(r,r,*)      (g,r,*)
Example
V1
red green blue

V2                          V3
red                         red green

(*,*,*)

(r,*,*)      (g,*,*)

(r,r,*)      (g,r,*)

(g,r,r) (g,r,g)
Example
V1
red green blue

V2                        V3
red                       red green

(*,*,*)

(r,*,*)      (g,*,*)        (b,*,*)

(r,r,*)      (g,r,*)        (b,r,*)

(g,r,r) (g,r,g) (b,r,r) (b,r,g)
Forward Checking
   Backtracking is still wasteful
– A lot of time is spent searching in areas where no
solution remains
– Ex. setting V4 to value X1 eliminates all possible values
for V8 under the given constraints
– Can cause thrashing

   Forward checking removes restricted values from
the domains of all uninstantiated variables
– If a domain becomes empty backtracking is done
immediately
Heuristics
   The search can usually be sped up by searching
intelligently:
– Most-constrained variable: Expand subtree of
variables that have the fewest possible values within
their domain first
– Most-constraining variable: Expand subtree of
variables which most restrict others first
– Least-constraining value: Choose values that allow
the most options for the remaining variables first
Contents

 Representations
 Solving with Tree Search and Heuristics
 Constraint Propagation
 Tree Clustering
Constraint Propagation

   A preprocessing step to shrink the CSP
– Constraints are used to gradually narrow down the
possible values from the domains of the variables

   A singleton may result
– If the domains of each variable contain a single value
we do not need to search
Arc Consistency
   Arc (Vi,Vj) in a constraint graph is arc
consistent if for every value of Vi there is
some value that is permitted for Vj

   Algorithm:
do
foreach edge (i,j)
delete values from Di that cause Arc(Vi,Vj) to fail
while deletions

   Complexity O(ed3)
Example

V1
green

V2                     V3
red green blue             green blue

Consider edge (1,3)
Example

V1
green

V2                     V3
red green blue             green blue

Consider edge (3,1)
Example

V1
green

V2                     V3
red green blue             green blue

Consider edge (2,1)
Example

V1
green

V2                     V3
red green blue             green blue

Consider edge (2,3)
Example

V1
green

V2                         V3
red green blue                 green blue

Consistent and a singleton!
Levels of Consistency
   Algorithms we have seen before are
combinations of tree search and arc
consistency:
Generate and Test       TS
Backtracking            BT = TS + AC 1/5
Forward Checking        FC = TS + AC 1/4
Partial Lookahead       PL = FC + AC 1/3
Full Lookahead          FL = FC + AC 1/2
Really Full Lookahead   RFL = FC + AC

Backtracking
   Given:
– check(i,Xi,j,Xj): true if Vi = Xi and Vj = Xj is
permitted by constraints
– revise(i,j): true if Di is empty after making
Arc(Vi,Vj) = true
function BT(i,var)                      function BT(i)
for(var[i]=Di)                          EMPTY_DOMAIN = check_backward(i)
CONSISTENT = true                      if ~EMPTY_DOMAIN
for(j=1:i-1)                            for(var[i]=Di)
CONISITENT = check(i,var[i],j,var[j])   Di = var[i]
end                                      if i==n
disp(var)
if CONSISTENT                            else
if i==n                                  BT(i+1)
disp(var)                            end
else
BT(i+1,var)                         function check_backward(i)
end                                     for(j=1:i-1)
if revise(i,j) return true
end
return false
Forward Checking
function FC(i)
EMPTY_DOMAIN = check_forward(i)
if ~EMPTY_DOMAIN
for(var[i]=Di)
Di = var[i]
if i==n
disp(var)
else
FC(i+1)
end

function check_forward(i)
if i>1
for(j=i:n)
if revise(j,i-1) return true
end
return false

   Similar to backtracking except more arc-
consistency
Levels of Consistency

Generate and Test       TS
Backtracking            BT = TS + AC 1/5
Forward Checking        FC = TS + AC 1/4
Partial Lookahead       PL = FC + AC 1/3
Full Lookahead          FL = FC + AC 1/2
Really Full Lookahead   RFL = FC + AC

A Stronger Degree of Consistency
   A graph is K-consistent if we can choose values
for any K-1 variables that satisfy all the
constraints, then for any Kth variable be able to
assign it a value that satisfies the constraints

   A graph is strongly K-consistent if J-consistent
for all J < K
– Node consistency is equivalent to strong 1-consistency
– Arc consistency is equivalent to strong 2-consistency
Towards Backtrack Free
Search
   A graph that has strong n-consistency
requires no search
– Acquiring strong n-consistency is exponential
in the number of variables (Cooper, 1989)

   For a general graph that is strongly k-
consistent (where k < n) backtracking
cannot be avoided
Example
V1
red green

V2                       V3
red green                  green blue

(*,*,*)

(r,*,*)

(r,r,*)         …

Arc consistent, yet a search will backtrack!
Constraint Graph Width
V1    V1    V2   V2    V3    V3
V1
V2    V3    V1   V3    V1    V2
V2        V3
V3    V2    V3   V1    V2    V1
1     1     1    2     1        2  1
    The nodes of a constraint graph can be ordered
 The width of a node in an ordered graph is equal
to the number of incoming arcs from higher up
nodes
 The width of an ordered graph is the max width of
its vertices
 The width of a constraint graph is the min width of
each of its orderings
Backtrack Free Search
   Theorem: If a constraint graph is strongly K-
consistent, and K is greater than its width, then
there exists a search order that is backtrack free

– K>2 consistency algorithms add arcs requiring even
greater consistency
– If a graph has width 1 we can use node and arc
consistency to get strong 2-consistency without adding
arcs
– All tree structured constraint graphs have width 1
(Freuder 1988)
Contents

 Representations
 Solving with Tree Search and Heuristics
 Constraint Propagation
 Tree Clustering
Tree Clustering Motivation
   Tree structured constraint graphs can be solved
without backtracking
– We would like to turn non-tree graphs into trees by
grouping variables
– The grouped variables themselves become smaller
CSP’s
– Solving a CSP is exponential in the worst case so
reducing the number of variables we consider at once is
also important

   If we want the CSP for many queries it is worth
investing more time in restructuring it

(Dechter, 1988)
Redundancy
   Constraints in the dual graph are equalities

 Variables: A, B, C, D, E, F
 Constraints: (ABC), (AEF), (CDE), (ACE)

ABC       A    AEF      ABC            AEF
C
AC             AE E     AC            AE

ACE CE         CDE      ACE CE         CDE

Join graph/tree
Tree Clustering
   If the dual graph cannot be reduced to a join tree
we can still make it acyclic:

– Condition for acyclicity: A CSP is acyclic iff its primal
graph is chordal and conformal

   Given a primal graph its dual can be made acyclic:
– Triangulate graph to make it chordal
– The maximal cliques are constraints/nodes in the new
dual graph

(Beeri, 1983)
Triangulation

   Use maximum cardinality search (m-ordering) to
order the nodes

that are connected by nodes higher in the ordering

(Tarjan, 1984)
The Algorithm

   Build the primal graph for the CSP
– O(n2)
   Triangulate
– O(n2)
   Use maximal cliques as new nodes in dual graph
– O(n)
   Remove any redundancies in the new graph
– O(n)
Example
 Variables: A, B, C, D, E
 Constraints: (A,C), (A,D), (B,D), (C,E), (D,E)

BD                        BD
D        D                D        D

A                  E      A                   E

AC        C         CE   AC         C          CE

Still cyclic!
Example
 Variables: A, B, C, D, E
 Constraints: (A,C), (A,D), (B,D), (C,E), (D,E)

B

E                A                 E
C       D                          C       D
C
A       B                          A       B
D

E

Order: E, D, C, A, B
Example
 Variables: A, B, C, D, E
 Constraints: (A,C), (A,D), (B,D), (C,E), (D,E)

E                 BD                 BD
C       D         D        D         D
ACD        CDE    ACD         CDE
A       B         CD                 CD

Acyclic!
Solving the CSP
   Solve each node of the tree as a separate small
CSP
– This can be done in parallel
– The solutions to each node constitute the domain of that
node in the tree
– O(d m)
 Use arc consistency to reduce the domains of each
node
 Solve the entire CSP without backtracking
Appendix
Example CSP’s

 N-queens
 Map coloring
 Cryptoarithmatic

 Wireless network base station placement
 Object recognition from image features
Heuristic Repair

choose a variable and reassign it so that fewest
constraints are violated

   Repeat this some number of times, if constraints
instantiation

   Similar to GSAT
Graham’s Algorithm
   Given a dual constraint graph
– If Vi is a variable that appears in exactly one node then
remove Vi
– If the variables in Ni are a subset of variables in another
node Nj then remove Ni
 Repeat until neither applies
 Graph is acyclic if the result is the empty set
 Easy to verify

(Graham, 1979)
Graham’s Algorithm
   Trees collapse to empty set
–    Edges in dual graph are constraints on common vars
–    Nodes in a tree share vars only with their parents
–    Step 1 removes any unique vars from the children
–    After step 1 the children are removed by step 2 since
they are now subsets of the parent

ab                      ab
ab           []

ag               bd        a             b

Step-1           Step-2        Step-1
Graham’s Algorithm
   Cycles don’t collapse
– Step 1 will fail since cycles are created among nodes
with vars that are shared among multiple nodes
– Step 2 must fail since if any node was a subset of
another it would have to share all of its variables with at
least one other node

ag

ab

bg
Graham’s Algorithm  Primal
Graph is Chordal
   Assume Graham’s algorithm succeeds
– Step 1 must have removed every node of the
primal graph
– Assume there was a chordless cycle
Let z be a node on the cycle that is first eliminated
Let x, y be nodes on the cycle adjacent to z

For step 1 to apply z must have belonged to only one
constraint (which are cliques/hyperedges)
With z gone the constraint is left with x and y

Thus x and y are connected  contradiction!
Why m-ordering?
   We want an ordering that will not add any edges
to chordal graphs

   Property P (for zero fill-in):
–   If u < v < w
–   If (u,w) is an edge
–   If (v,w) is not an edge
–   Then exists vertex x             w
   v<x
   (v, x) is an edge       v       u
   (w, x) is not an edge

x
Proof of Property P
   Assumptions
– Given chordal graph G
– Given an ordering a with Property P
   Define property Q:
– Let V0, V1, …, Vk be an unchorded path for which a(Vk)
is maximum
– Vk > … > Vi+1 > Vi < … < V2 < V1 < Vk < V0
– Not possible!
…
w     - order: u < v < w
- if no edge (v,w) then
…    v
v, u, w satisfies property Q
u
…
M-ordering Satisfies P

   Suppose u < v < w

w

v        u

x

```
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
 views: 2 posted: 11/8/2012 language: English pages: 58
How are you planning on using Docstoc?