1 Chapter 4 Constraint Logic Programming
1
Chapter 4
Constraint Logic Programming
2
Outline
Introduction The constraint logic programming scheme CLP languages and applications
CLP(R) CHIP B-Prolog
Conclusions
3
Introduction
Given a particular domain, a constraint expresses a desired relationship among one or more of the objects.
Many practical problems can be regarded as constraint satisfaction problems (CSPs).
Logic Programming (LP) languages such as Prolog, with their general purpose Horn clause represen-tation and single clear semantics, are very good at expressing constraints in a declarative fashion.
However, Prolog’s unification mechanism is not sufficiently powerful to handle constraints properly.
Unification is not good at processing constraints non-deterministically.
4
Limitation of Prolog Example 1:plus(X,Y,Z) :- Z = X+Y.It is unable to deal satisfactorily with:
?- plus(X,Y,2). Example 2:fact(0,1).fact(N,F):- N>0, N1 is N -1, fact(N1,F1), F is N*F1.
The query ?- fact(2,F). gives the answer F = 2,but Prolog fails with the query ?- fact(N,2).
5
CLP = logic Programming + Constraint Programming There has been some effort within the Logic Programming
community to extend Prolog to overcome these limitations with unification.
However, despite these improvements, LP language still suffer from significant efficiency problems when dealing with constraint satisfaction.
Their simple backtracking search method implies a generate-and-test procedure in which variable values are generated and the constraints are used passively to check the values.
Recently, there has been a radical approach at extending the Logic Programming paradigm to produce Constraint Logic Programming (CLP) languages.
CLP is a merger of two declarative paradigms: constraint programming and logic programming.
6
Improvements of CLP
Like Logic Programming, CLP uses the resolution principle. However, unification has been replaced by constraint solving over an application domain.
CLP improves on Logic Programming when dealing with constrained search problems, by providing: more expressive languages in which a user can work
directly with objects from the intended domain and employ the natural constraints for that domain, and
far more efficient execution employing specialized methods and algorithms.
7
THE CONSTRAINT LOGIC
PROGAMMING SCHEME Jaffar and Lassez have given the formal definition of a class
of languages for which there is a simple and unified declarative and operational semantics. This is a general framework from which many CLP languages can be derived.
Each instance of this scheme is obtained by specifying a solution-compact structure of computation.
A structure A consists of: a set D(A) – the domain of A a collection of n-ary function: An A; a collection of n-ary relations: An {TRUE, FALSE}.
An A-term is either a constant in ; a variable; or of the form f(X1,…,Xn) where f is a function and the Xi are A-
terms.
8
An constraint is of the form: p(X1,…,Xn) where p and the Xi are A-terms An atom is of the form: p(X1,…,Xn) where p is a predicate symbol and the
Xi are A-terms.
Countable structures, the structure of real numbers are solution-compact.
By specifying a solution-compact structure A, one obtains a programming language CLP(A) which is an instance of the CLP Scheme.
9
A CLP(A) program consists of a finite number of rules:
A0 :- C1, C2,…,Cn, A1, A2,…,Am
where n, m 0,
Ci are constraints over the A-relations and A-terms,
Ai are atoms over the A-terms. A CLP(A) goal is of the form:
?- C1, C2,…,Cn, A1, A2,…,Am
where n, m 0, n+m 1, Ci are constraints
Ai are atoms An atom in a goal is a subgoal.
If A, B are two atoms with the same predicate symbol, A = B is used to signify the collection of equations between corresponding arguments in these two atoms.
Example:If A is resistor(X,Y, 5) and B is resistor(2,8,Z),Then A = B denotes { X = 2, Y = 8, Z = 5}.
10
The CLP(A) Operational Model Let P denote a CLP(A) program. Let G1, G2 be two goals
containning the collections C1, C2 of constraints. Assume that both C1 and C2 are solvable.
There is a derivation step from G1 to G2 if:
G1 is of the form
?- C1,A1,A2,…,Am, where m>= 1 P contains a rule of the form
B0 :- C2,D1,D2,…,Dk. where k >= 0 ( B0 can match with Ai).
G2 is of the form
?- C1,C2, Ai = B0, A1,A2,…Ai-1,Ai+1,…,Am, D1,D2,…,Dk where 1 i m
Ai in G1 is called the selected subgoal, or the subgoal in G1 chosen to be reduced.
11
A derivation sequence is a sequence of goals in which there is a derivation step to each goal from the preceding goal.
A derivation sequence is successful if it is finite and its last goal contains only constraints. Such constraints are called answer constraints. Answer constraints constitute the output of a CLP(A) program.
A finitely-failed sequence is a non-successful finite sequence, where no derivation step is possible from its last goal.
A CLP(A) program and goal are executed by a process of continually reducing any remaining atoms in the subgoal.
12
A comparison of CLP to LPLogic Programming Constraint Logic
Programming
Domain of computation
Herbrand Universe of uninterpreted terms
Any solution compact structure
syntax syntax Horn clauses Horn clauses
Horn clauses with constraints
operational interpretation
unification and resolution
constraint solving and resolution
output mgu a set of constraints
13
CLP LANGUAGES AND APPLICATIONS In this section, we look at some of the best-known
and most successful implementations of the CLP schema.
The design and implementation of constraint solvers for these languages has been of key important: efficiency in dealing with simple constraints, which are the
most commonly occurring. incrementality, so that solving extra constraints does not
involve re-solving the original set. an internal representation facilities efficient backtracking.
We will study 3 languages CLP(R) CHIP B-Prolog
14
CLP() CLP() was developed by Jaffar and Michaylov at IBM,
Yorktown Heights and at Monash University, Australia. The domain of computation: reals.
Real constants and variables are arithmetic terms. If t1, t2 are arithmetic terms, then so are (t1+t2), (t1-t2),
(t1*t2) and (t1/t2). Arithmetic terms, uninterpreted constants and variables are
all terms. If f is an n-ary uninterpreted function and t1,…,tn are terms,
then so the tree t(t1,…,tn). An equation or inequality between arithmetic terms is an
arithmetic constraint, solvable when there exists a substitution for its variables that makes it true in the obvious way.
Two trees are equal when they share the same root function and the corresponding subtrees are equal.
15
The CLP() interpreter The CLP() interpreter:
employs the Prolog’s left-to-right atom selection rule. employs Prolog’s top-to-bottom depth-first-search strategy.
Its constraint solver does not determine the solvability of all linear non-constraints. The determination of constraint solvability may be delayed until the constraint is “sufficiently instantiated”.
In CLP(), a non-linear constraint c is delayed until the linear equations in the system entail that sufficient variables in c are ground, so as to make it linear. When a delayed constraint is awoken and found to be unsolvable, the system backtracks as in Prolog. The delaying and awakening process is automatic and is designed to be transparent to the user.
16
Input
Engine Interface
Solve directly
Equation Solver
Inequation Solver
delay
Solve directly Output
Module
CONSTRAINT
SOLVER
The architecture of the CLP(R) interpreter
17
The inference engine controls the execution of derivation steps and maintains variable bindings. Some simpler constraints can be solved directly by the engine. The remainder is passed on the interface, which will eventually return a Boolean answer to the engine.
The interface evaluates complex arithmetic expression and transforms constraints into a small number of standard forms. It can do some constraint satisfaction of its own, but in the main, passes on the standardized constraints to the constraint solver.
The constraint solver lets the equation solver deal with linear equations, using a form of Gaussian elimination. It calls the inequality solver to handle linear inequalities, using an incremental form of the first phase of the Two-phase Simplex method. It delays non-linear equation, awakening them when they become linear and then passing them to the equation solver.
18
The output module converts constraints so that they reflect relationships only between variables in the goal, and transform these into a compact standard canonical form.
Example Programs:fib(0,1).fib(1,1).fib(N+2, X +Y):- N>= 0, fib(N+1, X), fib(N,Y).
Steps in the computation of the goal fib(N0,3) are as follows:
19
?- fib(N0,3).?- N1 >= 0, N0 = N1 + 2, 3 = X1 + Y1, fib(N1+1, X1), fib(N1,Y1).…?- N1 >= 0, N0 = N1 + 2, 3 = X1 + Y1, N2 >= 0, N1 + 1 = N2 +2, X1 =
X2+Y2, fib(N1, Y1), fib(N2+1, X2), fib(N2,Y2).…?- N1 >= 0, N0 = N1 + 2, 3 = X1 + Y1, N2 >= 0, N1 + 1 = N2 +2, X1 =
X2+Y2, N1 = 1, Y1 = 1, fib(N2+1, X2), fib(N2,Y2).…?- N1 >= 0, N0 = N1 + 2, 3 = X1 + Y1, N2 >= 0, N1 + 1 = N2 +2, X1 =
X2+Y2, N1 = 1, Y1 = 1, N2+1=1, X2=1, fib(N2,Y2).…?- N1 >= 0, N0 = N1 + 2, 3 = X1 + Y1, N2 >= 0, N1 + 1 = N2 +2, X1 =
X2+Y2, N1 = 1, Y1 = 1, N2+1=1, X2=1, N2=0,Y2=1.
Solving the final constraint set, with respect to N0, we obtain: N0 = 3.
20
Electrical Circuit
CLP() program for selecting components in an electrical circuit.
ohmlaw(V, I, R):- V = I*R.
kirchoff(L):- sum(L,0).
sum([ ],0).
sum([H|T], N):- N = H+M, sum(T,M).
availres(10).
availres(14).
availres(27).
availres(60).
availres(100).
availcell(10).
availcell(20).
21
and the query: ?- 14.5< V2, V2< 16.25, availres(R1), availres(R2), avail(V),
ohmlaw(V1,I1,R1), ohmlaw(V2, I2, R2), kirchoff([I1, -I2]), kirchoff([-V, V1, V2]).
CLP() computes the three sets of solution:V = 20, R1 = 10, R2 = 27,V = 20, R1 = 14, R2 = 60,V = 20, R1 = 27, R2 = 100.
R1
V1
V
R2
I2
I1
V2
22
The CLP Language CHIP
CHIP(constraint handling in Prolog) was developed at ECRC, Munchen.
There are three domains of computation finite domains, Boolean algebra and rational numbers.
23
Finite Domains Constraints may be:
numerical- equations, inequalities and disequations on arithmetic terms over domain variables.
symbolic- e.g., element(N, List, Var) meaning that Var is the N-th element of List.
optimization – e.g. minimize(Term, Function) which uses a branch-and-bound technique to find solution to Goal that minimizes Function.
Constraint solving domain variables are solved through Consistency Techniques, which uses constraints to reduce the domains of variables and so the size of the search space. The following two steps are iterated until a solution is reached: propagation the constraints as far as possible making a choice
24
Cryptarithmetic Puzzle The well known cryptarithmetic puzzle: S E N D + M O R E -------------- M O N E Y can be represented by the CHIP program:
sendmore([S,E,N,D],[M,O,R,E],[M,O,N,E,Y]):-[S, E, N, D, M, O, R, Y]:: 0..9,alldifferent([S, E, N, D, M, O, R, Y]),S 0, M 0,
Send = 1000*S + 100*E + 10*N + D,More = 1000*M + 100*O + 10*R + E,Money = 10000*M + 1000*O + 100*N + 10*E + Y,Send + More # = Money,labelling([S, E, N, D, M, O, R, Y]).
#= is the equality constraint for linear terms.labelling() generates values for the variables
25
Cryptarithmetic Puzzle (cont.)
Just by constraint manipulation and propagation, the search space is reduced to: S = 9, M = 1, O = 0, E [4..7], N [5..8], R [2..8], D [2..8], Y [2..8] before enumeration starts.
26
Rational Arithmetic
Used for modeling continuous problems (where there are an infinite number of points in the search space to explore).
Constraints may be: numerical – equations, inequalities and disequations
on linear rational terms optimization – e.g., rmax(Func) which finds the
maximum value of Func, subject to a set of constraints. CHIP provides a decision procedure for
constraints on linear rational terms that is based on a version of the Simplex algorithm.
27
The constraint solver The constraint solver has the following features:
it is embedded fully in the CHIP language, rather than a separate module.
It is incremental, in that adding a new constraint doesn’t mean starting from scratch again;
equations and inequalities are treated in a uniform manner – no need to transform equations into inequalities and introduce artificial variables.
The solution returned is the most general one, allowing an infinite number of solutions to be represented symbolically in a finite way;
The same solver can be used both for deciding whether a set of constraints is satisfiable as well as for finding an optimal solution.
28
Example Program Consider the transportation problem, that involves two
factories with can supply in total 4 and 6 and three warehouses with total demands of 3,5 and 2. Given a 2 3 matrix of unit transportation costs from factory to warehouse, the aim is to find how much each factory should supply to each warehouse so that the overall transportation costs are kept a minimum, while keeping to the supply and demand constraints.
Transport costs
Warehouse 1
Warehouse 2
Warehouse 3
Total
Supply Factory 1 5 1 1 4
Factory 2 2 6 9 6
Total Demand
3 5 2 10
29
Transportation problem
The problem can be expressed in CHIP as follows:top :-
X11 + X21 >= 3,
X12 + X22 >= 5,
X13 + X23 >= 2,
X11 + X12 + X13 <= 4,
X21 + X22 + X23 <= 6,
Cost = 5*X11 + X12 + X13 + 2*X21 + 6*X22 + 9*X23, rmin(Cost).
30
B-Prolog B-Prolog is a system for running Prolog and CLP(FD)
programs. It can - runs ISO Prolog programs, and - also supports constraint solving over finite domains and Booleans. The system can work on SunOS, Solaris, Linux and MSDOS
(Windows). B-Prolog was developed by Neng Fa Zhou. In general, a CLP(FD) program is composed of three parts:
Variable generation which generates variables and specifies their domains
Constraint generation which specifies constraint over the variables
Labeling which instantiates the variables.
31
Example 1- Constraint Propagation Solving a CSP with constraint set = { C< D, E<C,
E<D} and variables C, D, E {1,2,3,4}
Note: The predicate labeling(L) instantiates the list of variables L by enumeration. L in D means the domain of the list of variables L is D.
% File: clp2.plcsp2(L):- L=[C,D,E], L in 1..4, C#< D, E#<C, E#<D, labeling(L).
?- csp2(L).L=[2,3,1];L=[2,4,1];L=[3,4,1];L=[3,4,2];
32
Example 2 Constraint Propagation Solving a CSP with constraint set = { X+Y = 9,
2X+4Y= 24 } and X,Y in 0..9% File: clp1.pl% Date: 3/2004csp1(L):- L=[X,Y], L in 0..9, X+Y #= 9, 2*X +4*Y#=24, labeling(L).?- csp1(L).L = [6,3]
33
Example 3: Light meal A program for devising light meals whose total of
calories is less than 10.lightmeal(A,M,D):- L=[I,J,K], L in 0..10, I+J+K #=<10, appetiser(A,I), main(M,J), dessert(D,K), labeling(L).main(M,I):- meat(M,I); fish(M,I).appetiser(radishes,1).appetiser(pasta,6).meat(beaf,5).meat(pork,7).fish(sole,2).fish(tuna,4).dessert(fruit,2).dessert(icecream,6).
?- lightmeal(A,M,D).A = radishes M = beef D = fruitA = radishes M = pork D = fruitA = radishes M = sole D = fruitA = radishes M = sole D = icecreamA = radishes M = tuna D = fruitA = pasta M = sole D = fruit
34
Example 4 - NQueens % File: clp_queens.pl% Purpose: Solving N-Queens problemqueen_N(N,List):- makelist(N,List), List in 1..N, constrain_queens(List), labeling_ff(List). /* labelling with “first fail” variable ordering */constrain_queens([]).constrain_queens([X|Y]):- safe(X,Y,1), constrain_queens(Y).safe(_,[],_).safe(X,[Y|T],K):- noattack(X,Y,K), K1 is K+1, safe(X,T,K1).
35
noattack(X,Y,K):- X#\=Y, X+K#\= Y, X-K#\=Y.makelist(0,[]):- !.makelist(N,[_|Rest]):- N1 is N-1, makelist(N1,Rest).
Note: The predicate makelist(N, L) generates L, a list of N variables.
?- queen_N(8,L).L=[1,5,8,6,3,7,2,4]
36
Example 5: Graph Coloring The problem is to label the vertices of a graph so
that no two adjacent vertices are assigned to the same color.
% File :clp_color.pl% Date : 3/2004% Purpose: graph coloring with B-Prologgraphcolor(N,Vars):- makelist(N,Vars), Vect =..[f|Vars], Vars in 0..3, build_vars(N,Vect), labeling(Vars).
37
213
56
7 8
10 11 12 13
9
4
38
build_vars(N,_):- N=<0,!.build_vars(N,Vect):- neighbors(N,Neibs), arg(N,Vect,Var), constrain_color(Var,Neibs,Vect), N1 is N-1, build_vars(N1,Vect).constrain_color(_,[],_).constrain_color(Var,[N|Neibs],Vect):- arg(N,Vect,Var1), Var#\=Var1, constrain_color(Var,Neibs,Vect).makelist(0,[]):- !.makelist(N,[_|Rest]):- N1 is N-1, makelist(N1,Rest).
39
Graph Coloring (cont.)
neighbors(1,[5,6,7,10]).neighbors(2,[6,7,8,10,11]).neighbors(3,[10,11,12]).neighbors(4,[]).neighbors(5,[1,8,11]).neighbors(6,[1,2,7,11,12]).neighbors(7,[1,2,6,11,12]).neighbors(8,[2,5,12]).neighbors(9,[]).neighbors(10,[1,2,3]).neighbors(11,[2,3,5,6,7]).neighbors(12,[3,6,7,8]).neighbors(13,[]).
?- graphcolor(13,V).V = [0,0,0,0,1,1,2,2,0,1,3,3,0]: We assign color 0 to vertices 1,2,3,4,9,13; color 1 to vertices 5,6,10; color 2 to vertices 7,8; color 3 to vertices 11,12.
40
Example 6 – Scheduling with Precedent Constraints
Problem Statement. We are given
a set of n tasks where each task i has its duration di and
a set of precedent constraints. A precedence constraint between tasks i and j
implies that task j must start after the completion of task i.
The project starts at time 0, and the problem is to find a schedule that minimizes the total duration of the project.
We add a fictitious task of duration 0, called end task, which is preceded by all other tasks.
41
The durations of tasks can be used to calculate two basic quantities for each tasks: its earliest time and its latest time.
The earliest time for a task is the time at which the task will start if the preceding tasks are started as early as possible. The earliest time point ti to start task i is
ti = max(tj +dj) for all tasks j which proceed task i.
tend is the earliest time point for the end task and also the minimum duration of the project.
If the duration of the project is tend, the latest time point Ti to start task i is given by
Ti = min(Tj - di)
for all tasks j s.t. task i precedes task j, assuming that Tend is equal to tend.
42
So the starting time of a task i can be represented by a domain [ti,Ti].
The slack mi of task i is defined to be the difference between the earliest starting time and the latest starting time. The tasks whose slacks are 0 are called critical tasks.
Problem Representation To each task we associate a variable Si representing the
starting time of task i. Now a precedence constraint between task i and task j can be
Sj >= Si + di
Example. The following table describes a project with 10 tasks A, B, C, D,E, F, G, H, J, and K.
43
Code of the task
Name of the task Duration (in
weeks) Previous tasks
A Masonry 7 -
B Carpentry for roof 3 A
C Roof 1 B
D Sanitary and electrical installation
8 A
E Front 2 D,C
F Windows 1 D,C
G Garden 1 D,C
H Ceiling 3 F
J Painting 2 H
K Moving in 1 E, G, J
44
/* Title : House building scheduling problem *//* House building scheduling problem with 10 tasks */house(L):- L =[SA,SB,SD,SC,SE,SF,SG,SH,SJ,SK,Send], L in 0..30, SB #>= SA+7, SD #>= SA+7, SC #>= SB+3, SE #>= SC+1, SE #>= SD+8, SG #>= SC+1, SG #>= SD+8, SF #>= SD+8, SF #>= SC+1, SH #>= SF+1, SJ #>= SH+3, SK #>= SG+1, SK #>= SE+2, SK#>= SJ+2, Send #>= SK+1,
minof(labeling(L),Send).
45
Note: 1.The variables SA,…,SK represent the starting dates
of the tasks of the project, and the Send is the starting date of the end task, i.e., the finishing date.
2.The predicate minof(Goal, Exp) finds a satisfiable instance of Goal such that Exp has the minimum optimal value. Here, Goal is used as generator (e.g., labeling(L)), and Exp is an expression. All satisfiable instances of Goal must be created, and for every such instance, Exp must be an integer expression.
In B-Prolog, the search for an optimum solution uses a kind of depth-first branch and bound technique.
46
For example, when a solution with a value F0 is found, the constraint (Goal < F0) is dynamically added to the program. While searching a new solution, all branches of the search space where the value of Goal is greater than F0 are pruned. The optimal solution is achieved when no new solution better than the most recent one can be found.
?- house(LD). LD = [0,7,7,10,15,15,15,16,19,21,22]. That means SA = 0, SB = 7, SC=7, SD = 10, SE=15, SF=15,
SG=15, SH=16, SJ=19, SK=21, Send = 22.
47
Example 7: Project selection A company is considering expansion by building a new factory
in either city L or city S, or perhaps in both cities. It also is considering building at most one new warehouse, but the choice of location is restricted to a city where a new factory is being built.
The net present value (total profitability) of each of these alternatives is shown in the fourth column of the following table.
Decision
Number
Yes-or-No Question Decision
Variable
Net Present
Value
Capital Required
1 Build factory in L x1 9 M 6M
2 Build factory in S x2 5 M 3 M
3 Build warehouse in L x3 6 M 5 M
4 Build warehouse in S x4 4 M 2 M
48
Project selection (cont.)
Capital available: 10 million The rightmost column gives the capital required for the
respective investments. The total capital available is 10 million.
The objective is to find the feasible combination of alternatives that maximizes the total net present value.
Because the last two decisions are mutual exclusive, we need the constraint
x3 + x4 1 Furthermore, decision 3 and 4 are contingent decisions,
because they are contingent on decisions 1 and 2. x3 x1 x4 x2.
49
projs(L):- L= [D1,D2, D3,D4], L in 0..1, 6*D1 +3*D2+5*D3+2*D4 #=< 10, D3 + D4 #=< 1, D3 #=< D1, D4 #=< D2, maxof(labeling(L), 9*D1+5*D2 + 6*D3+4*D4). ?- projs(L). L = [1,1,0,0] That means the company should build factories in both cites
but no warehouse.
50
Example 8: Assignment Problem The assignment problem is a problem where assignees are
being assigned to perform tasks. For example, the assignees might be employees who need
to be given work assignments. However, the assignees could be machines, or vehicles or plants.
To fit the definition of an assignment problem, the applications need to be formulated in a way that satisfies the following assumptions.
The number of assignees and the number of tasks are the same. (This number is denoted by n.)
Each assignee is to be assigned to exactly one task. Each task is to be performed by exactly one assignee. There is a cost cij associated with assignee i (i = 1,2,…,n)
performing task j (j =1,2,…,n). The objective is to determine how all n assignments should
be made in order to minimize the total cost.
51
Example: A company has purchased 3 new machines of different types. There are 4 available locations in the shop where a machine could be installed. Some of these locations are more desirable than others. Therefore, the objective is to assign the new machines to the available locations to minimize the total cost of material handling.
The estimated cost per unit of material handling involving each of the machines is given in the following table.
Task 1 2 3 4 1 13 16 12 11 2 15 M 20 13Machine 3 5 7 0 0 4(D) 0 0 0 0 An very large cost M is attached to the assign-ment of machine 2 to
location 2 to prevent this assignment in the optimal solution.
52
We must introduce a dummy machine to the extra location.assign(L):- L=[X11,X12,X13,X14,X21,X22,X23,X24, X31,X32,X33,X34,X41,X42,X43,X44], L in 0..1,
X11+X12+X13+X14 #=1, X21+X22+X23+X24 #=1, X31+X32+X33+X34 #=1, X41+X42+X43+X44#=1, X11+X21+X31+X41 #=1, X12+X22+X32+X42 #=1, X13+X23+X33+X43 #=1, X14+X24+X34+X44 #=1, minof(labeling(L), 13*X11+16*X12+12*X13+11*X14 + 15*X21 +1000*X22 + 13*X23 + 20*X24+ 5*X31 + 7*X32 + 10*X33 + 6*X34).
?- assign(L).L =[0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,0]X14 = 1, X23 = 1, X31= 1, X42 = 1That means: machine 1 is assigned to location 4, machine 2 to location 3, machine 3 to location 1.
53
CONCLUSIONS CLP extends unification to constraint solving in new
computation domains richer than the usual Herbrand universe.
CLP allows building the systems that combine logic and mathematical techniques – qualitative and quantitative, symbolic and numeric, heuristics and algorithm.
The programmer can reason directly in term of the intended domain, instead of being forced to code semantic objects in term of a Herbrand universe.
The modeling of problems which involves choosing the computation domain, variables, values and constraints,
is vital in achieving concise descriptions and efficiency.
54
Successful modeling requires a good understanding of the problem, of relevant AI and Operations Research techniques
and of the CLP system itself.