the course logic programming id2213
DESCRIPTION
The Course Logic Programming ID2213. Thomas Sjöland [email protected] SCS, Software and Computer Systems ICT - School of Information and Communication Technology KTH, The Royal Institute of Technology. Outline of lectures. W35: F1: Theory, Elementary Programs, unification - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/1.jpg)
The Course Logic Programming ID2213
Thomas Sjöland [email protected]
SCS, Software and Computer Systems
ICT - School of Information and Communication Technology
KTH, The Royal Institute of Technology
![Page 2: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/2.jpg)
Outline of lecturesW35:F1: Theory, Elementary Programs, unification Theory, Model Theory of LP, proof trees and search trees
W36:F2: Programming Style, recursion, equality primitives, representation Advanced Recursive Techniques, accumulators, diff-structures, ADT
W37:F3: Search Based Programming, cut and negation Concurrency, Search Based Programming, state space, puzzles, games
W38:F4: Logic programming and Grammars, parsing with DCG
W39:F5: Program Transformation. Higher-order programming. Metaprogramming, Expert Systems
W40:F6: Case study: A compiler for a simple stack machine
W41:F7: Case study: Support for reasoning about electronic circuits Red1: Project presentation 4 hours
W42: Written Examination
![Page 3: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/3.jpg)
F1: Theory and simple programs
Sterling and Shapiro ch. 1,2,4,5,6Nilsson and Maluszynski ch.1,2,3,6
![Page 4: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/4.jpg)
Theory for Logic Programming
![Page 5: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/5.jpg)
Outline
Informal introduction to logic programming theoryData in logic programs: Individual constants, term
constructors, logical variables, compound terms, trees and lists
Equality theory, UnificationLogic Programs: Definite (Horn) ClausesModel theory (least Herbrand model, term interpretation)Proof theory and operational semantics of Prolog
(SLD-resolution, proof trees)Simple databases
Recursive rules
![Page 6: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/6.jpg)
Logic Programming
Using proofs to compute To each proof you can order a computation To each computation you can order a proof
Representation of knowledge and computations - algorithms - functions - relations
![Page 7: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/7.jpg)
Data in Logic Programs
Programs express facts about a world of objects Constants
Functors
NumbersCompounded structures (normally finite)
Lists
Trees
![Page 8: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/8.jpg)
Objects in Logic ProgramsIndividual constants
a b foo 4711 -37 34.5 Functors
structure names of trees and graphssame syntax as non-numerical constants
Arity (number of arguments): term/4, a/0
Syntax example: term(a,b,-4711,other(b,a))
![Page 9: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/9.jpg)
Logical Variables - Syntax
Syntax: begin with a capital letter (or '_')
X Y Z Foo _Bar _
Variables can occur wherever constants or structures occur
Range over logical objects
_ is "anonymous" or "void"
![Page 10: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/10.jpg)
Programs are Theories
sets of relations (predicates) over objects
The classical form of a definition is as a clausal form where a positive literal P has exactly one occurrence:
P or not Q1 or ... or not Qn
This can be written as P if Q1 & ... & ... Qn.
If all goals Qi are true the clause becomes P.
![Page 11: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/11.jpg)
Program = Definitions + Query
The general form of a relation definition is
P if (Q11 & ... & Q1n) or ...or (Qm1 & ... & Qmn).
1..m and 1..n are index sets large enough to cover all goal atoms, Qij
![Page 12: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/12.jpg)
Program = Definitions + Query
Elementary literals (atoms)true, false, X=Ycannot be redefined (only used in queries and definition bodies)
Defined literals (p above)
![Page 13: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/13.jpg)
Definite Clauses: Facts
Facts: statements of form P :- true.Also written simply as P.Example: brother(nils,karl).Means that the binary relation brother holds between individual constants nils and karl.
![Page 14: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/14.jpg)
Definite Clauses: Rules
Rules: conditional formulae of the form
P :- Q1,....,Qn.
P is called the head and Q1,...,Qn the body of the clause and P, Q1,...,Qn are atomic formulas (relation symbols). Some of the Qi may be predefined relation symbols (=, <)
":-" is read as "if", "," is read as "and"
![Page 15: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/15.jpg)
Definite Clauses: Rules, example
Example of a rule:
grandfather(X,Y) :- father(X,Z), father(Z,Y).
The binary relation grandfather holds between two individuals represented by variables X and Y if the relation father holds between X and some Z and between that Z and Y.
![Page 16: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/16.jpg)
Clause Syntax
Example : p(17).p(X) :- X<8, q(X).p(X) :- q(X), X=s(Y), p(Y).
In english the above example could be stated as follows:- The property p holds for the constant 17. - The property p holds for a term denoted by the
variable X if X<8 and q holds for X. - The property p holds for X if q holds for X, X
equals a term s(Y) and p holds for Y.
![Page 17: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/17.jpg)
Programs are Theories
Definitions are collections of facts and rules - sets of relations (predicates) over the objects
e.g. (for predicate p/2 using q/2 and r/2)
p(foo,bar).p(Foo,Bar) :- q(Foo,Baz), r(Baz,Bar).
Functions are special cases of relations (deterministic)
![Page 18: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/18.jpg)
Query, Goal
formula to be verified (or falsified) Questions posed to the system are of the form
?- Q1,...,Qn.
for example ?- q(Foo,Baz), r(Baz,Bar).
If the system succeeds to prove the formula, the values of the variables (the bindings) that are the result are shown, otherwise the proof attempt has failed or possibly loops.
Note that more than one solution is possible.
![Page 19: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/19.jpg)
How Prolog works A user query ?- p(Args). is proven using resolution - look for all definition clauses of p - pick one, save others as alternatives - match the arguments in Args with the
terms in the head of the clause, create necessary variable bindings
- if the matching unification fails, try next alternative
- else prove the goal clauses of the body from left to right
- if all proofs are done, the bindings are presented
![Page 20: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/20.jpg)
Database for family relationships
parent(Parent, Child), male(Person) and female(Person)
parent(erik, jonas). male(erik).parent(erik, eva). male(jonas).parent(lena, jonas). female(lena).
?- parent(lena, jonas).
Yes
?-parent(X,Y).X=erik, Y=jonas; X=erik, Y=eva; X= lena, Y= jonas
?- parent(X, jonas).X=erik; X=lena
![Page 21: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/21.jpg)
Logical variables - semanticsVariables can occur wherever constants or
structures occur.
Range over logical objects.
Bound to structures and to other variables.
The semantics is "single-assignment"- starts "unbound"
- once bound, stays the same in the whole proof
![Page 22: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/22.jpg)
Example cont.: rules
father(Dad, Child):- parent(Dad, Child), male(Dad).mother(Mum, Child):- parent(Mum, Child), female(Mum).
?- father(X,Y). ?- mother(erik, jonas).X=erik, Y=jonas NoX=erik, Y=eva ?- mother(Erik, jonas). Yes. Why?
%sibling(Person1, Person2) :- ...sibling(X,Y) :- parent(Z,X), parent(Z,Y).
%cousin(Person1, Person2):- ...cousin(X,Y) :- parent(Z,X), parent(U,Y), sibling(Z,U).
![Page 23: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/23.jpg)
syntactic sugar ';'
The symbol ';' can be used to avoid defining auxiliary predicates or to reduce the number of clauses.
';' is read as "or".
A clause of the formP :- Q1, (Q2 ; Q3), Q4.is the same as P :- Q1, Q, Q4.Q :- Q2.Q :- Q3.
![Page 24: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/24.jpg)
Equality theory - Substitutions
X equals Y iffX is an unbound variable or Y is an unbound variableorX and Y are (bound to) the same constantorX and Y are terms with the same functor and aritye.g. X is term(Z1,..,Zn) and Y is term(U1,...,Un)and for all arguments 1=<i=<n: Zi equals Ui.
![Page 25: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/25.jpg)
Substitutions
A substitution is a function Subst: Var -> Term
Substitutions can be applied to terms or substitutions and also to formulas
We may represent a substitution as a conjunction of simple equalities v=t where a variable v occurs on the left hand side at most once
or as a set {v/t | v=t} meaning a function thatreplaces v with t for each v/t in the set
![Page 26: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/26.jpg)
Unifier
A unifier is a substitution suchthatst
(applying tosand totcreates identical terms)
![Page 27: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/27.jpg)
Most general unifier
A unifier is more general than a unifier iff there exists another unifier such that
A unifier is the most general unifier of two termsiff is more general than any other unifier of the two
terms
![Page 28: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/28.jpg)
Most general unifier, example
Example :
t(X,Y,Z) and t(U,V,W)
are unified by{X/a,Y/b,Z/c, U/a,V/b,W/c}
consider for instance the mgus in this case{X/U,Y/V,Z/W} and {U/X,V/Y,W/Z}
![Page 29: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/29.jpg)
Unification procedure
An algorithm that constructs most general unifiers for two terms in an environment is a unification procedure.
Since the most general unifier is unique (modulo renaming of variables), unification can also be understood as a function
unify : Subst x Term x Term -> Subst
![Page 30: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/30.jpg)
Theory and simple programs (cont) Operational Semantics, SLD
Sterling and Shapiro ch. 1,2,4,5,6Nilsson and Maluszynski ch.1,2,3,6
![Page 31: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/31.jpg)
Example cont.: structured data
Use compound (not atomic) terms for the description of persons. parent(erik, jonas).
parent(erik, eva).
parent(lena, jonas).
male(person(erik,50,180cm)).
male(person(jonas,25,_)).
father(Dad,Child) :- Dad = person(DadName,_,_), Child=person(ChildName,_,_), parent(DadName, ChildName),
male(Dad).
?-father(person(_,50,_), person(X,_,_)). X=jonas (second solution: X = eva)
NB: how does the unification algorithm work here?
![Page 32: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/32.jpg)
Logical Variables in ProgramsVariables and parameters are implicitly quantified
syntax: variables start with capital letterp(X,Y) :- q(X,Z), r(Z,Y).
is understood as forallX,Y:(p(X,Y) <-
exists Z:(q(X,Z), r(Z,Y)))
Parameters (X,Y) are often confusingly named "global variables" as opposed to "local variables" (Z)
but if X is global and Y is local, what is Y, if X=Y occurs in program?
![Page 33: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/33.jpg)
Example cont.: recursive rules
ancestor(Ancestor, Descendant) :- parent(Ancestor, Descendant).
ancestor(Ancestor, Descendant) :- parent(Ancestor, Person), ancestor(Person, Descendant).
parent(ulf, erik). …
?- ancestor(X, Y).
![Page 34: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/34.jpg)
Declarative vs procedural
A logic program can be understood in either of two ways:
it can be seen as a set of Horn clauses specifying facts about
data (a theory). This is the declarative or model-
theoretical reading of a logic program. What?
it can be viewed as a program describing a particular
execution (how to find a proof). This is the procedural
or proof-theoretical reading of a logic program. How?
![Page 35: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/35.jpg)
Modus Ponens
P Q:-P --------------
Q
![Page 36: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/36.jpg)
Proof methods with Horn clauses
Given a database: p :- q,r. q :- q1, q2. q1. q2. r.
Proof methods to prove p:
Forward chaining - use modus ponens to
accumulate known truths, starting from facts.
Backward chaining - prove p by proving q
and then proving r etc. (used in prolog)
![Page 37: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/37.jpg)
Model Theory: Herbrand interpretation
When reading a program as a specification we need to determine the meaning of the symbols.
A term interpretation, or "Herbrand interpretation" is an association of a unique function to each functor occurring in the program and an association of sets of tuples of terms to relations.
An interpretation is a model for a program if all statements in the interpretation are true.
![Page 38: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/38.jpg)
Model Theory: Least Herbrand Model
The least Herbrand model is the least term interpretation such that it is a model.
For definite clauses such a unique model always exists.
![Page 39: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/39.jpg)
Least Herbrand Model computed
The model can be inductively built up from the relation symbols and the terms built from constants and terms in the program by constructing a fixpoint.
Use the monotone Tp-operator. (N&M p. 29 ch 2.4), ground(P) is the set of all ground instances of clauses in a program P (assume always at least one functor or constant and only finite structures).
Tp(I) := {A0 | A0:-A1,...,Am in ground(P) & {A1,...,Am} subset I }.
Start from the empty theory and determine the least fixpoint for I=Tp(I) U I.
Note that the model does not contain variables.
![Page 40: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/40.jpg)
Constructing a model with Tp
p :- q,r. q :- q1, q2. q1. q2. r. s.
0: {} 1: {q1,q2,r,s} 2: {q1,q2,r,s,q} 3: {q1,q2,r,s,q,p} 4: {q1,q2,r,s,q,p} Done
The fixpoint is the model {q1,q2,r,s,q,p}
![Page 41: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/41.jpg)
Constructing a model with Tp
p(X) :- q(X,Y),r(X). q(X,Y) :- q1(X,Y), q2(Y,X). q1(a,b). q2(b,a). r(a).
Herbrand universe: {a,b}
0: {} 1: {q1(a,b),q2(b,a),r(a)} 2: {q1(a,b),q2(b,a),r(a),q(a,b)} 3: {q1(a,b),q2(b,a),r(a),q(a,b),p(a)}
4: {q1(a,b),q2(b,a),r(a),q(a,b),p(a)} Done
The fixpoint is the model: {q1(a,b),q2(b,a),r(a),q(a,b),p(a)}
![Page 42: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/42.jpg)
Infinite structures
Assuming that the least Herbrand Model defines the intended meaning of the program, unification must preserve the property that infinite (cyclic) terms are not allowed. This requires an occurs-check in the unification algorithm prohibiting for example X=f(X) from generating
X=f(f(f(f(f(f(f(........This is very inefficient so occurs-check is the responsibility
of the programmer. In critical cases a special test must be performed after the unification.
Note that SICStus Prolog uses rational trees in X=f(X)
Theoretically sound unification: unify_with_occurs_check/2
![Page 43: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/43.jpg)
Proof theory:Execution is search for a proof or failure, generating an or-tree
restrictions on the variables are shown as bindings of the variables
![Page 44: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/44.jpg)
Search trees and proof trees
proof
Search tree Proof tree
![Page 45: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/45.jpg)
SLD-resolution rule
<- A1,..,Ai-1,Ai,Ai+1,...,Am B0 <- B1,...,Bn ------------------------------------------<- (A1,...,Ai-1,B1,...,Bn,Ai+1,...,Am)
Where P is a program,A1,...,Am are atomic formulas (goals),B0<- B1,...,Bn is a (renamed) clause in Pand=mgu(Ai,B0)
![Page 46: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/46.jpg)
Goal and clause selection
A goal selection function specifies which goal Ai is selected by the SLD-rule.
The order in which clauses are chosen is determined with a clause selection rule.
![Page 47: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/47.jpg)
Soundness of SLD-resolution
Any query (goal) that is provable with SLD-resolution is a logical consequence of the program.
![Page 48: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/48.jpg)
Completeness of SLD-resolution
Any query (goal) that is (true) in the least Herbrand model is provable with SLD-resolution.In the case of an infinite SLD-tree, the selection
function has to be fair (as in breadth first search). For finite SLD-trees left-first-with-backtracking as used in Prolog gives a complete method.
![Page 49: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/49.jpg)
Conclusion
LP can be used as a uniform language for representing databases, e.g. data structure and queries can be written in a single language
LP extends traditional databases by having recursive rules and structured data facilities
![Page 50: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/50.jpg)
F2: Logic Programming Style
Sterling and Shapiro ch. 2,6,7,13 (except 2.4, 2.5, 3.6, 6.3, 7.6, 13.3, 13.4)Nilsson and Maluszynski ch.7 (except 7.3)
![Page 51: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/51.jpg)
Outline
Programming techniquesArithmetic in PrologDifferent primitives for equality: =/2, ==/2
Recursive definitionsProcedural - declarativeImperative - logical style
binary trees, listsappend/3 reverse/2 quicksort/2
![Page 52: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/52.jpg)
Specifying the use of a procedure
For serious projects it is good programming practice to specify the intended use of important procedures, such as the predicates intended to use in a library.
For instance this could be given as a comment of the following form:
% procedure foo(T1,T2,...Tn)%% Types: T1: type 1% T2: type 2% T3: type 3% ...% Tn: type n% Relation scheme:...% Modes uf use: (input arguments T1,T2) (output arguments T3,...,Tn)% Multiplicities of solution: deterministic (one solution only)
![Page 53: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/53.jpg)
Built-in arithmetics
is/2 a built-in predicate for evaluation of arithmetical expressions
?- Value is Expression. - first, Expression is evaluated and, second, unified with Value
For example,
?- X = 2, Y is 1+X*3. - Y = 7?- X = 2, 4 is X*X. - yes?- Z is 1+x. - instantiation error, x is a constant?- Z is 1+X. - instantiation error, X is not instantiated?- 2 is 1+X. - instantiation error, X is not instantiated?- X=1+2. - Yes. X = 1+2.
![Page 54: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/54.jpg)
Built-in arithmetics
is/2 evaluates expressions containing:
+ - * / // mod
- plus, minus, multiplication, division, integer division, remainder/\ \/ # \ << >>
- bitwise conjunction, disjunction, exclusive or, negation, shift to the left, shift to the right
abs(X), min(X), max(X), sin(X), cos(X), sqrt(X).
(for a complete list, see the SICStus manual)
Typical error: failing to unify floating point numbers.
![Page 55: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/55.jpg)
NB: different "equals"= - unification= = ( \== ) - equality (inequality) of terms =:= ( =\= ) - arithmetic, boolean (not)equal is/2 - evaluation and unification
?- X=2, X=Y. - Yes. X=2, Y=2.?- X=2, X==Y. - No.?- X=:=2. - instantiation error ?- X=2, Y=2, X=:=Y. - Yes. X=2, Y=2.?- X=2+3, Y is X. - Yes. X=‘+’(2,3), Y=5.
![Page 56: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/56.jpg)
Elementary programs
Sterling and Shapiro ch. 1,2,4,5,6Nilsson and Maluszynski ch.1,2,3,6
![Page 57: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/57.jpg)
Composing recursive programs
think about declarative meaning of recursive data type (a definition)
write down recursive clause and base clauserun simple examples - check different goalscheck what is happening (do you get the
expected result?)
![Page 58: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/58.jpg)
Composing recursive programs
Typical errors: missing (or erroneously failing) base
case error in data structure representationwrong arity of structuresmixing an element and a listpermuted arguments
![Page 59: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/59.jpg)
Natural numbers
Unary syntaxFor example,
0 - denotes zeros(0) - denotes 1
... s(…s(s(0))…) - denotes n
Defining the natural numbers
natural_number(0).natural_number(s(X)) :-
natural_number(X).
![Page 60: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/60.jpg)
Natural numbers
plusplus(0, X, X) :- natural_number(X).plus(s(X), Y, s(Z)) :- plus(X, Y, Z).
?- plus(s(0),0,s(0)). - checks 1+0=1Yes.
?- plus(X,s(0),s(s(0)). - checks X+1=2, (e.g. compute X=2-1)X=s(0).
?- plus(X, Y, s(s(0))). - checks X+Y=2, (e.g. generate all pairs of natural numbers, whose sum equals 2)
X=0, Y=s(s(0));
X=s(0), Y=s(0);
X=s(s(0)), Y=0.
![Page 61: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/61.jpg)
Natural numbersless or equal
le(0, X) :- natural_number(X).le(s(X), s(Z)) :- le(X, Z).
multiplication
times(0, X, 0) :- natural_number(X).times(s(X), Y, Z) :-
plus(Y, Z1, Z), times(X, Y, Z1).
check how substitution works!
![Page 62: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/62.jpg)
Recursive Arithmetic
sum([],0).sum([H|T],S) :- sum(T,V), S is H+V.
sum0([],0).sum0([H|T],S) :- sum0(T,V), S=H+V.
![Page 63: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/63.jpg)
Binary treesSyntax (not built-in, create own compound terms)
For example, void - denotes empty tree tree(Element, Left, Right) - denotes a tree, where Element is
root and Left, Right are subtrees
tree(5,tree(8,void,void),tree(9,void,tree(3,void,void)))
defining a tree
binary_tree(void).binary_tree(tree(Element, Left, Right)) :-
binary_tree(Left), binary_tree(Right).
![Page 64: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/64.jpg)
Binary trees
membershiptree_member(X,tree(X,_,_)).tree_member(X,tree(Y,Left ,_)):- tree_member(X,Left). tree_member(X,tree(Y,_,Right)):- tree_member(X,Right).
NB: X might be equal to Y in clauses 2 and 3!
![Page 65: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/65.jpg)
Lists
Syntax
[Head|Tail] cons cell
Head is an element, Tail is a list '.'(Head,Tail)
[] empty list
simpler syntax[a | [] ] = [a] [a | [ b | [] ] ] = [a, b] [erik], [person(erik,_,_),jonas|[lena, eva]]
defining a listlist([]). - defines the basislist([X|Xs]) :- list(Xs). - defines the recursion
![Page 66: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/66.jpg)
Lists
checking membershipmember(X, [X|Xs]).member(X, [Y|Ys]) :- member(X, Ys).
?- member(a, [b,c,a,d]). - checks membership
?- member(X, [b,c,a,d]). - takes an element from a list
?- member(b, Z). - generates a list containing b
![Page 67: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/67.jpg)
Listsconcatenation of lists
append([], Xs, Xs).append([X|Xs], Y, [X|Zs]) :- append(Xs, Y, Zs).
?- append([a,b], [c], X). - addition of two lists
?- append(Xs, [a,d], [b,c,a,d]).
- finds a difference between lists
?- append(Xs, Ys, [a,b,c,d]).
- divides a list into two lists
Check SLD-tree!
Typical error: wrong "assembly" of a resulting list
![Page 68: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/68.jpg)
Lists
reversing listsreverse([], []).reverse([H|T],R) :- reverse(T,S), append(S,[H],R).
?- reverse([a,b,c,d],R). - gives R=[d,c,b,a]
Check SLD-tree!
Typical error: wrong "assembly" of resulting listwrong_reverse([H|T],R):-
reverse(T,S), append(S,H,R).
![Page 69: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/69.jpg)
Lists
sortingquicksort([X|Xs], Ys) :-
partition(Xs, X, Littles, Bigs),quicksort(Littles, Ls),quicksort(Bigs, Bs),append(Ls, [X|Bs], Ys).
quicksort([], []).
partition([Y|Ys], X, [Y|Ls], Bs) :- X>Y, partition(X, Ys, Ls, Bs).
partition([Y|Ys], X, Ls, [Y|Bs]) :- X=<Y, partition(X, Ys, Ls, Bs).
partition([], _, [], []).
![Page 70: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/70.jpg)
DictionariesFinding and adding a value in a dictionary (an (ordered) binary tree) %lookup(+,?,?)
lookup(Key, tree(Key,Value, Left, Right), Value):- !.
lookup(Key, tree(Key1, Value1, Left, Right), Value) :- Key < Key1, lookup(Key, Left,
Value).
lookup(Key, tree(Key1, Value1, Left, Right), Value) :- Key > Key1, lookup(Key, Right,
Value).
?- lookup(1, D, fifi),lookup(2, D, mumu),lookup(1,D, X).D=tree(1, fifi, _C, tree(2, mumu, _B, _A)), X=fifi.
NB: for finding a key of a value, the traversal of tree should be implemented.
![Page 71: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/71.jpg)
Composing recursive programsFinal exampleDefine a predicate unsort_deg(Xs, D) that, given a list of numbers, finds its unsort degree D.
The unsort degree of a list is the number of pairs of element positions in the list such that the first position precedes the second in the list, but the number occupying the first position is greater than the number occupying the second position.
Some examples: the unsort degree of the list [1, 2, 3, 4] is 0 the unsort degree of the list [2, 1, 4, 3] is 2 the unsort degree of the list [4, 3, 2, 1] is 6
![Page 72: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/72.jpg)
Representing setsSets can be represented by the existing datatypes in a convenient way by
enforcing an order on a structure used to store the set. For instance using an ordered list (or tree) where each element has a unique occurrence and where all operations are assumed to take ordered unique lists as input and produce ordered unique lists.
If the sets are allowed to contain uninstantiated elements, however, we may have some problems with enforcing the requirement that the lists are ordered and unique, since the requirement may be violated in a later stage.
Consider for instance[X,Y,Z] as a representation of a set with three uninstantiated elements. Of course if X=Y is executed, the list no longer contains unique elements. Perhaps even more obvious is that we cannot ensure that the order of the elements is the one intended until the elements are at least partially known.
invariants are the responsibility of the programmer
![Page 73: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/73.jpg)
Syntactic support
Using op/3 properties (priority, prefix,infix,postfix, associativity) of operators can be defined and then used. (see manual for details)
Predicates defined by the user are written with the same syntax as structures, for instance
:- op(950, xfy, [in]).foo(Y) :- X in Y, baz(Y in U,Z).
![Page 74: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/74.jpg)
Advanced recursive techniques
Sterling and Shapiro ch. 7,8,13.3, 15Nilsson and Maluszynski ch. 7.3.
![Page 75: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/75.jpg)
Outline
Programming with accumulating parameters
Programming with difference-structures
Queues with difference-structures
Abstract data types, separation of data definitions (types) and the program's logic
![Page 76: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/76.jpg)
Accumulating parameters
reverse listsa) naive reverse (using append in each recursion step) reverse([], []). reverse([X|Xs], Ys) :-
reverse(Xs, Zs), append(Zs, [X], Ys).
b) reverse-accumulate reverse(Xs, Ys) :-
reverse(Xs, [], Ys). reverse([], Acc, Acc). reverse([X|Xs], Acc, Ys) :-
reverse(Xs, [X|Acc], Ys).
advice: draw simple SLD-tree and check substitutions!
![Page 77: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/77.jpg)
Built-in arithmetics
ExampleDefine the predicate for computing the factorial of a given integer.
a) recursion
factorial(0, 1).factorial(N, F) :-
N > 0,N1 is N -1,factorial(N1, F1),F is N*F1.
![Page 78: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/78.jpg)
Built-in arithmetics
ExampleDefine the predicate for computing the factorial of a given integer.
b) recursion with an accumulator
factorial(N, F) :- factorial(N, F, 1).factorial(0, F, F).factorial(N, F, F1) :-
N > 0,N1 is N -1,F2 is N*F1,factorial(N1, F, F2).
![Page 79: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/79.jpg)
Built-in arithmeticsExample
Define the predicate for computing the sum of members of integer-list.
a) recursionsumlist([], 0).sumlist([I|Is], Sum) :-
sumlist(Is, Sum1),Sum is Sum1 + I.
b) iteration (with accumulator)sumlist(List, Sum) :- sumlist(List, 0, Sum).sumlist([], Sum, Sum).sumlist([I|Is], Sum1, Sum) :-
Sum2 is Sum1 + I,sumlist(Is, Sum2, Sum).
![Page 80: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/80.jpg)
Using Abstract Data Types
Separation of data definitions (types) and the program's logic.
Specify a set of objectsSpecify set of operations (relations, functions)
on the objects Allow access to objects only through defined
operations
![Page 81: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/81.jpg)
Using Abstract Data Types
Assume the "data type predicates" specifying operations on a given representation of lists:
cons(H,T,[H|T]). nil([]). equal(X,X).
Using this method allows change in representation without change in the code of the algorithm.
![Page 82: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/82.jpg)
Abstract form of append/3
append(A,B,C) :- nil(A), equal(B,C).
append(A,B,C) :-cons(H,T,A),cons(H,R,C),append(T,B,R).
![Page 83: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/83.jpg)
Changing Representation
Note that the representation of lists can be changed without changing the algorithmic code defining append/3
by replacing these "datatype predicates": cons(H,T,foo(T,H)). nil(bar).
![Page 84: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/84.jpg)
Difference-lists
syntax D1-D2, where D1 is a list, which ends with D2
D-D - empty list
diff-lists representing [a,b,c][a, b, c| R] – R[a, b, c, d, e] - [d,e][a, b, c]-[]
adding two lists by unification only [a, b, c] use D1=[a,b,c|R1]-R1=D0-R1 [d] use D2=[d|R2]-R2
[a,b,c,d]use D=D0-R2, assuming that R1=[d|R2]
![Page 85: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/85.jpg)
Difference-lists
concatenationappend_dl(D0-D1, D1-D2, D0-D2).
reversereverse(X, Y) :- reverse_dl(X, Y-[]).
reverse_dl([], Xs-Xs).reverse_dl([X|Xs], Ys-Zs) :-
reverse_dl(Xs, Ys-[X|Zs]).
![Page 86: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/86.jpg)
Difference-lists
sortingquicksort(Xs, Ys) :- quicksort_dl(Xs, Ys-[]).quicksort_dl([X|Xs], Ys-Zs) :-
partition(X, Xs, Littles, Bigs),quicksort_dl(Littles, Ys-[X|Z1]),quicksort_dl(Bigs, Z1-Zs).
quicksort_dl([], Xs-Xs).
partition(X,[Y|Ys],[Y|Ls],Bs) :- X > Y, partition(X,Ys,Ls,Bs).
partition(X,[Y|Ys],Ls,[Y|Bs]) :- X =< Y, partition(X,Ys,Ls,Bs).
partition(_,[],[],[]).
![Page 87: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/87.jpg)
Queues
A queue may be implemented as a difference listenqueue and dequeue
- enqueue(Element, OldQueue, NewQueue) enqueue(X, Qh-[X|Qt], Qh-Qt).
- dequeue(Element, OldQueue, NewQueue) dequeue(X,[X|Qh]-Qt, Qh-Qt).
![Page 88: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/88.jpg)
Queues (cont)
S=[in(5), in(9), in(10), out(X1), out(X2), in(4)]
- an input list for queueing
queue(S) :- queue(S, Q-Q).queue([], Q).queue([in(X)|Xs], Q) :- enqueue(X, Q, Q1), format("In ~d ~n", X),
queue(Xs, Q1). queue([out(X)|Xs], Q) :- dequeue(X, Q, Q1), format("Out ~d ~n", X),
queue(Xs, Q1).
![Page 89: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/89.jpg)
F3: Programming with search
Sterling and Shapiro ch. 6,7,11,14,20,21Nilsson and Maluszynski ch.4,5,11,12, A.3
![Page 90: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/90.jpg)
Outline - Search and control
Proof treesCutNegation, SLDNF
![Page 91: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/91.jpg)
Outline
Cutexecution of a program with cutsinsertion of cuts in your own program:
"green" and "red" cuts
implementation of if-then-else
Negationbasic conceptsexecution of programs with negationimplementation of negation
![Page 92: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/92.jpg)
Controlling search
Sometimes when a solution to a subproblem has been found, no other solutions to it or to earlier proved subgoals of the current goal need to be considered.
By using the non-logical primitive predicate !, named 'cut', you remove alternative branches to subgoals and to the clause that is currently being proved. The alternatives on a 'higher' level, that is to the clause which the current goal is a part of are, though, kept. This can decrease the amount of unnecessary computation.
![Page 93: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/93.jpg)
Cut
syntax !, can be placed in the body of a clause or a goal as one of its atoms to cut branches of an SLD-tree p(X) :- q(X), !, r(X).
effects divides the body into two parts: when "!" is reached, it is evaluated to
true and all backtracking of the left-side of the body is disallowed. The execution of the right-side of the clause body continues as usual.
new matches of the head of the clause are disallowed e.g. backtracking is stopped one level up in the SLD-tree
![Page 94: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/94.jpg)
Cut performs two operations
P :- Q, !, R.P :- ...
removes alternatives to Q that haven't been tried when passing the cut
removes alternatives to P that haven't been tried when passing the cut
![Page 95: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/95.jpg)
Cut
example: execution of a program with cutsConsider the following program:
top(X,Y):- p(X,Y).top(X,X) :- s(X).p(X,Y) :- true(1), q(X), true(2), r(Y).p(X, Y) :- s(X), r(Y).q(a). q(b). r(c). r(d). s(e).true(X).
?- top(X,Y).¤ in the given program (seven answers)¤ when true(1) is replaced by ! (five answers)¤ when true(2) is replaced by ! (three answers)
![Page 96: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/96.jpg)
Cut
inserting cuts in your own program in order to increase efficiency"green" cut:
does not change the semantics of a program (cuts away only failing branches in an SLD-tree)
"red" cut: changes the semantics of a program (cuts also away
success branches in an SLD-tree)in general, the red cuts are considered harmful
![Page 97: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/97.jpg)
Cut
"Green cut": an exampleGiven two sorted integer-lists Xs and Ys, construct a sorted integer-list Zs, containg elements from Xs and Ys.
merge([], Ys, Ys).merge(Xs, [], Xs).merge([X|Xs], [Y|Ys], [X|Zs]) :-
X < Y, merge(Xs, [Y|Ys], Zs).merge([X|Xs], [Y|Ys], [X, Y|Zs]) :-
X = Y, merge(Xs, Ys, Zs). merge([X|Xs], [Y|Ys], [Y|Zs]) :-
X > Y, merge([X|Xs], Ys, Zs).
![Page 98: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/98.jpg)
Cut
"Green cut": an example (cont.)
merge([], Ys, Ys):- !.merge(Xs, [], Xs):- !.merge([X|Xs], [Y|Ys], [X|Zs]) :-
X < Y, !, merge(Xs, [Y|Ys], Zs).merge([X|Xs], [Y|Ys], [X, Y|Zs]) :-
X = Y, !, merge(Xs, Ys, Zs). merge([X|Xs], [Y|Ys], [Y|Zs]) :-
X > Y, !, merge([X|Xs], Ys, Zs).
![Page 99: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/99.jpg)
Cut
"Red cut": an exampleFind the minimum of two integers.
Try:minimum(X, Y, X) :- X =< Y, !.minimum(X, Y, Y).
?- minimum(4,5,Z). - Yes, Z = 4.?- minimum(5,4,Z). - Yes, Z = 4.?- minimum(4,5,5). - Yes.
Correction:minimum(X, Y, Z) :- X =< Y, !, Z=X.minimum(X, Y, Y).
![Page 100: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/100.jpg)
Cut
"Red cut": an exampleChecking membership in a list.
member(X, [X|Xs]) :- !.member(X, [Y|Ys]) :- member(X, Ys).
?- member(a, [b,c,a,d]). - checks membership, OK
?- member(X, [b,c,a,d]). - takes elements from a list, takes only the first element
?- member(b, Z). - generates lists containing bgenerates only one list
OBS: Check the example lookup/3 from the previous lecture!
![Page 101: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/101.jpg)
Cut
implementation of if-then-else
P :- Condition, !, TruePart.P :- ElsePart.
or
(Condition -> TruePart; ElsePart)
For example,
minimum(X, Y, Z) :- (X =< Y -> Z = X; Z = Y).
![Page 102: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/102.jpg)
Negation: how to use and prove negative information?
A negated query 'not_p(x)' should succeed if the proof of the statement 'p(x)' fails and it should fail if the proof of the statement 'p(x)' succeeds.
%not_p(++) (++ stands for a ground term)not_p(X) :- p(X), !, false. not_p(_).
![Page 103: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/103.jpg)
Closed world assumption
That which is not stated explicitly is false
animal(cow).not_animal(X) :- animal(X), !, false.not_animal(_).
?- not_animal(X), X=house.
A house is not an animal so the query should succeedUnfortunately it fails. Why?
![Page 104: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/104.jpg)
Closed world assumption
animal(cow).
not_animal(X) :- animal(X),!, false.not_animal(_).
not_not_animal(X) :- not_animal(X),!, false.not_not_animal(_).
?- not_not_animal(X), X=house.
Unfortunately this succeeds. Why?
![Page 105: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/105.jpg)
Negationhow to use and prove negative information?
to apply closed world assumption (cwa):
the statement \+ A is derivable if A is a formula which cannot be derived by SLD-resolution.- Problem with infinite SLD-trees
implementation: negation as failure (naf):
the statement \+ A is derivable if the goal A has a finitely failed SLD-tree.The problem when A has variables remains.unmarried_student(X) :- \+ married(X), student(X).student(erik).married(jonas).
![Page 106: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/106.jpg)
Negation
SLDNF-resolutionthe combination of SLD-resolution to resolve positive
literals and negation as failure to resolve negative literals
foundation(X) :- on(Y, X), on_ground(X).on_ground(X) :- \+ off_ground(X).off_ground(X) :- on(X, Y).above(X, Y) :- on(X, Y).above(X, Y) :- on(X, Z), above(Z, Y).on(c, b).on(b, a).
![Page 107: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/107.jpg)
Negation
Four kinds of SLDNF-derivations:refutations (that end with success branches);infinite derivations;(finitely) failed derivations;stuck derivations (if none of the previous apply).
NB: check examples in N&M, pp. 71-73.
![Page 108: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/108.jpg)
Negation
implementation of \+
\+ Goal :- call(Goal), !, fail.\+ Goal.
examplep(a).
?- p(X). Yes, X = a.?- \+ \+ p(X). true, X is not instantiated
![Page 109: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/109.jpg)
Search based programming
Sterling and Shapiro ch. 6,7,11,14,20,21Nilsson and Maluszynski ch.4,5,11,12, A.3
![Page 110: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/110.jpg)
Outline- Search based programming
State space programminggenerate-and-testsearching in a state-space
Graph theoretical examples Euler paths, Hamilton paths
Puzzle-solving, game-playing
Sterling and Shapiro ch. 14,20Nilsson and Maluszynski ch. 11
![Page 111: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/111.jpg)
Generate-and-test
A technique in algorithm design, which defines two processes the first generates the set of candidate solutionsthe second tests the candidates
In PROLOG: find(X):- generate(X), test(X).
Important optimisation: to "push" the tester inside the generator as "deep" as possible
![Page 112: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/112.jpg)
Generate-and-test
important optimisation: to "push" the tester inside the generator as "deep" as possible
find(X):- generate1(X), test1(X), generate2(X), test2(X),generate3(X), test3(X), generate4(X), test4(X).
![Page 113: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/113.jpg)
Generate-and-testExample 1
Finding parts of speech in a sentence:
verb(Sentence,Word) :
member(Word,Sentence),verb(Word).
noun(Sentence,Word) :
member(Word,Sentence),noun(Word).
article(Sentence,Word):
member(Word,Sentence),article(Word).
noun(man). noun(woman). article(a). verb(loves).
?- noun([a, man, loves, a woman], N).
N=man; N=woman
NB. member/2 should not contain cuts. Why?
![Page 114: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/114.jpg)
Generate-and-test Example 2
Place N queens on a NxN chess-board in such a way that any two queens are not attacking each other.
a) Naive generate and test places N queens and then test whether they are not attacking each other. The answer is a list of queens' positions, for example [3, 1, 4, 2].
queens(N, Qs) :- range(1, N, Ns), % Ns is the list of integers in 1..N permutation(Ns, Qs), % Qs is a permutation of Nssafe(Qs). % true, if the placement Qs is safe
range(M, N, [M|Ns]) :- M < N, M1 is M +1, range(M1, N, Ns).
range(N, N, [N]).
![Page 115: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/115.jpg)
Generate-and-test
Example 2 (cont.)permutation(Xs, [Z|Zs]) :-
select(Z, Xs, Ys), permutation(Ys, Zs).
permutation([], []).
select(X, [X|Xs], Xs).select(X, [Y|Ys], [Y|Zs]) :- select(X, Ys, Zs).
safe([Q|Qs]) :- safe(Qs), \+ attack(Q, Qs).safe([]).
attack(X, Xs) :- attack(X, 1, Xs).attack(X, N, [Y|Ys]) :- X is Y+N; X is Y-N.attack(X, N, [Y|Ys]) :- N1 is N+1, attack(X, N1, Ys).
![Page 116: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/116.jpg)
Generate-and-test
Example 2 (cont.)b) When generating a position of a queen, test whether it is permitted
queens(N, Qs) :- range(1, N, Ns),queens(Ns, [], Qs).
queens(UnplacedQs, SafeQs, Qs) :-select(Q, UnplacedQs, UnplacedQs1),\+ attack(Q, SafeQs),queens(UnplacedQs1, [Q|SafeQs], Qs).
queens([], Qs, Qs).
select/3, attack/2 are the same as in a).
![Page 117: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/117.jpg)
Searching in a State-space
- loop-avoidance in searching for a path
- efficiency issues
- different search strategies
![Page 118: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/118.jpg)
Searching in a State-space
Many problems in computer science can be formulated as follows:
Given some start-state S0 and a set of goal-states determine whether there exists a sequenceS0 ---> S1, S1 ---> S2, …, Sn-1 ---> Sn,such that Sn belongs to a set of goals.
States can be seen as nodes in a graph whose edges represent the pairs in the transition-relation, then the problem reduces to that of finding a path from the start-state to one of the goal-states.
![Page 119: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/119.jpg)
Searching in a state-space
Finding a pathpath(X,X).path(X,Z) :- edge(X,Y), path(Y,Z).
edge(X,Y) :- % define construction/finding of the next node
For exampleedge(a,b). edge(b,c). edge(c,d).
?- path(a,d). - Yes.?- path(a,X). - Yes. X=a; X=b; X=c; X=d.?- path(X,d). - Yes. X=d; X=a; X=b; X=c.
![Page 120: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/120.jpg)
Searching in a state-space
Loop detectionpath(X, Y) :-
path(X, Y, [X]).
path(X, X, Visited).path(X, Z, Visited):-
edge(X, Y),\+ member(Y, Visited),path(Y, Z, [Y|Visited]).
member(X, [X|Y]) :- !.member(X, [Y|Z]) :- member(X, Z).
![Page 121: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/121.jpg)
Searching in a state-space
Returning the path as an answer to the goal path(X, Y, Path) :-
path(X, Y, [X], Path).
path(X, X, Visited, Visited).path(X, Z, Visited, Path):-
edge(X, Y),\+ member(Y, Visited),path(Y, Z, [Y|Visited], Path).
member(X, [X|Y]) :- !.member(X, [Y|Z]) :- member(X, Z).
![Page 122: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/122.jpg)
Searching in a state-space
Puzzle: Missionaries and cannibalsThree missionaries and three cannibals must cross a river, but the
only available boat will hold only two people at a time. There is no bridge, the river cannot be swum, and the boat cannot cross the river without someone in it. The cannibals will eat any missionaries they outnumber on either bank of the river.
The problem is to get everyone across the river with all the missionaries uneaten.
![Page 123: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/123.jpg)
Searching in a state-space
puzzle( Moves ) :-path( state(3, 3, left), state(3, 3, right), Moves).
path(InitNode, FinalNode, Path) :-path(InitNode, FinalNode, [InitNode], Path).
path(InitNode, FinalNode, _, []) :- InitNode = FinalNode, !.path(Node0, FinalNode, VisitedNodes, [Arc|Path]):-
edge(Node0, Arc, Node1),\+ member(Node1, VisitedNodes),path(Node1, FinalNode, [Node1|VisitedNodes], Path).
![Page 124: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/124.jpg)
Searching in a state-space
Example (cont.) edge( state(M0, C0, L0), move( M, C, D), state (M1, C1, L1) ):-
member(M, [0, 1, 2]),member(C, [0, 1, 2]),M + C >= 1,M + C =< 2,M0 >= M,C0 >= C,M1 is 3 - (M0 - M),C1 is 3 - (C0 - C), ( M1 =:= 0 ; M1 =:= 3; M1 = := C1), (L0 = left -> ( D = leftRight, L1 = right); ( D = rightLeft, L1 = left) ).
![Page 125: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/125.jpg)
Searching in a state-space
Better representation – simpler algorithmStore the whole graph as one fact
graph([edge(a,b),edge(c,d),edge(b,c)]).
path(X, Y, Path) :- graph(G),path(X, Y, Path, G, []).
path(X, X, [X], G, G).path(X, Z, Path, G0, G1):-
deleteedge(X, Y, G0, Gt),path(Y, Z, [Y|Path], Gt,G1).
deleteedge(X, Y, [edge(X,Y)|T], T) :- !.deleteedge(X, Y, [A|T], [A|R]) :-
deleteedge(X, Y, T, R).
![Page 126: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/126.jpg)
Searching in a state-space
Basic search methodsdepth-first - interprets current nodes as a stackbreadth-first - interprets current nodes as a queuebounded-depth - "controls" the depth of the searchiterative-deepening -"controls" the depth of the searchheuristic methods – using domain specific knowledge
![Page 127: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/127.jpg)
Searching in a state-space
Heuristic searchto solve larger problem, some domain-specific
knowledge must be added to improve search efficiency
the term heuristic is used for any advice that is often effective, but isn't guaranteed to work in every case
a heuristic evaluation function estimates the cost of a shortest path between a pair of states
![Page 128: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/128.jpg)
Many search strategiesBottom-up - inductively generate facts from known
factsTop-down - recursively find supporting rules for query
Serial - alternatives one at a time, backtrack for moreOr- parallel - to prove A or B try A and B in parallelcollect all solutions or choose one (first found, best
etc.)Concurrent - to prove A & B try A and B concurrentlyAND-parallel - to prove A & B where A and B have nothing
in common do A and B in parallel, then combine results and go on
Iterative deepening – search all solutions down to a maximum depth, then increase max
Tabled execution – keep ongoing calls in a table to avoid redundant work
![Page 129: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/129.jpg)
Parallelism and Concurrency
Concurrent logic programming modelsParallel execution on multiprocessors
Sterling and Shapiro ch. 14.2 Nilsson and Maluszynski ch.12,14, A.3
![Page 130: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/130.jpg)
Concurrent Logic Programming
essense goals in the body of a clause can execute as interleaving processes p(X) :- q(X), r(X).
Synchronisation on variable unification "X? = Y" means "X must not be bound by unification"
effects
divides the body into two parts and switches execution between the goals.
deadlock is possible
![Page 131: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/131.jpg)
Parallel logic programming
Computation can be distributed over several computers possibly sharing memory.
OR-parallelismcopying of backtrack stack sharing of binding environment
AND-parallelismindependent AND (CIAO-Prolog)stream-and ("Penny", parallel AKL)
![Page 132: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/132.jpg)
Game playingGame trees
a game tree is an explicit representation of all possible plays of the game. The root node is the initial position of the game, its successors are the positions which the first layer can reach in one move, their successors are the positions resulting from the second player's replies and so on.
the trees representing the games contain two types of node: max at even levels from the root, and min nodes at odd levels of the root.
a search procedure combines an evaluation function, a depth-first search and the minimax backing-up procedure.
![Page 133: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/133.jpg)
Game playing
4
4 2
4 8 2 7 5
4 8 5 2 7 53
Maximise
Maximise
Minimise
![Page 134: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/134.jpg)
F4: Logic and grammars
Sterling and Shapiro ch. 19 (except 19.2),24Nilsson and Maluszynski ch.10 SICStus Prolog Manual.
![Page 135: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/135.jpg)
Outline
grammarscontext free grammarscontext dependent grammars
![Page 136: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/136.jpg)
Context Free Grammars
A context free grammar is a 4-tuple < N, T, P, S >
where N and T are finite, disjoint sets of nonterminal and terminal symbols respectively, (N U T)* denotes the set of all strings (sequences) of terminals and non-terminals P is a finite subset of N x (N U T)* ,S is a nonterminal symbol called the start symbol. Empty string is denoted by and elements of P are usually written in the form of production rules:
A ::= B1, …, Bn (n > 0)A ::= (n = 0)
![Page 137: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/137.jpg)
Grammars
Example 1 <sentence> ::= <noun-phrase><verb-phrase><noun-phrase> ::= the <noun><verb-phrase> ::= runs<noun> ::= engine<noun> ::= rabbit
<sentence> derives the strings the rabbit runs, the engine runs. How?
![Page 138: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/138.jpg)
Grammars Example 2
prod_rule(sentence, [noun_phrase, verb_phrase]).prod_rule(noun_phrase, [the, noun]).prod_rule(verb_phrase, [runs]).prod_rule(noun, [rabbit]).prod_rule(noun, [engine]).
An interpreter for production rules:derives_directly(X, Y) :- derives(X, X).
append(Left, [Lhs|Right], X), derives(X, Z) :-prod_rule(Lhs, Rhs), derives_directly(X,
Y),append(Left, Rhs, Temp), derives(Y, Z).append(Temp, Right, Y) .
?- derives([sentence], X). Yes. What is X unified to?
How can you force all productions to be considered before terminating?
![Page 139: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/139.jpg)
Grammars
Example 3sentence(Z) :- append(X, Y, Z), noun_phrase(X), verb_phrase(Y).noun_phrase([the|X]) :- noun(X).verb_phrase([runs]).noun([rabbit]).noun([engine]).
append([], X, X).append([X|Xs], Y, [X|Zs]) :- append(Xs, Y, Zs).
?- sentence([the, rabbit, runs]). Yes.?- sentence([the, X, runs]). X = rabbit, X = engine?- sentence(X).
![Page 140: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/140.jpg)
Grammars
Example 4Usage of difference-lists:
sentence(X0-X2) :- noun_phrase(X0-X1), verb_phrase(X1-X2).
noun_phrase([the|X]-X2) :- noun(X-X2).verb_phrase([runs|X]-X).noun([rabbit|X]-X).noun([engine|X]-X).
?- sentence([the, rabbit|X] - X).?- sentence([the, rabbit, runs] - []).?- sentence([the, rabbit, runs, quickly] - [quickly]).?- sentence(X).
![Page 141: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/141.jpg)
Grammars
Example 5"Collecting" the result:
sentence(s(N, V), X0-X2) :- noun_phrase(N, X0-X1), verb_phrase(V, X1-X2).
noun_phrase(np(the, N), [the|X]-X2) :- noun(N, X-X2).verb_phrase(verb(runs), [runs|X]-X).noun(noun(rabbit), [rabbit|X]-X).noun(noun(engine), [engine|X]-X).
?- sentence(S, [the, rabbit, runs] - []).Yes. S=s(np(the, noun(rabbit)), verb(runs)).
![Page 142: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/142.jpg)
Grammars
Context dependent grammars <sentence> ::= <noun-phrase>(X) <verb>(X)<noun-phrase>(X) ::= <pronoun>(X)<noun-phrase>(X) ::= the <noun>(X)<verb>(singular) ::= runs<verb>(plural) ::= run<noun>(singular) ::= rabbit<noun>(plural) ::= rabbits<pronoun>(singular) ::= it<pronoun>(plural) ::= they
![Page 143: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/143.jpg)
Grammars
Example 6
sentence(X0-X2) :- noun_phrase(Y, X0-X1), verb(Y, X1-X2).
noun_phrase(Y, X - X2) :- pronoun(Y, X-X2).noun_phrase(Y, [the|X]-X2) :- noun(Y, X-X2).
verb(singular, [runs|X]-X).verb(plural, [run|X]-X).
noun(singular, [rabbit|X]-X).noun(plural, [rabbits|X]-X).
pronoun(singular, [it|X]-X).pronoun(plural, [they|X]-X).
![Page 144: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/144.jpg)
Recognizers for languages: Lexers and parsers
A program that recognizes a string in a formal language is often divided into two distinct parts:
Lexer: translation from lists of character codes to lists of 'tokens'
Parser: the translation from lists of 'tokens' to parse trees
Concrete syntax (describes a string in a language, a list of tokens)
<A> ::= <B>< C> [foo,bar]
Abstract syntax (describes a syntax tree, a term)
<A> :: <B>< C> ‘A’(B, C)
![Page 145: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/145.jpg)
Logical Input
char_infile(FileName,Offset,List) :-open(FileName,read,S),skipchars(S,Offset),readchars(S,List),close(S),!.
skipchars(_S,0) :- !.skipchars(S,I) :- I>0, get0(S,_), J is I-1,
skipchars(S,J).
readchars(S,L) :- get0(S,C), readchars0(S,L,C).
readchars0(_,L,-1) :- !, L=[].readchars0(S,L,C) :- L=[C|R], readchars(S,R).
![Page 146: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/146.jpg)
A recognizer for s-expressions
An s-expression is a general representation form for data used in LISP and in some Prolog dialects, especially those embedded in a LISP or SCHEME environment.
We will show how a program identifying s-expressions looks in Prolog.
![Page 147: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/147.jpg)
Backus-Naur grammar for a legal s-expression
<s-expr> ::= <s-atom> | '(' <s-exprs> ['.' <s-expr>] ')'<s-exprs> ::= <s-expr> [<s-exprs>]<s-atom> ::= [<blanks>] <non_blanks> [<blanks>]<non_blanks> ::= <non_blank> [<non_blanks>]<blanks> ::= <blank> [<blanks>]
A non-blank is a character with a character code greater than 32 (decimal). A blank is a character with a character code less than or equal to 32.
The input to the parser is represented as a list of characters (or character codes).
![Page 148: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/148.jpg)
A recognizer for the s-expression grammar
The predicate sExpr(L1,L2,S) succeeds if the beginning of the list L1 is a list of characters representing an s-expression. As a result of the computation the structure S contains a structure (a list) representing the s-expression. The rest of the input text is stored in the list L2.
p :- sExpr("(A.B)",Out,S), write(Out), write(S).
![Page 149: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/149.jpg)
sExpr(In,Out,S) :-(blanks(In,I0); In=I0),(sAtom(I0,Out,S);lpar(I0,I1),sExprs(I1,I2,S,Last),(dot(I2,I3),sExpr(I3,I4,Last);I4=I2,Last=[]),rpar(I4,Out)).
![Page 150: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/150.jpg)
sExprs(In,Out,[H|T],Last) :-sExpr(In,I1,H),(sExprs(I1,Out,T,Last);Out=I1, T=Last).
sAtom(In,Out,A) :- nonBlanks(In,Out,A).
![Page 151: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/151.jpg)
nonBlanks(In,Out,[H|T]) :-nonBlank(In,I1,H),(nonBlanks(I1,Out,T);I1=Out,T=[]).
blanks(In,Out) :- blank(In,I1), (blanks(I1,Out) ; I1=Out).blank(In,Out) :- In=[C|Out], C<=32.
nonBlank(In,Out,C) :- In=[C|Out], C>=48.
lpar(In,Out) :- In=[#(|Out].rpar(In,Out) :- (blanks(In,I1); In=I1), I1=[#)|Out].dot(In,Out) :- (blanks(In,I1); In=I1), I1=[#.|Out].
![Page 152: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/152.jpg)
A Grammar For Horn Clauses
<clause> ::= <head> [ ':-' <body> ]<head> ::= <goal><body> ::= <goal> [ ',' <body> ]<goal> ::= <name> '(' <termlist> ')' | <cut> | <false><termlist> ::= <term> [ ',' <termlist> ]<term> ::= <variable>
| <dataconstructor> [ '(' termlist ')' ]| <constant>| <list>| <integer>| <expression>
<list> ::= '[' <term> [ <moreterms> ] [ '|' <term> ] ']'<moreterms> ::= ',' <term> [ <moreterms> ]<expression> ::= <term> <operator> <term> | <operator> <term><operator> ::= '=' | '<' | '=<' | '>=' | '>' | '+' | '-' | '*' | '!'<cut> ::= '!'<false> ::= 'false'
![Page 153: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/153.jpg)
Outline - Definite Clause Grammars
Definite clause grammarsParsing Translating grammars into logic programs
Sterling and Shapiro ch. 19 (except 19.2)Nilsson and Maluszynski ch 10.4,10.5SICStus Prolog Manual
![Page 154: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/154.jpg)
Definite Clause Grammars
(DCGs) special syntax for language specifications. The system automatically compiles DCG into a Prolog
clause. DCGs are a generalisation of CFGs.
![Page 155: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/155.jpg)
Definite Clause Grammars
Formalism<N, T, P> N - a possibly infinite set of atoms (non-terminals) T - a possibly infinite set or terms (terminals) P is in N x (N U T)* - a finite set of production rules N and T are disjoint
![Page 156: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/156.jpg)
Definite Clause GrammarsSyntax
terminals are enclosed by list-brackets;nonterminals are written as ordinary compound terms or
constants;',' separates terminals and nonterminals in the right-hand
side;'-->' separates nonterminal to the left from terminals and
nonterminals in the right-hand side;extra conditions, in the form of Prolog procedure calls,
may be included in the right-hand side of a grammar rule. Such procedure calls are written enclosed in '{ }' brackets;
the empty string is denoted by the empty list []
![Page 157: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/157.jpg)
Definite Clause Grammars
Examplesentence --> noun_phrase, verb_phrase.noun_phrase --> [the], noun.verb_phrase --> [runs].noun --> [rabbit].noun --> [engine].
?- sentence(X,A).
Yes
X=[the, rabbit, runs], A=[]
X=[the, engine, runs], A=[]WHY? see the next page.
![Page 158: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/158.jpg)
Definite Clause Grammars
Compilation of DCG's into Prologp(A1, …, An) --> T1, .., Tm
is translated into the clause:p(A1, …, An, X0, Xm) :- T1', …, Tm',
where each Ti' is of the form:q(S1,…Sn, Xi-1, Xi) if Ti is of the form q(S1, …, Sn)'C'(Xi-1, X, Xi) if Ti is of the form [X]T, Xi-1 = Xi if Ti is of the form {T}Xi-1 = Xi if Ti is of the form []
and X1,…Xm are distinct variables
![Page 159: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/159.jpg)
Definite Clause Grammars
Example translated to:
expr(X) --> expr(X, X0, X4) :- term(Y), term(Y, X0, X1),[+], 'C'(X1, +, X2),expr(Z), expr(Z, X2, X3),{X is Y + Z}. X is Y+Z, X3 = X4.
NB:sentence --> noun, verb. sentence(B,C) :-
noun(B,A),verb(A,C).
![Page 160: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/160.jpg)
Definite Clause Grammars
Example grammar<expr> ::= <term> + <expr><expr> ::= <term> - <expr><expr> ::= <term><term> ::= <factor> * <term><term> ::= <factor> / <term><term> ::= <factor><factor> ::= 0|1|2|….
![Page 161: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/161.jpg)
Definite Clause Grammars
Example grammar as DCG (cont.)expr(X) --> term(Y), [+], expr(Z), { X is Y + Z}.expr(X) --> term(Y), [-], expr(Z), { X is Y-Z}.expr(X) --> term(X).term(X) --> factor(Y), [*], term(Z), { X is Y*Z}.term(X) --> factor(Y), [/], term(Z), { X is Y/Z}.term(X) --> factor(X).factor(X) --> [X], {integer(X)}.
?- expr(X, [2, *, 2, +, 4, *, 4], []). X = 20.
NB: avoid rules, which lead to "left hand recursion"expr --> expr, [+], expr.
![Page 162: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/162.jpg)
Definite Clause GrammarsExample
Write a DCG which accepts strings in the language an bm cn (n, m >= 0).
a) if n and m are fixed: n=1, m=2.
abc --> a, b, c.a --> [a].b --> [bb].c --> [c].
test(String) :- abc(String, []).?- test(X). Yes. X=[a,bb,c] ?- test([a,bb,c]). Yes.
![Page 163: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/163.jpg)
Definite Clause Grammars
Example (cont.)Write a DCG which accepts strings in an bm cn dm (n, m >= 0).
b)general case:
abcd(N,M) --> lit(a,N), lit(b,M), lit(c,N), lit(d,M).lit(L, 0) --> [].lit(L, I) --> [L], lit(L, I1), {I is I1+1}.
test(String) :- abcd(N, M, String, []).
?- test([a, b, b, c, d, d]). Yes.
![Page 164: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/164.jpg)
Interpreter as transition relation
An interpreter can be formulated as a transition relation p/2 from states to new states
S0 ---> S1 ---> S2 ---> ... ---> Sn-1 ---> Sn
p(S0,S1), p(S1,S2), … p(Sn-1, Sn)
![Page 165: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/165.jpg)
Assignment as predicate
For instance
X:=E would be modeled as a predicate
assign(X,E,StateIn,StateOut) :- ...
![Page 166: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/166.jpg)
imperative program
state transition relation in a procedure in an imperative language
proc {Prog Z := X X := Y Y := Z
}
![Page 167: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/167.jpg)
Program as transition relation
prog(In,Out) :- assign(Z,X,In,T1), assign(X,Y,T1,T2), assign(Y,Z,T2,Out).
![Page 168: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/168.jpg)
Using grammar notation
The state transformation could be expressed using the grammar notation
prog --> assign(z,x), assign(x,y), assign(y,z).
![Page 169: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/169.jpg)
Transition relations declaratively
State transition predicates are expressed in a perfectly declarative way
They still look very similar to the usage of assignment in an imperative language
It expresses the change of a thread of state objects logically
![Page 170: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/170.jpg)
Ö4: Case study: A compiler for three model computers
Clocksin, ch. 9
![Page 171: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/171.jpg)
F7: Program Transformation
Sterling and Shapiro ch. 13,16,18
![Page 172: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/172.jpg)
Outline
Transformations of programsfold/unfold - partial evaluationHigher order programming
defining and using apply, map
![Page 173: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/173.jpg)
Transformation rules for programs
Since logic programs are defined as axioms, it is often possible to define logically based transformation rules, usable to improve programs.
Here are some examples of such rules:
![Page 174: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/174.jpg)
Equality reordering
P :- … e1…q…e2…-------------------------
-P :- e1,e2…q …
Motivation:
In a (pure) logic program the search will be made more efficient if information about equalities is known as soon as possible to the search procedure.
![Page 175: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/175.jpg)
Equality removal
P :- …,e1,…,e1,…,e1,…-------------------------
-------P :- …,e1,…
Motivation:
In a (pure) logic program statements about equalities need not be repeated. Unification is idempotent, that is the bindings of variables achived by applying a unification Term1 = Term2 will not be extended by a second application of the same unification.
![Page 176: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/176.jpg)
Clause level transformation
A clause (j) is a specialized version of a clause (i)
if (Pi :- Q1,…,Qm) = Pj :- Q1',…,Qm' in a program:..(i) Pi :- Q1,…,Qm
.
.(j) Pj :- Q1',…,Qm'
.
.When clause (j) is a specialized version of clause (i) it is redundant (in a pure logic program).
But: specialization can increase efficiency and also make an otherwise looping program terminate. That is it might be advantageous to generate different versions for different forms of the arguments and then apply other transformations to the resulting clauses.
![Page 177: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/177.jpg)
Removal of failing clauses
Suppose that
(Pi :- Q1,…,Qm) = Pj :- falseThis specialized clause may be removed, since it can never contribute to a solution.
Moreover, clauses Ck containing a goal that only matches the head Pj can be converted into
Ck :- false
and the process can be repeated.
![Page 178: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/178.jpg)
Removal of repeated goals
P :- …,Qn,…,Qn,…-------------------------
P :- …,Qn,…Motivation:
The reasoning concerning equalities above holds for goals in general in a pure logic program. Note that we consider programs equivalent with respect to the Herbrand model. The set of solutions found in proofs may not coincide exactly after such a transformation, but the set of true consequences of a program indicated by the model do coincide given an appropriate interpretation of the free variables in the proofs.
![Page 179: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/179.jpg)
Reordering of goals
P :- …,Qi,…,Qk,…-------------------------
-P :- …,Qk,…,Qi,…
Motivation:
This rule can for instance be used to push recursive calls towards the end of a clause.
![Page 180: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/180.jpg)
Fold/Unfold
P :- Q. | P :- (B1 ; B2).Q :- B1. | Q :- B2. |
-----------> (unfolding)<---------- (folding)
Applying the rules above in combination with rules like those given earlier can create more efficient programs (note that variables must be renamed and the introduction of explicit equalities might be necessary to keep the semantics of P).
![Page 181: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/181.jpg)
Partial deduction/evaluation
Partial deduction - logical semantics is kept
Partial evaluation - operational semantics is kept (same number of solutions, presented in the same order)
Partial evaluation is much harder than partial deduction since it should work even in the presence of non-logical goals such as cut (!), I/O etc.
![Page 182: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/182.jpg)
Stepwise enhancement
identify program skeletons that indicate the control flow.
enhance by adding operations (S&S chap 13)
list([X|Xs]) :- list(Xs).list([]).
sumlist([X|Xs],S) :- sumlist(Xs,S0), S is S0+X.
sumlist([],0).
![Page 183: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/183.jpg)
Stepwise enhancement (cont)
length([_|Xs],L) :- length(Xs,L0), L is L0+1.
length([],0).
sum_length_list([X|Xs],S,L) :- sum_length_list(Xs,S0,L0), S is S0+X, L is L0+1.
sum_length_list([],0,0).
![Page 184: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/184.jpg)
Functions Functions are deterministic relations.There is one unique value in the output
domain for each input tuple.A function f: Term* -> Term can for
instance be encoded as a definition in a logic program as f(X1,…,Xn,Y) with a unique output Y for each input tuple X1,…,Xn.
The relation f/n corresponding to a function with n-1 arguments is deterministic, that is, when all arguments (except possibly the one corresponding to the output value of the function) are fully instantiated.
![Page 185: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/185.jpg)
Higher order
Higher order functions are not directly expressible since functions are not objects in the first-order logical model of a program. We will see later how such programming techniques can be encoded using metaprogramming techniques.
![Page 186: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/186.jpg)
Higher order programming:apply
general formapply(foo,X1...Xn) :- foo(X1...Xn).
![Page 187: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/187.jpg)
mapping a predicate Predname(In,Out) to each element of a list
map_list([X|Xs],Predname,[Y|Ys]) :- apply(Predname,X,Y), map_list(Xs,Predname,Ys).
map_list([],_,[]).
Higher order programming: map
![Page 188: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/188.jpg)
All-solutions predicates
It might be useful to collect several solutions in a list. Prolog gives support for this through some "higher-order" predicates.
father(sven,olle). father(sven,lisa). father(bengt,lisa). father(bengt,sven).
children(X,Kids) :- findall(Kid, father(X,Kid),Kids).
The query
?- children(bengt,Kids).gives
Kids=[lisa,sven]
![Page 189: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/189.jpg)
All-solutions predicates (cont)
father(sven,olle). father(sven,lisa). father(bengt,lisa). father(bengt,sven).
the query
?- findall(F, father(F,Kid),Fathers).
gives
Fathers=[sven,sven,bengt,bengt]
![Page 190: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/190.jpg)
All-solutions predicates (cont)
Instead of a single solution collecting all fathers to some child we might want a separate solution for each child. There is another set precidate for this.
father(sven,olle). father(sven,lisa). father(bengt,lisa). father(bengt,sven).
?- bagof(F, father(F,Kid),Fathers).Kid=lisa Fathers=[sven,bengt]Kid=sven Fathers=[bengt]Kid=olle Fathers=[sven]
![Page 191: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/191.jpg)
All-solutions predicates (cont)
It is often sensible to present sorted lists of unique solutions. This is achieved by setof.
father(sven,olle). father(sven,lisa). father(bengt,lisa). father(bengt,sven).
?- setof(F, father(F,Kid),Fathers).Kid=lisa Fathers=[bengt,sven]Kid=sven Fathers=[bengt]Kid=olle Fathers=[sven]
![Page 192: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/192.jpg)
Ö5: Metaprogramming, Expert Systems
Sterling and Shapiro ch. 10,17 (not 17.5),19.2,22 Nilsson and Maluszynski ch. 8,9
![Page 193: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/193.jpg)
Outline - Metaprogramming
What is a metastatement?Metalogic predicates (built in)solve, augmenting solveIterative deepeningMixing object and metalevel programmingSupport for dynamically changing knowledge bases
![Page 194: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/194.jpg)
What is a metastatement?
A metastatement is a statement about statements
Stockholm is a nine-letter word.
'X+1-Y' has the size five.
'X+1-Y' contains two variables.
This statement is true.
This statement is false.
'P :- Q1...Qn.' is a clause.
This is a metastatement.
![Page 195: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/195.jpg)
Meta-logic
Metalogic refers to reasoning about a formalization of some (other) logical system.
If the metalogic deals with itself it is called circular or metacircular.
In logic programming metalogic has two meanings:
1.using logical inference rules expressed as axioms with a meta-interpreter.
2.expressing properties of the proof procedure.
For the latter case the term "meta-logical predicate" is used, for instance in the SICStus manual.
![Page 196: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/196.jpg)
Ground representation of facts and rules
The logical approach to metaprogramming requires a clear division between object level and meta-level.
Formulas are represented as ground facts, where in particular variables on the object level are represented as constants on the meta-level
Each constant of the object language is represented by a unique constant of the meta-language
Each variable of the object language is represented by a unique constant of the meta-language
Each n-ary functor of the object language is represented by a unique n-ary functor of the meta-language
Each n-ary predicate symbol of the object language is represented by a unique n-ary functor of the meta-language
Each connective of the object language is represented by a unique functor of the meta-language (with corresponding arity)
![Page 197: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/197.jpg)
Ground representation
clause(if(list(x),equals(x,[]))).clause(if(list(x),and(equals(x,cons(x,h,t)),list(t)))).
clause(if(p(x),true)).clause(if(p(x),and(q(x,a),p(b)))).
![Page 198: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/198.jpg)
SLD-resolution rule
The SLD-resolution rule (p. 43 Nilsson & Maluszynski)
<- A1,..,A(i-1),Ai,A(i+1),...,Am B0 <- B1,...,Bn
----------------------------------------------------------
<- (A1,...,A(i-1),B1,...,Bn,A(i+1),...,Am)
![Page 199: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/199.jpg)
The SLD-rule encoded as a relation
step(Goal,NewGoal) :-select(Goal,Left,Selected,Right),clause(C),rename(C,Goal,Head,Body),unify(Head,Selected,Mgu),combine(Left,Body,Right,TmpGoal),apply(Mgu,TmpGoal,NewGoal).
![Page 200: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/200.jpg)
The SLD-rule encoded as a relation (cont)
select/4 describes the relation between a goal and the selected subgoals
clause/1 describes the property of being a clause in the object language
rename/4 describes the relation between four formulas such that two are uniquely renamed variants of the other two
unify/3 describes the relation between two atoms and their mgu
combine/4 describes the relation between a goal and three conjunctions
apply/3 describes the relation between a substitution and two goals
![Page 201: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/201.jpg)
The SLD-rule encoded as a relation (cont)
derivation(G,G).derivation(G0,G2) :-
step(G0,G1), derivation(G1,G2).
![Page 202: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/202.jpg)
Why self-interpreters?
flexibility alternative search strategies
debugging
programs that change during their execution
collecting the actual proof of a satisfied goal (explanation)
non-standard logics: fuzzy logic, non-monotonic logic, modal logic
program transformation, program verification, program synthesis
![Page 203: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/203.jpg)
Non-ground representation
Efficiency of the previous representation is low-> Use object language variables for meta-level also
Seems straightforward, but mixing object level and meta-level has important semantic consequences.
Consider this representation.(with 'if' and 'and' as infix operators):
for facts: ax(Fact if true).for rules: ax(Head if Body).
![Page 204: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/204.jpg)
Metainterpreter for pure Prolog
using the above representation
solve(true).solve(P) :- ax(P if Q), solve(Q).solve(P and Q) :- solve(P), solve(Q).
In order to extend the meta-interpreter to handle also non-logical features of Prolog a different interpreter must be written. For instance ! (cut) is hard to handle.
![Page 205: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/205.jpg)
Metainterpreter generating a proof
Augmented metainterpreter
solve(true,true).solve(P,if(P,ax(P if Q),Qt)) :- ax(P if Q), solve(Q,Qt).solve(P and Q,and(Pt,Qt)) :- solve(P,Pt), solve(Q,Qt).
This metainterpreter generates a proof .
![Page 206: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/206.jpg)
Depth-bounded pure Prolog
An augmented meta-interpreter for depth-bounded search pure Prolog
solve(true,N) :- N>=0.solve(P,N) :- N>0, ax(P if Q), N1 is N-1, solve(Q,N1).solve(P and Q,N) :- solve(P,N), solve(Q,N).
This meta-interpreter finds a proof with a search tree depth of at most N levels.
depth(0).depth(N) :- depth(N1), N is N1+1.
solve(G) :- depth(N), solve(G,N).
solve/1 tries at gradually deeper levels of the tree, iterative deepening.
![Page 207: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/207.jpg)
Meta-logic
built-in predicates that perform operations that require reasoning about: the current instantiation of terms;decomposing terms into their constituents.
Instantiation checking:var(X) - checks that X is uninstantiated variable (not a
structure)nonvar(X) - opposite to var/1.ground(X) - checks that X is completely instantiated
![Page 208: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/208.jpg)
Meta-logic
Example.?- var(X), X=1 -Yes, X=1.?- X=1, var(X). -No.?- nonvar(father(X,Y)). -Yes.
Define the predicate plus/3 which uses built-in arithmetics and performs plus and minus.
plus(X, Y, Z):- nonvar(X), nonvar(Y), Z is X+Y.
plus(X, Y, Z):-nonvar(X), nonvar(Z), Y is Z-X.
plus(X, Y, Z):-nonvar(Y), nonvar(Z), X is Z-Y.
![Page 209: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/209.jpg)
Meta-logic
Type checking:integer(X) - X is instantiated to an integer
float(X) - X is instantiated to a floatnumber(X) - X is instantiated to a numberatom(X) - X is instantiated to an atom (non-variable term of arity 0, other than a number)atomic(X) - X is instantiated atom or numbersimple(X) - X is uninstantiated or instantiated to an
atom or number compound(X) - X is instantiated to a term of arity > 0, i.e.
a list or a structure
![Page 210: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/210.jpg)
Meta-logic, decomposing terms
functor(Term, FunctorName, Arity)Term has functor FunctorName and arity Arity
?- functor(father(erik, jonas), father, 2). - Yes
?- functor(father(erik, jonas), F, A). - F=father, A=2
?- functor(Term, father, 2). - Term=father(_A, _B)
?- functor(Term, father, N).- instantiation error
![Page 211: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/211.jpg)
Meta-logic, decomposing termsarg(N, Term, Argument)
the Nth argument of a compound term Term is Argument
?- arg(1, father(erik, jonas), Arg). - Arg=erik.
?- arg(2, father(erik, X), jonas). - X = jonas.
?- arg(N, father(erik, jonas), jonas).- instantiation error.
?- arg(2, Y, jonas).- instantiation error.
?- arg(1, father(X, Y), Z). - Z = X.
?- arg(3, father(X, Y), Z). - No.
![Page 212: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/212.jpg)
Meta-logic, decomposing terms
Term =.. List (=.. is called univ)List is a list whose head is the atom corresponding to the principal functor of Term, and whose tail is a list of the arguments of Term.
?- father(person(erik,A,b),person(jonas,X,Y)) =.. List.
- List=[father, person(erik,A,B), person(jonas, X,Y)].
?- Term =.. [father, erik, X]. - Term=father(erik,X).
?- father(erik, jonas) =.. [father, erik, jonas].- Yes.
![Page 213: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/213.jpg)
Meta-logic
Define the predicate subterm(Sub,Term), for checking if Sub is subterm of Term
subterm(T, T).subterm(S, T) :-
compound(T),functor(T, F, N),subterm(N, S, T).
subterm(N, S, T) :-N > 1, N1 is N-1,subterm(N1, S, T).
subterm(N, S, T) :-N > 0, arg(N, T, Arg),subterm(S, Arg).
![Page 214: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/214.jpg)
Meta-logicDefine the predicate subterm(Sub,Term) for checking if Sub is
subterm of Term
subterm(T, T).subterm(S, T) :-
compound(T), T =.. [F|Args],
subtermList(S, Args).
subtermList(S, [Arg|Args]) :-
subterm(S, Arg).
subtermList(S, [Arg|Args]) :-
subtermList(S, Args).
![Page 215: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/215.jpg)
Meta-logic
define =.. using functor/3 and arg/3a) Term T is given
T =.. [F|Args] :- functor(T, F, N),args(T, Args, 0, N).
args(_, [], N, N).args(T, [Arg|Args], I, N) :-
I < N,I1 is I+1,arg(I1, T, Arg),args(T, Args, I1, N).
![Page 216: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/216.jpg)
Meta-logicdefine =.. using functor/3 and arg/3
b) List [F|Args] is given T =.. [F|Args] :-
length(Args, N),functor(T, F, N),args(Args, T, 1).
args([], _, _).args([Arg|Args], T, N) :-
arg(N, T, Arg),N1 is N+1,args(Args, T, N1).
![Page 217: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/217.jpg)
Support for dynamic knowledge bases
assert(Clause) - Clause is added to the programclause(Head, Body) - clause with head Head and body Bodyretract(Clause) - Clause is erased from the program
For example,
member(X, [X|Ys]).member(X, [Y|Ys]) :- member(X,Ys).
?- clause(member(H1, H2), B).
H1=X, H2=[X|Ys], B= true;H1=X, H2=[Y|Ys], B=member(X,Ys).
![Page 218: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/218.jpg)
Expert systems
Expert System = Knowledge-base (KB) + Inference engine (IE) + User Interface (UI)
Expert System Shell = (IE) + (UI)
![Page 219: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/219.jpg)
Expert systems: Production rules
knowledge base often consist of a set of production rules of the form
IF A1 AND(OR) A2 ….THEN C1 AND C2 …
![Page 220: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/220.jpg)
Expert systems: forward/backward chaining
forward-chaining: start from assumptions (axioms) and find conclusions
backward-chaining: start from conclusions (hypothesis) and look for supporting assumptions
![Page 221: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/221.jpg)
Expert systems in Prolog
in PROLOG knowledge base = set of clauses inference engine = SLD-resolution
SLD-resolution is a backward chaining proof procedure
![Page 222: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/222.jpg)
Uncertainty
Expert systems might contain rules and/or facts which hold with some degree of uncertainty
IF it is summer and there are no clouds THEN the temperature is above 20 degrees CCERTAINTY 80%
![Page 223: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/223.jpg)
Expert systems, forward/backward
ExampleDevelop an expert system, which finds a name of a fruit when some fruit characteristics such as shape, diameter, surface , colour and the number of seeds are given. Gonzalez: "The engineering of knowledge-based systems." (p91).
Rule 1:IF Shape=long and Colour=green or yellowTHEN Fruit=bananafruit(Name, Shape, Diameter, Surface, Colour, FruitClass, SeedCount, SeedClass):-
Shape == long, (Colour == green; Colour == yellow), Name = banana.
Rule 2:IF Shape=round or oblong and Diameter > 4 inchesTHEN FruitClass=vinefruit(Name, Shape, Diameter, Surface, Colour, FruitClass, SeedCount, SeedClass):-
var(FruitClass), (Shape == round; Shape ==oblong), integer(Diameter), Diameter>4, FruitClass= vine, fruit(Name, Shape, Diameter, Surface, Colour, FruitClass, SeedCount, SeedClass).
![Page 224: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/224.jpg)
Expert systems, forward/backwardRule 4:IF SeedCount=1THEN SeedClass=stonefruitfruit(Name, Shape, Diameter, Surface, Colour, FruitClass, SeedCount, SeedClass)):-
var(SeedClass), integer(SeedCount), SeedCount =:= 1, SeedClass = stonefruit, fruit(Name, Shape, Diameter, Surface, Colour, FruitClass, SeedCount, SeedClass).
Rule 5:IF Seedcount>1THEN SeedClass=multiplefruit(Name, Shape, Diameter, Surface, Colour, FruitClass, SeedCount, SeedClass):-
var(SeedClass), integer(SeedCount), SeedCount > 1, SeedClass = multiple, fruit(Name, Shape, Diameter, Surface, Colour, FruitClass, SeedCount, SeedClass).
Rule 11:IF FruitClass=tree and Colour=red and SeedClass=stonefruitTHEN Fruit=cherryfruit(Name, Shape, Diameter, Surface, Colour, FruitClass, SeedCount, SeedClass):-
FruitClass == tree, Colour == red, SeedClass == stonefruit, Name = cherry.
?- fruit(Name, round, 3, Surface, red, FruitClass, 1, SeedClass). Yes. Name = cherry.
![Page 225: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/225.jpg)
User interface - dialogue
An expert system is often not automatic=> user interaction guides the search
graphical user interfacedialogue
![Page 226: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/226.jpg)
Explanation facilities
Expert systems should be able to explain its conclusions to different people (experts, programmers, users)
- How did you come to your conclusion?
- Why does A follow from B ?
![Page 227: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/227.jpg)
Knowledge acquisition
An expert system should allow incremental updates of the knowledge base and rule base
knowledge can be aquired through dialogue with an expert, or through analysis of the system
![Page 228: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/228.jpg)
Rule base as Prolog clauses
IF A1 AND (A2 OR A3) THEN C1 AND C2
C1 :- A1, (A2 ; A3).C2 :- A1, (A2 ; A3).
![Page 229: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/229.jpg)
Taxonomy of a car-engine
car
fuel system ignition electric system
fuel pump starting motor
spark plugs
fuel battery
fuse
needs(car,fuel_system). ....needs(electric_system,fuse).
![Page 230: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/230.jpg)
Expert System: diagnosis
IF Y is a necessary component for X and Y is malfunctioning THEN X is also malfunctioning
IF X exhibits a fault-symptom Z THEN either X is malfunctioning or there exists another malfunctioning component which is necessary for X
![Page 231: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/231.jpg)
Expert system: diagnosis
X has an indirect fault if there exists a component which is necessary for X and which malfunctions
malfunctions(X) :- needs(X,Y), malfunctions(Y).
malfunctions(X) :- symptom(Y,X), not
indirect(X).
indirect(X) :- needs(X,Y), malfunctions(Y).
![Page 232: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/232.jpg)
Expert systems: abduction
The knowledge base is usually incomplete
symptoms are not known, but need to be established by asking questions in a dialogue
KB + cause |- symptom
Finding cause is named abduction
![Page 233: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/233.jpg)
self-interpreter generating a proof
solve(true,true).solve(P,proof(P,Qt)) :-
kb(P if Q), solve(Q,Qt).solve(P and Q,and(Pt,Qt)) :-
solve(P,Pt), solve(Q,Qt).
This meta-interpreter generates a proof .
![Page 234: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/234.jpg)
query-the-user
solve(true).solve(P and Q) :- solve(P), solve(Q).solve(symptom(X,Y)) :- confirm(X,Y).solve(P) :- kb(P if Q), solve(Q).
confirm(X,Y) :-write('Is the '),write(Y), tab(1),write(X), write('? '),read(yes).
![Page 235: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/235.jpg)
knowledge base
kb(malfunctions(X) if possible_fault(Y,X) and symptom(Y,X)).
kb(possible_fault(flat,tyre) if true).
:- solve(malfunctions(X)).
Is the tyre flat?>yes
X=tyre
(anything but 'yes' as answer makes the query fail)
![Page 236: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/236.jpg)
F8: Case study: Support for reasoning about electronic circuits
Clocksin, ch. 7,8
![Page 237: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/237.jpg)
Ö6: Constraint Logic Programming
SICStus Prolog ManualNilsson and Maluszynski ch.14Course compendium
This lecture is given by Christian Schulte. The written material is based on slides from Per Kreuger SICS and Christian Schulte KTH/ICT/ECS
![Page 238: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/238.jpg)
Significance
Constraint programming identified as a strategic direction in computer science research
[ACM Computing Surveys, December 1996]
![Page 239: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/239.jpg)
This Talk…
…concerned with constraints for
solving combinatorial problems
designed as basic tutorial
![Page 240: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/240.jpg)
Application Areas
Timetabling Scheduling Crew rostering Resource allocation Workflow planning and optimization Gate allocation at airports Sports-event scheduling Railroad: track allocation, train allocation, schedules Automatic composition of music Genome sequencing Frequency allocation …
![Page 241: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/241.jpg)
Techniques
Artificial intelligence
Operations research
Algorithms
Programming languages
![Page 242: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/242.jpg)
Overview
Basics modeling: variables and constraints solving: propagation, distribution, search
Solving realistic problems: scheduling modeling solving
Constraint programming research systems
Case studies instruction scheduling for compiler bus scheduling for real-time system
Conclusion
![Page 243: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/243.jpg)
Constraint Programming (CP)
based on the idea of an abstract space of statements or conditions, a
constraint space
x{4,5} y{4,5}
xy y>3
![Page 244: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/244.jpg)
Constraint Programming (CP)
Some such statements can be regarded as completely determined:
E.g. “ A given train trip will leave from Avesta
15.05 on Thursday, October 10th 2002.”
![Page 245: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/245.jpg)
Constraint Programming (CP)
Other statements are less exact with respect to e.g. the resources some task will need:
E.g.“OVAKO Steel needs to transport between
320 and 280 kilotons of steel from Hofors and Hellefors to Malmö next year.”
![Page 246: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/246.jpg)
Constraint Programming (CP)
Such statements can be represented as constraints in a constraint programming system.
These constitute conditions on the values that variables may take (i.e. a form of type).
![Page 247: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/247.jpg)
Constraint Programming (CP)
It is nontrivial to determine e.g. how the two above mentioned propositions would be related in some model of a planning problem.
Sometimes it is possible to determine some form of “consistency” of such propositions.
![Page 248: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/248.jpg)
Constraint Programming (CP)
EnumerationIt is also possible (in principle) to compute
one or more witnesses (a consistent assignment of values to all the variables) of such a system of conditions.
This is called to enumerate the constraint space and generally involves search.
![Page 249: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/249.jpg)
Constraint Programming (CP)
If more than one witness is computed they can be compared with respect to various cost measures.
To determine the (in some sense) best assignment is modeled as an optimization problem in the constraint system.
![Page 250: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/250.jpg)
Constraint propagation
Much of the search in the enumeration of a constraint space for a given problem can generally be eliminated by a technique called constraint propagation.
x in {2,…,5} & y in {3,…,9}2x+3=y x in {2,3} & y in {7,…,9}2x+3=y & y<9 x<3 x=2 y=7
![Page 251: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/251.jpg)
Constraint propagation
Much of the search in the enumeration of a constraint space for a given problem can generally be eliminated by a technique called constraint propagation.
Each (non primitive constraint) can be regarded as a temporarily suspended computation (of the values of the involved variables) that can be made to interact with other such suspended/reinvoked computations.
![Page 252: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/252.jpg)
Constraint propagation
Computations are suspended when information needed to determine a value is missing but is rescheduled as soon as that information becomes available.
One can view the constraint programming system as a pool of concurrent processes that communicate, interact and synchronize through shared variables.
![Page 253: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/253.jpg)
Constraint propagation
Propagation is normally not sufficient to completely determine the values of the involved variables.
To achieve this we need to combine propagation with enumeration in such a way that values chosen during search trigger further propagation which in turn guides the continued search, etc.
![Page 254: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/254.jpg)
Constraint Modelling (CP)
The computational complexity of the task to find a solution to a given problem depends to a large extent on the expressive power of the language used to formalize the problem.
To formulate a mathematical model of some real process is generally difficult. It requires a thorough understanding of both the problem domain and the methods employed to solve the problem.
![Page 255: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/255.jpg)
Constraint Programming (CP)
To some extent this is still more of a craft than a science.
A large body of typical problems with standard models have been identified.
Early attempts to develop a methodology has started to give results.
![Page 256: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/256.jpg)
Finite Domains
The constraint programming systems that have been most actively developed the last ten years are those that built on finite domains.
In such a system each variable can take on values from a finite set of discrete values.
This type of variable is natural to use to model discrete entities such as the number of engines or staff that have been allocated to a given task.
![Page 257: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/257.jpg)
Continuous Domains
Finite domain constraints are, however, unnecessarily restrictive when the modeling concerns values that can be assumed to vary over continuous domains (with an infinite number of possible values), for instance time.
![Page 258: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/258.jpg)
Comparison with Operations Research ---OR
Techniques from Operations Research, e.g. linear programming (LP) and integer programming (IP) efficiently handles models where:
1. Most of the variables are continuous.2. The model can be relatively directly expressed
as a set of simple (linear) equations and inequalities.
3. A simple (linear) and well defined cost function captures well the “goodness” of different solutions to a given problem.
![Page 259: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/259.jpg)
Comparison with Operations Research (2)
The techniques that have been developed in constraint programming, using finite domains, work well also when:
1. A majority of the variables model naturally discrete entities.
2. The cost function is hard to determine.3. The model contains complicated (for instance
non-linear) conditions.In this way these two classes of techniques can be
said to complement each other.
![Page 260: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/260.jpg)
Global constraints
The first type of constraint that was studied in constraint programming was constraints that limits one or relate two variables, e.g. constraints like:
< > =< >= = /=
![Page 261: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/261.jpg)
Global constraints
In contrast to these simple binary constraints the focus has in recent years more and more been on complex constraints between an unlimited number of variables.
E.g. constraints: - relating variables with the value of a linear sum - maintaining pairwise disequality of an
arbitrarily large set of variables - implementing various scheduling, matching,
packing and/or placement mechanisms
![Page 262: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/262.jpg)
Global constraints (2)
The expression “global constraints” for this type of constraints was introduced in {BC94} and refers to arguments that can be made over a multitude of variables related with a non-binary condition.
![Page 263: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/263.jpg)
Global constraints (2)
Global constraints can in principle often be encoded in terms of a set of simpler binary constraints which semantically have the same meaning.
This is rarely practical, however, since an efficient solution can seldom be achieved by only considering the variables pairwise.
![Page 264: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/264.jpg)
Global constraints (2)
Global constraints constitute abstractions of more complicated properties of problems and enables computations on a more detailed model
![Page 265: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/265.jpg)
Algorithms as constraint abstractions Often methods from operations analysis,
matching theory or graph algorithms can be integrated into a constraint programming system as global constraints.
This is an active and very promising research area in constraint programming{bel00}.
![Page 266: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/266.jpg)
An example: Getting Started
A toy problem… Modeling
Solving: propagation and search
![Page 267: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/267.jpg)
Send More Money (SMM)
Find distinct digits for letters, such that
SEND+ MORE= MONEY
![Page 268: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/268.jpg)
Constraint Model for SMM
Variables: S,E,N,D,M,O,R,Y {0,…,9}
Constraints:distinct(S,E,N,D,M,O,R,Y)
1000×S+100×E+10×N+D + 1000×M+100×O+10×R+E = 10000×M+1000×O+100×N+10×E+Y
S0 M0
![Page 269: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/269.jpg)
Solution for SMM
Find values for variables such thatall constraints satisfied
![Page 270: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/270.jpg)
Finding a Solution
Enumerate assignments: poor! Constraint programming
compute with possible values prune inconsistent values
constraint propagation search
distribute: define search tree explore: explore for solution
![Page 271: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/271.jpg)
Some Concepts
Constraint store Basic constraint Propagator Non-basic constraint Constraint propagation
![Page 272: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/272.jpg)
Constraint Store
Stores basic constraints map variables to possible values
Domains: finite sets, real intervals, trees, …
x{3,4,5} y{3,4,5}
finite domain constraints
![Page 273: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/273.jpg)
Propagators
Implement non-basic constraints
distinct(x1,…,xn)
x + 2×y = z
![Page 274: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/274.jpg)
Propagators
Amplify store by constraint propagation
x{3,4,5} y{3,4,5}
xy y>3
![Page 275: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/275.jpg)
Propagators
Amplify store by constraint propagation
x{3,4,5} y{4,5}
xy y>3
![Page 276: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/276.jpg)
Propagators
Amplify store by constraint propagation
x{3,4,5} y{4,5}
xy y>3
![Page 277: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/277.jpg)
Propagators
Amplify store by constraint propagation
x{4,5} y{4,5}
xy y>3
![Page 278: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/278.jpg)
Propagators
Amplify store by constraint propagation Disappear when entailed
no more propagation possible
x{4,5} y{4,5}
xy
![Page 279: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/279.jpg)
Constraint Space
Store with connected propagators
x{4,5} y{4,5}
xy y>3
![Page 280: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/280.jpg)
Propagation for SMM
Results in storeS=9 E{4,…,7} N{5,…,8} D{2,…,8}
M=1 O=0 R{2,…,8} Y{2,…,8}
Propagation alone not sufficient! create simpler sub-problems distribution
![Page 281: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/281.jpg)
Distribution
Yields spaces with additional constraints Enables further constraint propagation
x{4,5} y{4,5}
xy y>3
x{4} y{4}
xy y>3
x{5} y{5}
xy y>3
x=4 x4
![Page 282: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/282.jpg)
Distribution Strategy
Pick variable x with at least two values Pick value n from domain of x Distribute with
x=n and xn
Part of model
![Page 283: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/283.jpg)
Search
Iterate propagation and distribution Orthogonal: distribution exploration Nodes:
Distributable Failed Succeeded
![Page 284: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/284.jpg)
SMM: Solution
SEND+ MORE= MONEY
9567+ 1085= 10652
![Page 285: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/285.jpg)
Heuristics for Distribution(CLP jargong: Labelling)
Which variable? least possible values (first-fail) application dependent heuristic
Which value? minimum, median, maximum
x=m or xm split with median m
x<m or xm In general: application specific
![Page 286: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/286.jpg)
SMM: Solution With First-fail
SEND+ MORE= MONEY
9567+ 1085= 10652
![Page 287: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/287.jpg)
Send Most Money (SMM++)
Find distinct digits for letters, such that
and MONEY maximal
SEND+ MOST= MONEY
![Page 288: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/288.jpg)
Best Solution Search
Naïve approach: compute all solutions choose best
Branch-and-bound approach: compute first solution add “betterness” constraint to open nodes next solution will be “better” prunes search space
Also possible: restart strategy
![Page 289: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/289.jpg)
Branch-and-bound Search
Find first solution
![Page 290: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/290.jpg)
Branch-and-bound Search
Explore with additional constraint
![Page 291: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/291.jpg)
Branch-and-bound Search
Explore with additional constraint
![Page 292: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/292.jpg)
Branch-and-bound Search
Guarantees better solutions
![Page 293: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/293.jpg)
Branch-and-bound Search
Guarantees better solutions
![Page 294: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/294.jpg)
Branch-and-bound Search
Last solution best
![Page 295: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/295.jpg)
Branch-and-bound Search
Proof of optimality
![Page 296: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/296.jpg)
Modelling SMM++
Constraints and distribution as before Order among solutions with constraints
so-far-best solution S,E,N,D,M,O,T,Y current node S,E,N,D,M,O,T,Y constraint added10000×M+1000×O+100×N+10×E+Y
<10000×M+1000×O+100×N+10×E+Y
![Page 297: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/297.jpg)
SMM++: Branch-and-bound
SEND+ MOST= MONEY
9782+ 1094= 10876
![Page 298: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/298.jpg)
SMM++: All Solution Search
SEND+ MOST= MONEY
9782+ 1094= 10876
![Page 299: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/299.jpg)
Summary
Modeling variables with domain constraints to state relations distribution strategy solution ordering
Solving constraint propagation constraint distribution search tree exploration
![Page 300: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/300.jpg)
The Art of Modeling
Avoid search, avoid search, avoid… Techniques
increase propagation strength stronger propagators redundant propagators
remove symmetrical solutions good distribution heuristics smart search engines
![Page 301: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/301.jpg)
Distribution Exploration
Distributiondefines shape of search tree
Exploration left-most depth-first interactive, graphical parallel branch-and-bound [prunes tree]
![Page 302: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/302.jpg)
Scheduling
Modeling Propagation
Global constraints
![Page 303: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/303.jpg)
Scheduling
Among the examples of global reasoning that have successfully been introduced into constraint programming systems are a number of fundamental scheduling mechanisms.
![Page 304: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/304.jpg)
Scheduling
A scheduling problem consists of a number of tasks with restrictions on start times, stop times and task duration.
Often the tasks are partially ordered into totally ordered sequences.
Such a totally ordered subset of tasks is often called a job.
![Page 305: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/305.jpg)
Scheduling
Each task uses one or more resources during certain time intervals.
The so called job shop scheduling problem is a classic and well studied case.
![Page 306: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/306.jpg)
Scheduling
Resources can in general model widely different type of entities.
For instance:1. processing equipment in a production
process.2. staff or vehicles in a transport net.3. network resources such as routers and
transport links with limited capacity.
![Page 307: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/307.jpg)
Scheduling
To arrange the tasks so that no limitations in resources are violated is called to schedule the tasks and it is in general a very difficult (NP-complete) computational problem.
Nevertheless the many practical applications for methods in this area make it fairly well studied.
![Page 308: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/308.jpg)
Scheduling: Given
Tasks duration resource
Precedence constraints determine order among two tasks
Resource constraints at most one task per resource
[disjunctive, non-preemptive scheduling]
![Page 309: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/309.jpg)
Scheduling: Bridge Example
![Page 310: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/310.jpg)
Scheduling: Solution
Start time for each task
All constraints satisfied
Earliest completion time minimal make-span
![Page 311: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/311.jpg)
Scheduling: Model
Variable for start-time of task astart(a)
Precedence constraint: a before bstart(a) + dur(a) start(b)
![Page 312: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/312.jpg)
Propagating Precedence
start(a){0,…,7}start(b){0,…,5}
a
b
a before b
![Page 313: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/313.jpg)
Propagating Precedence
start(a){0,…,7}start(b){0,…,5}
a
b
a
b
a before b
start(a){0,…,2}start(b){3,…,5}
![Page 314: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/314.jpg)
Scheduling: Model
Variable for start-time of task astart(a)
Precedence constraint: a before bstart(a) + dur(a) start(b)
Resource constraint:a before b
orb before a
![Page 315: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/315.jpg)
Scheduling: Model
Variable for start-time of task astart(a)
Precedence constraint: a before bstart(a) + dur(a) start(b)
Resource constraint:start(a) + dur(a) start(b)
orb before a
![Page 316: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/316.jpg)
Scheduling: Model
Variable for start-time of task astart(a)
Precedence constraint: a before bstart(a) + dur(a) start(b)
Resource constraint:start(a) + dur(a) start(b)
orstart(b) + dur(b) start(a)
![Page 317: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/317.jpg)
Reified Constraints
Use control variable b{0,1}c b=1
Propagate c entailed propagate b=1 c entailed propagate b=0 b=1 entailed propagate c b=0 entailed propagate c
not easy!
![Page 318: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/318.jpg)
Reification for Disjunction
Reify each precedence[start(a) + dur(a) start(b)] b0=1
and
[start(b) + dur(b) start(a)] b1=1
Model disjunctionb0 + b1 1
![Page 319: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/319.jpg)
Model Is Too Naïve
Local view individual task pairs O(n2) propagators for n tasks
Global view all tasks on resource single propagator smarter algorithms possible
![Page 320: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/320.jpg)
Edge Finding
Find ordering among tasks (“edges”) For each subset of tasks {a}B
assume: a before Bdeduce information for a and B
assume: B before adeduce information for a and B
join computed information can be done in O(n2)
![Page 321: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/321.jpg)
Scheduling Architecture
Constraint programmingnatural modeling
specification modelcompiler
![Page 322: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/322.jpg)
Scheduling Architecture
Constraint programmingexpressive modeling
specification modelcompiler
![Page 323: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/323.jpg)
Summary
Modeling easy but not always efficient constraint combinators (reification) global constraints smart heuristics
More on constraint-based schedulingBaptiste, Le Pape, Nuijten. Constraint-basedScheduling, Kluwer, 2001.
![Page 324: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/324.jpg)
Why Does CP Matter?
Middleware for combining smart algorithmic components
scheduling graphs flows …
plus essential extra constraints
![Page 325: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/325.jpg)
Research in Constraints
Propagation algorithms Search methods Innovative applications Programming and modeling languages
Hybrid methods linear programming local search
![Page 326: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/326.jpg)
Constraints in Sweden
Swedish constraint network
SweConsNet [founded May 2002]
http://www.dis.uu.se/~pierref/astra/SweConsNet/
![Page 327: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/327.jpg)
CP Systems
Commercial ILOG Solver C++ OPL Studio Modeling SICStus Prolog Prolog-based Eclipse Prolog-based
Free GNU Prolog Prolog-based Mozart Oz CHOCO Claire
![Page 328: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/328.jpg)
Oz and Mozart
Constraint-based programming system concurrent and distributed programming combinatorial problem solving and combinations: intelligent agents, …
Mozart implements Oz concurrent constraint programming language with: objects, functions, threads, …
Developed by Mozart ConsortiumSaarland University, GermanySICS/KTH, SwedenUniversité catholique de Louvain, Belgium
![Page 329: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/329.jpg)
Mozart Fact Sheet
Freely available at www.mozart-oz.org
Many platforms supportedUnix Windows Mac OS
Active user community Comes with extensive documentation Many applications
![Page 330: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/330.jpg)
Constraints in Mozart
Rich set of constraintsfinite domains schedulingfinite sets records
New propagators via C++ API Search and combinators [unique]
programmable concurrency-compatible fully compositional
Book: Schulte, Programming Constraint Services. LNAI, Springer 2002.g
![Page 331: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/331.jpg)
Some Research Issues
Search methods Architecture and implementation Automatic selection of good propagator
domain versus bound
Challenging applications
![Page 332: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/332.jpg)
Case Study
Instruction scheduling Bus scheduling
![Page 333: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/333.jpg)
Instruction Scheduling
Optimized object code by compiler Minimum length instruction schedule
precedence latency resources
per basic block
Best paper CP 2001, Peter van Beek and Kent Wilken, Fast Optimal Scheduling for Single-issue Processors with Arbitrary Latencies, 2001.
![Page 334: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/334.jpg)
Model
All issue times must be distinct use single distinct constraint (as in SMM) is resource constraint or unit duration
Latency constraints precedence constraints (as before) difference: duration latency
![Page 335: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/335.jpg)
Making It Work
Only propagate bounds information relevant for distinct
Add redundant constraints regions: additional structure in DAG successor and predecessor constraints
[special case of edge-finding]
![Page 336: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/336.jpg)
Results
Tested with gcc SPEC95 FP Large basic blocks
up to 1000 instructions
Optimally solved less than 0.6% compile time increase limited static improvement (< 0.1%) better dynamic impact (loops)
Far better than ILP approach
![Page 337: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/337.jpg)
Off-Line Scheduling of Real-Time System
System with global clock time-triggered real-time processes message exchange over shared bus
Infinite, periodic schedule map to single fixed time window repeat
Klaus Schild, Jörg Würtz. Scheduling of Time-Triggered Real-Time Systems, Constraints 5(4), 2000.
![Page 338: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/338.jpg)
Model
Single resource: data bus Maximal latencies:
messages valid for at most n time units
Infinite schedule repeat finite schedule of given length repetition does not violate constraints
![Page 339: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/339.jpg)
Performance
Problem size 6,000,000 time units 3500 processes and messages
Model size up to 10 million constraints
Run time from 10 min to 2 hrs (200 MHz PPro)
![Page 340: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/340.jpg)
Summary
Useful for small components in software systems large offline optimization
Widely applicable in your area? hardware design?
![Page 341: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/341.jpg)
Conclusion
Constraint programming useful easy modeling open to new techniques
![Page 342: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/342.jpg)
Constraints for Concurrency
Constraints describe data structures used for control [as opposed to Prolog]
Logic variables as dataflow variables unconstrained suspension constrained resumption synchronization is automatic
Well established idearesumption condition is logical entailment
[Maher,87], ccp [Saraswat,90]
![Page 343: The Course Logic Programming ID2213](https://reader038.vdocuments.us/reader038/viewer/2022110404/56812f2f550346895d94c236/html5/thumbnails/343.jpg)
Problem Solving
Constraint domains tree constraints (records, feature) finite domains finite sets
Programmable search and combinators based on computation spaces makes search compatible with concurrency book:
Christian Schulte, Programming Constraint Services
LNAI 2302, Springer-Verlag, 2002