LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules....

35
LECTURE 3 PROLOG

Transcript of LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules....

Page 1: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

LECTURE 3

PROLOG

Page 2: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Introduction

• Prolog program consists of clauses which are facts and rules.

• Predicate is the name given to the relation

• likes(bill, tennis)

predicate namearguments

Page 3: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Anonymous Variable

• The anonymous variable ‘_’can be used in place of any other variable. It can’t be set to a value.

• Goal: parent(Parent, _).

• Finds all the parents

• Anonymous variables can be used in facts.

• owns(_, shoes). Everyone owns shoes

• eats( _ ). Everyone eats

Page 4: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Constants start with a small letter.

Variables start with a capital letter.

/* Example CH03 –3 */predicates likes(symbol,symbol)

clauses likes(ellen, reading). likes(john, computers). likes(john, badminton). likes(leonard, badminton). likes(eric, swimming). likes(eric, reading).

likes(X, reading).

likes(Person, reading).

Page 5: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/* Ch03ex04.pro*/ predicates male(symbol) female(symbol) parent(symbol, symbol)

clauses male(bill). male(joe).

female(sue). female(tammy).

parent(bill, joe). parent(sue, joe). parent(joe, tammy).

Goal: parent(Person, _) and male(Person).

father(X,Y):-

parent(X, Y),

male(X).

Write a goal statement that finds the fathers

Another way of defining father predicate

Page 6: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/* Ch03ex04.pro*/ predicates male(symbol) female(symbol) parent(symbol, symbol)

clauses male(bill). male(joe).

female(sue). female(tammy).

parent(bill, joe). parent(sue, joe). parent(joe, tammy).

First solve the sub-goal parent(Person, _)

Then bind the variable Person to a value returned by parent.

The value returned by parent is now used to satisfy the goal male(Person)

Compound goals are composed of conjunction (AND) and disjunction (OR).

Page 7: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/* Ch03Ex05 */

predicates car(symbol,real,integer,symbol,integer) truck(symbol,real,integer,symbol,integer)

clauses car(chrysler, 130000, 3, red, 12000). car(ford, 90000, 4, gray, 25000). car(datsun, 8000, 1, red, 30000). truck(ford, 80000, 6, blue, 8000). truck(datsun, 50000, 5, orange, 20000). truck(toyota, 25000, 2, black, 25000).

Goal: car(Make, Odometer, Years-on-road, Body, 25000)

Goal: car(Make, Odometer, Years-on-road, Body, Cost) and cost < 25000.

Page 8: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

• Type declaration: to speed up the running time

• Clauses: facts and rules

• Predicates: declare predicates and domains of the arguments. (If standard domains are used for the predicate they need not be declared in the domain section)

• Domains: declare domains that aren’t PDC Prolog’s standard domain

• Goal: When the program is to run independent of the PDC Prolog development environment.

If standard domains are used for the predicates they need not be declared in the domain section.

PDC Prolog Programs

Page 9: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

A PDC Prolog program has the following basic structure

Domain /* domain decleration*/ Predicates/*... */Goal /* subgoal1 Subgoal2…… */Clauses /*… rules and facts….. */

Page 10: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Rules are of the form

HEAD:- <subgoal1>, <subgoal2>, …, <subgoaln>

For a rule to succeed, Prolog must satisfy all of its subgoals.

Backtracking: If a subgoal fails prolog backs up and looks for alternatives for the earlier sub goals.

Page 11: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Unification

When a clause is matched to the goal, it binds values to free variables so that the goal and the clause are identical. This matching operation is called unification.

Page 12: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/* Ch04Ex01.pro */domains product, sum = integer

predicates add_em_up(sum, sum, sum) multiply_em(product, product, product)

clauses add_em_up(X, Y, Sum) :- Sum = X + Y. multiply_em(X, Y, Product) :- Product = X * Y.

To double the product of 31 and 17 one may write

multiply_em_up(31, 17, Sum)

Add_em(Sum, Sum, Answer).

Type error – Product and Sum are different domains

Page 13: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/* Ch04ex02.pro – Domain declerations to catch type errors */

domains brand, color = symbol age, price = integer mileage = real

predicates car(brand, mileage, age, color, price)

clauses car(chrysler, 130000, 3, red, 12000). car(ford, 90000, 4, gray, 25000). car(datsun, 8000, 1, red, 30000).

If the order of the arguments are mixed up in the goal statement ‘type error’ is produced.

Page 14: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/*Unification Ch05Ex01.pro*/ domains title, author = symbol pages = integer

predicates book(title, pages) written_by(author, title) long_novel(title)

clauses written_by(fleming, "DR NO"). written_by(melville, "MOBY DICK"). book("MOBY DICK", 250). book("DR NO", 310). long_novel(Title) :- written_by(_, Title), book(Title, Length), Length > 300.

Goal: written_by(X, Y) X=fleming, Y=DR NO X=melville, Y=MOBY DICK 2 Solutions

Goal:

Trace CALL: written_by( _, _) RETURN: *written_by("fleming","DR NO”)YES

Goal: long_novel(Title)

Page 15: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/* Backtracking Cho5ex02.pro */ predicates likes(symbol,symbol) tastes(symbol,symbol) food(symbol) clauses likes(bill, X) :- food(X), tastes(X, good).

tastes(pizza, good). tastes(brussels_sprouts, bad).

food(brussels_sprouts). food(pizza).

CALL: likes("bill",_)CALL: food(_)RETURN: *food("brussels_sprouts")CALL: tastes("brussels_sprouts","good")REDO: tastes("brussels_sprouts","good")REDO: food(_)RETURN: food("pizza")CALL: tastes("pizza","good")RETURN: tastes("pizza","good")RETURN: likes("bill","pizza")

Goal: likes(bill, X)X=pizza1 Solution

Page 16: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Summary

• When Prolog begins an attempt to satisfy a goal, it starts at the top of the program in search of a match.

• When a new call is made, a search for a match to that call also begins at the top of the program.

• When a call has found a successful match, the call is said to return, and the next subgoal in turn may be tried.

• Once a variable has been bound in a clause, the only way to free that binding is through backtracking.

• Backtracking always goes up to the last indeterministic call and tries to resatisfy that call.

Page 17: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/* Bactracking Ch05Ex05 */predicates type(symbol, symbol) is_a(symbol, symbol) lives(symbol, symbol) can_swim(symbol)goal can_swim(What) , write("A ", What, " can swim.").clauses type(ungulate, animal). type(fish, animal).

is_a(zebra, ungulate). is_a(herring, fish). is_a(shark, fish).

lives(zebra, on_land). lives(frog, on_land). lives(frog, in_water). lives(shark, in_water).can_swim(Y) :- type(X, animal) , is_a(Y, X) , lives(Y, in_water).

CALL: _PROLOG_Goal()CALL: can_swim(_)CALL: type(_,"animal")RETURN: *type("ungulate","animal")CALL: is_a(_,"ungulate")RETURN: is_a("zebra","ungulate")CALL: lives("zebra","in_water")REDO: lives("zebra","in_water")FAIL: lives("zebra","in_water")REDO: type(_,"animal")REDO: type(_,"animal")RETURN: type("fish","animal")CALL: is_a(_,"fish")REDO: is_a(_,"fish")RETURN: *is_a("herring","fish")CALL: lives("herring","in_water")REDO: lives("herring","in_water")REDO: lives("herring","in_water")REDO: lives("herring","in_water")FAIL: lives("herring","in_water")REDO: is_a(_,"fish")RETURN: is_a("shark","fish")

CALL: lives("shark","in_water")REDO: lives("shark","in_water")RETURN: lives("shark","in_water")RETURN: can_swim("shark")RETURN: write("A ")

write("shark") write(" can swim.")

Page 18: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Controlling the Search for Solutions

• Deterministic call produces only one solution

• Nondeterministic call may produce multiple solutions.

• Fail – to force backtracking

• Cut (!) – to prevent backtracking

Page 19: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/* use of fail - Ch05ex06.pro */ domains name = symbol

predicates father(name, name) everybody

clauses father(leonard, katherine). father(carl, jason). father(carl, marilyn). everybody :- father(X, Y), write(X, " is ", Y, "'s father\n"), fail.

Goal: father(X, Y)X=leonard, Y=katherineX=carl, Y=jasonX=carl, Y=marilyn3 SolutionsGoal:

Without ‘fail’Goal: everybodyleonard is katherine’s fatherYESGoal:

With ‘fail’Goal: everybody leonard is katherine's father carl is jason's father carl is marilyn's father No Goal:

Page 20: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Cut

Green Cut: When it is known in advance that certain possibilities will never give rise to meaningfull solutions (waste of time and storage)

Red Cut. The logic of the program demands the cut to prevent considerations of alternate subgoals. Prevent backtracking to a previous subgoal in a rule

Example

Rl:- a, b, !, c.

Shows the satisfaction with finding the first solution that prolog finds to the subgoals a and b.

Page 21: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/* Cut Example - Ch05ex07.pro */predicates buy_car(symbol, symbol) car(symbol, symbol, integer) colors(symbol, symbol)

clauses buy_car(Model, Color) :- car(Model, Color, Price), colors(Color, sexy),!, Price < 25000.

car(maserati, green, 25000). car(corvette, black, 24000). car(corvette, red, 26000). car(porsche, red, 24000). colors(red, sexy). colors(black, mean). colors(green, preppy).

Goal: buy_car(X, Y)No Solution

CALL: buy_car(_,"red")CALL: car(_,"red",_)REDO: car(_,"red",_)REDO: car(_,"red",_)RETURN: *car("corvette","red",26000)CALL: colors("red","sexy")RETURN: colors("red","sexy") 26000<25000FAIL: buy_car(_,"red")

Goal: buy_car(X, red)No Solution

Page 22: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Use of cut to implement case structure

r(X) :- X =1, ! , a, b, c.r(X) :- X =2, ! , d.r(X) :- X =3, ! , c.r(_) :- write(“This is a catch-all clause.”).

r(1) :- ! , a, b, c.r(2) :- ! , d.r(3) :- ! , c.r(_) :- write(“This is a catch-all clause.”).

Using the cut makes r a deterministic predicate

Page 23: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

*/ The cut as a go to -- Ch05ex14 --*/

predicates action(integer)

clauses action(1) :- !, write("You typed 1.").

action(2) :- !, write("You typed two."). action(3) :- !, write("Three was what you typed."). action(_) :- !, write("I don't know that number!").

goal write("Type a number from 1 to 3: "), readreal(Choice), action(Choice).

Page 24: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

The not predicate

likes(bill, Anyone) :-likes(sue, Anyone),not(hates(bill, Anyone)).

likes(bill, Anyone) :-not(hates(bill, Anyone)),likes(sue, Anyone).

Will work

Will not work

The not predicate succeeds when the subgoal can’t be proven true.

Free variables are not allowed in not.

Page 25: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Simple and Compound Objects

Simple Data Objects

A simple data object is either a variable or a constant. If it is a constant, it is a character (a char), a number (an integer or a real), or an atom ( a string or a symbol).

Variables as Data Objects

Variables must begin with an upper case letter (A *Z) or an underscore (_).

In prolog variables can bind with any legal Prolog argument or data object.

Prolog variables are local not global. That is, if two clauses each contain a variable called X, these X’s are two distint Xs.

Page 26: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Simple and Compound Objects

Constants as Data Objects

Constants include characters, numbers, and atoms. A constan’s value is its name. That is, the constant 2 can olny stand for the number 2.

Characters

Characters are char type; they consist of printable and unprintable ASCII characters.

Numbers

Numbers are either integer (-32, 768 to 32, 767) or real (1e-308 to 1e308) types.

Page 27: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Simple and Compound Objects

Atoms

An atom is either a symbol or a string type.

Symbol Atoms

food

rick_jones_2

new_york

a

String Atoms

“Jesse James”

“123 Pike street”

“a”

“New York”

Page 28: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/* Ch06ex02 */ domains row, column, step = integer movement = up(step); down(step); left(step); right(step)predicates move_cursor(row, column, movement)clauses move_cursor(R, C, up(Step)) :- cursor(R, C), R1=R-Step, cursor(R1, C). move_cursor(R, C, down(Step)) :- cursor(R, C), R1=R+Step, cursor(R1, C). move_cursor(R, C, left(Step)) :- cursor(R, C), C1=C-Step, cursor(R, C1). move_cursor(R, C, right(Step)) :- cursor(R, C), C1=C+Step, cursor(R, C1).

cursor(Row, Column) is a built in predicate.

Two purposes:

• denotes where the cursor is

• places the cursor

Page 29: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/*Ch06ex03*/

domains name = person(symbol, symbol) /* (First, Last) */ birthday = b_date(symbol, integer, integer) /* (Month, Day, Year) */

ph_num = symbol /* Phone_number */

predicates phone_list(name, symbol, birthday) get_months_birthdays convert_month(symbol, integer) check_birthday_month(integer, birthday) write_person(name)

Page 30: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/*Ch06ex03 - continue*/clauses get_months_birthdays :- makewindow(1, 7, 7, " This Month's Birthday List ", 0, 0, 25, 80), write(" First name\t Last Name\n"), date(_, This_month, _), /* Get month from system clock (yy/mm/dd/ */ phone_list(Person, _, Date), check_birthday_month(This_month, Date), write_person(Person), fail.

get_months_birthdays :- write("\n\n Press any key to continue: "), readchar(_).

write_person(person(First_name, Last_name)) :- write(" ", First_name, "\t\t ", Last_name), nl.

check_birthday_month(Mon, b_date(Month, _, _)) :- convert_month(Month, Month1), Mon = Month1.

Page 31: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

/*Ch06ex03 - continue*/phone_list(person(ed, willis), "767-8463", b_date(jan, 3, 1955)). phone_list(person(benjamin, thomas), "438-8400", b_date(feb, 5, 1985)). phone_list(person(ray, william), "555-5653", b_date(mar, 3, 1935)). phone_list(person(thomas, alfred), "767-2223", b_date(apr, 29, 1951)). phone_list(person(chris, grahm), "555-1212", b_date(may, 12, 1962)). phone_list(person(dustin, robert), "438-8400", b_date(jun, 17, 1980)). phone_list(person(anna, friend), "767-8463", b_date(jun, 20, 1986)). phone_list(person(brandy, rae), "555-5653", b_date(jul, 16, 1981)). convert_month(jan, 1). convert_month(feb, 2). convert_month(mar, 3). convert_month(apr, 4). convert_month(may, 5). convert_month(jun, 6). convert_month(jul, 7). convert_month(aug, 8). convert_month(sep, 9). convert_month(oct, 10). convert_month(nov, 11). convert_month(dec, 12).

Page 32: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Lists and Recursion based search in Prolog

List specification: [1, 2, 3, 4]List representation: [H| T]

/* Ch08ex06 */domains namelist = name* name = symbol

predicates is_a_member_of(name, namelist)

clauses is_a_member_of(Name, [Name|_]). is_a_member_of(Name, [_|Tail]) :- is_a_member_of(Name,Tail).

Page 33: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

domainslist = symbol*

predicates colours(list) member(symbol, list)

clauses colours([red, orange, green, blue, yellow]). member(X, List) :- member (X, [X| - ]), member(X, [T]).

goal colours(X), member (green, X).

Members of a List

Page 34: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

3x3 Knight’s tour problem

domains liste=integer*predicates path(integer, integer, liste) member(integer, liste) move(integer, integer)clauses move(1,6). move(1,8). move(2,7). move(2,9). move(3,4). move(3,8). move(4,3). move(4,9). move(6,7). move(6,1). move(7,6). move(7,2). move(8,3). move(8,1). move(9,4). move(9,2).

51 2 34 67 8 9

path(Z, Z, L).path(X, Y, L):- move(X, Z), not(member(Z, L)), path(Z, Y, [Z|L]). member(X, [X|T]). member(X, [Y|T]):- member(X, T).

Goal: path(1, 3, [1]).

Page 35: LECTURE 3 PROLOG. Introduction Prolog program consists of clauses which are facts and rules. Predicate is the name given to the relation likes(bill, tennis)

Recursive Program that Adds the Elements of a List

domains list = integer*predicates sum_of(list, integer)goal

sum_of([1, 2, 3, 4], S).

clauses

sum_of([], 0).

sum_of([H|T], S):- sum_of(T, Sum), S = Sum+H.