Example: Map-Coloring

Constraint Satisfaction Problems Northern

Territory
Western Queensland
Australia

South
Australia
Chapter 5 New South Wales

Victoria

Tasmania
Variables W A, N T , Q, N SW , V , SA, T
Domains Di = {red, green, blue}
Constraints: adjacent regions must have different colors
e.g., W A 6= N T (if the language allows this), or
(W A, N T ) ∈ {(red, green), (red, blue), (green, red), (green, blue), . . .}
Chapter 5 1 Chapter 5 4

Outline Example: Map-Coloring contd.

♦ CSP examples
♦ Backtracking search for CSPs
♦ Problem structure and problem decomposition Northern
Territory
Western Queensland
♦ Local search for CSPs Australia

South
Australia
New South Wales

Victoria

Tasmania

Solutions are assignments satisfying all constraints, e.g.,

{W A = red, N T = green, Q = red, N SW = green, V = red, SA = blue, T = green}

Chapter 5 2 Chapter 5 5

Constraint satisfaction problems (CSPs) Constraint graph

Standard search problem: Binary CSP: each constraint relates at most two variables
state is a “black box”—any old data structure
Constraint graph: nodes are variables, arcs show constraints
that supports goal test, eval, successor
CSP: NT
state is defined by variables Xi with values from domain Di Q
WA
goal test is a set of constraints specifying
allowable combinations of values for subsets of variables SA NSW

Simple example of a formal representation language V

Victoria

Allows useful general-purpose algorithms with more power

than standard search algorithms T

General-purpose CSP algorithms use the graph structure

to speed up search. E.g., Tasmania is an independent subproblem!
Chapter 5 3 Chapter 5 6
 Varieties of CSPs Real-world CSPs
Discrete variables Assignment problems
finite domains; size d ⇒ O(dn) complete assignments e.g., who teaches what class
♦ e.g., Boolean CSPs, incl. Boolean satisfiability (NP-complete)
infinite domains (integers, strings, etc.) Timetabling problems
♦ e.g., job scheduling, variables are start/end days for each job e.g., which class is offered when and where?
♦ need a constraint language, e.g., StartJob1 + 5 ≤ StartJob3 Hardware configuration
♦ linear constraints solvable, nonlinear undecidable
Spreadsheets
Continuous variables
♦ e.g., start/end times for Hubble Telescope observations Transportation scheduling
♦ linear constraints solvable in poly time by LP methods
Factory scheduling
Floorplanning

Notice that many real-world problems involve real-valued variables

Chapter 5 7 Chapter 5 10

Varieties of constraints Standard search formulation (incremental)

Unary constraints involve a single variable, Let’s start with the straightforward, dumb approach, then fix it
e.g., SA 6= green
States are defined by the values assigned so far
Binary constraints involve pairs of variables,
e.g., SA 6= W A ♦ Initial state: the empty assignment, { }

Higher-order constraints involve 3 or more variables, ♦ Successor function: assign a value to an unassigned variable
e.g., cryptarithmetic column constraints that does not conflict with current assignment.
⇒ fail if no legal assignments (not fixable!)
Preferences (soft constraints), e.g., red is better than green
often representable by a cost for each variable assignment ♦ Goal test: the current assignment is complete
→ constrained optimization problems
1) This is the same for all CSPs!
2) Every solution appears at depth n with n variables
⇒ use depth-first search
3) Path is irrelevant, so can also use complete-state formulation
4) b = (n − `)d at depth `, hence n!dn leaves!!!!

Chapter 5 8 Chapter 5 11

Example: Cryptarithmetic Backtracking search

Variable assignments are commutative, i.e.,
[W A = red then N T = green] same as [N T = green then W A = red]
T WO F T U W R O Only need to consider assignments to a single variable at each node
+ T WO ⇒ b = d and there are dn leaves
F O U R
Depth-first search for CSPs with single-variable assignments
X3 X2 X1
is called backtracking search
Variables: F T U W R O X1 X2 X3 Backtracking search is the basic uninformed algorithm for CSPs
Domains: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
Can solve n-queens for n ≈ 25
Constraints
alldiff(F, T, U, W, R, O)
O + O = R + 10 · X1, etc.

Chapter 5 9 Chapter 5 12
 Backtracking search Backtracking example

function Backtracking-Search(csp) returns solution/failure

return Recursive-Backtracking({ }, csp)
function Recursive-Backtracking(assignment, csp) returns soln/failure
if assignment is complete then return assignment
var ← Select-Unassigned-Variable(Variables[csp], assignment, csp)
for each value in Order-Domain-Values(var, assignment, csp) do
if value is consistent with assignment given Constraints[csp] then
add {var = value} to assignment
result ← Recursive-Backtracking(assignment, csp)
if result 6= failure then return result
remove {var = value} from assignment
return failure

Chapter 5 13 Chapter 5 16

Backtracking example Backtracking example

Chapter 5 14 Chapter 5 17

Backtracking example Improving backtracking efficiency

General-purpose methods can give huge gains in speed:

1. Which variable should be assigned next?

2. In what order should its values be tried?
3. Can we detect inevitable failure early?
4. Can we take advantage of problem structure?

Chapter 5 15 Chapter 5 18
 Minimum remaining values Forward checking
Minimum remaining values (MRV): Idea: Keep track of remaining legal values for unassigned variables
choose the variable with the fewest legal values Terminate search when any variable has no legal values

WA NT Q NSW V SA T

Chapter 5 19 Chapter 5 22

Degree heuristic Forward checking

Tie-breaker among MRV variables Idea: Keep track of remaining legal values for unassigned variables
Terminate search when any variable has no legal values
Degree heuristic:
choose the variable with the most constraints on remaining variables

WA NT Q NSW V SA T

Chapter 5 20 Chapter 5 23

Least constraining value Forward checking

Given a variable, choose the least constraining value: Idea: Keep track of remaining legal values for unassigned variables
the one that rules out the fewest values in the remaining variables Terminate search when any variable has no legal values

Allows 1 value for SA

Allows 0 values for SA WA NT Q NSW V SA T

Combining these heuristics makes 1000 queens feasible

Chapter 5 21 Chapter 5 24
 Forward checking Arc consistency
Idea: Keep track of remaining legal values for unassigned variables Simplest form of propagation makes each arc consistent
Terminate search when any variable has no legal values
X → Y is consistent iff
for every value x of X there is some allowed y

WA NT Q NSW V SA T
WA NT Q NSW V SA T

Chapter 5 25 Chapter 5 28

Constraint propagation Arc consistency

Forward checking propagates information from assigned to unassigned vari- Simplest form of propagation makes each arc consistent
ables, but doesn’t provide early detection for all failures:
X → Y is consistent iff
for every value x of X there is some allowed y

WA NT Q NSW V SA T

WA NT Q NSW V SA T

N T and SA cannot both be blue!

If X loses a value, neighbors of X need to be rechecked
Constraint propagation repeatedly enforces constraints locally

Chapter 5 26 Chapter 5 29

Arc consistency Arc consistency

Simplest form of propagation makes each arc consistent Simplest form of propagation makes each arc consistent
X → Y is consistent iff X → Y is consistent iff
for every value x of X there is some allowed y for every value x of X there is some allowed y

WA NT Q NSW V SA T WA NT Q NSW V SA T

If X loses a value, neighbors of X need to be rechecked

Arc consistency detects failure earlier than forward checking
Can be run as a preprocessor or after each assignment

Chapter 5 27 Chapter 5 30
 Arc consistency algorithm Tree-structured CSPs

function AC-3( csp) returns the CSP, possibly with reduced domains
inputs: csp, a binary CSP with variables {X1, X2, . . . , Xn} A E
local variables: queue, a queue of arcs, initially all the arcs in csp
while queue is not empty do B D
(Xi, Xj ) ← Remove-First(queue)
if Remove-Inconsistent-Values(Xi , Xj ) then
for each Xk in Neighbors[Xi] do
C F
add (Xk , Xi) to queue
Theorem: if the constraint graph has no loops, the CSP can be solved in
function Remove-Inconsistent-Values( Xi , Xj ) returns true iff succeeds
O(n d2) time
removed ← false
for each x in Domain[Xi] do Compare to general CSPs, where worst-case time is O(dn)
if no value y in Domain[Xj ] allows (x,y) to satisfy the constraint Xi ↔ Xj
then delete x from Domain[Xi ]; removed ← true This property also applies to logical and probabilistic reasoning:
return removed an important example of the relation between syntactic restrictions
and the complexity of reasoning.
O(n2d3), can be reduced to O(n2d2) (but detecting all is NP-hard)

Chapter 5 31 Chapter 5 34

Problem structure Algorithm for tree-structured CSPs

1. Choose a variable as root, order variables from root to leaves
NT such that every node’s parent precedes it in the ordering
Q
WA A E
SA NSW B D A B C D E F
C F
V
Victoria

2. For j from n down to 2, apply RemoveInconsistent(P arent(Xj ), Xj )

T
3. For j from 1 to n, assign Xj consistently with P arent(Xj )
Tasmania and mainland are independent subproblems
Identifiable as connected components of constraint graph

Chapter 5 32 Chapter 5 35

Problem structure contd. Nearly tree-structured CSPs

Suppose each subproblem has c variables out of n total Conditioning: instantiate a variable, prune its neighbors’ domains
c
Worst-case solution cost is n/c · d , linear in n NT NT
Q Q
E.g., n = 80, d = 2, c = 20 WA WA

280 = 4 billion years at 10 million nodes/sec SA NSW NSW

4 · 220 = 0.4 seconds at 10 million nodes/sec

V
Victoria V
Victoria

T T

Cutset conditioning: instantiate (in all ways) a set of variables

such that the remaining constraint graph is a tree
Cutset size c ⇒ runtime O(dc · (n − c)d2), very fast for small c

Chapter 5 33 Chapter 5 36
 Iterative algorithms for CSPs Summary
Hill-climbing, simulated annealing typically work with CSPs are a special kind of problem:
“complete” states, i.e., all variables assigned states defined by values of a fixed set of variables
goal test defined by constraints on variable values
To apply to CSPs:
allow states with unsatisfied constraints Backtracking = depth-first search with one variable assigned per node
operators reassign variable values
Variable ordering and value selection heuristics help significantly
Variable selection: randomly select any conflicted variable
Forward checking prevents assignments that guarantee later failure
Value selection by min-conflicts heuristic:
choose value that violates the fewest constraints Constraint propagation (e.g., arc consistency) does additional work
i.e., hillclimb with h(n) = total number of violated constraints to constrain values and detect inconsistencies
The CSP representation allows analysis of problem structure
Tree-structured CSPs can be solved in linear time
Iterative min-conflicts is usually effective in practice

Chapter 5 37 Chapter 5 40

Example: 4-Queens
States: 4 queens in 4 columns (44 = 256 states)
Operators: move queen in column
Goal test: no attacks
Evaluation: h(n) = number of attacks

h=5 h=2 h=0

Chapter 5 38

Performance of min-conflicts
Given random initial state, can solve n-queens in almost constant time for
arbitrary n with high probability (e.g., n = 10,000,000)
The same appears to be true for any randomly-generated CSP
except in a narrow range of the ratio
number of constraints
R=
number of variables
CPU
time

R
critical
ratio

Chapter 5 39