home—lectures—exams—hws—breeze (snow day)

lect10b
prolog intro

teaching coverage: I actually spent several minutes, going over what was mentioned at the end of lect09b: the difference between assigning to a local, and assigning to a variable.

Review: Families of languagues:

functional: racket, lisp, haskell, ...
“imperative” might be viewed as a constrast to functional: using assignment and mutation.
procedural: Ada, C, Algol, Fortran.
object-oriented: C++, Java, smalltalk
scripting: php, javascript, ruby, python, perl,..
declarative: prolog, SQL, Excel
You declare *what* a correct answer is, but not *how* to compute it.

These are of course all fuzzy distinctions; you can do functional programming in Java; Racket has an object-system and does allow mutation; you can write C++ code which isn't object-oriented, etc..

If you ssh into rucs.radford.edu, you can type:

xsb

to start a prolog interpreter. Our demo has two phases: (a) the knowledge base (a file of facts and rules), and (b) making interactive queries.

% Data:

female(alice).
male(bob).
male(charlie).
female(dee).
male(ethan).


% (A) Find dance partners -- one man, one woman:

partner(A,B) :- male(A), female(B).
partner(A,B) :- female(A), male(B).

The above lines (facts and rules) are the "knowledge base". If you put this into a file named (say) “lect10b.P”, then we can run xsb, and load the knowledge base from the file by typing “[lect10b].” (note the square-brackets, the lack of file-suffix, and the period).

Once the knowledge base is loaded, we can interactively make queries:

partner(alice,bob).
partner(bob,alice).

Here's the ultra-cool part: I can put in a variable like “X” (anything that starts with upper-case is considered a variable, not a symbol), and prolog will solve the predicate for me — find all values of

that make the predicate true!

partner(bob,X).
partner(X,bob).
partner(X,Y).

In the interactive window, we can type “.” to accept the answer, or “,” to have it look for more.

Some more facts:

drinks(alice,gin).
drinks(alice,martini).
drinks(bob,soda).
drinks(charlie,soda).
drinks(charlie,whiskey).
drinks(charlie,martini).
drinks(ethan,water).

Note: If you are in a prolog shell, and you edit your knowledge-base file foo.P, you'll want to re-set your shell to discard all the old rules. I just exist xsb and re-start, myself.

How might we...

Find every drink that alice likes?
Find everybody who likes martinis?
Find a drink that both alice and bob like?
Find every possible drinking buddy of alice?

a limitation: Unfortunately, in Prolog, we can't easily ask "is there a person who does not like any drink?" While Prolog is great with "find me example", it's not so good at "find me something with no examples".

We can go further though: What is a rule to tell if two people both like the same drink?

drinkWith_v1(A,B,Drnk) :- drinks(A,Drnk), drinks(B,Drnk).
%
% Close, but not quite.
% Note that we'll have somebody drinking with themselves.
% Fix with '\=':
drinkWith(A,B,Drnk) :- drinks(A,Drnk), drinks(B,Drnk), A \= B.

Self-check: Write a predicate drinkWith/2, that tells if two people could be compatible drinking-buddies.

Note: ITEC380 does not condone underage drinking, driving while drinking, programming while drinking, or programming while under the influence of bad languages.

No fundamental difference between facts and rules; a fact is just a rule with no variables:

drinks(charlie,X).
%
% Charlie should join AA; he drinks anything.
% [Including ...other people?!]

This line is equivalent to drinks(charlie,X) :- ., where there are not constraints on the right-hand-side. To prolog's mind: Any value of X satisfies every constraint on the right-hand-side.

% It's weird to name a variable which we never use;
% the special variable `_` can be used.
%
drinks(charlie,_).
%
% Underscore is special because even if you mention it
% two or more times, it can match two *different* values:
%
twoNonTeaTotalers(A,B) :- drinkWith(A,_), drinkWith(B,_).
% A and B may not drink the same thing 
% (but they both drink *something*, unlike dee.)

Summary: Why Prolog?

From CS2, we learned to think of abstract data types, and interfaces different from implementations (with English comments about the purpose/spec of each method, not its implementation). In Prolog, we take the interface/implementation to the next level: we describe a predicate's purpose (specification) in actual code! (e.g. drinksWith: Can somebody be their own drinking buddy? the prolog spec will address that one way or the other, unambiguously.) This makes us think harder about corner cases up front (and, ties in to developing good unit tests).
Prolog's pattern-matching is cool. Several languages have since integrated it.

home—lectures—exams—hws—breeze (snow day)

©2012, Ian Barland, Radford University
Last modified 2012.Nov.07 (Wed) Please mail any suggestions
(incl. typos, broken links)
to ibarlandradford.edu

lect10b prolog intro

lect10b
prolog intro