The course logic programming id2213
This presentation is the property of its rightful owner.
Sponsored Links
1 / 343

The Course Logic Programming ID2213 PowerPoint PPT Presentation


  • 47 Views
  • Uploaded on
  • Presentation posted in: General

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

Download Presentation

The Course Logic Programming ID2213

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


The course logic programming id2213

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

Outline of lectures

W35:

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


F1 theory and simple programs

F1: Theory and simple programs

Sterling and Shapiro ch. 1,2,4,5,6

Nilsson and Maluszynski ch.1,2,3,6


Theory for logic programming

Theory for Logic Programming


Outline

Outline

Informal introduction to logic programming theory

Data in logic programs: Individual constants, term constructors, logical variables, compound terms, trees and lists

Equality theory, Unification

Logic Programs: Definite (Horn) Clauses

Model theory (least Herbrand model, term interpretation)

Proof theory and operational semantics of Prolog

(SLD-resolution, proof trees)

Simple databases

Recursive rules


Logic programming

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


Data in logic programs

Data in Logic Programs

Programs express facts about a world of objects

Constants

Functors

Numbers

Compounded structures (normally finite)

Lists

Trees


Objects in logic programs

Objects in Logic Programs

Individual constants

a b foo 4711 -37 34.5

Functors

structure names of trees and graphs

same syntax as non-numerical constants

Arity (number of arguments):

term/4, a/0

Syntax example:

term(a,b,-4711,other(b,a))


Logical variables syntax

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"


Programs are theories

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 Qiare true the clause becomesP.


Program definitions query

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


Program definitions query1

Program = Definitions + Query

Elementary literals (atoms)

true, false, X=Y

cannot be redefined

(only used in queries and definition bodies)

Defined literals (p above)


Definite clauses facts

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.


Definite clauses rules

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"


Definite clauses rules example

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.


Clause syntax

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.


Programs are theories1

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)


Query goal

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.


How prolog works

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


Database for family relationships

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


Logical variables semantics

Logical variables - semantics

Variables 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


Example cont rules

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=jonasNoX=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).


Syntactic sugar

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 form

P :- Q1, (Q2 ; Q3), Q4.

is the same as

P :- Q1, Q, Q4.

Q :- Q2.

Q :- Q3.


Equality theory substitutions

Equality theory - Substitutions

X equals Y iff

X is an unbound variable or Y is an unbound variable

or

X and Y are (bound to) the same constant

or

X and Y are terms with the same functor and arity

e.g. X is term(Z1,..,Zn) and Y is term(U1,...,Un)

and for all arguments 1=<i=<n: Zi equals Ui.


Substitutions

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 that

replaces v with t for each v/t in the set


Unifier

Unifier

A unifier is a substitution s suchthatssºts

(applying s tosand totcreates identical terms)


Most general unifier

Most general unifier

A unifier s is more general than a unifier d

iff

there exists another unifier w such that s w º d

A unifier s is the most general unifier of two terms

iff

s is more general than any other unifier of the two terms


Most general unifier example

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}


Unification procedure

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


Theory and simple programs cont operational semantics sld

Theory and simple programs (cont) Operational Semantics, SLD

Sterling and Shapiro ch. 1,2,4,5,6

Nilsson and Maluszynski ch.1,2,3,6


Example cont structured data

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?


Logical variables in programs

Logical Variables in Programs

Variables and parameters are implicitly quantified

syntax: variables start with capital letter

p(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?


Example cont recursive rules

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).


Declarative vs procedural

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-theoreticalreading 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?


Modus ponens

Modus Ponens

  • PQ:-P

  • --------------

    • Q


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)

Proof methods with Horn clauses


Model theory herbrand interpretation

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.


Model theory least herbrand model

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.


Least herbrand model computed

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.


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}

Constructing a model with Tp


Constructing a model with tp1

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)}

Constructing a model with Tp


Infinite structures

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 treesinX=f(X)

Theoretically sound unification: unify_with_occurs_check/2


Proof theory execution is search for a proof or failure generating an or tree

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


Search trees and proof trees

Search trees and proof trees

proof

Search tree

Proof tree


Sld resolution rule

SLD-resolution rule

<- A1,..,Ai-1,Ai,Ai+1,...,Am B0 <- B1,...,Bn

------------------------------------------

<- (A1,...,Ai-1,B1,...,Bn,Ai+1,...,Am)s

Where P is a program,

A1,...,Amare atomic formulas (goals),

B0<- B1,...,Bnis a (renamed) clause in P

and s=mgu(Ai,B0)


Goal and clause selection

Goal and clause selection

A goal selection function specifies which goal Aiis selected by the SLD-rule.

The order in which clauses are chosen is determined with a clause selection rule.


Soundness of sld resolution

Soundness of SLD-resolution

Any query (goal) that is provable with SLD-resolution is a logical consequence of the program.


Completeness of sld resolution

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.


Conclusion

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


F2 logic programming style

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)


Outline1

Outline

Programming techniques

Arithmetic in Prolog

Different primitives for equality: =/2, ==/2

Recursive definitions

Procedural - declarative

Imperative - logical style

binary trees, lists

append/3 reverse/2 quicksort/2


Specifying the use of a procedure

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)


Built in arithmetics

Built-in arithmetics

is/2a built-in predicate for evaluation of arithmetical expressions?- Value is Expression. - first, Expression is evaluated and, second, unified with ValueFor 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.


Built in arithmetics1

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 rightabs(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.


Nb different equals

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.


Elementary programs

Elementary programs

Sterling and Shapiro ch. 1,2,4,5,6

Nilsson and Maluszynski ch.1,2,3,6


Composing recursive programs

Composing recursive programs

think about declarative meaning of recursive data type (a definition)

write down recursive clause and base clause

run simple examples - check different goals

check what is happening (do you get the expected result?)


Composing recursive programs1

Composing recursive programs

Typical errors:

missing (or erroneously failing) base case

error in data structure representation

wrong arity of structures

mixing an element and a list

permuted arguments


Natural numbers

Natural numbers

Unary syntaxFor example, 0- denotes zeros(0) - denotes 1 ... s(…s(s(0))…)- denotes n

Defining the natural numbersnatural_number(0).natural_number(s(X)) :- natural_number(X).


Natural numbers1

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.


Natural numbers2

Natural numbers

less or equalle(0, X) :- natural_number(X).le(s(X), s(Z)) :- le(X, Z).

multiplicationtimes(0, X, 0) :- natural_number(X).times(s(X), Y, Z) :-

plus(Y, Z1, Z), times(X, Y, Z1).

check how substitution works!


Recursive arithmetic

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.


Binary trees

Binary trees

Syntax (not built-in, create own compound terms)For example, void - denotes empty treetree(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 treebinary_tree(void).binary_tree(tree(Element, Left, Right)) :- binary_tree(Left), binary_tree(Right).


Binary trees1

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!


Lists

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


Lists1

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


Lists2

Lists

concatenation of listsappend([], 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


Lists3

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).


Lists4

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([], _, [], []).


Dictionaries

Dictionaries

Finding 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.


Composing recursive programs2

Composing recursive programs

Final example

Define 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


Representing sets

Representing sets

Sets 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


Syntactic support

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).


Advanced recursive techniques

Advanced recursive techniques

Sterling and Shapiro ch. 7,8,13.3, 15

Nilsson and Maluszynski ch. 7.3.


Outline2

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


Accumulating parameters

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-accumulatereverse(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!


Built in arithmetics2

Built-in arithmetics

ExampleDefine the predicate for computing the factorial of a given integer.a) recursionfactorial(0, 1).factorial(N, F) :-N > 0,N1 is N -1,factorial(N1, F1),F is N*F1.


Built in arithmetics3

Built-in arithmetics

ExampleDefine the predicate for computing the factorial of a given integer.b) recursion with an accumulatorfactorial(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).


Built in arithmetics4

Built-in arithmetics

ExampleDefine 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).


Using abstract data types

Using Abstract Data Types

Separation of data definitions (types) and the program's logic.

Specify a set of objects

Specify set of operations (relations, functions) on the objects

Allow access to objects only through defined operations


Using abstract data types1

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.


Abstract form of append 3

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).


Changing representation

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).


Difference lists

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]


Difference lists1

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]).


Difference lists2

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(_,[],[],[]).


Queues

Queues

A queue may be implemented as a difference list

enqueue and dequeue- enqueue(Element, OldQueue, NewQueue)enqueue(X, Qh-[X|Qt], Qh-Qt).

- dequeue(Element, OldQueue, NewQueue)dequeue(X,[X|Qh]-Qt, Qh-Qt).


Queues cont

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).


F3 programming with search

F3: Programming with search

Sterling and Shapiro ch. 6,7,11,14,20,21

Nilsson and Maluszynski ch.4,5,11,12, A.3


Outline search and control

Outline - Search and control

Proof trees

Cut

Negation, SLDNF


Outline3

Outline

Cut

execution of a program with cuts

insertion of cuts in your own program:

"green" and "red" cuts

implementation of if-then-else

Negation

basic concepts

execution of programs with negation

implementation of negation


Controlling search

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.


The course logic programming id2213

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-treep(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


Cut performs two operations

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


The course logic programming id2213

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)


The course logic programming id2213

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


The course logic programming id2213

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).


The course logic programming id2213

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).


The course logic programming id2213

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).


The course logic programming id2213

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 listOBS: Check the example lookup/3 from the previous lecture!


The course logic programming id2213

Cut

implementation of if-then-elseP :- Condition, !, TruePart.P :- ElsePart.or (Condition -> TruePart; ElsePart)For example,minimum(X, Y, Z) :- (X =< Y -> Z = X; Z = Y).


Negation how to use and prove negative information

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(_).


Closed world assumption

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 succeed

Unfortunately it fails. Why?


Closed world assumption1

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?


Negation

Negation

how 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).


Negation1

Negation

SLDNF-resolution

the 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).


Negation2

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.


Negation3

Negation

implementation of \+\+ Goal :- call(Goal), !, fail.\+ Goal.

examplep(a).?- p(X). Yes, X = a.?- \+ \+ p(X).true, X is not instantiated


Search based programming

Search based programming

Sterling and Shapiro ch. 6,7,11,14,20,21

Nilsson and Maluszynski ch.4,5,11,12, A.3


Outline search based programming

Outline- Search based programming

State space programming

generate-and-test

searching in a state-space

Graph theoretical examples

Euler paths, Hamilton paths

Puzzle-solving, game-playing

Sterling and Shapiro ch. 14,20

Nilsson and Maluszynski ch. 11


Generate and test

Generate-and-test

A technique in algorithm design, which defines two processes

the first generates the set of candidate solutions

the 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


Generate and test1

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).


Generate and test2

Generate-and-test

Example 1Finding 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?


Generate and test3

Generate-and-test

Example 2Place 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]).


Generate and test4

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).


Generate and test5

Generate-and-test

Example 2 (cont.)b) When generating a position of a queen, test whether it is permittedqueens(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).


Searching in a state space

Searching in a State-space

- loop-avoidance in searching for a path

- efficiency issues

- different search strategies


Searching in a state space1

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 sequence

S0 ---> 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.


Searching in a state space2

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 nodeFor 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.


Searching in a state space3

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).


Searching in a state space4

Searching in a state-space

Returning the path as an answer to the goalpath(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).


Searching in a state space5

Searching in a state-space

Puzzle: Missionaries and cannibals

Three 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.


Searching in a state space6

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).


Searching in a state space7

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) ).


Searching in a state space8

Searching in a state-space

Better representation – simpler algorithm

Store 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).


Searching in a state space9

Searching in a state-space

Basic search methods

depth-first - interprets current nodes as a stack

breadth-first - interprets current nodes as a queue

bounded-depth - "controls" the depth of the search

iterative-deepening -"controls" the depth of the search

heuristic methods – using domain specific knowledge


Searching in a state space10

Searching in a state-space

Heuristic search

to 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


Many search strategies

Many search strategies

Bottom-up - inductively generate facts from known facts

Top-down - recursively find supporting rules for query

Serial - alternatives one at a time, backtrack for more

Or- parallel - to prove A or B try A and B in parallel

collect all solutions or choose one (first found, best etc.)

Concurrent - to prove A & B try A and B concurrently

AND-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


Parallelism and concurrency

Parallelism and Concurrency

Concurrent logic programming models

Parallel execution on multiprocessors

Sterling and Shapiro ch. 14.2

Nilsson and Maluszynski ch.12,14, A.3


Concurrent logic programming

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


Parallel logic programming

Parallel logic programming

Computation can be distributed over several computers possibly sharing memory.

OR-parallelism

copying of backtrack stack

sharing of binding environment

AND-parallelism

independent AND (CIAO-Prolog)

stream-and ("Penny", parallel AKL)


Game playing

Game playing

Game 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.


Game playing1

Game playing

4

Maximise

4

2

Minimise

8

5

4

7

2

Maximise

8

5

2

4

7

5

3


F4 logic and grammars

F4: Logic and grammars

Sterling and Shapiro ch. 19 (except 19.2),24

Nilsson and Maluszynski ch.10

SICStus Prolog Manual.


Outline4

Outline

grammars

context free grammars

context dependent grammars


Context free grammars

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 e and elements of P are usually written in the form of production rules:A ::= B1, …, Bn (n > 0)A ::= e(n = 0)


Grammars

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?


Grammars1

Grammars

Example 2prod_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?


Grammars2

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).


Grammars3

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).


Grammars4

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)).


Grammars5

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


Grammars6

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).


Recognizers for languages lexers and parsers

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)


Logical input

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).


A recognizer for s expressions

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.


Backus naur grammar for a legal s expression

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).


A recognizer for the s expression grammar

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).


The course logic programming id2213

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)).


The course logic programming id2213

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).


The course logic programming id2213

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].


A grammar for horn clauses

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'


Outline definite clause grammars

Outline - Definite Clause Grammars

Definite clause grammars

Parsing

Translating grammars into logic programs

Sterling and Shapiro ch. 19 (except 19.2)

Nilsson and Maluszynski ch 10.4,10.5

SICStus Prolog Manual


Definite clause grammars

Definite Clause Grammars

(DCGs) special syntax for language specifications.

The system automatically compiles DCG into a Prolog clause.

DCGs are a generalisation of CFGs.


Definite clause grammars1

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


Definite clause grammars2

Definite Clause Grammars

Syntax

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 []


Definite clause grammars3

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.


Definite clause grammars4

Definite Clause Grammars

Compilation of DCG's into Prolog

p(A1, …, An) --> T1, .., Tmis 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


Definite clause grammars5

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).


Definite clause grammars6

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|….


Definite clause grammars7

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.


Definite clause grammars8

Definite Clause Grammars

ExampleWrite 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.


Definite clause grammars9

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.


Interpreter as transition relation

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)


Assignment as predicate

Assignment as predicate

For instance

X:=E

would be modeled as a predicate

assign(X,E,StateIn,StateOut) :- ...


Imperative program

imperative program

state transition relation in a procedure in an imperative language

proc {Prog

Z := X

X := Y

Y := Z

}


Program as transition relation

Program as transition relation

prog(In,Out) :-

assign(Z,X,In,T1),

assign(X,Y,T1,T2),

assign(Y,Z,T2,Out).


Using grammar notation

Using grammar notation

The state transformation could be expressed using the grammar notation

prog -->assign(z,x),

assign(x,y),

assign(y,z).


Transition relations declaratively

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


4 case study a compiler for three model computers

Ö4: Case study: A compiler for three model computers

Clocksin, ch. 9


F7 program transformation

F7: Program Transformation

Sterling and Shapiro ch. 13,16,18


Outline5

Outline

Transformations of programs

fold/unfold - partial evaluation

Higher order programming

defining and using apply, map


Transformation rules for programs

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:


Equality reordering

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.


Equality removal

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.


Clause level transformation

Clause level transformation

A clause (j) is a specialized version of a clause (i)

if (Pi :- Q1,…,Qm) s = 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.


Removal of failing clauses

Removal of failing clauses

Suppose that

(Pi :- Q1,…,Qm) s = Pj :- false

This 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.


Removal of repeated goals

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.


Reordering of goals

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.


Fold unfold

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).


Partial deduction evaluation

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.


Stepwise enhancement

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).


Stepwise enhancement cont

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).


Functions

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.


Higher order

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.


Higher order programming apply

Higher order programming:apply

general form

apply(foo,X1...Xn) :- foo(X1...Xn).


Higher order programming map

Higher order programming: map

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([],_,[]).


All solutions predicates

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]


All solutions predicates cont

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]


All solutions predicates cont1

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]


All solutions predicates cont2

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]


5 metaprogramming expert systems

Ö5: Metaprogramming, Expert Systems

Sterling and Shapiro ch. 10,17 (not 17.5),19.2,22

Nilsson and Maluszynski ch. 8,9


Outline metaprogramming

Outline - Metaprogramming

What is a metastatement?

Metalogic predicates (built in)

solve, augmenting solve

Iterative deepening

Mixing object and metalevel programming

Support for dynamically changing knowledge bases


What is a metastatement

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.


Meta logic

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.


Ground representation of facts and rules

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)


Ground representation

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)))).


Sld resolution rule1

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)s


The sld rule encoded as a relation

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).


The sld rule encoded as a relation cont

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


The sld rule encoded as a relation cont1

The SLD-rule encoded as a relation (cont)

derivation(G,G).

derivation(G0,G2) :-

step(G0,G1),

derivation(G1,G2).


Why self interpreters

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


Non ground representation

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).


Metainterpreter for pure prolog

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.


Metainterpreter generating a proof

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 .


Depth bounded pure prolog

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.


Meta logic1

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


Meta logic2

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.


Meta logic3

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


Meta logic decomposing terms

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


Meta logic decomposing terms1

Meta-logic, decomposing terms

arg(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.


Meta logic decomposing terms2

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.


Meta logic4

Meta-logic

Define the predicate subterm(Sub,Term), for checking if Sub is subterm of Termsubterm(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).


Meta logic5

Meta-logic

Define the predicate subterm(Sub,Term) for checking if Sub is subterm of Termsubterm(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).


Meta logic6

Meta-logic

define =.. using functor/3 and arg/3a) Term T is givenT =.. [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).


Meta logic7

Meta-logic

define =.. using functor/3 and arg/3b) List [F|Args] is givenT =.. [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).


Support for dynamic knowledge bases

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 programFor 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).


Expert systems

Expert systems

Expert System =

Knowledge-base (KB)

+ Inference engine (IE)

+ User Interface (UI)

Expert System Shell = (IE) + (UI)


Expert systems production rules

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 …


Expert systems forward backward chaining

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


Expert systems in prolog

Expert systems in Prolog

in PROLOG

knowledge base = set of clauses

inference engine = SLD-resolution

SLD-resolution is a backward chaining proof procedure


Uncertainty

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 C

CERTAINTY 80%


Expert systems forward backward

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 yellow

THEN Fruit=banana

fruit(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 inches

THEN FruitClass=vine

fruit(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).


Expert systems forward backward1

Expert systems, forward/backward

Rule 4:

IF SeedCount=1

THEN SeedClass=stonefruit

fruit(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>1

THEN SeedClass=multiple

fruit(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=stonefruit

THEN Fruit=cherry

fruit(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.


User interface dialogue

User interface - dialogue

An expert system is often not automatic

=> user interaction guides the search

graphical user interface

dialogue


Explanation facilities

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 ?


Knowledge acquisition

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


Rule base as prolog clauses

Rule base as Prolog clauses

IF A1 AND (A2 OR A3) THEN C1 AND C2

C1 :- A1, (A2 ; A3).

C2 :- A1, (A2 ; A3).


Taxonomy of a car engine

Taxonomy of a car-engine

car

electric system

fuel system

ignition

starting motor

spark plugs

fuse

fuel pump

fuel

battery

needs(car,fuel_system). ....needs(electric_system,fuse).


Expert system diagnosis

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


Expert system diagnosis1

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).


Expert systems abduction

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


Self interpreter generating a proof

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 .


Query the user

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).


Knowledge base

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)


F8 case study support for reasoning about electronic circuits

F8: Case study: Support for reasoning about electronic circuits

Clocksin, ch. 7,8


6 constraint logic programming

Ö6: Constraint Logic Programming

SICStus Prolog Manual

Nilsson and Maluszynski ch.14

Course 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


Significance

Significance

Constraint programming identified as a strategic direction in computer science research

[ACM Computing Surveys, December 1996]


This talk

This Talk…

  • …concerned with constraints for

    solving combinatorial problems

  • designed as basic tutorial


Application areas

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


Techniques

Techniques

  • Artificial intelligence

  • Operations research

  • Algorithms

  • Programming languages


Overview

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


  • Constraint programming cp

    xy

    y>3

    x{4,5} y{4,5}

    Constraint Programming (CP)

    based on the idea of an abstract space of statements or conditions, a

    constraint space


    Constraint programming cp1

    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.”


    Constraint programming cp2

    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.”


    Constraint programming cp3

    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).


    Constraint programming cp4

    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.


    Constraint programming cp5

    Constraint Programming (CP)

    Enumeration

    It 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.


    Constraint programming cp6

    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.


    Constraint propagation

    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


    Constraint propagation1

    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.


    Constraint propagation2

    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.


    Constraint propagation3

    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.


    Constraint modelling cp

    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.


    Constraint programming cp7

    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.


    Finite domains

    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.


    Continuous domains

    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.


    Comparison with operations research or

    Comparison with Operations Research ---OR

    Techniques from Operations Research, e.g. linear programming (LP) and integer programming (IP) efficiently handles models where:

    • Most of the variables are continuous.

    • The model can be relatively directly expressed as a set of simple (linear) equations and inequalities.

    • A simple (linear) and well defined cost function captures well the “goodness” of different solutions to a given problem.


    Comparison with operations research 2

    Comparison with Operations Research (2)

    The techniques that have been developed in constraint programming, using finite domains, work well also when:

    • A majority of the variables model naturally discrete entities.

    • The cost function is hard to determine.

    • The model contains complicated (for instance non-linear) conditions.

      In this way these two classes of techniques can be said to complement each other.


    Global constraints

    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:

    • < > =< >= = /=


    Global constraints1

    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


    Global constraints 2

    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.


    Global constraints 21

    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.


    Global constraints 22

    Global constraints (2)

    • Global constraints constitute abstractions of more complicated properties of problems and enables computations on a more detailed model


    Algorithms as constraint abstractions

    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}.


    An example getting started

    An example: Getting Started

    A toy problem…

    Modeling

    Solving: propagation and search


    Send more money smm

    Send More Money (SMM)

    • Find distinct digits for letters, such that


    Constraint model for smm

    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

      S0M0


    Solution for smm

    Solution for SMM

    • Find values for variablessuch that

      all constraints satisfied


    Finding a solution

    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


    Some concepts

    Some Concepts

    • Constraint store

    • Basic constraint

    • Propagator

    • Non-basic constraint

    • Constraint propagation


    Constraint store

    Constraint Store

    • Stores basic constraints

      map variables to possible values

    • Domains: finite sets, real intervals, trees, …

    finite domain constraints

    x{3,4,5} y{3,4,5}


    Propagators

    Propagators

    • Implement non-basic constraints

      distinct(x1,…,xn)

      x + 2×y = z


    Propagators1

    Propagators

    • Amplify store by constraint propagation

    xy

    y>3

    x{3,4,5} y{3,4,5}


    Propagators2

    xy

    y>3

    Propagators

    • Amplify store by constraint propagation

    x{3,4,5} y{4,5}


    Propagators3

    xy

    y>3

    Propagators

    • Amplify store by constraint propagation

    x{3,4,5} y{4,5}


    Propagators4

    xy

    y>3

    Propagators

    • Amplify store by constraint propagation

    x{4,5}y{4,5}


    Propagators5

    Propagators

    • Amplify store by constraint propagation

    • Disappear when entailed

      • no more propagation possible

    xy

    x{4,5} y{4,5}


    Constraint space

    xy

    y>3

    x{4,5} y{4,5}

    Constraint Space

    • Store with connected propagators


    Propagation for smm

    Propagation for SMM

    • Results in store

      S=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


    Distribution

    xy

    xy

    xy

    y>3

    y>3

    y>3

    x{4,5} y{4,5}

    x{4} y{4}

    x{5} y{5}

    Distribution

    • Yields spaces with additional constraints

    • Enables further constraint propagation

    x4

    x=4


    Distribution strategy

    Distribution Strategy

    • Pick variable x with at least two values

    • Pick value n from domain of x

    • Distribute with

      x=nandxn

    • Part of model


    Search

    Search

    • Iterate propagation and distribution

    • Orthogonal: distribution  exploration

    • Nodes:

      DistributableFailedSucceeded


    Smm solution

    SMM: Solution


    Heuristics for distribution clp jargong labelling

    Heuristics for Distribution(CLP jargong: Labelling)

    • Which variable?

      • least possible values (first-fail)

      • application dependent heuristic

  • Which value?

    • minimum, median, maximum

      x=morxm

    • split with median m

      x<mor xm

  • In general: application specific


  • Smm solution with first fail

    SMM: Solution With First-fail


    Send most money smm

    Send Most Money (SMM++)

    • Find distinct digits for letters, such that

      and MONEY maximal


    Best solution search

    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


  • Branch and bound search

    Branch-and-bound Search

    • Find first solution


    Branch and bound search1

    Branch-and-bound Search

    • Explore with additional constraint


    Branch and bound search2

    Branch-and-bound Search

    • Explore with additional constraint


    Branch and bound search3

    Branch-and-bound Search

    • Guarantees better solutions


    Branch and bound search4

    Branch-and-bound Search

    • Guarantees better solutions


    Branch and bound search5

    Branch-and-bound Search

    • Last solution best


    Branch and bound search6

    Branch-and-bound Search

    • Proof of optimality


    Modelling smm

    Modelling SMM++

    • Constraints and distribution as before

    • Order among solutions with constraints

      • so-far-best solutionS,E,N,D,M,O,T,Y

      • current node S,E,N,D,M,O,T,Y

      • constraint added

        10000×M+1000×O+100×N+10×E+Y

        <

        10000×M+1000×O+100×N+10×E+Y


    Smm branch and bound

    SMM++: Branch-and-bound


    Smm all solution search

    SMM++: All Solution Search


    Summary

    Summary

    • Modeling

      • variables with domain

      • constraints to state relations

      • distribution strategy

      • solution ordering

  • Solving

    • constraint propagation

    • constraint distribution

    • search tree exploration


  • The art of modeling

    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


    Distribution exploration

    Distribution  Exploration

    • Distribution

      defines shape of search tree

    • Exploration

      • left-most depth-first

      • interactive, graphical

      • parallel

      • branch-and-bound[prunes tree]


    Scheduling

    Scheduling

    Modeling

    Propagation

    Global constraints


    Scheduling1

    Scheduling

    • Among the examples of global reasoning that have successfully been introduced into constraint programming systems are a number of fundamental scheduling mechanisms.


    Scheduling2

    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.


    Scheduling3

    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.


    Scheduling4

    Scheduling

    Resources can in general model widely different type of entities.

    For instance:

    • processing equipment in a production process.

    • staff or vehicles in a transport net.

    • network resources such as routers and transport links with limited capacity.


    Scheduling5

    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.


    Scheduling given

    Scheduling: Given

    • Tasks

      • duration

      • resource

  • Precedence constraints

    • determine order among two tasks

  • Resource constraints

    • at most one task per resource

      [disjunctive, non-preemptive scheduling]


  • Scheduling bridge example

    Scheduling: Bridge Example


    Scheduling solution

    Scheduling: Solution

    • Start time for each task

    • All constraints satisfied

    • Earliest completion time

      • minimal make-span


    Scheduling model

    Scheduling: Model

    • Variable for start-time of task a

      start(a)

    • Precedence constraint: a before b

      start(a) + dur(a)  start(b)


    Propagating precedence

    a

    b

    Propagating Precedence

    a before b

    start(a){0,…,7}

    start(b){0,…,5}


    Propagating precedence1

    a

    a

    b

    b

    Propagating Precedence

    a before b

    start(a){0,…,7}

    start(b){0,…,5}

    start(a){0,…,2}

    start(b){3,…,5}


    Scheduling model1

    Scheduling: Model

    • Variable for start-time of task a

      start(a)

    • Precedence constraint: a before b

      start(a) + dur(a)  start(b)

    • Resource constraint:

      a before b

      or

      b before a


    Scheduling model2

    Scheduling: Model

    • Variable for start-time of task a

      start(a)

    • Precedence constraint: a before b

      start(a) + dur(a)  start(b)

    • Resource constraint:

      start(a) + dur(a)  start(b)

      or

      b before a


    Scheduling model3

    Scheduling: Model

    • Variable for start-time of task a

      start(a)

    • Precedence constraint: a before b

      start(a) + dur(a)  start(b)

    • Resource constraint:

      start(a) + dur(a)  start(b)

      or

      start(b) + dur(b)  start(a)


    Reified constraints

    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!


    Reification for disjunction

    Reification for Disjunction

    • Reify each precedence

      [start(a) + dur(a)  start(b)]  b0=1

      and

      [start(b) + dur(b)  start(a)]  b1=1

    • Model disjunction

      b0 + b1 1


    Model is too na ve

    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


  • Edge finding

    Edge Finding

    • Find ordering among tasks (“edges”)

    • For each subset of tasks {a}B

      • assume: a before B

        deduce information fora and B

      • assume: B before a

        deduce information fora and B

      • join computed information

      • can be done in O(n2)


    Scheduling architecture

    Scheduling Architecture

    • Constraint programming

      natural modeling

    compiler

    specification

    model


    Scheduling architecture1

    Scheduling Architecture

    • Constraint programming

      expressive modeling

    compiler

    specification

    model


    Summary1

    Summary

    • Modeling

      • easy but not always efficient

      • constraint combinators (reification)

      • global constraints

      • smart heuristics

  • More on constraint-based scheduling

    Baptiste, Le Pape, Nuijten. Constraint-based

    Scheduling, Kluwer, 2001.


  • Why does cp matter

    Why Does CP Matter?

    • Middleware for combining smart algorithmic components

      • scheduling

      • graphs

      • flows

      • plus

      • essential extra constraints


    Research in constraints

    Research in Constraints

    • Propagation algorithms

    • Search methods

    • Innovative applications

    • Programming and modeling languages

    • Hybrid methods

      • linear programming

      • local search


    Constraints in sweden

    Constraints in Sweden

    • Swedish constraint network

      SweConsNet[founded May 2002]

    http://www.dis.uu.se/~pierref/astra/SweConsNet/


    Cp systems

    CP Systems

    • Commercial

      • ILOG SolverC++

      • OPL Studio Modeling

      • SICStus PrologProlog-based

      • EclipseProlog-based

  • Free

    • GNU PrologProlog-based

    • MozartOz

    • CHOCOClaire


  • 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 Consortium

    Saarland University, Germany

    SICS/KTH, Sweden

    Université catholique de Louvain, Belgium

    Oz and Mozart


    Mozart fact sheet

    Mozart Fact Sheet

    • Freely available at

      www.mozart-oz.org

    • Many platforms supported

      UnixWindows Mac OS

    • Active user community

    • Comes with extensive documentation

    • Many applications


    Constraints in mozart

    Constraints in Mozart

    • Rich set of constraints

      finite domainsscheduling

      finite setsrecords

    • New propagators via C++ API

    • Search and combinators [unique]

      • programmable

      • concurrency-compatible

      • fully compositional

        Book: Schulte, Programming Constraint Services. LNAI, Springer 2002.g


    Some research issues

    Some Research Issues

    • Search methods

    • Architecture and implementation

    • Automatic selection of good propagator

      • domain versus bound

  • Challenging applications


  • Case study

    Case Study

    Instruction scheduling

    Bus scheduling


    Instruction scheduling

    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.


    Model

    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


  • Making it work

    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]


  • Results

    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


  • Off line scheduling of real time system

    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.


  • Model1

    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


  • Performance

    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)


  • Summary2

    Summary

    • Useful for

      • small components in software systems

      • large offline optimization

  • Widely applicable

    • in your area?

    • hardware design?


  • Conclusion1

    Conclusion

    • Constraint programming useful

      • easy modeling

      • open to new techniques


    Constraints for concurrency

    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 idea

    resumption condition is logical entailment

    [Maher,87], ccp [Saraswat,90]


  • Problem solving

    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


  • Login