Post on 21-Dec-2015
OntologiesReasoningComponentsAgentsSimulations
Constraint Solving:Constraint Solving:Problems and DomainsProblems and Domains
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)
Nominal FD
Finite CD Infinite CD
{non-overlapping, complete}
=, , true, false
String CD
concat
Mixed CD2 .. *
,
Ordinal FD
,
Boolean CD
, , , ~, ,
{0,1}
Integer Linear Equations Inequalities N
Real Linear Equations Inequalities+, -, *
Real Polynomial Equations Inequalities
+, -, *, ^
Symbolic FDReal
Equations Inequalities
,
+, -, *, /, ^, logn, sin, cos,
...
R
InfiniteSymbolic CD
Integer FDEquations
InequalitiesN
Symbolic CD Numeric CD
{non-overlapping, complete}
RationalTrees CD
Function Symbolname: String
1 .. *
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