Constraint Solving and Constraint Satisfaction Search

OntologiesReasoningComponentsAgentsSimulations

Constraint Solving andConstraint Solving andConstraint Satisfaction SearchConstraint Satisfaction Search

Jacques Robin

OutlineOutline

What is constraint solving? Constraint domains Constraint solving inference services Constraint solvers properties Practical applications of CSP Finite domain Constraint Solving Problem (CSP) solving

through search CSP search algorithms

What is Constraint Solving?What is Constraint Solving?

A versatile paradigm for symbolic, numerical and hybrid symbolico-numerical automated reasoning

Relies on hybrid logical-numerical knowledge representation formalism

Relies on AI search, term rewriting, operation research and mathematical inference algorithms

Allows reasoning with incomplete information Takes as input intentional and extensional knowledge

When input knowledge is consistent and complete, returns as output extensional knowledge

When input knowledge is consistent but incomplete, returns as output intentional and extensional knowledge that is more concise and easy to understand than the input

Identifies inconsistent input knowledge Most other automated reasoning paradigms (monotonic

deduction, belief revision, belief update, abduction, planning, optimization) can be reformulated as one form of constraint solving

Constraint Solving Problems (CSP)Constraint Solving Problems (CSP)

Input: Set of variables, each one associated with an associated domain of

possible values (constants) Set of functions defining mapping between these domains Set of relations (called primitive constraints), including equations

and inequations, over these domains A logical conjunction of such relations (called a compound

constraints) Output:

Composed of same elements as input If the input is just rightly constrained, the output is one complete

consistent variable valuation, i.e., a logical conjunction of equations of the form <variable> = <constant value>.

If the input is underconstrained, the output is a simplification of the input, i.e., a logically equivalent conjunction of primitive constraints containing fewer constraints and/or functions and/or variables.

If the input is overconstrained, the output is “fail” for there exists no variable valuation that simultaneously satisfy all constraints.

CSP Example: Analog Circuit CSP Example: Analog Circuit ModelingModeling

Particular circuit instance data sets: PD1 = ( V = 10 R1 = 10 R2 = 5 ), extensional PD2 = ( V = 10 R2 = 10 I1 = 5 ), extensional PD3 = ( R1 = 10 R2 = 5 ), extensional PD4 = ( V = 10 R1 = 5 I = 1 0 R2 ), intensional Solving particular circuit instance model PM1 = GM PD1 yields extensional consistent solution: V = 10 V1 = 10 V2 = 10 R1 = 10 R2 = 5 I = 6 I1 = 5 I2 = 1

Solving particular circuit instance model PM2 = GM PD2yields extensional consistent solution:V = 10 V1 = 10 V2 = 10 R1 = 2 R2 = 10 I = 6 I1 = 5 I2 = 1

Solving particular circuit instance model PM2 = GM PD2yields intentional consistent solution:V x 3 = I x 10

Solving particular circuit instance model PM4 = GM PD4yields fail (inconsistent input)

II1

I2

V

+

--3_

+

--

V1V2

--

R1 R2

Intentional generic circuitclass model GM:

021

021

021

02

01

222

111

III

III

VV

VV

VV

RIV

RIV

CSP Example: Building SchedulingCSP Example: Building Scheduling

Particular query Q1:TS = 0 Tm = min(TE)

Solution to particular problem GM Q1:TS = 0 TA = 7

TB = 11 TC = 10

TD = 12 TE = 15

Tm = 15

Particular query Q2:TE 14

Solution to particular problem GM Q2: fail

start

foundations

interior walls

exterior walls

chimney

roof

doors

tiles

windows3

3

2

2

3

3

4

7

0

CE

DE

BE

CD

AD

AC

AB

SA

S

TT

TT

TT

TT

TT

TT

TT

TT

TGeneric Building Model GM:

Building a House

Doors2 days

Stage B

Interior Walls4 days

Chimney3 days

Stage D

Stage E

Tiles3 days

Roof2 days

Windows3 days

Stage C

Exterior Walls3 days

Stage A

Foundations7 days

Stage S

CSP Example: Map ColoringCSP Example: Map Coloring

Generic Australia map coloring model AMCM:WT SO WT NT NT SO NT Q Q SO Q NSW NSW SO NSW V V SO

Color set instance BGR:WT {blue, green, red} SO {blue, green, red} NT {blue, green, red} Q {blue, green, red} NSW {blue, green, red} V {blue, green, red} T {blue, green, red}

Solving specific Australian map coloring problemAMCM BGR yields complete consistent solution:SO = blue WA = red NT = green Q = red NSW = green V = red T = green

Solving specific Australian map coloring problem with any set instance with two-color domains for all variables yields fail

The Language of CSP: MOF The Language of CSP: MOF Metamodel Metamodel

AndFormula

CompoundConstraint

Valuation

Non-FunctionalTerm

FunctionalTerm

{ non-overlapping, complete }

ConstraintDomain1 ..*

1 ..*

ConstantSymbol1 ..*

VariableAssignment1 ..*

FOL Formula

<<enum>FOL

Quantifier

FOL Atom1 ..*

0 ..*

<<enum>>FOL

Connective

connective

Variable

FOL Term

0 ..*

args

PredicateSymbol

functor

FunctionSymbol

functor

PrimitiveConstraint

1 ..*

ConstraintSymbol

QuantifierPrefix

0 .. *

args 0 .. *

Solution

Ground Term

Non-GroundTerm

{ non-overlapping, complete }

CSP Domains: MOF MetamodelCSP Domains: MOF Metamodel

Constraint Domain (CD)

Symbolic FD

Nominal FD

Symbolic CD Numeric CD

{non-overlapping, complete}

Finite CD Infinite CD

{non-overlapping, complete}

=, , true, false

Real Equations Inequalities

,

+, -, *, /, ^, logn, sin, cos,

...

RReal Polynomial

Equations Inequalities+, -, *, ^

Real Linear Equations Inequalities +, -, *

Integer Linear Equations Inequalities N

Ordinal FD

,

Boolean CD

, , , ~, ,

{0,1}

InfiniteSymbolic CD

String CD

concatRationalTrees CD

Function Symbolname: String

1 .. *

Integer FDEquations

Inequalities

Mixed CD2 .. *

,

CSP Solving ServicesCSP Solving Services

Substitution Satisfaction Absolute Implication Absolute Equivalence Normalization Absolute Simplification Projection Relative Implication Relative Equivalence Relative Simplification Local Propagation Optimization Labeling

CSP Solving Services: SubstitutionCSP Solving Services: Substitution

Substitute(:Valuation, C:CompoundConstraint):CompoundConstraint returns result of substituting in C the variables in by their value

in . Examples:

C: B = P + I x P B2 = B + I x B 1: B = 1200 P = 1000 I = 20/100 B2 = 1440

1(C): 1200 = 1000 + 20/100 x 1000 1440 = 1200 + 20/100 x 1200

2: B = 1 I = 1

2(C): 1 = P + 1 x P B2 = 1 + 1 x 1

3: B = 1 P = 0 I = 1 B2 = 1

3(C): 1 = 0 + 1 x 0 1 = 1 + 1 x 1

CSP Solving Services: SatisfactionCSP Solving Services: Satisfaction

Satisfiable(C:CompoundConstraint):Boolean result = true iff :Valuation | Substitute(, C) holds if result = true, also returns .

Examples: C1: B = P + I x P B2 = B + I x B Satisfiable(C1) = true, since: 1 = (B = 1200 P = 1000 I = 20/100 B2 = 1440) 1(C1) = (1200 = 1000 + 20/100 x 1000 1440 = 1200 + 20/100

x 1200) (1200 = 1000 + 20000/100 1440 = 1200 + 24000/100) (1200 = 1000 + 200 1440 = 1200 + 240) (1200 = 1200 1440 = 1440) (true true) true

C2: X = Y + 1 Y = X + 1 Satisfiable(C2) = false, since C2 (X = X + 1 + 1 Y = X + 1) (X = X + 2 Y = X + 1)

(0 = 2 Y = X + 1) (false Y = X + 1) false

CSP Solving Services: CSP Solving Services: Absolute Implication and EquivalenceAbsolute Implication and Equivalence

Implies(C1:CompoundConstraint, C2:CompoundConstraint):Boolean result = true iff :Valuation, (C1) satisfiable (C2) satisfiable

Examples: C1 = (TS 0 TA TS + 7 TB TA + 4 TC TA + 3

TD TC + 2 TE TB + 2 TE TC + 3 TE TD + 3) C2 = TB TC

Implies(C1,C2) = false Since = (TS = 0 TA = 7 TB = 11 TC = 12 TD = 14 TE = 17)

satisfies C1 but not C2 C3 = C1 TE = 15 Implies(C3,C2) = true Since C3 12 TD 10 TC TA 7 TB 11

Equivalent(C1:CompoundConstraint, C2:CompoundConstraint): Boolean result = true iff :Valuation, (C1) satisfiable (C2) satisfiable

C1 C2 iff (C1 C2) and (C2 C1)

CSP Solving Services: NormalizationCSP Solving Services: Normalization

Solved form compound constraint: X1 = e1 ... XN = eN such that none of the variables X1 ... XN occur in any of the expressions e1 ...

eN. Normalize(C:CompoundConstraint):CompoundConstraint

result = S is in solved form and verifies S C C Examples:

C = (X = 2 + Y 2*Y + X – T = Z X + Y = 4 Z + T = 5) S = Normalize(C) = (X = 3 Y = 1 Z = 5 – T) C (X = 2 + Y 2*Y + 2 + Y – T = Z 2 + Y + Y = 4 Z = 5 - T) (X = 2 + Y 3*Y + 2 – T = 5 - T 2*Y = 4 - 2 Z = 5 - T) (X = 2 + Y 3*Y + 2 = 5 Y = 1 Z = 5 - T) (X = 2 + 1 3*1 + 2 = 5 Y = 1 Z = 5 - T) (X = 3 5 = 5 Y = 1 Z = 5 - T) (X = 3 true Y = 1 Z = 5 - T) (X = 3 Y = 1 Z = 5 - T) = S

CSP Solving Services:CSP Solving Services:Absolute SimplificationAbsolute Simplification

Simplify(C:CompoundConstraint):CompoundConstraint result = S is equivalent, simpler constraint, i.e., S C and S has fewer primitive constraints than C and/or S has more constraints in solved form than C and/or S has fewer function symbols than C and/or S has fewer variables than C ??

Examples: C = (X Y + Z U + V X + V U = Z + Y V + V = 0 {U,V,X,Y,Z} N) S = (X = Y + Z U = Z + Y V = 0 {U,V,X,Y,Z} N) Since C (X Y + Z U + V X + V U = Z + Y V = 0 {U,V,X,Y,Z}

N) (X Y + Z 0 + U X + 0 U = Z + Y {U,V,X,Y,Z} N V =

0) (X Y + Z U X U = Z + Y {U,V,X,Y,Z} N V = 0) (X Y + Z Z + Y X U = Z + Y V = 0 {U,X,Y,Z} N) S

CSP Solving Services: ProjectionCSP Solving Services: Projection

Valuation extension: Given a valuation B of the form (X1 = v1 ... XB = vB)

Any valuation E of the form (X1 = v1 ... XB = vB XB+1 = vB+1 ... XE = vE )is an extension of B.

Partial solution: A valuation P is a partial solution of a constraint C iff

F :Valuation, F extends P and P is a solution of C

Notation: vars(C) = set of variables occurring in constraint C Project(C:CompoundConstraint,Vs:VariableSet):CompoundConst

raint precondition: Vs vars(C) result P verifies:1. vars(P) Vs2. C P3. P :Valuation over Vs, P solution of P P partial solution of C

Projection ExamplesProjection Examples

C1 = (X Y Y Z Z T T 0) Project(C1,{X}) = X 0

C2 = (f(Y,Y) = f(X,Z) s(Z) = s(T)) Project(C1,{X,Z}) = (X = Z)

C3 = (X + Y 1 X - Y 1 - X + Y 1 - X - Y 1) Project(C1,{X}) = (- 1 X X 1)

Counter-example: C1 = (X = f(Y,Z)) Project(C1,{X}) = fail there is no primitive constraint in C1

that either do not contain X or can be simplified

YY

- Y- Y

XX- X- X11- 1- 1

- 1- 1

11

XX- X- X11- 1- 1

CSP Solving Services:CSP Solving Services:Relative Implication and EquivalenceRelative Implication and Equivalence

Implies(C1:CompoundConstraint, C2:CompoundConstraint Vs:VariableSet):Boolean result = true iff F1 = (X1 = v1 ... XN = vN ...),

F1 solution of C1 P1 = (X1 = v1 ... XN = vN) partial solution of C2

Equivalent(C1:CompoundConstraint, C2:CompoundConstraint Vs:VariableSet):Boolean

Equivalent(C1,C2,Vs) = true iffImplies(C1,C2,Vs) and Implies(C2,C1,Vs)

Example: C1 = (Z = f(g(U),g(U)) X = g(U) Y = g(U) T = U) C2 = (Y = g(T)) Equivalent(C1,C2,{Y,T})

CSP Solving Services:CSP Solving Services:Relative SimplificationRelative Simplification

Simplify(C:CompoundConstraint,Vs:VariableSet):CompoundConstraint result = S verifies: 1. Equivalent(C,S,Vs) = true 2. S has fewer primitive constraints than C and/or3. S has more constraints in solved form than C and/or4. S has fewer function symbols than C and/or5. S has fewer variables than C

CSP Solving Services: Local CSP Solving Services: Local PropagationPropagation

Determined solved form of compound constraint: X1 = v1 ... XN = vN

where X1 ... XN are variables and v1 ... vN are constants

Propagate(Cd:CompoundConstraint, C:CompoundConstraint):CompoundConstraint preconditions: 1. Cd sub-conjunction of C2. Cd in determined solved form result = Propagate(Cd(C),choose(Cd’,determines(Cd,C))), i.e.,1. apply Cd as valuation substitution on C2. find which other sub-conjunctions of C become determined by this

substitution -- determines(Cd,C)3. choose one of them Cd’4. recursively propagate Cd’ on Cd(C)5. stop when propagation fails to determine new member of C

Local Propagation ExampleLocal Propagation Example

C = (V = V1 V = V2 V1 = I1 x R1 V2 = I2 x R2 I = I1 + I2) Cd = (V = 10 R1 = 5 R2 = 10) Propagate(Cd,C) = (V = 10 V1 = 10 V2 = 10 I1 = 2 I2 = 3 I =

3)

Since:1. Cd(C) = (10 = V1 10 = V2 V1 = I1 x 5 V2 = I2 x 10 I = I1 + I2)2. Cd’ = (V1 = 10 V2 = 10)3. Cd’(Cd(C)) = (10 = 10 10 = 10 10 = I1 x 5 10 = I2 x 10 I = I1 +

I2)4. Cd’’ = (I1 = 2 I2 = 1)5. Cd’’(Cd’(Cd(C))) =

(10 = V1 10 = V2 10 = 2 x 5 10 = 1 x 10 I = 2 + 1)

CSP Solving Services: OptimizationCSP Solving Services: Optimization

Optimize(C:CompoundConstraint, F:CostFunction):Valuation if C overconstrained result = fail if C just rightly constrained result = unique u such that u(C)

satisfiable if C underconstrained result = one of the lower-cost solution, i.e.,

o such that o(C) satisfiable and such that (C) satisfiable, F(o) F()

if there is no such lower-cost solution, result = none Examples:

C1 = (X + Y 4) F(X,Y) = X^2 + Y^2 Optimize(C1,F) = (X = 2 Y = 3) G(X,Y) = X + Y Optimize(C1,F) = any solution to C2 = (X + Y = 4) C3 = X 0 H(X) = X Optimize(C3,H) = none

CSP Solving Services: LabelingCSP Solving Services: Labeling

Label(C:CompoundConstraint):ValuationSet precondition: C over finite domain result = {:Valuation | (C) satisfiable}

Example: C1 = (WT SO WT NT NT SO NT Q Q SO

Q NSW NSW SO NSW V V SO) C2 = (WT {blue, green, red} SO {blue, green, red}

NT {blue, green, red} Q {blue, green, red} NSW {blue, green, red} V {blue, green, red} T {blue, green, red})

Label(C1 C2) = (SO = blue WA = red NT = green Q = red NSW = green V = red T = green)

Constraint SolversConstraint Solvers

Constraint solver: software providing one CSP service Many CSP services can be implemented through judicious

assembly and reuse of other CSP services

Properties: Correct Complete Normalizing Set-based Variable name independent Monotonic (falsity preserving) Projecting Weakly projecting

Constraint Solvers PropertiesConstraint Solvers Properties

Correct: guaranteed to return only correct solutions Complete: guaranteed to return all existing solutions

Possible only for small instances of CSP over specific domains Most CSP are NP-Hard, some are semi-decidable or even undecidable Satisfiable service returns “unknown” when it can neither conclude

that the input constraint is satisfiable nor that it is unsatisfiable Normalizing: return results in solved form

Directly legible, usable result No need for simplification or projection post-processing

Set-based: returns same solution for two equivalent compound constraints differing only in primitive constraint order and/or repetitions

Variable-name independent: returns same solution for two equivalent compound constraints different only in terms of variable names

Monotonic: C1,C2 satisfies(C1) = false satisfies(C1 C2) = false

Constraint Simplifiers PropertiesConstraint Simplifiers Properties

Projecting: returns solutions with fewer variables than input vars(simplify(C:Constraint,V:VariableSet)) V

Weakly projecting: returns solutions with minimum number of variables to insure satisfaction C1,C2: Constraint, V:VariableSet equivalent(C1,C2,V)

size(vars(simplify(C1:Constraint, V:VariableSet)) \ V) size(vars(C2:Constraint) \ V)

Canonical form simplifier: returns same solution for equivalent constraints C1,C2: Constraint, V:VariableSet equivalent(C1,C2,V)

simplify(C1,V) = simplify(C2,V) Canonical form constraint: simplification of constraint with

respect to its variables using a canonical form simplifier CanonicalForm(C:Constraint):Constraint returns s(C,vars(C))

where s is a canonical form simplifier for the domain of C.

Soft ConstraintsSoft Constraints

Define preference order over valuations consistent with hard constraints

Hard constraint example: a professor cannot teach two courses with overlapping time slots

Soft constraint example: a professor prefers its undergraduate and graduate course to be scheduled on the same day

Most satisfiability problems with hard and soft constraints can be transformed into optimization problems: The preference defined by the soft constraints is captured by the

cost function to optimize

Primitive Constraint ArityPrimitive Constraint Arity

Arity: primitive constraint argument number Zero-ary: true, false Unary: boolean negation, =, , , , , with one variable and one

constant Binary: =, , , , , with two variables Primitive high-order FD constraints:

Alldiff(V1 D, ... , Vn D), no pair of variables from {V1, ... , Vn} can share the same value in finite domain D

Atmost(TD,V1 D, ... , Vn D), T V1 +, ... , + Vn

Element(I {1, ... ,n}, [V1, ... , Vn], X), if I = i, then X = Vi

Any primitive high-order FD constraints can be converted to an equivalent conjunction of binary primitive FD constraints by the introduction of additional, auxiliary variables

But, special-purpose propagation techniques handle primitive high-order FD constraints far more efficiently than general purpose propagation techniques can handle their conversion as a conjunction of binary constraints

CSP DomainsCSP Domainsand Algorithmsand Algorithms

Constraint Domain (CD)

Symbolic FD

Nominal FD

Symbolic CD Numeric CD Finite CD Infinite CD

Real Equations Inequalities

Real Polynomial Equations Inequalities

Real Linear Equations Inequalities

Integer Linear Equations Inequalities

Ordinal FD

Boolean CDInfinite

Symbolic CD

String CD RationalTrees CD

Integer FDLinear

Equations Inequalities

Local Propagation

Unification

Real Linear Equations

Gauss-Jordan Elimination

Real Linear Inequalities

Fourier Elimination

Simplex Optimization

• Chronological Backtracking (CBT)• Simple, w/ Forward Checking

• Conflict-Directed Backjunping (CDBJ)• Simple, w/ Forward Checking

• k-Consistency Propagation• CBT w/ k-Consistency Propagation• CDBJ w/ k-Consistency Propagation• Min-Conflict

Interval FD

• Bounds Consistency Propagation (BCP)• CBT w/ BCP• CDBJ w/ BCP

FD Constraint Satisfaction as SearchFD Constraint Satisfaction as Search

FD CSP: D = {v1, ... , vm} X1 D ... Xn D Cs

where Cs = c1(Xi1,Xj

1) ... cp(Xip,Xj

p)

Finite domain allows solving by enumeration of possible valuations (search)

Formulation as incremental search: Initial state: no variable assigned, i.e., X1 D ... Xn D Cs

Successor function: add Xi = vj to current valuation Xk = vl ... Xq = vr such that Xk = vl ... Xq = vr Xi = vj Cs satisfiable

Goal test: X1 = vi1 ... Xn = vi

n Cs satisfiable Path cost: 1 per step

Formulation as complete-state search: Initial state: all variables randomly assigned,

i.e., X1 = vi1 ... Xk = vi

k ... Xn = vin

Successor function: change assignment of one variable in current valuation resulting in X1 = vi

1 ... Xk = vil X1 = vi

1 ... Xn = vin

where vil vi

k.

Goal test: same as incremental search

General Problem-Solving SearchGeneral Problem-Solving Searchvs. FD CSP Searchvs. FD CSP Search

General problem-solving General problem-solving search:search:

State representation: Problem-specific Black-box data structure

Successor function: Problem-specific Arbitrary black-box

Goal test function: Problem-specific Arbitrary black-box

Heuristic functions: Domain-specific

FD CSP search:FD CSP search: State representation:

Standard for all CSP Compositional logical knowledge

representation language Successor function:

Standard for all CSP Instantiation of one piece of

intentional knowledge into extensional knowledge

Goal test function: Standard for all CSP Satisfaction of all instantiated

primitive constraints Heuristic functions:

Standard for all CSP Domain-independent!

Backtracking Search for FD CSPBacktracking Search for FD CSP

General algorithm: At each step, choose one variable to assign one value to it and

choose that value from the variable’s associated domain If the resulting partial valuation satisfies all the primitive

constraints, recur to choose next variable-value assignment pair Otherwise, backtrack to a earlier assignment pair choice, choose

an alternative pair and resume forward search from that point Notes:

Path to solution state irrelevant Base, uninformed version:

Chooses variable to assign randomly among remaining options Chooses value to assign randomly among remaining options Always backtracks to last choice point (chronological backtracking) Does not perform any pruning of future options based on the

propagation of the consequences of its last assignment Xi = vi to the domains of variables adjacent to Xi in the constraint graph

Backtracking Search: ExampleBacktracking Search: Example

X Y Y Z D X D Y D Z ( ) ( ) ( ) { , }1 2

X Y Y Z

Choose var X domain {1,2}

X 1

1 Y Y ZChoose var Y domain {1,2}

Y 1

1 1 1 Z

partial_satisfiablepartial_satisfiable false

Y 2

1 2 2 Z

Choose var Z domain {1,2}

Z 1

1 2 2 1 No variables, and false

Z 2

1 2 2 2

No variables, and false

Variable X domain {1,2}

X 2

2 Y Y ZChoose var Y domain {1,2}

2 1 1 Z 2 2 2 Z

Heuristic Improvements of Heuristic Improvements of Backtracking Search for FD CSPBacktracking Search for FD CSP

How to choose next variable to assign at each forward step? How to choose next value to assign to that variable? Where to backtrack when current valuation fails? What to record when current valuation fails to avoid repeating

following such unsuccessful path in the future? Domain-independent, general-purpose heuristics for each

decision Whether or not to combine it with consistency-based constraint

propagation to prune the domains of the values Such propagation can be done either as a pre-processing step Or after each variable assignment

FD CSP GraphsFD CSP Graphs

Summarize dependencies between variables through constraints

Useful for: Computing FD CSP

search heuristic functions

Complexity analysis of FD CSP search algorithm

FD CSP BT SearchFD CSP BT SearchForward Phase HeuristicsForward Phase Heuristics

Next variable choice: Most constrained by current partial valuation

a.k.a., MRV (Minimum Remaining Values) heuristic Why? Speed-ups failure detection, avoids BT in hopeless search space

regions Most constrained with currently unassigned variables

a.k.a., Highest Degree heuristic Why? Reduces future effective branching factor

Common combination: HD as tie breaker for MRV Next value choice:

Least constraining value Why? Leaves options open, avoids BT triggered by early commitment

with insufficient knowledge Instance of general AI heuristic of “least-commitment”

FD CSP BT SearchFD CSP BT SearchForward Phase Heuristics ExamplesForward Phase Heuristics Examples

Next variable choice: most constrained by current partial valuation

Next variable choice: most constrained with currently unassigned variables

Next value choice: least constraining value

Improves scalability from25-Queens for uninformed BTto 1000-Queens

FD CSP BT SearchFD CSP BT Searchwith Forward Checkingwith Forward Checking

In forward phase After each new variable assignment Xi = vi

Add step to delete vi from the domains of adjacent(Xi) in the constraint graph


In forward phase After each new variable assignment Xi =

vi




vi




vi



Forward checking does not provide early detection for all failures

After 3 steps, domains of adjacent variablesNT and SA are both reduced to {blue} which leads to failure

Systematic early detection requires multi-step constraint propagation after each assignment

k-Consistencyk-Consistency

CSP P1 = (D = {v1, ... , vm} X1 D ... Xn D Cs) where Cs is a compound constraint on X1 ... Xn

CSP P2 is a sub-problem of P1 iff it is of the form: D = {v1, ... , vm} X1 D ... Xn-1 D Cs

k-Consistency: An FD CSP is k-consistent iff any consistent partial valuation involving k-1

variables can be extended into a consistent valuation assigning anyone of the remaining unassigned variables

1-Consistency a.k.a. Node Consistency Every variable has a consistent assignment in any non-empty sub-domain of

D 2-Consistency a.k.a. Arc Consistency

Every consistent single variable assignment can be extended into a consistent variable assignment pair for any other variable

3-Consistency a.ka. Path Consistency Every consistent variable assignment pair can be extended into a consistent

variable assignment triple for any third variable Strong k-Consistency:

An FD CSP is strongly k-consistent iff it is k-consistent, k-1 consistent, ... path-consistent, arc-consistent and node-consistent

k-Consistency Examplesk-Consistency Examples

CSP1: X Y Y Z Z 2 X D Y D Z D D = {1,2,3,4} is not node consistent Primitive constraint Z 2 rules out any consistent assignment for

Z over sub-domain {3,4} CSP2: X Y Y Z Z 2 X D Y D Z D

D = {1,2} is node consistent CSP2 is not arc-consistent

Y = 1 X Y X {1,2} is unsatisfiable Australia map coloring problem with two colors is not globally

satisfiable but still arc-consistent

Node and Arc-Consistency Node and Arc-Consistency PropagationPropagation

Node consistency: For each unary constraints U(X)

Delete all the values from Domain(X) that violate U

Arc-consistency: For each binary constraint B(X,Y)

Delete all the values from Domain(X) and Domain(Y) that violates the arc-consistency of the CSP

Node and Arc Consistency ExampleNode and Arc Consistency Example

Colouring Australia: with constraints

WA NT WA SA NT SA

NT Q SA Q SA NSW

SA V Q NSW NSW V

WA red NT yellow

WA NT SA Q NSW V T

Node consistency


WA NT WA SA NT SA

NT Q SA Q SA NSW

SA V Q NSW NSW V

WA red NT yellow

WA NT SA Q NSW V T

Arc consistency



WA NT WA SA NT SA

NT Q SA Q SA NSW

SA V Q NSW NSW V

WA red NT yellow

WA NT SA Q NSW V T

Arc consistency



WA NT WA SA NT SA

NT Q SA Q SA NSW

SA V Q NSW NSW V

WA red NT yellow

WA NT SA Q NSW V T

Arc consistency

Answer:

unknown


Min-Conflict ExampleMin-Conflict Example

States: 4 queens in 4 columns (44 = 256 states). Actions: move queen in column. Goal test: no attacks. Evaluation: h(n) = number of attacks Given random initial state, can solve n-queens in almost

constant time for arbitrary n with high probability (e.g., n = 10,000,000)

Performance ExperimentsPerformance Experiments

Problem Backtracking

BT+MRV ForwardChecking

FC+MRV Minimum

Conflicts

USA(4-colors)

(>1.000K) (>1.000K)

2K 60 64

n-Queens(2 < n < 50)

(>40.000K) 13.500K (>40000K)

817K 4K

Zebra(ex. 5.13)

3.859K 1K 35K 0.5K 2K

Random 1 415K 3K 26K 2K Not run

Random 2 942K 27K 77K 15K Not run

Documents

Constraint Solving and Constraint Satisfaction Search