Derived from csc.villanova.edu/~dmatusze/8310summer2001/index.html/prolog1.ppt

1

Prolog

2

SWI-Prolog

• SWI-Prolog is a good, standard Prolog for Windows, Mac OS X 10.4 and 10,5, and Linux

• It’s licensed under GPL, therefore freely available

• Downloadable from:

• http://www.swi-prolog.org/

3

Syllogisms

• “Prolog” is all about programming in logic.

• Aristotle described syllogisms 2300 years ago

• Sample syllogism:– Socrates is a man.– All men are mortal.– Therefore, Socrates is mortal.

• This is logic. Can Prolog do it?

4

Forward and backward reasoning

• A syllogism gives two premises, then asks, “What can we conclude?”– This is forward reasoning -- from premises to

conclusions– it's inefficient when you have lots of premises

• Instead, you ask Prolog specific questions– Prolog uses backward reasoning -- from

(potential) conclusions to facts

5

Syllogisms in Prolog

Syllogism

Socrates is a man.

All men are mortal.

Is Socrates mortal?

Prolog

man(socrates).

mortal(X) :- man(X).

?- mortal(socrates).

6

Facts, rules, and queries

• Fact: Socrates is a man.• man(socrates).• Rule: All men are mortal.• mortal(X) :- man(X).• Query: Is Socrates mortal?• mortal(socrates).• Queries have the same form as facts

7

Running Prolog

• Create your “database” (program) in any editor• Save it as text only, with a .pl extension• Here’s the complete program:

man(socrates).mortal(X) :- man(X).

8

Running Prolog continued

• Prolog is completely interactive. Begin by– Double-clicking on your .pl file, or

– Double-clicking on the Prolog application and consulting your file at the ?- prompt:

• ?- consult('C:\\My Programs\\adv.pl').

• Then, ask your question at the prompt:– ?- mortal(socrates).

• Prolog responds:– Yes

9

Prolog is a theorem prover

• Prolog’s “Yes” means “I can prove it” --Prolog’s “No” means “I can't prove it”– ?- mortal(plato).

No

• This is the closed world assumption: The Prolog program knows everything it needs to know

• Prolog supplies values for variables when it needs to in order to complete a “proof”:– ?- mortal(X).

X = socrates

10

Syntax I: Structures

• A structure consists of a name and zero or more arguments.

• Omit the parentheses if there are no arguments

• Example structures:– sunshine– man(socrates)– path(garden, south, sundial)

11

Syntax II: Base Clauses

• A base clause is just a structure.

• A base clause represents a simple fact.

• Example base clauses:– debug_on.– loves(john, mary).– loves(mary, bill).

12

Syntax III: Nonbase Clauses

• A nonbase clause is a structure, a “turnstile” :- (meaning IF), and a list of structures.

• Example nonbase clauses:– mortal(X) :- man(X).– mortal(X) :- woman(X)– happy(X) :- healthy(X), wealthy(X),

wise(X).

• The comma between structures means AND

13

Syntax IV: Predicates

• A predicate is a collection of clauses with the same functor (name) and arity (number of arguments).

• loves(john, mary). loves(mary, bill). loves(chuck, X) :- female(X), rich(X).

14

Syntax V: Programs

• A program is a collection of predicates.

• Predicates can be in any order.

• Clauses within a predicate are used in the order in which they occur.

15

Syntax VI: Variables and atoms

• Variables begin with a capital letter: X, Socrates, _result

• Atoms do not begin with a capital letter: x, socrates

• Atoms containing special characters, or beginning with a capital letter, must be enclosed in single quotes:– 'C:\\My Documents\\examples.pl'

16

Syntax VII: Strings are atoms

• In a quoted atom, a single quote must be doubled or backslashed:– 'Can''t, or won\'t?'

• Backslashes in file names must also be doubled:– 'C:\\My Documents\\examples.pl'

17

Common problems

• Capitalization is extremely important!• No space is allowed between a functor and its

argument list: man(socrates), not man (socrates).

• Double quotes indicate a list of ASCII character values, not a string

• Don’t forget the period! (But you can put it on the next line.)

18

Backtracking

• loves(chuck, X) :- female(X), rich(X).• female(jane).• female(mary).• rich(mary).• ---------- Suppose we ask: loves(chuck, X).

– female(X) = female(jane), X = jane.– rich(jane) fails.– female(X) = female(mary), X = mary.– rich(mary) succeeds.

19

Backtracking and Beads

• Each Prolog call is like a “bead” in a string of beads:

call

fail

exitredo

• Each structure has four ports: call, exit, redo, fail• Exit ports connect to call ports;

fail ports connect to redo ports

20

Calls as nested beads

loves(chuck, X) :- female(X), rich(X).

loves(chuck, X)

female(X) rich(X)call

fail

exitredo

21

Additional answers

• female(jane).female(mary).female(susan).

• ?- female(X).• X = jane ;• X = mary• Yes

female(jane)

female(mary)

female(susan)

female(X)

22

Readings

• loves(chuck, X) :- female(X), rich(X).

• Declarative reading: Chuck loves X if X is female and rich.

• Approximate procedural reading: To find an X that Chuck loves, first find a female X, then check that X is rich.

• Declarative readings are almost always preferred.

23

Monotonic logic

• Standard logic is monotonic: once you prove something is true, it is true forever

• Logic isn't a good fit to reality

• If the wallet is in the purse, and the purse in is the car, we can conclude that the wallet is in the car

• But what if we take the purse out of the car?

24

Nonmonotonic logic

• Prolog uses nonmonotonic logic• Facts and rules can be changed at any time

– such facts and rules are said to be dynamic

• assert(...) adds a fact or rule

• retract(...) removes a fact or rule

• assert and retract are said to be extralogical predicates

25

Examples of assert and retract

• assert(man(plato)).• assert((loves(chuck,X) :- female(X), rich(X))).• retract(man(plato)).• retract((loves(chuck,X) :- female(X), rich(X))).

• Notice that we use double parentheses for rules– This is to avoid a minor syntax problem

– Suppose we say: assert(foo :- bar, baz).– How many arguments did we give to assert?

26

Limitations of backtracking

• In Prolog, backtracking over something generally undoes it

• Output can't be undone by backtracking

• Neither can assert and retract be undone by backtracking

• Perform any necessary testing before you use write, nl, assert, or retract

27

Modeling “real life”

• Real life isn’t monotonic; things change• Prolog is superb for modeling change• Games are often a model of real (or

fantasy!) life• Prolog is just about ideal for adventure

games

28

Starting PrologWelcome to SWI-Prolog (Multi-threaded, 32 bits,

Version 5.6.59)Copyright (c) 1990-2008 University of Amsterdam.SWI-Prolog comes with ABSOLUTELY NO WARRANTY.

This is free software, and you are welcome to redistribute it under certain conditions.

Please visit http://www.swi-prolog.org for details.For help, use ?- help(Topic). or ?- apropos(Word)

1 ?- consult('C:\\prolog\\dragon.pl').% C:\prolog\dragon.pl compiled 0.00 sec, 12,468 bytes

true.

29

Instructions

• ?- start.• Enter commands using standard Prolog syntax.

Available commands are:start. -- to start the game.n. s. e. w. -- to go in that direction.take(Object). -- to pick up an object.drop(Object). -- to put down an object.use(Object). -- to use an object.attack. -- to attack an enemy.look. -- to look around you again.instructions. -- to see this message again.halt. -- to end the game and quit.

30

Starting out

• You are in a meadow. To the north is the dark mouth of a cave; to the south is a small building. Your assignment, should you decide to accept it, is to recover the famed Bar-Abzad ruby and return it to this meadow.

True.

31

Going south

• ?- s.• You are in a small building. The exit is

to the north. The room is devoid of furniture, and the only feature seems to be a small door to the east.

There is a flashlight here.

true

32

Taking things, locked doors

• ?- take(flashlight).• OK.

True.• ?- e.• The door appears to be locked.

You can't go that way.

True.

33

Some time later...

• ?- use(key).• The closet is no longer locked.

True.• Later still...• ?- look.• You are in a big, dark cave. The air is

fetid.

There is a chest here.

34

Essential facts

• Where I am at present:– i_am_at(meadow).

• Where other things are at:– at(flashlight, building).

• What I am holding:– holding(key).

• Which facts may be changed:– :- dynamic i_am_at/1, at/2, holding/1.

35

Input and output

• Input is unpleasant; we avoid it by giving commands (as questions) directly to Prolog– take(flashlight).

• write(...) outputs its one argument

• nl ends the line (writes a newline)• describe(closet) :-

write('You are in an old storage closet.'), nl.

36

The map

cave_entrance cave

meadow

building closet

N W E S

37

Implementing the map

• path(cave, w, cave_entrance).path(cave_entrance, e, cave).

• path(meadow, s, building).path(building, n, meadow).

• Could have done this instead:– path(cave, w, cave_entrance).

path(X, e, Y) :- path(Y, w, X).

38

listing

• listing(predicate) is a good way to examine the current state of the program

• ?- listing(at).– at(key, cave_entrance).

at(flashlight, building).at(sword, closet).

true.

39

North, south, east, west

• The commands n, s, e, w all call go.

• n :- go(n).

s :- go(s).

e :- go(e).

w :- go(w).

40

go

• go(Direction) :- i_am_at(Here), path(Here, Direction, There), retract(i_am_at(Here)), assert(i_am_at(There)), look.

• go(_) :- write('You can''t go that way.').

41

take

• take(X) :- i_am_at(Place), at(X, Place), retract(at(X, Place)), assert(holding(X)), write('OK.'), nl.

42

You can’t always take

take(A) :- holding(A), write('You\'re already holding it!'), nl.

take(A) :- (actually take something, as before).

take(A) :- write('I don\'t see it here.'), nl.

43

Making things fail

• A predicate will fail if it doesn’t succeed• You can explicitly use fail• fail works like this:

• This often isn't strong enough; it doesn't force the entire predicate to fail

failcall

fail

44

cut

• The “cut,” written ! , is a commit point– It commits to the clause in which it occurs, and– everything before it in that clause

• Using cut says: Don’t try any other clauses, and don’t backtrack past the cut

!call exit

45

cut-fail

• The cut-fail combination: !, fail means really fail

• It commits to this clause, then fails

• This means no other clauses of this predicate will be tried, so the predicate as a whole fails

46

A locked door

• path(building, e, closet) :- locked(closet), write('The door appears to be locked.'), nl, !, fail.path(building, e, closet).

• If the closet door isn't locked, the first clause fails “normally,” and the second clause is used

• If the closet door is locked, the cut prevents the second clause from ever being reached

47

Dropping objects

drop(A) :- holding(A), i_am_at(B), retract(holding(A)), assert(at(A, B)), write('OK.'), nl.drop(A) :- write('You aren\'t holding it!'), nl.

48

What else is Prolog good for?

• Prolog is primarily an AI (Artificial Intelligence) language

• It's second only to LISP in popularity

• It's more popular in Britain than in the U.S.

• Prolog is also a very enjoyable language in which to program (subjective opinion, obviously!)

49

Prolog II

50

The Notion of Unification

• Unification is when two things “become one”• Unification is kind of like assignment• Unification is kind of like equality in algebra• Unification is mostly like pattern matching• Example:

– loves(john, X) can unify with loves(john, mary)– and in the process, X gets unified with mary

51

Unification I

• Any value can be unified with itself.– weather(sunny) = weather(sunny)

• A variable can be unified with another variable.– X = Y

• A variable can be unified with (“instantiated to”) any Prolog value.– Topic = weather(sunny)

52

Unification II

• Two different structures can be unified if their constituents can be unified.– female(X) = female(jane)– mother(mary, X) = mother(Y, father(Z))

• A variable can be unified with a structure containing that same variable. This is usually a Bad Idea.– X = f(X)

53

Unification III

• The explicit unification operator is =• Unification is symmetric:

Steve = father(isaac)means the same as father(isaac) = Steve

• Most unification happens implicitly, as a result of parameter transmission.

54

Scope of Names

• The scope of a variable is the single clause in which it appears.

• The scope of the “anonymous” (“don't care”) variable, _, is itself.– loves(_, _) = loves(john, mary)

• A variable that only occurs once in a clause is a useless singleton; you should replace it with the anonymous variable

55

Clauses as Cases

• A predicate consists of multiple clauses, each of which represents a “case”

grandson(X,Y) :- son(X,Z), son(Z,Y).

grandson(X,Y) :- son(X,Z), daughter(Z,Y).abs(X, Y) :- X < 0, Y is -X.

abs(X, X) :- X >= 0.

56

Ordering

• Clauses are always tried in order• buy(X) :- good(X).

buy(X) :- cheap(X).

cheap(‘Java 2 Complete’).good(‘Thinking in Java’).

• What will buy(X) choose first?

57

Ordering II

• Try to handle more specific cases (those having more variables instantiated) first.

dislikes(john, bill).

dislikes(john, X) :- rich(X).

dislikes(X, Y) :- loves(X, Z), loves(Z, Y).

58

Recursion

ancestor(X, Y) :- child(Y, X).(X is an ancestor of Y if Y is a child of X.)

ancestor(X, Y) :- child(Z, X), ancestor(Z, Y).(X is an ancestor of Y if Z is a child of X and Z is an ancestor of Y).

Handle the base cases first

Recur only with a simpler case

59

Basic and derived clauses

• You can often choose which facts you want to be "basic" and which derived

son(isaac, steven).child(X, Y) :- son(X, Y).

male(isaac).child(isaac, steven).son(X, Y) :- male(X), child(X, Y).

60

Recursive Loops

• Prolog proofs must be tree structured, that is, they may not contain recursive loops.

– child(X,Y) :- son(X,Y).

– son(X,Y) :- child(X,Y), male(X).

– ?- son(isaac, steven). May loop!

• Why? Neither child/2 nor son/2 is basic

61

Lists

• [ ] is the empty list.

• [x, 2+2, [a, b, c]] is a list of three elements.• The first element in the list is its “head”.• The list with the head removed is the “tail”.

– The head of [x, 2+2, [a, b, c]] is x– The tail is [2+2, [a, b, c]]

62

Lists

• Unification can be performed on lists:– [a, b, c] = [X, Y, Z] results in

• results in X = a, Y = b, Z = c

– [a, b, c] = [Head | Tail]• results in Head = a, Tail = [b, c]

• Nonempty lists can be matched against [Head|Tail].

• Empty lists will not match [Head|Tail].

63

Matching Heads and Tails

• If [a, b, c] = [Head | Tail], then a = Head and [b, c] = Tail

• If [a, b, c] = [X, Y | Tail], then a = X, b = Y, and [c] = Tail

• If [a, b, c] = [X, Y, Z | Tail], then a = X, b = Y, c = Z, and [ ] = Tail

• The tail of a list is always itself a list.• [X | Y, Z] isn’t legal.

64

Recursion

• Recursion is fully supported• element(1, [X | _ ], X).• element(N, [ _ | X], Y) :-

M is N - 1, element(M, X, Y).

• This is the typical way to process lists: do something with the head, recur with the tail.

65

member

• member(X, [X | _ ]).• member(X, [ _ | Y]) :- member(X,

Y).• As usual, base cases go first, then recursive

cases.

• There is in general no need for a “fail” case, because that’s automatic.– member( _, [ ]) :- fail.

66

Accumulated Information

• If you reach a clause, you can assume that the earlier clauses of the same predicate have failed.

• member(X, [X | _ ]).• If you fail this clause, the first element is

not the one you want, somember(X, [ _ | Y] :- member(X, Y).

67

Fail Loops

• It is possible to build a “fail loop” in Prolog

• print_elements(List) :- member(X, List), write(X), nl, fail.

• But recursion is almost always better:print_elements([Head|Tail]) :- write(Head), nl, print_elements(Tail).

68

Forcing a predicate to succeed

notice_objects_at(Place) :- at(X, Place), write('There is a '), write(X), write(' here.'), nl, fail.notice_objects_at(_).

69

Forcing a predicate to fail

loves(chuck, X) :- really_ugly(X), !, fail.

loves(chuck, X) :- female(X), rich(X).

70

"Wrapping" another predicate

• The buzz_off/0 predicate might succeed or fail. This is usually what we want.

• But sometimes we want to ignore failure.

optional_buzz_off :- buzz_off.optional_buzz_off.

71

Asserting Clauses

• assert(new_clause).– assert(path(garden, n, toolshed)).– assert(( loves(chuck,X) :- female(X) ,

rich(X) )).

• asserta(new_clause).• assertz(new_clause).

72

Removing clauses

• retract(clause).– retract(path(garden, n, toolshed)).– retract(path(X, Y, X)).– retract(( loves(chuck,X) :- female(X) ,

rich(X) )).

• abolish(path, 3).

73

Marking Clauses as “Dynamic”

• Standard Prolog allows you to assert and retract clauses without any restrictions.

• SWI-Prolog and some others require you to mark variable clauses as “dynamic.”

• :- dynamic i_am_at/1, at/2, alive/0.• The “:-” at the beginning says “do it now.”

74

Solving problems with dynamic

• If Prolog already knows a clause, and it's static, it's too late to mark it dynamic

• Prolog must see :- dynamic functor/arity before it sees any clauses of functor/arity.– This includes clauses loaded in from an earlier

consult• You can restart SWI-Prolog, or…• …you can use abolish(functor, arity)

75

Arithmetic

• The equals sign, =, means “unify.”• 2+2 does not unify with 4.• To force arithmetic to be performed, use “is”: X

is 2 + 2, X = 4.• Comparisons =:= =/= > >= < <=

also force their operands to be evaluated.• + - * / mod, when evaluated, have their usual

meanings.

Derived from csc.villanova.edu/~dmatusze/8310summer2001/index.html/prolog1.ppt

76

The End