Bahar Pamuk

OutlineIntroductionSyntaxaClauses, Programs and QueriesList ManipulationOperatorsBacktracking, CutsReferences

IntroductionDeclarative programming languageInstead of specifying how to achieev a goal,

we specify what the situation (facts, rules) and the goal(query) are and let Prolog to derive the solution.

Facts mother(“A”, “B”).

sister(“B”, “C”).

Rules is_bigger(X, Y) :- bigger(X, Y).

is_bigger(X, Y) :- bigger(X,Z), is_bigger(Z, Y)

Introduction

Syntax

Terms Atoms

a, ab123, z_999, a_b_c, 'an atom sample'

Numbers Variables

A, Z_1_2, _123, _

Compound Termsmother(ali, X), f(g(X, _))

Clauses, Programs & Queries Clauses

Fact: A certain instance of a relation is true.

Rule: The goal expressed by its head is true, if we show that all of the expressions in the rule's body are true.

Program: Sequence of clauses

Queries: Ask prolog interpreter whether all its predicates are provably true.

is_bigger(elephant, donkey).

is elephant bigger than donkey. small(X), green(X), slimy(X).

is there any X that small(X), green(X) and slimy(X) are all true.

Built-in Predicates= (equality) X=Y

consult('myprogram.pl').

?-write('hello world'), n1.

hello world

Yes

?-X = elephant, write(X), n1.

elephant

X=elephant

Yes

?-atom(elephant)

Yes

?- compound(f(elephant)).

Yes

Matching Queries?- is_bigger(X, dog) =

is_bigger(elephant, dog).

X=elephant

Yes

?- p(X, 2, 2) = p(1, Y, X).

No

?- p(_, 2, 2) = p(1, Y, _)

Y=2

Yes

?- f(a, g(X, Y)) = f(X, Z), Z= g(W, h(X)).

X=a

Y=h(a)

Z=g(W, h(a))

W=a

Yes

?- X=my_functor(Y).

X=my_functor(_G177)

Y=_G177

Yes

Goal Execution All man are mortal. Socrates is a man. Hence Socrates is mortal.

mortal(X):-man(X)

man(socrates)

?- mortal(socrates).

Yes

mortal(socrates) is the initial goal.

mortal(X) is the first possible fact to match. X=socrates

Variable inst. Is extended to the body of the rule.

man(socrates)

man(socrates) is our new goal

It is matched to the fact man(socrates).

Current goal succeeds, so initial goal succeeds.

List Manipulation

[elephant, horse, dog, cat]

[elephant, [], X, parent(X, tom), [a, b, c], f(22)]

[a,b,c] =

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

Head: first element

Tail: Rest of the list

?- [1,2,3,4] = [Head | Tail]

Head = 1

Tail=[2,3,4]

Yes

List Manipulation ?-concat_lists([1,2], [3,4,5], X).

X=[1,2,3,4,5]

concat_lists([],List, List).

concat_lists([Elem | List1], List2, [Elem | List3]) :- concat_lists(List1, List2, List3).

?- concat_lists(X, Y, [1,2,3]).

X=[]

Y=[1,2,3];

X=[1]

Y=[2,3];

X=[1,2]

Y=[3];

X=[1,2,3]

Y=[]

Built-in Predicates

length([1,2,3], X).

X=3

length(List, 3).

List=[_G123, _G234, _G456]

member(Elem, List)

append(List1, List2, List3)

last(Elem, List)

reverse(List1, List2) % reverse order of List1

select(List1, Elem, List2) % select elements of List1 after Elem

Arithmetic Expressions2+3 = 5 % they do not match

X is 2+3, X=5.

X=5

5 is 2+3.

Yes

2+3 is 5. % is evaluates rhs and matches it to left.

No

max, min, abs, //, **... for rhs of is operator

Relations

Compare two evaluated arithmetic expressions.

Whenever an arithmetic expression is used, the arguments are evaluated (no need to use is operator.)

<, >, <=, >=, =:=, =\=

=:= arithmetically equal,

= pattern matching

2 ** 3 =:= 3 + 5 Yes

2 ** 3 =8 3 + 5 No

Operators

Every operator is associated with an integer denoting its precedence. The lower the precedence the stronger the operator is binding.

The precedence of a term is defined as 0 unless its principal functor is an operator.3+5 -> 500

3 * 3 + 5 * 2 -> 400

elephant -> 0

(3+5) -> 0

Backtracking, Cuts & Negation

During proof search, Prolog keeps track of choice points; situations where there is more than 1 match.

When the chosen path is a failure/the user asks for alternative solutions, the systems jumps back to the last choice point and try the next alternative.

permutation ([], []).

permutation ( List, [Elem | Perm]) :-

select(List, Elem, Rest),

permutation (Rest, Perm).

Backtracking

?- permutation( [1,2,3], X).

X = [1,2,3];

X = [1,3,2];

X = [2,1,3];

X = [2,3,1];

X = [3,1,2];

X = [3,2,1];

No

Backtracking

remove_dup ([], []).

remove_dup ([Head | Tail], Result) :- member(Head, Tail), remove_dup(Tail, Result).

remove_dup ([Head | Tail], [Head| Result]) :- remove_dup(Tail, Result).

?- remove_dup ([a, b, b, c, a], X).

X = [b,c,a];

X = [b, b,c,a];

X = [a,b,c,a];

X = [a,b,b,c,a];

No.

Derivation Treeremove_dup ([a, b, b, c, a], X)

member(a,[ b,b,c,a])remove_dup([b,b,c,a],

Result)

member(b, [b,c,a])remove_dup([b,c,a], Result)

member(b, [c,a])remove_dup([b|c,a], [b|Result]):-

remove_dup([c,a], Result)

member(c, [a])remove_dup([c|a], [c|Result]):-

remove_dup([a], Result)

member(a, [])remove_dup([a|], [a|Result]):-

remove_dup([], Result) Result=[]

Result=[a]

Result=[c,a]

Result=[b,c,a]

Derivation Treeremove_dup ([a, b, b, c, a], X)

member(a,[ b,b,c,a])remove_dup([b,b,c,a],

Result)

member(b, [b,c,a])remove_dup([b,c,a], Result)

member(b, [c,a])remove_dup([b|c,a], [b|Result]):-

remove_dup([c,a], Result)

member(c, [a])remove_dup([c|a], [c|Result]):-

remove_dup([a], Result)

member(a, [])remove_dup([a|], [a|Result]):-

remove_dup([], Result)

remove_dup([b|b,c,a], [b|Result]):-

remove_dup([b,c,a], Result)Result=[b,c,a]

Result=[b,b,c,a]

CutsIt is possible to cut out backtracking points and

preventing unwanted alternative solutions.

! is a predicate and can be placed anywhere inside rule body. Execution of ! will always succeed

remove_dup ([Head|Tail], Result) :- member(Head, Tail), !,remove_dup(Tail, Result).

Without cut, alternative solution search will continue. But when cut is passed this isn't possible anymore.

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

X = [b,c,a];

No.

NegationIn order to give a positive answer to a query

Prolog has to construct a proof to show that the set of facts and rules implies that query.

Yes means the query is provably true.No doesn’t mean that the query is

necessarily false, just not provably true.Closed world assumption: Negating

everything that is not explicitly in the program.

ReferencesEndriss, U, Lecture Notes, An

Introduction to Prolog Programming, King's College, London