1 / 34

# Chapter 7 - PowerPoint PPT Presentation

King Saud University College of Computer and Information Sciences Information Technology Department IT422 - Intelligent systems . Chapter 7. Part 2 Introduction to Prolog. Introduction. PRO LOG = PRO gramming in LOG ic

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about ' Chapter 7' - rania

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

College of Computer and Information Sciences

Information Technology Department

IT422 - Intelligent systems

### Chapter 7

Part 2

Introduction to Prolog

• PROLOG = PROgramming in LOGic

• 1970: using logic as a programming language (R. Kowalski, M. Van Emden, A. Colmerauer from Edinburg and Marseille).

• 1982: Prolog software product in markets.

• 1995: extension CLP Constraint Logic Programming.

• Procedural/Object Oriented Programming (PP/OOP) vs. Declarative Programming

• PP/OOP:a program instructs the computer

• what to do

• how to do

• in what order

• Declarative Programming:a program describes what to do without a detailed plan of how to do

• Prolog is the most widely used logic programming language.

• Prolog programs are set of definite clauses written in a notation somewhat different from standard FOL.

• Three basic mechanisms among others:

• Pattern Matching,

• Tree based data structuring

• Back-Tracking.

• Suitable for problems that involve structured objects and relations between them.

• The execution of Prolog programs is done through depth-first backward chaining search with no checks for infinite recursion.

• It allows symbolic computation.

• Examples:

• Red sphere is behind green box.

• If object X is closer to the observer than object Y and object Y is closer than object Z than X is closer than Z.

• Prolog basic concepts by an example:

• Let’s consider the Parent relation

ali

layla

nour

omar

meriam

khaled

zahra

• This relation can be defined by the following Prolog program:

• parent(leyla, omar).

• parent(ali, omar).

• parent(omar, meriam).

• parent(omar, khaled).

• parent(ali, nour).

• parent(khaled, zahra).

• This program consists of 6 Clauses. Each clause declares one fact about the relation parent.

• The clause parent(omar, meriam) is an instance of the relation parent. A relation is defined as a set of instances.

• What can we do with this program?

• Question: is omar parent of khaled?

• In prolog ?- parent(omar, khaled).

• Question: is leyla parent of meriam?

In prolog ?- parent(leyla, meriam).

• Question: who is zahra’s parent?

In prolog ?- parent(X, zahra).

The system tells what is the value of X for which the statement is true.

• Question: who are omar’s children?

In prolog ?- parent(omar,X).

X= khaled

no

• Question: Who is parent of whom?

In prolog ?- parent(X,Y).

Answer: X= leyla Y=omar; X=ali Y=omar; X=omar Y=meriam; X=omar Y= khaled; X=ali Y=nour; X=khaled y=zahra;

• Question: who is grandparent of khaled?

In prolog ?- parent(X, khaled), parent(Y, X).

Note: the logical meaning remains the same if we change the order of the two requirements.

Answer: X= omar Y= ali; X= omar Y=leyla

• Question: Who are ali grandchildren?

In prolog ?- parent(ali,X), parent (X,Y).

Answer: X= omar y=khaled; X=omar Y=meriam;

• Question: Do meriam and nour have a common parent?

In prolog ?- parent(X, meriam), parent(X,nour).

First who is parent of meriam (X) ?

Second is it (X) the same parent of nour ?

• It is easy in Prolog to define a relation such as parent by stating the n-tuples of objects that satisfy the relation. In this case we have defined a relation by a set of facts represented by clauses.

• We can easily express queries in Prolog.

• A Prolog program consists of clauses. Each clause terminates with a full stop.

• The arguments of relations can be: concrete objects, constants, general objects such as X and Y.

• Questions to the system consist of one or more goals. The answer can be positive (goal satisfiable) or negative (goal unsatisfiable).

• If several answers satisfy the question than Prolog will find as many of them as desired by the user.

• Prolog system recognizes the type of an object in the program by its syntactic form.

• The syntax of Prolog specifies different forms for each type of data object.

• All data objects in Prolog are called TERMS.

• Atoms and numbers:

• An atom can be constructed in three ways:

• String of letters, digits and the underscore ‘_’ starting with a lower case e.g. ali, x25, x_y…

• Strings of special characters e.g. <__>,::=, .. Predefined string: ‘:-’

• Strings of characters enclosed in single quotes e.g.‘Ali’, ‘Saudi-Arabia’…

• Numbers:

• Used in Prolog include integer numbers and real numbers e.g.1997, -94, 0, 3.14, 0.0035….

• Variables:

• Strings of letters, digits and underscore characters. They start with an upper case letter or an underscore character e.g.X, Result, _23, _x33, _ , ….

• Note: Prolog uses anonymous variables _ that are represented by underscores in clauses.

• Structures

• Structured objects = object that has several components. The components themselves can, in turn, be structures.

• e.g. date(1,may,2001), date(Day,may,2007)

• Note: This method for data structuring is simple and powerful symbolic manipulation.

• All structured objects can be pictured as trees.

• Structures

D=date

T=triangle

1 may 2007

• point pointpoint

• Date(1,may,2007)

3 1 4 3 6 0

functor

arguments

T=triangle(point(3,1),point(4,3),point(6,0))

• Fact ≠ Rule

• A fact is always, unconditionally, true.

• A rule specifies a thing that is true if some condition is specified. It has:

• a condition part (right hand side of the rule).

• a conclusion part (left hand side of the rule).

• A clause is written “backwards” from what we are used to.

Instead of A B => C

in Prolog we have C:- A, B.

• e.g. let’s define the relation offspring:

For all X and Y

Y is an offspring of X if

X is a parent of Y

• Corresponding Prolog clause:

offspring (Y,X):-parent (X,Y)

head (conclusion part) body (condition part)

• Interpretation:

for all X and Y

if X is parent of Y then

Y is an offspring of X

• If we ask the question: ?-offspring(khaled,omar).

• Y is substituted with khaled and X with omar: the process is called instantiation Y=khaled X=omar

• Offspring(khaled,omar):-parent(omar,khaled).

• Try to find whether the condition is true.

• The goal offspring(khaled,omar) is replaced with the goal parent(omar,khaled)

• More complex rules:

• Let’s add the following facts:

female(leyla). male(omar).

female(nour). male(khaled).

female(meriam). male(ali).

female(zahra).

• Now, let’s define the relation mother:

For all X and Y

X is the mother of Y if

X is female and

X is parent of Y.

• The corresponding Prolog rule is:

Mother(X,Y):-female (X) , parent(X,Y).

• Head (conclusion part): mother (X,Y)

• Body (condition part): female (X), parent(X,Y)

• ‘,’ : to express conjunction (AND operator).

• Nodes correspond to objects: arguments of relations.

• Arcs between nodes correspond to binary relations. Arcs are oriented so as to point from the first to the second argument.

• Unary relations are represented by marking the corresponding node by the name of the relation.

X

X

X

offspring

parent

mother

parent

parent

grandparent

Y

Y

Y

parent

Z

• Question: define the relation sister

• For any X and Y

• X is a sister of Y if

• Both X and Y have the same parent

• X is a female

• sister(X,Y):- female(X), parent(Z,X), parent(Z,Y).

Z

parent

parent

X

Y

sister

• is meriam sister of khaled?

• ?-sister(meriam,khaled).

• Another question: who is khaled’s sister?

• ?-sister(X,khaled).

• Prolog programs can be extended by simply adding new clauses.

• Prolog clauses are of three types: facts, rules and questions.

• Facts declare things that are always, unconditionally, true.

• Rules declare things that are true depending on a given condition.

• By means of questions the user can ask the program what things are true.

• Prolog clauses consist of the head and the body. The body is a list of goals separated by commas. Commas are understood as conjunctions.

• Facts are clauses that have a head and the empty body. Questions have only the body. Rules have a head and a body.

• Variables are instantiated when the system answers questions.

• Variables are assumed to be universally quantified (for all).

• Recursive rules

Let’s define the relation predecessor.

First possibility

For all X and Z

X is a predecessor of Z if

X is a parent of Z.

Second possibility

For all X and Z

X is a predecessor of Z if

X is a parent of Y and

Y is a parent of Z.

• Recursive rules

• More general definition:

• For all X and Z

• X is a predecessor of Z

• If there exits a Y such that

• X is a parent of Y

• Y is a predecessor of Z

• Corresponding Prolog clause

predecessor (X,Z):-

parent (X,Y),

predecessor(Y,Z).

• Complete program for predecessor relation:

predecessor (X,Z):-

parent (X,Z).

predecessor (X,Z):-

parent (X,Y),

predecessor(Y,Z).

• This is a recursive definition of the relation predecessor.

• Question: who are ali’s successors?

• Prolog allows manipulation of lists.

• Syntax:

a list always starts and ends with square brackets, and each of the items they contain is separated by a comma.

e.g. [first,second,third]

• Prolog also has a special facility:

• Split the first part of the list (called the head) away from the rest of the list (known as the tail).

• Place a special symbol | (pronounced 'bar') in the list to distinguish between the first item in the list and the remaining list.

• For example, consider the following. [first,second,third] = [X|Y]where X = first and Y=[second,third]

• [ ] /* this is a special list, it is called the empty list because it contains nothing */

• Now lets consider some comparisons of lists:

• [a] unifies with [H|T] resulting in H=a and T=[]

• [a,b,c] unifies with [a|T] resulting in T=[b,c]

• [a,b,c] doesn't unify with [b|T]

• [] doesn't unify with [H|T]

• [] unifies with []. Two empty lists always match

Consider the following fact.

p([H|T], H, T).

Lets see what happens when we ask some simple queries.

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

X=a Y=[b,c]

Yes

?- p([a], X, Y).

X=a Y=[]

Yes

?- p([], X, Y).

no

• Clauses are statements about what is true about a problem, instead of instructions how to accomplish the solution.

• The Prolog system uses the clauses to work out how to accomplish the solution by searching through the space of possible solutions.

• Not all problems have pure declarative specifications. Sometimes extralogical statements are needed.