Loading...

PPT – Prolog Programming for Artificial Intelligence 3rd ed. 2001 PowerPoint presentation | free to view - id: 13f00a-MzgwN

The Adobe Flash plugin is needed to view this content

Prolog Programming for Artificial

Intelligence 3rd ed. 2001

- By Ivan Bratko

Resources

- SWI Prolog http
- //www.swi-prolog.org/
- Ciao Prolog http
- //clip.dia.fi.upm.es/Software/Ciao/
- Learning Prolog
- http//www.amzi.com/products/learning_products.htm

- Prolog tutorial
- http//www.csupomona.edu/jrfisher/www/prolog_tuto

rial/contents.html

Prolog tutorial

1. An Overview of Prolog

Contents

- An example program defining family relations
- Extending the example program by rules
- A recursive rule definition
- How Prolog answers questions
- Declarative and procedure meaning of programs

An Example Program

- Prolog is a programming language for symbolic,

non-numeric computation. - It is specially well suited for solving problems

that involve objects and relations between

objects.

parent(tom,bob). parent(pam,bob). parent(tom,liz).

parent(bob,ann). parent(bob,pat). parent(pat,jim)

.

An Example Program

?- parent(bob,pat). yes ?- parent(liz,pat). no ?-p

arent(tom,ben). no ?- parent(X,liz). Xtom. ?-

parent(bob,X). Xann Xpat no

parent(tom,bob). parent(pam,bob). parent(tom,liz).

parent(bob,ann). parent(bob,pat). parent(pat,jim)

.

An Example Program

Who is a parent of whom? Find X and Y such that X

is a parent of Y. ?- parent(X,Y). Xpam Ybob Xt

om Ybob Xtom Yliz ...

parent(tom,bob). parent(pam,bob). parent(tom,liz).

parent(bob,ann). parent(bob,pat). parent(pat,jim)

.

An Example Program

Who is a grandparent of Jim? (1) Who is a parent

of Jim? Assume that this is some Y. (2) Who is a

parent of Y? Assume that this is some X. ?-

parent(Y,Jim), parent(X,Y). Xbob Ypat

parent(tom,bob). parent(pam,bob). parent(tom,liz).

parent(bob,ann). parent(bob,pat). parent(pat,jim)

.

?- parent(X,Y),parent(Y,Jim). will produce the

same result.

An Example Program

Who are Toms grandchildren? ?-

parent(tom,X),parent(X,Y). Xbob Yann Xbob Ypa

t

parent(tom,bob). parent(pam,bob). parent(tom,liz).

parent(bob,ann). parent(bob,pat). parent(pat,jim)

.

An Example Program

Do Ann and Pat have a common parent? (1) Who is a

parent, X, of Ann? (2) Is (this same) X a parent

of Pat? ?- parent(X,ann), parent(X,pat). Xbob

parent(tom,bob). parent(pam,bob). parent(tom,liz).

parent(bob,ann). parent(bob,pat). parent(pat,jim)

.

An Example Program

- It is easy in Prolog to define a relation by

stating the n-tuples of objects that satisfy the

relation. - The user can query the prolog system about

relations defined in the program. - The arguments of relations can be
- concrete objects, or constants, or general

objects. - Questions to the system consist of one or more

goals. - An answer to the question can either be positive

or negative. - If several answers satisfy the question than

Prolog will find as many of them as desired by

the user.

Extending the Example Program by Rules

- Adding more facts

female(pam). male(tom). male(bob). female(liz). fe

male(pat). female(ann). male(jim).

sex(pam, feminine). sex(tom, masculine). sex(bob,

masculine). sex(liz , feminine). sex(pat ,

feminine). sex(ann , feminine). sex(jim,

masculine).

Extending the Example Program by Rules

- We could define offspring in a similar way as the

parent relation. - However, the offspring relation can be defined

much more elegantly by making use of the fact

that it is the inverse of parent, and that parent

has already been defined.

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

For all X and Y, Y is an offspring of X if X is

a parent of Y.

A rule in Prolog

Extending the Example Program by Rules

- Difference between facts and rules
- A fact is something that is always,

unconditionally, true. - Rules specify things that are true if some

condition is satisfied.

Extending the Example Program by Rules

- Rules have
- a condition part (the LHS of the rule) and
- a conclusion part (the RHS of the rule).

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

head

body

Extending the Example Program by Rules

?- offspring(liz,tom).

Applying the rule, it becomes

offspring(liz,tom)-parent(tom,liz).

parent(tom,bob). parent(pam,bob). parent(tom,liz).

parent(bob,ann). parent(bob,pat). parent(pat,jim)

.

Prolog tries to find out whether the condition

part is true.

Extending the Example Program by Rules

- The mother relation can be based on the following

logical statement

For all X and Y, X is the mother of Y if X is a

parent of Y and X is a female. mother(X,Y)-paren

t(X,Y), female(X).

Extending the Example Program by Rules

- The grandparent relation can be immediately

written in Prolog as

grandparent(X,Z)-parent(X,Y),parent(Y,Z).

Extending the Example Program by Rules

For any X and Y, X is a sister of Y if (1) both X

and Y have the same parent, and (2) X is a female.

?- sister(ann,pat). yes ?- sister(X,pat). Xann X

pat

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

Z

parent

parent

X

Y

sister

female

Pat is a sister of herself !

Extending the Example Program by Rules

- An improved rule for the sister relation can then

be

sister(X,Y)- parent(Z,X), parent(Z,Y), female(Z),

different(X,Y). different(X,Y).

A Recursive Rule Definition

X

X

parent

parent

Y1

Y1

parent

predecessor

predecessor

predecessor(X,Z)- parent(X,Z).

parent

Y2

Y2

parent

X

parent

parent

Y3

Z

predecessor

parent

Y

parent

predecessor(X,Z)- parent(X,Y1),

parent(Y1,Y2), parent(Y2,Z).

Z

Z

predecessor(X,Z)- parent(X,Y1),

parent(Y1,Y2), parent(Y2,Y3), parent(Y3,Z).

predecessor(X,Z)- parent(X,Y), parent(Y,Z).

A Recursive Rule Definition

- There is, however, an elegant and correct

formulation of the predecessor relation it will

be correct in the sense that it will work for

predecessor at any depth. - The key idea is to define the predecessor

relation in terms of itself.

A Recursive Rule Definition

For all X and Z, X is a predecessor of Z if there

is a Y such that (1) X is a parent of Y and (2) Y

is a predecessor of Z

predecessor(X,Z)- parent(X,Y), predecessor(Y,Z).

A Recursive Rule Definition

- We have thus constructed a complete program for

the predecessor relation, which consists of two

rules - one for direct predecessor and
- one for indirect predecessor.

predecessor(X,Z)- parent(X,Z). predecessor(X,Z)-

parent(X,Y), predecessor(Y,Z).

?- predecessor(pam,X). Xbob Xann Xpat Xjim

A Recursive Rule Definition

- The use of predecessor itself may look

surprising - When defining something, can we use this same

thing that has not yet been completely defined? - Such definitions are, in general, called

recursive definitions.

How Prolog Answers Questions

- A question to Prolog is always a sequence of one

or more goals. - To answer a question, Prolog tries to satisfy all

the goals. - To satisfy a goal means to demonstrate that the

goal logically follows from the facts and rules

in the program. - If the question contains variables, Prolog also

has to find what are the particular objects for

which the goals are satisfied.

How Prolog Answers Questions

- An appropriate view of the interpretation of a

Prolog program in mathematical terms is then as

follows - Prolog accepts facts and rules as a set of

axioms, and the users question as a conjectured

theorem then it tries to prove this theorem.

How Prolog Answers Questions

- Prolog starts with the goals and, using rules,

substitutes the current goals with new goals,

until new goals happen to be simple facts.

predecessor(tom,pat)

by rule pr1

by rule pr1

parent(tom,pat)

parent(tom,Y) predecessor(Y,pat)

no

Ybob by fact parent(tom,bob)

parent(tom,Y) predecessor(Y,pat)

by rule pr1

parent(tom,Y) predecessor(Y,pat)

Declarative and Procedural Meaning

- The declarative meaning is concerned only with

the relation defined by the program. - The declarative meaning thus determines what will

be the output of the program. - The procedural meaning determines how this output

is obtained i.e., how are the relations actually

evaluated by the Prolog system.

Declarative and Procedural Meaning

- The ability of Prolog to work out many procedural

details on its own is considered to be one of its

specific advantages. - It encourages the programmer to consider the

declarative meaning of program relatively

independently of their procedural meaning. - This is of practical importance because the

declarative aspects of programs are usually

easier to understand than the procedural details.

2. Syntax and Meaning

Contents

- Data Objects
- Matching
- Declarative meaning of Prolog
- Procedural meaning
- Example monkey and banana
- Order of clauses and goals
- The relation between Prolog and logic

Data Objects

- Data objects in Prolog

Data Objects

- Atoms can be constructed in three ways
- Strings of letters, digits and _, starting with

a lower-case letter. - anna nil x25 x_25 x_ x_ _y
- Strings of special characters
- lt---lt gt ... ..
- String of characters enclosed in single quote
- Tom South_America Sarah Jones ??
- Numbers used in Prolog include integer numbers

and real numbers.

Data Objects

- Variables are strings of letters, digits and

underscore characters, starting with an

upper-case character - X Result Object2 _x23 _23
- Anonymous variable
- haschild(X)-parent(X,Y).
- haschild(X)-parent(X, _ )
- somebody_has_child-parent(_,_).
- somebody_has_child-parent(X,Y).

Data Objects

- Structured objects (or simply structure) are

objects that have several components. - The components themselves can, in turn, be

structures. - The date can be viewed as a structure with three

components day, month, year. - date(1,may,1983)

date

may

1983

functor

arguments

1

- Any day in May 1983 can be represented as
- date(Day, may, 1983)

Data Objects

P1point(1,1) P2point(2,3) Sseg(P1,P2)

seg(point(1,1),point(2,3)) Ttriangle(point(4,2),

point(6,4), point(7,1))

Data Objects

- We can use the same name, point, for points in

both 2D and 3D - point(X,Y) point(X,Y,Z)
- Prolog will recognize the difference because each

functor is defined by two things - the name, whose syntax is that of atoms
- the arity - i.e., the number of arguments.

Data Objects

- All structured objects in Prolog are trees,

represented in the program by terms.

(ab)(c-5) ((a,b),-(c,5))

c

5

a

b

Data Objects

seq

par

seq(r1,r2)

par(r1,r2)

r1

r2

r1

r2

par

r1

par

par(r1,par(r2,r3))

r2

r3

par

r1

seq

par(r1,seq(par(r2,r3),r4))

par

r3

r2

r3

Matching

- The most important operation on terms is

matching. - Given two terms, we say that they match if
- they are identical or
- the variables in both terms can be instantiated

to objects in such a way that after the

substitution of variables by those objects the

terms become identical. - For example, the following instantiation makes

the terms date(D,M,1983) and date(D1,may,Y1)

identical - D is instantiated to D1
- M is instantiated to may
- Y1 is instantiated to 1983.

Matching

- Matching is a process that takes as input two

terms and checks whether they match. - If the terms do not match we say that this

process fails. - If they do match then the process succeeds and it

also instantiates the variables in both terms to

such value that the terms become identical.

Matching

- The request for the matching operation can be

communicated to the Prolog system by using the

operator . - ?- date(D,M,1983)date(D1,may,Y1).

DD1 Mmay Y11983

D1 D11 Mmay Y11983

Dthird D1third Mmay Y11983

Matching in Prolog always results in the most

general instantiation.

Matching

?- date(D,M,1983)date(D1,may,Y1),

date(D,M,1983)date(15,M,Y).

To satisfy the first goal DD1 Mmay Y11983

After having satisfied the second

goal D15 D115 Mmay Y11983 Y1983

Matching

- The general rules to decide whether two terms, S

and T, match - If S and T are constants the S and T match only

if they are the same object. - IF S is a variable and T is anything, then they

match, and S is instantiated to T. Conversely, if

T is a variable then T is instantiated to S. - If S and T are structures then they match only if
- S and T have the same principal functor, and
- all their corresponding components match

Matching

triangle

point

A

2

2

triangle

X

point

point

4

y

2

Z

Matching

vertical(seg(point(X,Y),point(X,Y1)). horizontal(s

eg(point(X,Y),point(X1,Y)).

?-vertical(seg(point(1,1),point(1,2)). yes ?-verti

cal(seg(point(1,1),point(2,Y)). no ?-horizontal(se

g(point(1,1),point(2,Y)). Y1 ?-vertical(seg(point

(2,3),P)). Ppoint(2,Y) ?-vertical(S),horizontal(S

). Sseg(point(X,Y),point(X,Y))

Declarative Meaning of Prolog Programs

- Given a program and a goal G, the declarative

meaning says - A goal G is true (i.e., satisfiable, or logically

follows from the program) if and only if - there is a clause C in the program such that
- there is a clause instance I of C such that
- the head of I is identical to G, and
- all the goals in the body of I are true.

Declarative Meaning of Prolog Programs

- In general, a question to the Prolog system is a

list of goals separated by commas. - A list of goals is true if all the goals in the

list are true for the same instantiation of

variables. - A comma between goals thus denotes the

conjunction of goals they all have to be true. - The disjunction of goals any one of the goals in

a disjunction has to be true.

Procedural Meaning

- The procedural meaning specifies how Prolog

answers question.

Example Monkey and Banana

- The problem
- There is a monkey at the door into a room. In the

middle of the room a banana is hanging from the

ceiling. The monkey is hungry and and wants to

get the banana, but he cannot stretch high enough

from the floor. At the window of the room there

is a box the monkey may use. The monkey can

perform the following actions walk on the floor,

climb the box, push the box around and grasp the

banana if standing on the box directly under the

banana. Can the monkey get the banana?

Example Monkey and Banana

- Finding a representation of the problem
- We can think of the monkey world as always

being in some state that can change in time. - The current state is determined by the positions

of the objects. - For example, the initial state is determined by
- Monkey is at door.
- Monkey is on the floor.
- Box is at window.
- Monkey does not have banana.

Example Monkey and Banana

- It is convenient to combine all these four pieces

of information into one structured object. - Let us choose the word state as the functor to

hold the four components together. - The initial state becomes
- state(atdoor,onflorr,atwindow,hasnot)

Vertical position of monkey

Position of box

Monkey has or has not banana

Horizontal position of monkey

Example Monkey and Banana

- Formalize the rules of the game
- The goal is a situation in which the monkey has

the banana. - state(_, _, _, has)
- What are the allowed moves that change the world

from one state to another? - grasp banana, climb box, push box, walk around
- Such rules can be formalized in Prolog as a

3-place relation named move move(State1, Move,

State2)

Example Monkey and Banana

canget(state(_, _, _, has)). canget(State1)-

move(State1,move State2), canget(State2).

move(state(middle,onbox,middle,hasnot),

grasp, state(middle,onbox,middle,has)).

move(state(P,onfloor,P,H), climb,

state(P,onbox,P,H)).

move(state(P1,onfloor,P1,H),

push(P1,P2), state(P2,onfloor,P2,H)).

State1

Statem

State2

move

canget

canget

has

move(state(P1,onfloor,B,H),

walk(P1,P2), state(P2,onfloor,B,H)).

Example Monkey and Banana

state(atdoor,onfloor,arwindow,hasnot)

walk(atdoor,P2)

state(P2,onfloor,arwindow,hasnot)

push(P2,P2) P2atwindow

climb

backtrack

state(atwindow,onbox,arwindow,hasnot)

state(P2,onfloor,P2,hasnot)

No move possible

climb

state(P2,onbox,P2,hasnot)

grasp P2middle

state(middle,onbox,middle,has)

Order of Clauses and Goals

- Danger of indefinite looping
- Program variation through reordering of clauses

and goals

3. Lists, Operators, Arithmetic

Contents

- Representation of lists
- Some operations on lists
- Operator notation
- Arithmetic

Representation of Lists

- The list is a simple data structure used in

non-numeric programming. - A list is a sequence of any number of terms.
- ann, tennis, tom, skiing
- An empty list is written as a Prolog atom .
- A list can be viewed as consisting of two things
- the first item, called the head of the list
- the remaining part of the list, called the tail.

Representation of Lists

- For ann, tennis, tom, skiing, the head is ann

and the tail is the list tennis, tom, skiing. - In general, the head can be anything the tail

has to be a list. - The head and tail are then combined into a

structure by a special functor (depending upon

the Prolog implementation). - .(Head, Tail)
- .(ann,.(tennis,.(tom,.(skiing,))))

Representation of Lists

.

.

ann

tennis

.

.

tom

skiing

Representation of Lists

?-List1a,b,c, List2.(a,.(b,.(c,.))). List

1a,b,c List2a,b,c ?-Hobbies1.(tennis,.(musi

c,)), Hobbies2skiing,food,

Lann,Hobbies1,tom,Hobbies2. Hobies1tennis,mus

ic Hobbies2skiing,food Lann,tennis,music,t

om,skiing,food

Representation of Lists

La,b,c LaTail Tailb,c a,b,ca,b,c

a,bc a,b,c

Some Operations on Lists

- Membership

member(b,a,b,c) is true member(b,a,b,c) is

not true

X is a member of L if either (1) X is the head of

L, or (2) X is a member of the tail of L.

member(X,XTail). member(X,HeadTail)-

member(X,Tail).

Some Operations on Lists

- Concatenation

conc(a,b,c,d,a,b,c,d) is true,

but conc(a,b,c,d,a,b,a,c,d) is false.

(1) If the first argument is the empty list then

the second and the third arguments must be

the same list. conc(,L,L). (2) If the first

argument of conc is a non-empty list then

it has a head and a tail and must look like

this XL1 conc(XL1,L2,XL3)- conc(L1,

L2,L3).

L1

X

L2

L3

X

Some Operations on Lists

?-conc(a,b,c,1,2,3,L). La,b,c,1,2,3 ?-conc(

a,b,c,d,a,,b). ?-conc(L1,L2,a,b,c). L1

L2a,b,c L1a L2b,c L1a,b L2c

L1a,b,c L2 no

?-conc(Before,mayAfter,

jan,feb,mar,apr,may,jun,

jul,aug,sep,oct,nov,dec). Beforejan,feb,mar,apr

Afterjun,jul,aug,sep,oct,

nov,dec ?-conc(_,Month1,may,Month2_,

jan,feb,mar,apr,may,jun,

jul,aug,sep,oct,nov,dec). Month1apr Month2jun

?-L1a,b,z,z,c,z,z,z,d,e, conc(L2,z,z,z_,L1

). L1a,b,z,z,c,z,z,z,d,e L2a,b,z,z,c

Some Operations on Lists

member1(X,L)- conc(_, X_,L).

Some Operations on Lists

- Adding an item
- add(X,L,XL).
- Deleting an item
- If X is the head of the list then the result

after the deletion is the tail of the list. - If X is in the tail then it is deleted from

there. - delete( X,XTail,Tail).
- delete(X,YTail,YTail1)-
- delete(X,Tail,Tail1).

Some Operations on Lists

?-delete(a,a,b,a,a,L). Lb,a,a La,b,a L

a,b,a no ?-delete(a,L,1,2,3). La,1,2,3 L

1,a,2,3 L1,2,a,3 L1,2,3,a no

insert(X,List,BiggerList)- delete(X,BiggerList

,List). member2(X,List)- delete(X,List,_).

Some Operations on Lists

- Sublist

sublist(c,d,e,a,b,c,d,e,f) is true,

but sublist(c,e,a,b,c,d,e) is not.

- The Prolog program for sublist can be based on

the same idea as member1. - S is a sublist of L if
- (1) L can be decomposed into two lists, L1 and

L2, and - (2) L2 can be decomposed into two lists, S and L3.

sublist(S,L)- conc(L1,L2,L), conc(S,L3,L2).

L

L1

S

L3

L2

Some Operations on Lists

- Permutations
- ?-permutation(a,b,c,P).
- Pa,b,c
- Pa,c,b
- Pb,a,c

Some Operations on Lists

- The program
- If the first list is empty then the second list

must also be empty - If the first list is not empty and it has the

form XL, then a permutation can be constructed

by first permute L obtaining L1 and then insert X

at any position into L1.

L

X

permutation(,). permutation(XL,P)-

permutation(L,L1), insert(X,L1,P).

permute L

L1

Some Operations on Lists

permutation2(,). permutation2(L,XP)-

delete(X,L,L1), permutation2(L1,P).

Operator Notation

- An infix expression, for example, 2abc, can be

written in Prolog as ((2,a),(b,c)). - Since we normally prefer to have expressions

written in infix style, Prolog caters for this

notational covenience. - Prolog will therefore accept the expression as

2abc. - This will be, however, only the external

representation of the object, which will be

automatically converted into the usual form of

Prolog terms. - Thus operators in Prolog are merely a notational

extension.

Operator Notation

- In order that Prolog properly understands

expressions such as abc, Prolog has to know

that binds stronger than . - The precedence of operators decides what is the

correct interpretation of expressions. - For example, abc can be understood either as

(a,(b,c)) or as ((a,b),c). - The general rule is that the operator with

highest precedence is the principal functor of

the term. - If expression containing and are to be

understood according to our normal convention,

then has to have a higher precedence than .

Operator Notation

- A programmer can define her own operators.
- For example, we can define the atoms has and

support as infix operators and then write in the

program facts like - peter has information.
- floor supports table.
- These facts are exactly equivalent to
- has(peter, information).
- Supports(floor, table).

Operator Notation

- A programmer can define new operators by

inserting the program special kinds of clauses,

sometimes called directives, which act as

operator definitions. - An operator definition must appear in the program

before any expression containing that operator. - - op(600, xfx,has).
- This tells Prolog that we want to user has as

an operator, whose precedence is 600 and its type

is xfx, which is a kind of infix operator. - The form specifier xfx suggests that the

operator, denoted by f, is between the two

arguments denoted by x.

Operator Notation

- Operators are normally used, as functor, only to

combine objects into structures and not to invoke

action on data. - Operators are atoms, and their precedence must be

in some range which depends on the

implementation. (Assume 1,1200 here.) - There are three groups of operator types
- infix operators xfx, xfy, yfx
- prefix operators fx, fy
- postfix operators xf, yf

Operator Notation

- There is a difference between x and y.
- We need to introduce the concept of the

precedence of argument. - If an argument is enclosed in parentheses or it

is an unstructured object then its precedence is

0 - If an argument is a structure, then its

precedence is equal to the precedence of its

principal functor. - x represents an argument whose precedence must

be strictly lower than that of the operator. y

represents an argument whose precedence is lower

or equal to that of the operator.

Operator Notation

- These rules help to disambiguate expression with

several operators of the same precedence. - For example, the expression, a-b-c, is normally

understood as (a-b)-c, and not a-(b-c). - To achieve the normal interpretation the operator

has to be defined as yfx.

a

c

Prec. 0

Prec. 0

a

b

Precedence 500

Precedence 500

Operator Notation

- Consider the prefix operator not.
- If not is defined as fy then the expression
- not not p
- is legal.
- But if not is defined as fx then this expression

is illegal because the argument to the first not

is not p.

Operator Notation

- Predefined operators in the Prolog system

-op(1200,xfx,-). -op(1200,fx,-,?-). -op(1

100,xfy,). -op(1000,xfy,,). -op(700,xfx,,

is,lt,gt,lt,,\,\,). -op(500,,yfx,,-).

-op(500,fx,,-,not). -op(400,yfx,,/,div).

-op(300,xfx,mod).

Operator Notation

- The use of operators can greatly improve the

readability of programs.

(AB)ltgt A v B

-op(800,xfx,ltgt). -op(700,xfy,v). -op(600,xfy

,). -op(500,fy,).

equivalent(not(and(A,B)),

or(not(A),not(B))).

Arithmetic

- The means for numerical computing in Prolog are

rather simple - , , , /, mod

?-X12. X12 ?-X is 12. X3

?-X is 3/2,Y is 3 div 2. X1.5 Y1

?-27737gt10000. Yes ?-born(Name,Year),

Yeargt1950,Yearlt1960.

Arithmetic

?-1221. yes ?-1221. no ?-1AB2. A2 B

1

Arithmetic

- Given two positive integers, X and Y, their

greatest common divisor, D, can be found

according to three cases - If X and Y are equal then D is equal to X.
- If XltY then D is equal to the greatest common

divisor of X and YX. - If YltX then do the same as in the preceding case

with X and Y interchanged.

gcd(X,X,X). gcd(X,Y,D)- XltY,Y1 is Y-X,

gcd(X,Y1). gcd(X,Y,D)- YltX, gcd(Y,X,D).

Arithmetic

length(,0). length(_Tail,N)-

length(Tail,N1), N is N11.

4. Using Structures Example Programs

Contents

- Retrieving structured information from a database
- Doing data abstraction
- Simulating a non-deterministic automaton
- Travel planning
- The eight queens problem

Retrieving Structured Information from a DB

- This exercise develops the skill of representing

and manipulating structured data objects. - It also illustrates Prolog as a natural database

query language. - A database can be represented in Prolog as a set

of facts.

Retrieving Structured Information from a DB

- A database about families

family( person(tom,fox,date(7,may,1950),works(bb

c,15200)), person(ann,fox,date(9,may,1951),unemp

loyed), person(pat,fox,date(5,may,1973),unemplo

yed), person(jim,fox,date(5,may,1973),unemploye

d)).

- We can refer to all Armstrong families by
- family(person(_,armstrong,_,_),_,_)
- Refer to all families with three children
- family(_,_,_,_,_)

Retrieving Structured Information from a DB

- To find all married women that have at least

three children - ?-family(_,person(Name,Surname,_,_),
- _,_,__).

Retrieving Structured Information from a DB

- Provide a set of procedures that can serve as a

utility to make the intersection with the

database more comfortable.

husband(X)- family(X,_,_). wife(X)-

family(_,X,_). child(X)- family(_,_,Children),

member(X,Children). exist(X)-

husband(X) wife(X) child(X).

dateofbirth( person(_,_,Date,_),Date)). salary(

person(_,_,_Works(_,S),S)). salary(

person(_,_,_,unemployed),0).

Retrieving Structured Information from a DB

Find the names of all the people in the

DB ?-exists(person(Name,Surname,_,_)). Find all

children born in 1981 ?-child(X),dateofbirth(X,da

te(_,_,1981)). Find all employed

wives ?-wife(person(Name,Surname,_,works(_,_))).

Find the names of unemployed people who were born

before 1963 ?-exists(person,N,S,date(_,_,Y),unem

ployed)), Ylt1963. Find people born before 1950

whose salary is less than 8000 ?-exists(P),dateo

fbirth(P,date(_,_,Year)), Yearlt1950,salary(P,S),

Slt8000.

Retrieving Structured Information from a DB

- Total income of a family

total(,0). total(PersonList,Sum)-

salary(Person,S0, total(List,Rest), Sum is

SRest.

Simulating an NDA

b

final(s3). trans(s1,a,a1). trans(s1,a,s2). trans(s

1,b,s1). trans(s2,b,s3). trans(s3,b,s4). silent(s2

,s4). silent(s3,s1).

a

s1

s2

null

a

b

null

s4

s3

b

Simulating an NDA

?-accepts(s1,a,a,a,b). yes ?-accepts(S,a,b). S

s1 Ss3. ?-accepts(s1,X1,X2,X3). X1a X2a X3

b X1b X2a X3b no ?-String_,_,_,

accepts(s1,String). Stringa,a,b Stringb,a,b

no

accepts(State,)- final(State). accepts(State

,XRest)- trans(State,X,State1),

accepts(State1,Rest). accepts(State,String)-

silent(State,State1), accepts(State1,String).

Travel Planning

- Develop an advisor program that will be able to

answer useful questions, such as - What days of the week is there a direct flight

from London to Ljubljana? - How can I get from Ljubljana to Edinburgh on

Thursday? - I have to visit Milan, Ljubljana and Zurich,

starting from London on Tuesday and returning to

London on Friday. In what sequence should I visit

these cities so that I have no more than one

flight each day of the tour?

Travel Planning

- The program will be centered around a DB holding

the flight information. - timetable(Place1,Place2,List_of_flight)
- where List_of_flight is of the form

Departure_time/Arrival_time/Flight_number/List_of_

days

timetable(london,edinburgh,

940/1050/ba4733/alldays,

1740/2050/ba4833/mo,tu,we,th,fr,su).

Travel Planning

- To find exact routes between two given cities on

a given day of the week. - route(Place1,Place2,Day,Route)
- Here Route is a sequence of flight satisfying

the following criteria - the start point of the route is Place1
- the end of the route is Place2
- all the flights are one the same day of the week

Day - all the flight in Route are in the timetable

relation - there is enough time for transfer between flights.

Travel Planning

- The route is represented as a list of structured

objects of the form - From-toFlight_Numberdeparture_time
- Some auxiliary predicates
- flight(Place1,Place2,Day,Flight_num,Dep_time,Arr_t

ime) - deptime(Route,Time)
- transfer(time1,Time2)
- There is at least 40 minutes between Time1 and

Time2.

Travel Planning

- The problem of finding a route is similar to the

simulation of the NDA - States of NDA ? cities
- Transition between two states ? a flight between

two cities - transition ? timetable
- Finding a path ? finding a route.

Travel Planning

- Defining the route relation
- Direct flight
- route(Place1,Place2,Day,Place1-Place2FnumDep)

- - flight(Place,Place2,Day,Fnum,Dep,Arr).
- Indirect flight
- route(P1,P2,Day,P1-P3Fnum1Dep1Route)-
- route(P3,P2,Day,Route),
- flight(P1,P3,Fnum1,Dep1,Arr1),
- deptime(Route,Dep2),
- transfer(Arr1,Dep2).

See Fig. 4.5, pp 111-112 for the complete program.

Travel Planning

- Some example questions
- What days of the week is tehre a direct flight

from London to Ljubljana? - ?-flight(london,ljubljana,Day,_,_,_).
- Dayfr
- daysu
- no
- How can I get from Ljubljana to Edinburgh on

Thursday? - ?-route(ljubljana,edinburgh,th,R).
- Rljubljana-zurichyu3221130,
- zurich-londonsr8061610,
- london-edinburghba48221840

The Eight Queens ProblemProgram 1

- The problem here is to place eight queens on the

empty chessboard in such a way that no queen

attacks any other queen.

8

7

6

5

4

3

2

1

1

8

2

3

4

5

6

7

The Eight Queens Problem Program 1

- The problem is to find such as list
- X1/Y1,X2/Y2,X3/Y3,X4/Y4,X5/Y5,X6/Y6,X7/Y7,X8/Y8

- To make the search task easier, we fix the

X-coordinates - 1/Y1,2/Y2,3/Y3,4/Y4,5/Y5,6/Y6,7/Y7,8/Y8

The Eight Queens Problem Program 1

- Case 1 The list of the queen is empty the empty

list id certainly a solution because there is no

attack. - Case 2 The list of queen is non-empty it looks

like X/YOthers. Then - There must be no attack between the queens in the

list Others i.e., Others must be a solution. - X and Y must be integers between 1 and 8.
- A queen at square X/Y must not attack any of the

queens in the list Others.

The Eight Queens Problem Program 1

solution(). solution(X/YOthers)-

solution(Others), member(Y,1,2,3,4,5,6,7,8),

noattack(X/Y,Others). noattack(_,). noattack(

X/Y,X1/Y1Others)- Y\Y1,Y1-Y\X1-X,Y1-Y\

X-X1, noattack(X/Y,Others). template(1/Y1,2/Y

2,3/Y3,4/Y4,5/Y5, 6/Y6,7/Y7,8/Y8). ?-t

emplate(S),solution(S).

The Eight Queens Problem Program 2

- X-coordinates can be omitted, retaining only

Y-coordinates Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8. - To prevent the horizontal attack, no two queens

can be in the same row. - Each solution is therefore represented by a

permutation of the list 1,2,3,4,5,6,7,8. - Such a permutation, S, is a solution if all

queens are safe.

The Eight Queens Problem Program 2

solution(S)- permutation(1,2,3,4,5,6,7,8,S),

safe(S). safe(). safe(QueenOthers)-

sate(Others), noattack(Queen,Others,1). noattac

k(_,,_). noattack(Y,Y1Ylist,Xdist)-

Y1-Y\Xdist,Y-Y1\Xdist, Dist1 is Xdist1,

noattack(Y,Ylist,Disy1).

The Eight Queens Problem Program 2

Others

Queen

Xdist1

Xdist3