1. Game Search & Constrained Search
CMSC 25000
Artificial Intelligence
January 20, 2004

2. Roadmap I Searching for the right move Review adversial search
Optimal Alpha-beta
State-of-the-art: Specialized techniques
Dealing with chance

3. Optimal Alpha-Beta Ordering1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

4. Optimal Ordering Alpha-Beta
Significant reduction of work:
11 of 27 static evaluations
Lower bound on # of static evaluations:
if d is even, s = 2*b^d/2-1
if d is odd, s = b^(d+1)/2+b^(d-1)/2-1
Upper bound on # of static evaluations:
b^d
Reality: somewhere between the two
Typically closer to best than worst

5. Heuristic Game Search Handling time pressure Progressive deepening
Focus search
Be reasonably sure “best” option found is likely to be a good option.
Progressive deepening
Always having a good move ready
Singular extensions
Follow out stand-out moves

6. Singular Extensions
Problem: Explore to some depth, but things change a lot in next ply
False sense of security
aka “horizon effect”
Solution: “Singular extensions”
If static value stands out, follow it out
Typically, “forced” moves:
E.g. follow out captures

7. Additional Pruning Heuristics
Tapered search:
Keep more branches for higher ranked children
Rank nodes cheaply
Rule out moves that look bad
Problem:
Heuristic: May be misleading
Could miss good moves

8. Due to Russell and Norvig
Deterministic Games
Due to Russell and Norvig

9. Games with Chance Many games mix chance and strategy
E.g. Backgammon
Combine dice rolls + opponent moves
Modeling chance in game tree
For each ply, add another ply of “chance nodes”
Represent alternative rolls of dice
One branch per roll
Associate probability of roll with branch

10. Expectiminimax:Minimax+Chance
Adding chance to minimax
For each roll, compute max/min as before
Computing values at chance nodes
Calculate EXPECTED value
Sum of branches
Weight by probability of branch

11. Expecti… Tree

12. Summary Game search: Minimax search: Models adversarial game
Key features: Alternating, adversarial moves
Minimax search: Models adversarial game
Alpha-beta pruning:
If a branch is bad, don’t need to see how bad!
Exclude branch once know can’t change value
Can significantly reduce number of evaluations
Heuristics: Search under pressure
Progressive deepening; Singular extensions

13. Constraint Propagation
Artificial Intelligence
CMSC 25000
January 20, 2004

14. Agenda Constraint Propagation: Motivation
Constraint Propagation Example
Waltz line labeling
Constraint Propagation Mechanisms
Arc consistency
CSP as search
Forward-checking
Back-jumping
Summary

15. Leveraging Representation
General search problems encode task-specific knowledge
Successor states, goal tests, state structure
“black box” wrt to search algorithm
Constraint satisfaction fixes representation
Variables, values, constraints
Allows more efficient, structure-specific search

16. Constraint Satisfaction Problems
Very general: Model wide range of tasks
Key components:
Variables: Take on a value
Domains: Values that can be assigned to vars
Constraints: Restrictions on assignments
Constraints are HARD
Not preferences: Must be observed
E.g. Can’t schedule two classes: same room, same time

17. Constraint Satisfaction Problem
Graph/Map Coloring: Label a graph such that no two adjacent vertexes same color
Variables: Vertexes
Domain: Colors
Constraints: If E(a,b), then C(a) != C(b)

18. Constraint Satisfaction Problems
Resource Allocation:
Scheduling: N classes over M terms, 4 classes/term
Aircraft at airport gates
Satisfiability: e.g. 3-SAT
Assignments of truth values to variables such that 1) consistent and 2) clauses true

19. Constraint Satisfaction Problem
“N-Queens”:
Place N queens on an NxN chessboard such that none attacks another
Variables: Queens (1/column)
Domain: Rows
Constraints: Not same row, column, or diagonal

20. N-queens Q3 Q1 Q4 Q2

21. Constraint Satisfaction Problem
Range of tasks:
Coloring, Resource Allocation, Satisfiability
Varying complexity: E.g. 3-SAT NP-complete
Complexity: Property of problem NOT CSP
Basic Structure:
Variables: Graph nodes, Classes, Boolean vars
Domains: Colors, Time slots, Truth values
Constraints: No two adjacent nodes with same color,
No two classes in same time, consistent, satisfying ass’t

22. Problem Characteristics
Values:
Finite? Infinite? Real?
Discrete vs Continuous
Constraints
Unary? Binary? N-ary?
Note: all higher order constraints can be reduced to binary

23. Representational Advantages
Simple goal test:
Complete, consistent assignment
Complete: All variables have a value
Consistent: No constraints violates
Maximum depth?
Number of variables
Search order?
Commutative, reduces branching
Strategy: Assign value to one variable at a time

24. Constraint Satisfaction Questions
Can we rule out possible search paths based on current values and constraints?
How should we pick the next variable to assign?
Which value should we assign next?
Can we exploit problem structure for efficiency?

25. Constraint Propagation Method
For each variable,
Get all values for that variable
Remove all values that conflict with ALL adjacent
A:For each neighbor, remove all values that conflict with ALL adjacent
Repeat A as long as some label set is reduced

26. Constraint Propagation Example
Image interpretation:
From a 2-D line drawing, automatically determine for each line, if it forms a concave, convex or boundary surface
Segment image into objects
Simplifying assumptions:
World of polyhedra
No shadows, no cracks

27. CSP Example: Line Labeling
3 Line Labels:
Boundary line: regions do not abut: >
Arrow direction: right hand side walk
Interior line: regions do abut
Concave edge line: _
Convex edge line : +
Junction labels:
Where line labels meet

28. CSP Example: Line Labeling
Simplifying (initial) restrictions:
No shadows, cracks
Three-faced vertexes
General position:
small changes in view-> no change in junction type
4^2 labels for 2 line junction: L
4^3; 3-line junction : Fork, Arrow, T
Total: 208 junction labelings

29. CSP Example: Line Labeling
Key observation: Not all 208 realizable
How many? 18 physically realizable
All Junctions
L junctions Fork Junctions T junctions Arrow junctions + + _ + _ + _ + _ + + + _ _ _ _ + _ _ _ _ +

30. CSP Example: Line Labeling
Label boundaries clockwise
Label arrow junctions + + +

31. CSP Example: Line Labeling
Label boundaries clockwise

32. CSP Example: Line Labeling
Label fork junctions with +’s + + + + + + + + + + + + + + +

33. CSP Example: Line Labeling
Label arrow junctions with -’s + + + _ + + _ + + + _ _ _ + _ _ + + + _ + + _ + + + +

34. Waltz’s Line Labeling For each junction in image,
Get all labels for that junction type
Remove all labels that conflict with ALL adjacent
A:For each neighbor, remove all labels that conflict with ALL
Repeat A as long as some label set is reduced

35. Waltz Propagation Example+ + C D + _ X B X _ + A X

36. Waltz’s Line Labeling Full version: Physically realizable junctions
Removes constraints on images
Adds special shadow and crack labels
Includes all possible junctions
Not just 3 face
Physically realizable junctions
Still small percentage of all junction labels
O(n) : n = # lines in drawing

37. Constraint Propagation Mechanism
Arc consistency
Arc V1->V2 is arc consistent if for all x in D1, there exists y in D2 such that (x,y) is allowed
Delete disallowed x’s to achieve arc consistency

38. Arc Consistency Example
Graph Coloring:
Variables: Nodes
Domain: Colors (R,G,B)
Constraint: If E(a,b), then C(a) != C(b)
Initial assignments
R,G,B X
R,B B Y Z

39. Arc Consistency Example
Arc Rm Value
Assignments:
X = G
Y = R
Z = B
X -> Y None
X -> Z X=B
======>
Y-> Z Y=B
X -> Y X=R
X -> Z None
Y -> Z None
R,G,B X
R,B B Y Z

40. Limitations of Arc Consistency
Arc consistent:
No legal assignment
>1 legal assignment
G,B X
G,B
G,B Y Z
R,G X
G,B
G,B Y Z

41. CSP as Search
Constraint Satisfaction Problem (CSP) is a restricted class of search problem
State: Set of variables & assignment info
Initial State: No variables assigned
Goal state: Set of assignments consistent with constraints
Operators: Assignment of value to variable

42. CSP as Search Depth: Number of Variables Branching Factor: |Domain|
Leaves: Complete Assignments
Blind search strategy:
Bounded depth -> Depth-first strategy
Backtracking:
Recover from dead ends
Find satisfying assignment

43. CSP as Search X=R X=G X=B Y=R Y=B Y=R Y=B Y=R Y=B No! No! Z=B Z=R Z=B
Yes!
No!
No!
Yes!
No!
No!

44. Backtracking Issues CSP as Search Depth-first search
Maximum depth = # of variables
Continue until (partial/complete) assignment
Consistent: return result
Violates constraint -> backtrack to previous assignment
Wasted effort
Explore branches with no possible legal assignment

45. Backtracking with Forward Checking
Augment DFS with backtracking
Add some constraint propagation
Propagate constraints
Remove assignments which violate constraint
Only propagate when domain = 1
“Forward checking”
Limit constraints to test

46. Backtracking+Forward Checking
X=R
X=G
X=B
Y=B
Y=R
Y=B
Y=R
Z=B
Z=R
No!
No!
Yes!
Yes!

47. Heuristic CSP Improving Backtracking Standard backtracking
Back up to last assignment
Back-jumping
Back up to last assignment that reduced current domain
Change assignment that led to dead end

48. Heuristic backtracking: Back-jumping

49. Heuristic Backtracking: Backjumping

50. Heuristic Backtracking: Backjumping
Dead end! Why? C5

51. Back-jumping Previous assignment reduced domain
C3 = B
Changes to intermediate assignment can’t affect dead end
Backtrack up to C3
Avoid wasted work - alternatives at C4
In general, forward checking more effective

52. Heuristic CSP: Dynamic Ordering
Question: What to explore next
Current solution:
Static: Next in fixed order
Lexicographic, leftmost..
Random
Alternative solution:
Dynamic: Select “best” in current state

53. Dynamic Ordering Heuristic CSP
Most constrained variable:
Pick variable with smallest current domain
Least constraining value:
Pick value that removes fewest values from domains of other variables
Improve chance of finding SOME assignment
Can increase feasible size of CSP problem

54. Dynamic Ordering C1 C3 C5 C2 C4

55. Dynamic Ordering with FC

56. Incremental Repair Start with initial complete assignment
Use greedy approach
Probably invalid - I.e. violates some constraints
Incrementally convert to valid solution
Use heuristic to replace value that violates
“min-conflict” strategy:
Change value to result in fewest constraint violations
Break ties randomly
Incorporate in local or backtracking hill-climber

57. Incremental Repair Q2 Q4 5 conflicts Q1 Q3 Q1 Q2 Q3 Q4 Q1 Q2 Q3 Q4

58. Min-Conflict Effectiveness
N-queens: Given initial random assignment, can solve in ~ O(n)
For n < 10^7
GSAT (satisfiability)
Best (near linear in practice) solution uses min-conflict-type hill-climbing strategy
Adds randomization to escape local min
~Linear seems true for most CSPs
Except for some range of ratios of constraints to variables
Avoids storage of assignment history (for BT)

59. CSP Complexity Worst-case in general: Tree-structured CSPs
Depth-first search:
Depth= # of variables
Branching factor: |Domain|
|D|^n+1
Tree-structured CSPs
No loops in constraint graph
O(n|D|^2)

60. Tree-structured CSPs C1 C5 C2 C4 C3 C6 Constraint Graph
Create breadth-first ordering
Starting from leaf nodes [O(n)],
remove all values from parent domain that do not participate in some valid pairwise constraint [O(|D|^2)]
Starting from root node, assign value to variable

61. Iterative Improvement
Alternate formulation of CSP
Rather than DFS through partial assignments
Start with some complete, valid assignment
Search for optimal assignment wrt some criterion
Example: Traveling Salesman Problem
Minimum length tour through cities, visiting each one once

62. Iterative Improvement Example
TSP
Start with some valid tour
E.g. find greedy solution
Make incremental change to tour
E.g. hill-climbing - take change that produces greatest improvement
Problem: Local minima
Solution: Randomize to search other parts of space
Other methods: Simulated annealing, Genetic alg’s