CPS 170: Artificial Intelligence

http://www.cs.duke.edu/courses/spring09/cps170/

More search:
When the path to the solution
doesn’t matter

Instructor: Vincent Conitzer

Search where the path doesn’t matter
• So far, looked at problems where the path was the
solution
– Traveling on a graph
– Eights puzzle

• However, in many problems, we just want to find a

goal state
– Doesn’t matter how we get there
 Queens puzzle
• Place eight queens on a chessboard so that no
two attack each other

Q
Q
Q
Q
Q
Q
Q
Q
 Search formulation of the queens puzzle
• Successors: all valid ways of placing additional queen on
the board; goal: eight queens placed
Q

Q
How big is this tree?
Q
How many leaves?
What if they were rooks?
Q

Q Q Q Q Q

Q Q Q Q Q

Q Q Q Q Q

Q Q

Q Q Q Q Q

Q Q

Q Q Q Q Q
Search formulation of the queens puzzle
• Successors: all valid ways of placing a queen in the next
column; goal: eight queens placed
Q

Q Search tree size?

What if they were rooks?
What kind of search is best?
Q Q
Q Q
Q Q
Q

Q Q

Q
Q Q
Constraint satisfaction problems (CSPs)
• Defined by:
– A set of variables x1, x2, …, xn
– A domain Di for each variable xi
– Constraints c1, c2, …, cm
• A constraint is specified by
– A subset (often, two) of the variables
– All the allowable joint assignments to those variables
• Goal: find a complete, consistent assignment
• Queens problem: (other examples in next slides)
– xi in {1, …, 8} indicates in which row in the ith column to
place a queen
– For example, constraint on x1 and x2: {(1,3), (1,4), (1,5),
(1,6), (1,7), (1,8), (2,4), (2,5), …, (3,1), (3,5), … …}
 Meeting scheduling
• Meetings A, B, C, … need to be scheduled
on M, Tu, W, Th, F
• A and B cannot be scheduled on the same
day
• B needs to be scheduled at least two days
before C
• C cannot be scheduled on Th or F
• Etc.
• How do we model this as a CSP?
 Graph coloring
• Fixed number of colors; no two adjacent
nodes can share a color
red A

blue B C green

D
red
 Satisfiability
• Formula in conjunctive normal form:
(x1 OR x2 OR NOT(x4)) AND (NOT(x2) OR
NOT(x3)) AND …
– Label each variable xj as true or false so that
the formula becomes true

Constraint hypergraph:
X1 X2
each hyperedge
represents a constraint
X3 X4
 Cryptarithmetic puzzles

TWO
TWO+
FOUR
E.g., setting F = 1, O = 4, R = 8, T = 7, W = 3,
U = 6 gives 734+734=1468
 Cryptarithmetic puzzles…
TWO Trick: introduce auxiliary
variables X, Y
TWO+
O + O = 10X + R
FOUR
W + W + X = 10Y + U
T + T + Y = 10F + O
also need pairwise
constraints between
O R W U T F original variables if they
are supposed to be
different

X Y What would the search

tree look like?
 Generic approaches to solving CSPs
• State: some variables assigned, others not
assigned
• Naïve successors definition: any way of assigning
a value to an unassigned variable results in a
successor
– Can check for consistency when expanding
– How many leaves do we get in the worst case?
• CSPs satisfy commutativity: order in which actions
applied does not matter
• Better idea: only consider assignments for a single
variable at a time
– How many leaves?
 Choice of variable to branch on is still flexible!
• Do not always need to choose same variable at same level
• Each of variables A, B, C takes values in {0,1}
A=?,B=?,C=?

A=0,B=?,C=? A=1,B=?,C=?

A=0,B=0,C=? A=1,B=?, A=1,B=?,

A=0,B=1,
C=0 C=1
C=?

000 001 010 011 100 110 101 111

Can you prove that this never increases the number of leaves?
 A generic recursive search algorithm
(assignment is a partial assignment)
• Search(assignment, constraints)
• If assignment is complete, return it
• Choose an unassigned variable x
• For every value v in x’s domain, if setting x to v in
assignment does not violate constraints:
– Set x to v in assignment
– result := Search(assignment, constraints)
– If result != failure return result
– Unassign x in assignment
• Return failure
 Keeping track of remaining possible values
• For every variable, keep track of which values are still
possible
Q X X X Q X X Q

Q X X X Q X X Q

Q X X X Q X X Q

X X Q

Q X X X Q X X Q

X X X X Q Q

X X Q

Q X X X Q X X Q

only one possibility now only one left for done!

for last column; might other two columns (no real branching
as well fill in needed!)

• General heuristic: branch on variable with fewest values

remaining
 Arc consistency
• Take two variables connected by a constraint
• Is it true that for every remaining value d of the first
variable, there exists some value d’ of the other variable so
that the constraint is satisfied?
– If so, we say the arc from the first to the second variable is
consistent
– If not, can remove the value d
• General concept: constraint propagation
Q X X

Q X X Consider
X
cryptarithmetic
X Q X

X puzzle again…
Is the arc from the fifth to the eighth column consistent?
What about the arc from the eighth to the fifth?
 An example where arc
consistency fails
A
(A, B) in {(0,0), (1,1)} (A, C) in {(0,1), (1,0)}

B C
(B, C) in {(0,0), (1,1)}

• A = B, B = C, C ≠ A – obviously inconsistent
– ~ Moebius band

• However, arc consistency cannot eliminate

anything
 Tree-structured constraint graphs
• Suppose we only have pairwise constraints and
the graph is a tree (or forest = multiple disjoint trees)
X1

X2 X3 X4

X5 X7 X6
• Dynamic program for solving this (linear in #variables):
– Starting from the leaves and going up, for each node x, compute all the
values for x such that the subtree rooted at x can be solved
• Equivalently: apply arc consistency from each parent to its children, starting
from the bottom

– If no domain becomes empty, once we reach the top, easy to fill in solution
 Example: graph coloring with limited
set of colors per node
X1 {green, blue, red}

{green, blue, red} X

2
X3 {green, X4 {red}
blue}

{green} X5 X6 X7
{green, blue} {green}

• Stage 1: moving upward, cross out the values that cannot

work with the subtree below that node
• Stage 2: if a value remains at the root, there is a solution:
go downward to pick a solution
 A different approach: optimization
• Let’s say every way of placing 8 queens on a
board, one per column, is feasible
• Now we introduce an objective: minimize the
number of pairs of queens that attack each other
– More generally, minimize the number of violated
constraints

• Pure optimization
 Local search: hill climbing
• Start with a complete state
• Move to successor with best (or at least better) objective value
– Successor: move one queen within its column
Q Q Q

Q Q Q

Q Q Q Q

Q Q Q no more
Q Q Q
improvements
Q Q Q

Q Q

Q Q Q

4 attacking pairs 3 attacking pairs 2 attacking pairs

• Local search can get stuck in a local optimum

local optimum global optimum (also

a local optimum)
 Avoiding getting stuck with local search
• Random restarts: if your hill-climbing search fails
(or returns a result that may not be optimal),
restart at a random point in the search space
– Not always easy to generate a random state
– Will eventually succeed (why?)

• Simulated annealing:
– Generate a random successor (possibly worse than
current state)
– Move to that successor with some probability that is
sharply decreasing in the badness of the state
– Also, over time, as the “temperature decreases,”
probability of bad moves goes down
 Constraint optimization
• Like a CSP, but with an objective
– Example: no two queens can be in the same row or
column (hard constraint), minimize number of pairs of
queens attacking each other diagonally (objective)

• Can use all our techniques from before: heuristics,

A*, IDA*, …
• Also popular: depth-first branch-and-bound
– Like depth-first search, except do not stop when first
feasible solution found; keep track of best solution so far
– Given admissible heuristic, do not need to explore nodes
that are worse than best solution found so far
 Minimize #violated diagonal constraints
• Cost of a node: #violated diagonal constraints so far
• No heuristic Q

(matter of definition; Q

could just as well say Q

that violated
constraints so far is Q cost = 0
the heuristic and
interior nodes have Q
no cost)

cost = 0 cost = 1 cost = 0

Q Q Q

Q Q Q

Q Q Q

Q Q Q

Q Q Q

Depth first branch and bound will find a A* (=uniform cost here), IDA* Optimal solution is down here
suboptimal solution here first (no way to tell (=iterative lengthening here) will (cost 0)
at this point this is worse than right node) never explore this node
 Linear programs: example
• We make reproductions of
two paintings maximize 3x + 2y
subject to
4x + 2y ≤ 16

• Painting 1 sells for $30, painting 2 x + 2y ≤ 8

sells for $20 x+y≤5
• Painting 1 requires 4 units of blue, 1
green, 1 red x≥0
• Painting 2 requires 2 blue, 2 green, 1
red
y ≥ 0
• We have 16 units blue, 8 green, 5 red
Solving the linear program graphically
maximize 3x + 2y
8
subject to
4x + 2y ≤ 16 6

x + 2y ≤ 8
4 optimal solution:
x+y≤5 x=3, y=2

x≥0 2

y≥0
0 2 4 6 8
 Modified LP
maximize 3x + 2y
Optimal solution: x = 2.5,
subject to y = 2.5
4x + 2y ≤ 15 Solution value = 7.5 + 5 =
x + 2y ≤ 8 12.5
x+y≤5
x≥0 Half paintings?
y≥0
 Integer (linear) program
maximize 3x + 2y
8
subject to
optimal IP
4x + 2y ≤ 15 6 solution: x=2,
y=3
(objective 12)
x + 2y ≤ 8 optimal LP
4
solution: x=2.5,
x+y≤5 y=2.5
(objective 12.5)
2
x ≥ 0, integer
y ≥ 0, integer
0 2 4 6 8
 Mixed integer (linear) program
maximize 3x + 2y
8
subject to
optimal IP
4x + 2y ≤ 15 6 solution: x=2,
y=3
(objective 12)
x + 2y ≤ 8 optimal LP
4 solution: x=2.5,
x+y≤5 y=2.5
(objective 12.5)
2 optimal MIP
x≥0 solution: x=2.75,
y=2
y ≥ 0, integer (objective 12.25)

0 2 4 6 8
 Solving linear/integer programs
• Linear programs can be solved efficiently
– Simplex, ellipsoid, interior point methods…

• (Mixed) integer programs are NP-hard to solve

– Quite easy to model many standard NP-complete
problems as integer programs (try it!)
– Search type algorithms such as branch and bound

• Standard packages for solving these

– GNU Linear Programming Kit, CPLEX, …

• LP relaxation of (M)IP: remove integrality

constraints
– Gives upper bound on MIP (~admissible heuristic)
 Graph coloring as an integer program
A

B C

D
• Let’s say xB,green is 1 if B is colored green, 0 otherwise
• Must have 0 ≤ xB,green ≤ 1, xB,green integer
– shorthand: xB,green in {0,1}
• Constraint that B and C can’t both be green: xB,green + xC,green ≤ 1
• Etc.
• Solving integer programs is at least as hard as graph coloring, hence
NP-hard (we have reduced graph coloring to IP)
 Satisfiability as an integer program
(x1 OR x2 OR NOT(x4)) AND (NOT(x2) OR NOT(x3)) AND
…
becomes
for all xj, 0 ≤ xj ≤ 1, xj integer (shorthand: xj in {0,1})
x1 + x2 + (1-x4) ≥ 1
(1-x2) + (1-x3) ≥ 1
…

Solving integer programs is at least as hard as satisfiability,

hence NP-hard (we have reduced SAT to IP)
Try modeling other NP-hard problems as (M)IP!
 Solving the integer program with DFS branch and bound
maximize 3x + 2y maximize 3x + 2y
trick: for integer x and
maximize 3x + 2y subject to subject to
k, either x ≤ k
subject to 4x + 2y ≤ 15 4x + 2y ≤ 15
or x ≥ k+1 x + 2y ≤ 8 x + 2y ≤ 8
4x + 2y ≤ 15
x + 2y ≤ 8 x+y≤5 x+y≤5
x+y≤5 x≥3 x≥3
x≥3 y≥2 y≤1
LP solution: x≥4
maximize 3x + 2y LP solution: x=3,
infeasible LP solution:
subject to y=1.5, obj = 12
4x + 2y ≤ 15 infeasible
x + 2y ≤ 8 maximize 3x + 2y maximize 3x + 2y
x+y≤5 subject to subject to
maximize 3x + 2y 4x + 2y ≤ 15 4x + 2y ≤ 15
LP solution: x=2.5, subject to x + 2y ≤ 8 x + 2y ≤ 8
y=2.5, obj = 12.5 4x + 2y ≤ 15 x+y≤5 x+y≤5
x + 2y ≤ 8 x≥3 x≥3
x+y≤5 y≤1 y≤1
x≤2 x≤3
LP solution: x=3.25,
LP solution: x=2, y=1, obj = 11.75 LP solution: x=3,
y=3, obj = 12 if LP solution is integral, we are done y=1, obj = 11
 Again with a more fortunate choice
maximize 3x + 2y
subject to
4x + 2y ≤ 15
x + 2y ≤ 8
x+y≤5
x≥3
maximize 3x + 2y LP solution: x=3,
subject to y=1.5, obj = 12
4x + 2y ≤ 15 done!
x + 2y ≤ 8
x+y≤5
maximize 3x + 2y
LP solution: x=2.5, subject to
y=2.5, obj = 12.5 4x + 2y ≤ 15
x + 2y ≤ 8
x+y≤5
x≤2
LP solution: x=2,
y=3, obj = 12