1.0 - Constraint Satisfaction Problems

• Constraint Satisfaction Problems (CSPs) are a subset of search problems. They have the same assumptions about the world:
  • A single agent
  • Deterministic actions
  • Fully observed state
  • (Typically) discrete state spaces
• CSPs are specialised to identification problems (where we try to provide assignments to variables within the problem)
  • In conventional search problems, the path to the goal is important
  • In CSPs, only the end goal is important (i.e. assignment of values to variables)
  • All paths are the same depth (for most formulations)
    • This is given by the number of variables that we need to assign values to.
    • Need to find values within the CSP that don't violate any of the internal rules.
• At the end of the first part of this module, you should be able to:
  • Recognise and represent constraint satisfaction problems
  • Show how constraint satisfaction problems can be solved with search
  • Implement and trace arc-consistency of a constraint graph
    • Arc-consistency is a type of algorithm / solution that can be used to speed up the solving of CSPs

1.1 - Constraint Satisfaction Problems - Definition

A constraint satisfaction problem is given by:

• A set of variables $V_1, V_2, ..., V_n$
• Each variable $V_i$ has an associated domain $dom_{V_i}$ of possible variables
• A set of constraints on various subsets of the variables which are logical predicates specifying legal combinations of values for these variables
• A model of a CSP is an assignment of values variables that satisfies all of the constraints
  • "A model is a solution to the CSP"

There are also constraint optimisation problems, in which there is a function that gives a cost for each assignment of a value to each variable

• A solution in as assignment of values to the variables that minimises the cost function
• We'll skip constraint optimisation problems.

1.2 - Example - Scheduling Activities

• Variables $X=\{A, B, C, D, E\}$ that represent the starting times of various activities

• Domains Four start times for the activities

  $dom_A=\{1, 2, 3, 4\}, dom_B=\{1, 2, 3, 4\}, dom_C=\{1, 2, 3, 4\}, dom_D=\{1, 2, 3, 4\}$

  Each of the four activities can choose from 1 of 4 start times, $\{1, 2, 3, 4\}$

• Constraints Represent illegal conflicts between variables

  $(B \ne 3), (C \ne 2), (A\ne B), (B\ne C), (C<D), (A=D), (E<A), (E<B), ({\color{#FFCC00}B}<C), (E<D), (B \ne D)$

1.2.1 - Graph Colouring

Problem: Assign each state and territory such that no two adjacent states have the same colour

Variables $X=\{NSW, VIC, QLD, WA, SA, TAS, NT\}$

Domains $dom_X=\{r,g,b\} \text{ for each } x\in X$

• $\text{for each } x\in X$ describes that each state has the domain $\{r, g, b\}$

Constraints $(WA\ne SA)\wedge(WA\ne NT)\wedge(NT\ne QLD)\wedge...$

Variables $X=\{NSW, VIC, QLD, WA, SA, TAS, NT\}$

Domains $dom_X=\{r,g,b\} \text{ for each } x\in X$

• $\text{for each } x\in X$ describes that each state has the domain $\{r, g, b\}$

Constraints $(WA\ne SA)\wedge(WA\ne NT)\wedge(NT\ne QLD)\wedge...$

1.2.2 - Sudoku

Sudoku is one of the most popular puzzle games in the world. The goal of Sudoku is to fill a 9x9 board with numbers so that each, row, column and 3x3 grid section contain all the digits between 1→9. Every sudoku has a unique solution that can be reached logically → Sudoku can be modelled as a CSP

Variables The values in each square on the sudoku board.

The values in each square on the Sudoku board are values; These are the values to be allocated.

Domains Integers 1 to 9

Each square on the Sudoku board can take the values 1 to 9, so the domain of all variables (squares) in Sudoku is the integers 1 to 9

Constraints

For each row, every square in the row must be unique

For each column, every square in the column must be unique

For each 3x3 grid section, every square in the 3x3 grid must be unique

1.2 - Generate-and-Test Algorithm

How do we solve Constraint Satisfaction Problems?

• Generate the assignment space (a cartesian product of all domains)

  $$\text{dom}=\text{dom}_{V_1}\times\text{dom}_{V_2}\times\text{dom}_{V_3}\times...\times\text{dom}_{V_i}$$

• Test each assignment with the constraints

  • How many assignments need to be tested for $n$ variables with domain size $d$?

• For the graph (map) colour example before, in the worst case, $3^7 = 2187$ nodes need to be expanded

• This approach is basically to brute-force and try every possible combination of assignments

1.3 - Naively Apply DFS to a CSP

• States are defined by the value assigned so far (partial assignments)
• Initial State: the empty assignment {}
• Successor Function: Assign a value to an unassigned variable (possibly left-to-right, top-to-bottom)
• Goal Test: The current assignment is complete and satisfies all constraints

What can go wrong?

• Can hit the worst case in a DFS approach
• Amount of memory required to store all the entries increases exponentially.

DFS on CSPs → When to check constaints

• In the parent node (where all the relevant / in-scope assignments are satisfied), we try to expand its children nodes with various assignments
• When we try to expand these nodes with new assignments, we check the constaints
  • If the constraints are satisfied, continue expanding that node
  • Otherwise, terminate that branch of expansion and move to another child node or another branch of the search tree.

2.0 - Backtracking Algorithms

• Systematically explore the $\color{#3FF}\text{dom}$ by instantiating the variables one at a time
• Evaluate each constraint predicate as soon as all its variables are bound (within scope)
• Any partial assignment that doesn't satisfy the constraint can be pruned (stop expanding that partial solution)

Scheduling Example: Assignment $(A=1)\wedge(B=1)$ is inconsistent with constraint $A\ne B$ regardless of the value of other variables.

2.1 - Backtracking Algorithm - Graph Colouring Example

1. Expand all domain possibilities for WA

2. Expand all possibilities for the next variable (NT) → Not all graph colourings are possible, so prune those from the search tree.

3. Repeat for QLD

4. Repeat for SA

   → Does SA have any valid successors?

   No, as we have the constraints $WA\ne SA, NT\ne SA, QLD\ne SA$ which mean that there is no possible solution

If implementing this, we could have a dictionary with all of the partial assignments in it (so in the first row, there would only be a single partial assignment with the rest of the values either null or uninitialized. As we continue the search downward, the elements in the dictionary are populated).

2.2 - CSP as Graph Searching

Before performing a search on the problem space, you don't know whether there are: 1. No solutions 2. A single solution 3. Many solutions You may need to search through the entire problem space to find out

• A CSP can be solved by graph-searching with variable-ordering and fail-on-violation
  • Variable-ordering The order in which we assign values to the variables (given in this course)
  • Fail-on-violation Stop expanding when constraint is violated.
  • A node is an assignment of values to some of the variables
  • Suppose node $N$ is the assignment $X_1=v_1, ..., X_k=v_k$. (A partial assignment)
    • Select a variable $Y$ that isn't assigned in $N$ (Using your favourite graph searching algorithm or the given variable ordering)
  • For each value $y_i \in \text{dom}(Y)$, $X_1=v_1, ..., X_k=v_k, Y=Y_i$ is a neighbour if it is consistent with the constraints
    • Does the partial assignment satisfy or violate any constraints?
  • The start node is the empty assignment
  • A goal node is the total assignment that satisfies the constraints
• In the case where there are multiple solutions, the solution that your search algorithm arrives at first depends on your variable ordering and domain ordering (assuming that you stop when you find the first goal)

2.3 - Recursive Implementation of Backtracking Search

function backtrackingSearch(csp) returns solution/failure
	return recursiveBacktracking({}, csp)

function recursiveBacktracking(assignment, csp) returns solution/failure
	if assignment is complete then return assignment
	var <- selectUnassignedVariable(Variables[csp], assignment, csp)
	for each value in orderDomainValues(var, assignment, csp) do
			if value is consistent with assignment given constraints[csp] then
					add {var = value} to assignment
					result <- recursiveBacktracking(assignment, csp)
					if result != failure then return result
					remove {var = value} from assignment # if failure
	return failure

2.4 - Worked Example - Sudoku and Backtracking Search

The partial solution has already assigned variables to location (1,1) → 4, (1,3) → 6 etc.

The next variable to be assigned is (2,5), then (2,7) and (2,8)

For variable (2,5):

1. The value [1] is already in the 3x3 grid
2. The value [2] is already in the 3x3 grid
3. The value [3] is already in the 3x3 grid
4. The value [4] hasn't been used yet
5. The value [5] is already in the 3x3 grid
6. The value [6] is already in the 3x3 grid
7. The value [7] is already in the 3x3 grid
8. The value [8] is in the row
9. The value [9] hasn't been used yet

Expanding variable (2,7) given that (2, 5) = 4

Possible values [1]

Expanding variable (2,8) given that (2,5)=4 and (2,7=4)

• No values work (so we backtrack until we have reached a node that has other potential solutions

Go back until (2,5) = 9. We now consider the possible values for (2,7)

• [1, 4]

Suppose (2,7) = 1. Then (2,8) = 4 (and then expand the next rows).

Otherwise, if (2,7) = 4, then (2,8) = 4

3.0 - Consistency Algorithms

Algorithms that can use / exploit the additional structure and characteristics that general Search problems don't have, but CSPs have.

The idea with Consistency Algorithms is to prune the domains as much as possible before selecting values from them. A way of doing some pre-processing on the search problems to reduce the domain size.

• A variable is domain consistent (or 1-consistent) if no value of the domain of the node is ruled impossible by any of the constraints

• Example: Is the scheduling example domain consistent?

  • Variables $X=\{A, B, C, D, E\}$ that represent the starting times of various activities

  • Domains Four start times for the activities

    $dom_A=\{1, 2, 3, 4\}, dom_B=\{1, 2, 3, 4\}, dom_C=\{1, 2, 3, 4\}, dom_D=\{1, 2, 3, 4\}$

    Each of the four activities can choose from 1 of 4 start times, $\{1, 2, 3, 4\}$

  • Constraints Represent illegal conflicts between variables

    $(B \ne 3), (C \ne 2), (A\ne B), (B\ne C), (C<D), (A=D), (E<A), (E<B), ({\color{#FFCC00}B}<C), (E<D), (B \ne D)$

  The scheduling example is not domain consistent as we have the constraint $B\ne 3$ and $3\in dom_B$

• We can propagate this information to other unassigned variables.

3.1 - Constraint Network (as a bipartite graph)

• Bipartite graph: Has two types of nodes

  • There is a circle-shaped node for each variable
  • There is a rectangular node for each constraint

• There is a domain of values associated with each variable node

• There is an arc form variable X to each constraint that involves X

  • There is only one constraint on the variable A, hence there is only one edge connected to it.

• For example, two binary constraints would be represented as:

  

• Variables {A, B, C}

• Domains (not specified)

• Constraints $r_1(A,B)=(A<B),\ \ \ \ r_2(B, C)=(B<C)$

• Arcs $\langle A,\ r_1(A,B) \rangle, \langle B,\ r_1(A,B) \rangle, ...$

  • The term $\langle A,\ r_1(A,B) \rangle$ indicates that "Variable A is connected to constraint $r_1$"
  • Arcs are the edges that connect variables and edges - there are 4 arcs in the graph above.

• For the scheduling example from before, the Constraint Network / Graph would be constructed as follows



• We want to try to propagate restrictions that we know about in one domain to prune the domains of other variables through constraints (after applying domain consistency)

• This graph is not yet arc-consistent

4.0 - Arc-Consistency

4.1 - Forward Checking

• Idea Keep track of remaining legal values for unassigned variables
• Terminate the search when any variable has no legal values.
• This idea is embedded in "vanilla" backtracking search.
• 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.

4.2 - Arc Consistency

• Arc consistency is the simplest form of constraint propagation, which repeatedly enforces constraints locally.

• An arc $\langle X, r(X, \bar Y)\rangle$ is arc consistent if, for each value $x\in dom(X)$, there is some value $\bar y\in dom(\bar Y)$ such that $r(x,\bar y)$ is satisfied.

• An arc $\langle X, r(X, \bar Y)\rangle$ is arc consistent if, for every value $x$ of $X$, there is some allowed y.

• A network is arc consistent if all of its arcs are arc consistent.

• What if arc $\langle X, r(X, \bar Y)\rangle$ is not arc consistent?

  • All values of $X$ in $dom(X)$ for which there is no corresponding value in $dom(\bar Y)$ can be deleted from $dom(X)$ to make the arc $\langle X, r(X, \bar Y)\rangle$ consistent
  • This removal can never rule out any models - all models have arc-consistent network of constraints
  • This may require other variables' domains to be pruned.

4.2.1 - Arc Consistency Example - Graph Colouring

1. Suppose we set $SA=b$. As a result of the constraints defined, $NSW\ne SA$ which means that $NSW\ne b$ - as a result of a variable being updated, its neighbours have to be updated.

   

2. As a result of this update and the constraints provided, we note that $NSW\ne V$ which means that another neighbour has to be updated.

   

3. Additionally, given that $SA=b$, $NT\ne b$. Since blue is the remaining graph colouring option, this means that this configuration of colours is not a solution.

   Therefore, the colouring of $WA=r, QLD=g$ is not arc-consistent.

   

4.2.2 - Arc Consistency Algorithm

• The arcs can be considered in turn making each arc consistent.
• When an arc has been made consistent, does it ever need to be checked again?
  • YES! An arc $\langle X, r(X, \bar Y) \rangle$ needs to be revisited if the domain of one of the $Y$'s has been reduced.
• Regardless of the order in which arcs are considered, we will terminate with the same result: an arc-consistent network.
• Three possible outcomes when all arcs are made arc-consistent: (I.e. three answers to the question "Is there a solution?")
  • One domain is empty → No solution
  • Each domain has a single value → Unique solution
  • Some domains have more → There may or may not be a solution
    • Need to solve this new (usually simpler) CSP - the same constraints, but with reduced domains

4.2.3 - Arc Consistency Algorithm - Worst Case Complexity

• The worst-case complexity of this procedure:
  • Let the maximum size of a variable domain be d
  • Let the number of constraints be e
  • The complexity is $O(ed^3)$
• Some special cases are faster:
  • If the constraint graph is a tree, the arc consistency is $O(ed)$

4.2.4 - Finding a Solution from an Arc-Consistent Network

After performing arc-consistency the network, we have reduced the domain of each variable. If the result is indeterminate, we can perform search

• If some variable domains have more than one element, perform search (such has backtracking search)
  • The combination of arc consistency then backtracking search significantly speeds up the search process
  • We could even integrate arc-consistency into our search algorithm, either applying it when we expand nodes, or use some heuristic to determine when to use it.
• Some other advanced alternatives include
  • Variable and arc-ordering heuristics speed up arc consistency and search (by an order of magnitude)
  • Split a domain, then recursively solve each part
  • Use conditioning (fix a variable and prune its neighbours' domains) or cutset conditioning
    • Cutset conditioning - instantiate, in all ways, a set of variables such that the remaining constraint graph is a tree
  • Many other heuristics for exploiting graph structure

4.3 - Final Note on Hard and Soft Constraints

• Given a set of variables, assign a value to each variable that either:
  • Satisfies some set of constraints - satisfiability problems (with "hard constraints")
  • Minimise some cost function, where each assignment of values to variables has some cost - optimisation problems (with "soft constraints")
  • For soft constraint optimisation problems, value propagation algorithms are used in the same way that constraint propagation algorithms can be used.
  • In fact, the abstract algebra underpinning these two methods - the distributive law applied to c-semirings - is identical.
  • The same belief propagation algorithms use in Bayes-nets, message passing schemes used for turbo-codes and Nash propagation algorithms used in graphical games
• Many problems are a mix of hard and soft constraints (called constraint optimisation problems)