Constraint Satisfaction Problems

CSP
Constraint satisfaction means solving a problem under certain
constraints or rules.
• Constraint satisfaction is a technique where a problem is
solved when its values satisfy certain constraints or rules
of the problem. Such type of technique leads to a deeper
understanding of the problem structure as well as its
complexity.
 CSP
Constraint satisfaction depends on three components, namely:

• X: It is a set of variables.
• D: It is a set of domains where the variables reside. There
is a specific domain for each variable.
• C: It is a set of constraints which are followed by the set of
variables.
 Constraint satisfaction problems (CSPs)

• Standard search problem: state is a "black box“ – any data

structure that supports successor function and goal test
• CSP:
– state is defined by variables Xi with values from domain Di
– goal test is a set of constraints specifying allowable combinations
of values for subsets of variables

• Simple example of a formal representation language

• Allows useful general-purpose algorithms with more
power than standard search algorithms
 Solving Constraint Satisfaction
Problems
• The requirements to solve a constraint satisfaction problem
(CSP) is:

• A state-space
• The notion of the solution.
• A state in state-space is defined by assigning values to
some or all variables such as

• {X1=v1, X2=v2, and so on…}.

 An assignment of values to a
variable can be done in 3 ways:
• Consistent or Legal Assignment: An assignment which
does not violate any constraint or rule is called Consistent
or legal assignment.
• Complete Assignment: An assignment where every
variable is assigned with a value, and the solution to the
CSP remains consistent. Such assignment is known as
Complete assignment.
• Partial Assignment: An assignment which assigns values
to some of the variables only. Such type of assignments are
called Partial assignments.
 Types of Domains in CSP
There are following two types of domains which are used by
the variables :

• Discrete Domain: It is an infinite domain which can have

one state for multiple variables. For example, a start state
can be allocated infinite times for each variable.

• Finite Domain: It is a finite domain which can have

continuous states describing one domain for one specific
variable. It is also called a continuous domain.
 Constraint Types in CSP
With respect to the variables, basically there are following
types of constraints:

• Unary Constraints: It is the simplest type of constraints

that restricts the value of a single variable.
• Binary Constraints: It is the constraint type which relates
two variables. A value x2 will contain a value which lies
between x1 and x3.
• Global Constraints: It is the constraint type which involves
an arbitrary number of variables.
 Special types of algorithms to
solve the following constraints:
• Linear Constraints: These type of constraints are
commonly used in linear programming where each
variable containing an integer value exists in linear form
only.
• Non-linear Constraints: These type of constraints are used
in non-linear programming where each variable (an integer
value) exists in a non-linear form.
• Note: A special constraint which works in real-world is
known as Preference constraint.
 Example: Map-Coloring

• Variables WA, NT, Q, NSW, V, SA, T

• Domains Di = {red,green,blue}
• Constraints: adjacent regions must have different colors
• e.g., WA ≠ NT, or (WA,NT) in {(red,green),(red,blue),(green,red),
(green,blue),(blue,red),(blue,green)}
 Example: Map-Coloring

• Solutions are complete and consistent assignments

• e.g., WA = red, NT = green, Q = red, NSW =
green,V = red,SA = blue,T = green
•
 Constraint graph
• Binary CSP: each constraint relates two variables
• Constraint graph: nodes are variables, arcs are constraints
 Varieties of CSPs
• Discrete variables
– finite domains:
• n variables, domain size d → O(dn) complete assignments
• e.g., Boolean CSPs, incl. Boolean satisfiability (NP-complete)
– infinite domains:
• integers, strings, etc.
• e.g., job scheduling, variables are start/end days for each job
• need a constraint language, e.g., StartJob1 + 5 ≤ StartJob3
• Continuous variables
– e.g., start/end times for Hubble Space Telescope observations
– linear constraints solvable in polynomial time by LP
 Varieties of constraints
• Unary constraints involve a single variable,
– e.g., SA ≠ green
• Binary constraints involve pairs of variables,
– e.g., SA ≠ WA
• Higher-order constraints involve 3 or more
variables,
– e.g., cryptarithmetic column constraints
 Backtracking search
• Variable assignments are commutative, i.e.,
[ WA = red then NT = green ] same as [ NT = green then WA = red ]

• => Only need to consider assignments to a single variable at

each node

• Depth-first search for CSPs with single-variable assignments

is called backtracking search

• Can solve n-queens for n ≈ 25

Backtracking example
Backtracking example
Backtracking example
Backtracking example
 Improving backtracking efficiency

• General-purpose methods can give huge

gains in speed:
– Which variable should be assigned next?
– In what order should its values be tried?
– Can we detect inevitable failure early?
 Most constrained variable
• Most constrained variable:
choose the variable with the fewest legal values

• a.k.a. minimum remaining values (MRV)

heuristic
 Most constraining variable
• A good idea is to use it as a tie-breaker
among most constrained variables
• Most constraining variable:
– choose the variable with the most constraints on
remaining variables
–
 Least constraining value
• Given a variable to assign, choose the least
constraining value:
– the one that rules out the fewest values in the
remaining variables
–

• Combining these heuristics makes 1000

queens feasible
 Forward checking
• Idea:
– Keep track of remaining legal values for unassigned variables
– Terminate search when any variable has no legal values
–
 Forward checking
• Idea:
– Keep track of remaining legal values for unassigned variables
– Terminate search when any variable has no legal values
–
 Forward checking
• Idea:
– Keep track of remaining legal values for unassigned variables
– Terminate search when any variable has no legal values
–
 Forward checking
• Idea:
– Keep track of remaining legal values for unassigned variables
– Terminate search when any variable has no legal values
–
 Constraint propagation
• Forward checking propagates information from assigned to
unassigned variables, but doesn't provide early detection
for all failures:
•

• NT and SA cannot both be blue!

• Constraint propagation algorithms repeatedly enforce
constraints locally…
 Arc consistency
• Simplest form of propagation makes each arc consistent
• X →Y is consistent iff
•
for every value x of X there is some allowed y
 Arc consistency
• Simplest form of propagation makes each arc consistent
• X →Y is consistent iff
•
for every value x of X there is some allowed y
 Arc consistency
• Simplest form of propagation makes each arc consistent
• X →Y is consistent iff
•
for every value x of X there is some allowed y

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

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

• 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
 Arc consistency algorithm AC-3

• Time complexity: O(#constraints |domain|3)

Checking consistency of an arc is O(|domain|2)
 k-consistency
• A CSP is k-consistent if, for any set of k-1 variables, and for any consistent
assignment to those variables, a consistent value can always be assigned to
any kth variable
• 1-consistency is node consistency
• 2-consistency is arc consistency
• For binary constraint networks, 3-consistency is the same as path consistency
• Getting k-consistency requires time and space exponential in k
• Strong k-consistency means k’-consistency for all k’ from 1 to k
– Once strong k-consistency for k=#variables has been obtained, solution
can be constructed trivially
• Tradeoff between propagation and branching
• Practitioners usually use 2-consistency and less commonly 3-consistency