1 csc 8520 spring 2013. paula matuszek slides taken from david matuszek,...

1CSC 8520 Spring 2013. Paula Matuszek

Slides taken from David Matuszek, http://www.cis.upenn.edu/~matuszek/cis554-2012/Lectures/prolog-01.ppt

CS 8520: Artificial Intelligence

Prolog 1

Paula Matuszek

Spring, 2013

http://www.cis.upenn.edu/~matuszek/cis554-2012/Lectures/prolog-01.ppt



SWI-Prolog• SWI-Prolog is a good, standard Prolog for

Windows and Linux

• It's licensed under GPL, therefore free

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


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



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?




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




Syllogisms in Prolog

SyllogismSocrates is a man.All men are mortal.Is Socrates mortal?

man(socrates).

mortal(X) :- man(X).

?- mortal(socrates).

Prolog




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




Running Prolog I• 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).




Running Prolog II• 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').

– On a mac, opening a terminal window and typing swipl

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

• Prolog responds:– Yes




Prolog is a theorem prover• Prolog's "Yes" or “true” means "I can prove it" --

Prolog's "No" or “false” means "I can't prove it"– ?- mortal(plato).

False.

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

• Prolog supplies values for variables when it can– ?- mortal(X).

X = socrates


10

CSC 8520 Spring 2013. Paula Matuszek


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'

• Variables consisting of, or beginning with, _ are called anonymous variables. They are used when we don’t care what their value is.


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, failExit 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

– 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



Trying an Adventure Game• There is a file on the class webpage called dragon.pl.

Download it someplace you can find it.

• Start Prolog.

• Depending on your system, you may be able to click on dragon.pl, or there may be an icon, or you may have to get to a prompt and run it directly.

• For the mac, open a terminal window– paladin.home% swipl

• You may also need to set a path variable or make a link to where you have the executable.


29



Starting PrologWelcome to SWI-Prolog (Multi-threaded, 64 bits, Version 6.2.6)

Copyright (c) 1990-2012 University of Amsterdam, VU 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).

?-

?- consult('C:\\_Prolog\\dragon.pl').

% C:\_Prolog\dragon.pl compiled 0.00 sec, 54 clausestrue.

?-



30



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.

true.

?-


31



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.


32



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.


33



Taking things, locked doors• ?- take(flashlight).

• OK.

true.

• ?- e.

• The door appears to be locked.You can't go that way.

true.


34



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.


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



Implementing an Adventure Game• If you examine the code for dragon.pl you

can see how it is implemented.

• The following describe some of the decisions for implementation.

• Note that these are mostly descriptions of what is true or what something means. There is no control structure comparable to a language like Java or C.


37



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.

– Not all implementations of Prolog require dynamic, but swipl does.


38



The map

cave_entrance cave

meadow

building closet

N W E S


39



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).


40



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


41



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).


42



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.').


43



take• take(X) :-

i_am_at(Place), at(X, Place), retract(at(X, Place)), assert(holding(X)), write('OK.'), nl.


44



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.


45



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


46



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


47



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


48



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


49



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.


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• Once a variable has been unified with a

value, it continues to have that value for the rest of the clause, and can be used that way

• If we have– female(X) = female(jane)

• then– write(X) will write jane.


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



Writing Prolog Programs• Suppose the database contains

loves(chuck, X) :- female(X), rich(X). female(jane).and we ask who Chuck loves, ?- loves(chuck, Woman).

• female(X) finds a value for X , say, jane

• rich(X) then tests whether Jane is rich


56



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.


57



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?


58



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).


59



Ordering III• Some "actions" cannot be undone by

backtracking over them:– write, nl, assert, retract, consult

• Do tests before you do undoable actions:– take(Thing) :-

holding(Thing), write('You\'re already holding it!'), nl.


60



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).


61



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.


62



What else is Prolog good for?• Prolog is primarily an AI (Artificial

Intelligence) language

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

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

• More next week!


63



Some Resources• These slides and dragon.pl were borrowed from David

Matuszek. He has additional Prolog information at http://www.cis.upenn.edu/~matuszek/cis554-2012/index.html

• There is a good basic interactive Prolog tutorial at http://www.doc.gold.ac.uk/~mas02gw/prolog_tutorial/prologpages/ . If you are having problems I’d suggest working through that.

• The SWI Prolog site (http://www.swi-prolog.org) has a manual, a FAQ, a mailing list, and other resources.

• Or try asking a question on our Piazza page! https://piazza.com/villanova/spring2013/8520/home


http://www.cis.upenn.edu/~matuszek/cis554-2012/index.html

http://www.cis.upenn.edu/~matuszek/cis554-2012/index.html

http://www.doc.gold.ac.uk/~mas02gw/prolog_tutorial/prologpages/

http://www.doc.gold.ac.uk/~mas02gw/prolog_tutorial/prologpages/
