Prolog for Dummies

Ulf NilssonDept of Computer and Information ScienceLinköping University

Logic programs

A logic program describes individualsand relations between individuals

(or properties of individuals). The program is used to answer

queries about the world describedin the program.

Relations

Adam is a parent of BillParis is the capital of France5 is greater than 2 plus 2X times 1 is equal to XX is a subset of Y5 is the maximum of 2 and 5There is an edge from a to b

Properties

Adam is a parentAdam is maleX plus 1 is non-zeroParis is a capitalGrass is greenThe music was loud

Queries

Who is the father of Bill?Is there an edge from a to b?Which town is a capital?Who is male?

Language primitives

Constantsadam, paris, 5, 3.14, [], ´Adam’, ...

VariablesX, Y, List, _12, _, ...

Function symbolsplus/2, +/2, f/1, ...

Predicate symbolscapital/2, greater/2, non_zero/1, >/2, ...

Terms

Terms represent individuals

ConstantsVariablesCompound terms

E.g. paris, X, plus(2,3), plus(2,plus(3,4))Infix notation: 2+3

Atomic formulas

Atomic formulas describe relations:

If p is a predicate letter of arity n and t1,...,tn are terms then p(t1,...,tn) is an atomic formula.

E.g. capital(paris,france) greater(X,2)Infix notation: X > 2

Logic Programs

A logic program is a set of clauses: facts rules

The program is used to answer queries.

Facts

A fact is an expression of the form:A.

where A is an atomic formula.

Examples:edge(a, X).

parent(adam, bill).

Interpretation Facts

Consider a fact A.

Declarative (logical) reading:For all variables, A is true.

Procedural (operational) reading:A is solved.

Rules

A rule is an expression of the form:A0 :- A1, ... , An.

where each Ai is an atomic formula.

Examples: path(X,Y) :- edge(X,Y).

father(X,Y) :- parent(X,Y), male(X).

Interpretation Rules

Consider a rule A0 :- A1, ... , An.

Declarative (logical) reading:For all variables, A0 if A1 and...and An.

Procedural (operational) reading:To solve A0, first solve A1, then A2 etc.

Example

gp(X,Y) :- p(X,Z), p(Z,Y).

p(X,Y) :- f(X,Y).p(X,Y) :- m(X,Y).

f(adam,bill).f(bill,carl).m(anne,bill).

Queries

A query is an expression of the form:?- A1, ..., An.

where n=0,1,2,... and A1, ..., An are atomic formulas.

Examples:?- father(X, bill).

?- parent(X, bill), male(X).

Interpretation Queries

Consider a query ?- A1, ... , An.

Declarative (logical) reading:Are there variables such that A1 and...and

An?

Procedural (operational) reading:First solve A1, then A2 etc

Ground SLD-Resolution

?- A1,A2,...,An.

?- B1,...,Bm,A2,...,An.

A1 :- B1,...,Bm.

whereA1 :- B1,...,Bm is an instantiated program clause.

parent(X,Y) :-father(X,Y).

parent(X,Y) :-mother(X,Y).

father(adam,bill).mother(anne,bill).

A Derivation

?- parent(adam,bill)

?- father(adam,bill)

?- true

parent(X,Y) :-father(X,Y).

parent(X,Y) :-mother(X,Y).

father(adam,bill).mother(anne,bill).

parent(X,Y) :-father(X,Y).

parent(X,Y) :-mother(X,Y).

father(adam,bill).mother(anne,bill).

parent(X,Y) :-father(X,Y).

parent(X,Y) :-mother(X,Y).

father(adam,bill).mother(anne,bill).

Another Derivation

?- parent(anne,bill)

?- mother(anne,bill)

?- true

parent(X,Y) :-father(X,Y).

parent(X,Y) :-mother(X,Y).

father(adam,bill).mother(anne,bill).

parent(X,Y) :-father(X,Y).

parent(X,Y) :-mother(X,Y).

father(adam,bill).mother(anne,bill).

Full SLD-Resolution

?- A1,A2,...,An.

?- A1= B0, B1,...,Bm,A2,...,An.

B0 :- B1,...,Bm.

where:

• B0 :- B1,...,Bm is a renamed program clause.

?- (B1,...,Bm,A2,...,An).

• is a solution to the equation A1 = B0.

?- X=X1, bill=Y1, father(X1,Y1). ?- father(X,bill).

Yet Another Derivation

?- parent(X,bill).

parent(X1,Y1) :- father(X1,Y1).father(adam,bill).

?- X=adam, bill=bill. ?- true.

Answer: X=adam

And Another One...

?- gp(X,Y).

gp(X1,Y1) :- p(X1,Z1),p(Z1,Y1).

?- X=X1, Y=Y1, p(X1,Z1), p(Z1,Y1).?- p(X,Z1), p(Z1,Y).

p(X2,Y2) :- f(X2,Y2).

?- X=X2, Z1=Y2, f(X2,Y2), p(Z1,Y).?- f(X,Z1), p(Z1,Y).

f(adam,bill).

?- X=adam,Z1=bill, p(Z1,Y).?- p(bill,Y).

X=adam

p(X3,Y3) :- f(X3,Y3).

?- bill=X3, Y=Y3, f(X3,Y3).?- f(bill,Y).

f(bill,carl).?- bill=bill, Y=carl.?- true.

Y=carl

And a Failed One...

?- gp(X,Y).

gp(X1,Y1) :- p(X1,Z1),p(Z1,Y1).

?- X=X1, Y=Y1, p(X1,Z1), p(Z1,Y1).?- p(X,Z1), p(Z1,Y).

p(X2,Y2) :- f(X2,Y2).

?- X=X2, Z1=Y2, f(X2,Y2), p(Z1,Y).?- f(X,Z1), p(Z1,Y).

f(bill,carl).

?- X=bill,Z1=carl, p(Z1,Y).?- p(carl,Y).

X=bill

p(X3,Y3) :- f(X3,Y3).

?- carl=X3, Y=Y3, f(X3,Y3).?- f(carl,Y).

?- fail.FAILURE!!!

?- true.Y=carl

?- p(bill,Y).

X=adam

SLD-Tree

?- gp(X,Y).

?- f(bill,Y). ?- m(bill,Y).

?- fail.

?- p(X,Z),p(Z,Y).

?- f(X,Z),p(Z,Y).

?- p(carl,Y).

?- f(carl,Y).?- m(carl,Y).

?- fail. ?- fail.

?- m(X,Z),p(Z,Y).

?- f(bill,Y). ?- m(bill,Y).

?- true.Y=carl

?- fail.

?- p(bill,Y).

X=anne

Example

/* or(In1, In2, Out) */or(0, 0, 0).or(0, 1, 1).or(1, 0, 1).or(1, 1, 1).

/* nand(In1, In2, Out) */nand(X, Y, Z) :-

and(X, Y, Tmp),inv(Tmp, Z).

/* inv(In, Out) */inv(0, 1).inv(1, 0).

/* and(In1, In2, Out) */and(0, 0, 0).and(0, 1, 0).and(1, 0, 0).and(1, 1, 1).

Database

lecturer(Lecturer,Course) :- course(Course,_,Lecturer,_).

duration(Course,Length) :- course(Course,time(_,S,F),_,_), plus(S,Length,F).

teaches(Lect,Day) :- course(_, time(Day,_,_), Lect, _). occupied(Room,Day,Time) :- course(_,time(Day,S,F),_,Room), S =< Time, Time =< F.

% Databasecourse(logic, time(monday, 8, 10), dave, a12)....

Recursion

path(Node,Node).path(Node1,Node3) :-

edge(Node1,Node2),path(Node2,Node3).

edge(a,b).edge(a,c).edge(b,d).edge(c,d).edge(d,e).edge(f,g).

a

b

c

d

e

f

g

a

b

c

.

[]

.

.

c

b

a

List Notation

.(a, .(b, .(c, [])))

More On List Notation

The empty list: []A non-empty list: .(X,Y) or [X|Y]

Syntactic Sugar:[b] instead of [b|[]] and .(b, [])[a,b] instead of [a|[b]] and [a|[b|[]]][a,b|X] instead of [a|[b|X]]

List manipulation

list([ ]).list([X|Xs]) :- list(Xs).

member(X,[X|Xs]).member(X,[Y|Ys]) :- member(X,Ys).

append([ ],Ys,Ys).append([X|Xs],Ys,[X|Zs]) :- append(Xs,Ys,Zs).

List Manipulation

% reverse(A, B)% B is A in reverse orderreverse([ ],[ ]).reverse([X|Xs],Zs) :- reverse(Xs,Ys), append(Ys,[X],Zs).

% Alternative versionreverse(Xs,Ys) :- reverse(Xs,[ ],Ys).

reverse([ ],Ys,Ys).reverse([X|Xs],Acc,Ys) :- reverse(Xs,[X|Acc],Ys).

Insertion Sort

% sort(A,B)% B is a sorted version of Asort([X|Xs],Ys) :- sort(Xs,Zs), insert(X,Zs,Ys).sort([ ],[ ]).

% insert(A,B,C)% if B is a sorted list, then C is sorted% and contains all elements in B plus Ainsert(X,[ ],[X]).insert(X,[Y|Ys],[Y|Zs]) :- X > Y, insert(X,Ys,Zs).insert(X,[Y|Ys],[X,Y|Ys]) :- X =< Y.

Binary Trees

% binary_tree(A)% A is a binary treebinary_tree(void).binary_tree(tree(Element,Left,Right)) :-

binary_tree(Left), binary_tree(Right).

% tree_member(A,B)% A is a node in the tree Btree_member(X,tree(X,_,_)).tree_member(X,tree(_,Left,_)) :- tree_member(X,Left).tree_member(X,tree(_,_,Right)) :- tree_member(X,Right).

Built In Predicates

setof(X, p(X), S)~ S is the set of all X such that p(X)

bagof(X, p(X), B)~ B is the sequence of all X such that p(X)

findall(X, p(X), B)B is the sequence of all X such that p(X)

Negation

Prolog contains a weak form of negationcalled “negation as failure”.

Written: \+ p(a)A query ?- \+ p(a) succeeds if the

query ?- p(a) fails finitely.Robust only when the goal contains

no variables. (Use only as a test!)

Example Negation

on_top(X) :- \+ blocked(X).blocked(X) :- on(Y, X).on(a, b).

%----------------------------?- on_top(a).yes

b

a