Some Prolog information

[ Running/Obtaining Prolog | On-line Documentation | Books ]

[ Sample Prolog code | Typing in and running Prolog code | Debugging]

Running/Obtaining Prolog

On the CS Dept machines : Quintus Prolog 3.2 is installed on the Sols/Novas. The Prolog interpreter is /s/qp/bin/prolog. The Quintus system also includes a Prolog compiler, linker and other frills. It also has a GUI-based environment which is invoked by running /s/qp/bin/qui.

On your machine at home :

PCs running Windows 3.1/9X/NT, Linux (or even DOS ?!) : You can download and install SWI Prolog, which is reasonably compatible with the Quintus system.

Macs : Try out Open Prolog from the CMU AI repository.

Other systems : Take a look at the list of free/shareware Prolog implementations at the CMU AI repository.

On-line Tutorials/Guides/Documentation/Web resources Prolog : Amzi's Adventure in Prolog, a larger tutorial that is quick reading, with a good table of contents and good examples. A Prolog tutorial Manual for Edinburgh DEC-10 Prolog (similar to Quintus Prolog) (190KB text file) Quintus Prolog help is also available within the interpreter itself. See below in the 'Running Prolog Code' section. The Prolog Repository at CMU comp.lang.prolog FAQ (aka the Prolog Resource Guide) Logic Programming: Logic Programming Web resources (Check out the Prolog section)

Books

You can try out the following books :

Programming in Prolog by W F Clocksin and C S Mellish (3rd ed, Springer-Verlag, 1987). This is the classic Prolog text.
Prolog Programming for Artificial Intelligence by Ivan Bratko (Addison-Wesley, 1986). Supposed to be good for beginners, though the examples are AI-oriented.
The Art of Prolog by Leon Sterling and Ehud Shapiro (2nd ed, MIT Press, 1994). This is an advanced textbook and contains a number of examples of large and non-trivial Prolog programs.
The Craft of Prolog by Richard O' Keefe (MIT Press, 1990).

You can check out a longer list of Prolog books here. And if you want to read about the general idea of logic programming, take a look at R. Kowalski's Logic for Problem Solving (North-Holland NY, 1979)

Sample Prolog code

Check out the Code section of the CMU Prolog Repository .
A friend of mine had taken a course in Prolog at Oxford and here are the notes used for their lab sessions. There are some interesting exercises here (including logic circuits, graphs, sets, logical puzzles etc). The system they used was called Progol (not a typo) and was more than just a simple logic programming system. However, the examples they worked with should work fine with Quintus Prolog (except for the not predicate which needs to be replaced by \+, see below in the section on using the Prolog built-in predicates).

Lab 1 - Lab 2- Lab 3- Lab 4

Typing in and running Prolog code

A notation that you need to be familiar with is the Name/Number notation for denoting predicates : e.g., member/2 : this denotes a predicate called member which has 2 arguments. Also the comment delimiters for Prolog are /* and */ (a % marks the rest of the line as a comment.

Starting up and exiting Quintus Prolog

Fire up the Quintus Prolog interpreter by typing prolog at the shell prompt on the Sols/Vegas. You should get the following prompt :

sol24(82):prolog% prolog Quintus Prolog Release 3.2 (Sun 4, SunOS 5.4) Copyright (C) 1994, Quintus Corporation. All rights reserved. 301 East Evelyn Ave, Mountain View, California U.S.A. (415) 254-2800 Licensed to The University of Wisconsin | ?-

By default, Prolog is always in the query mode and the | ?- indicates that it is waiting for you to type in a query. To quit, either type Ctrl-D at the prompt or call the halt/0 predicate (don't forget the period at the end) :

| ?- halt. sol24(83):prolog%
Entering Prolog code (from a file or from the keyboard)
To add facts or rules to the Prolog database, you need to use the consult/1 predicate (which is like the use function of SML). To enter stuff from the keyboard, say consult(user). To load code from a file, specify a filename as an argument (preferably within apostrophes). You can specify multiple files as arguments to the consult predicate, but you will have to separate the names with commas. Prolog has a useful shorthand notation : [...] is the same as consult(...). So, I could add some facts from the keyboard like this (a period is necessary at the end of each line and I pressed Ctrl-D when I was done) :

| ?- consult(user). | male(john_doe). | female(susie_q). | awesome_band(black_sabbath). | ^D (or type in end_of_file)% user compiled in module user, 0.010 sec 596 bytes yes | ?- female(X),awesome_band(Y). X = susie_q, Y = black_sabbath ; no | ?-

Now if I created a file called test.pl that contained the following facts :

member( simon, simon_and_garfunkel ). member( garfunkel, simon_and_garfunkel ).

I can now load it into Prolog :

| ?- ['test.pl']. % compiling file /afs/cs.wisc.edu/p/course/cs538-larus/public/html/prolog/test.pl % test.pl compiled in module user, 0.030 sec 392 bytes yes | ?- member(X,simon_and_garfunkel). X = simon ; X = garfunkel ; no | ?-
CAVEAT : If you made a change in test.pl and then want to load the new clauses into the Prolog database in the same session, then use reconsult instead of consult. Reconsult replaces the clauses present in the database with the ones from the file while consult simply adds them on at the end, so you'll end up with multiple copies of your facts and rules.
Using the Prolog built-in predicates

Prolog has a number of built-in predicates. I'm listing the major ones that you might find useful for this assignment :
- Query construction
  
  , : the comma acts like a logical AND. So g1,g2 succeeds if both g1 and g2 succeed.
  
  ; : the semicolon acts like a logical OR (similar to , above ).
  
  \+ : this acts like a logical NOT (most other Prolog systems have a not built-in predicate). So \+ g succeeds iff g fails.
  
  call : This evaluates its argument as if it were a Prolog query.
- I/O
  
  read/1 : reads in a term from standard input and binds it to its argument. You must enter a period to terminate the term.
  
  write/1 : writes its argument to standard output.
  
  nl/0 : writes a newline to standard output.
  
  tab/1 : tab(n) prints n spaces to the standard output.
  
  get0/1 : binds its argument to the next character in the input stream.
  
  get/1 : binds its argument to the next printable character in the input stream.
  
  put/1 : writes its integer argument as a character (ASCII code) to the output stream.
- Arithmetic
  
  As described in class, the is predicate is used for evaluating arithmetic expressions. So, X is Y requires Y to be bound to a structure that can be interpreted as an arithmetic expression. This structure is evaluated to yield an integer and this integer is matched with X (Note : Quintus Prolog supports real math as well). So X has to be unbound or bound to the same integer for the match to succeed. The arithmetic operators allowed are the usual +,-,*,/ (integer division) and mod. Relational operators are also available : <, >, >=, =<.
- Term comparison
  
  = : this operator succeeds if its two arguments can be matched and binds variables in the arguments if the match succeeds.
  
  \= : This is the negation of the = operator. However Quintus Prolog doesn't provide this as a built-in predicate (though it does define it in a library module). So you will have to use the negation predicate \+ explicitly like this : \+ X=Y.
  
  == : This is a stricter version of = which considers an unbound variable equal to another unbound variable only if they are already "sharing". So, for example :
  
  ?- X == Y. no ?- X == X. X = _2001 yes ?- X = Y, X == Y. X = _2002 Y = _2002 yes
  \== : This is the negation of ==, and as mentioned above for \=, you'll have to use \+ explicitly. So say \+ X == Y.
- Term classification
  
  var/1 : Succeeds if its argument is an UNBOUND variable
  
  nonvar/1 : Succeeds if its argument is not an UNBOUND variable
  
  atom/1 : Succeeds if its argument is an atom. Remember that integers are not considered as atoms and strings (stuff within double quotes) are basically lists of integers, not atoms.
  
  integer/1 : Succeeds if its argument is an integer (or a variable bound to an integer.
  
  number/1 : Same as above, but applicable to reals as well as integers.
  
  atomic/1 : Succeeds if its argument is either an integer or an atom.
- Database manipulation
  
  assert/asserta/assertz : All these new predicates add a new clause (their argument) to the Prolog database. Assert is the same as assertz by default. Asserta adds a clause at the beginning before every other clause while assertz adds it at the end after every clause. Backtracking doesn't undo the effect of an assert, you need to do a retract as described below. The argument be sufficiently bound so that the main predicate is known (so it can't be an unbound variable).
  
  retract/1 : This removes a clause matching its argument from the database. As above, the argument must be sufficiently bound so that the main predicate is known. Backtracking to this goal causes it to look for more clauses which match with its argument and hence can be removed.
  
  NOTE : Before using assert or retract in Quintus Prolog, you will need to explicitly tell it not to compile the asserted/retracted predicates. Do this with the following command :
  :- dynamic predicate-name/num-arguments.
  
  consult/reconsult : You've seen these above in the section on typing in Prolog code.
  
  clause(X,Y) : Succeeds if X can be bound with the head of a clause in the database and Y with its body.
- Controlling backtracking
  
  true/0 : This goal always succeeds (but fails when you try to re-satisfy it after backtracking).
  
  fail/0 : This goal always fails. This can be used to force Prolog to backtrack.
  
  ! : (pronoounced "cut") This basically limits the scope of backtracking to all the goals that FOLLOW it in a query. Any attempt to backtrack to goals before the cut will cause the whole parent goal to fail, so if the cut was placed in the body of a clause and there are several clauses defining a predicate, then Prolog will ignore the rest of the clauses and fail on the whole predicate.
  
  repeat : This is like true above in that it always succeeds, but it is also re-satisfiable any number of times. So Prolog will never backtrack to goals before the repeat but keep trying to re-satisfy the goals after it.
- Building and de-composing structures :
  
  =.. : (pronounced "univ") allows you to either decompose a structure into its functor and argument list or combine these to build up a structure. X =.. L matches L with a list whose head is the functor of X and whose tail is the list of arguments of X, where X is a structure.
  
  functor(T,F,N) : Succeeds if T is a structure, F is its functor and N is its arity. Again this can be used to de-compose (T is initially bound) or build up structures (T is initially unbound).
  
  arg(N,T,A) : Succeeds if T is a structure, N is its arity and A is the list of its arguments. N and T MUST BE BOUND for this goal to succeed.
- Misc stuff :
  
  findall(X,G,L) : Succeeds if L is a list of all objects X that satisfy the goal G. It is assumed that G is bound to some goal which contains X as a variable.
On-line help

Type in help. at the Prolog prompt to access the on-line help system. This predicate searches for help topics whose names start with the string you provide it. A manual predicate gives you access to an on-line Prolog manual. Type manual(manual). to learn about the manual. It might be easier to read the manual while using the GUI-environment (/s/qp/bin/qui).
Quintus Prolog library

The Quintus Prolog libray files are stored in /s/qp/sun/qplib3.2/library. Do a 'manual(k-13)' to see the manual page describing the contents of the files in this directory. To load a library file, say : consult(library('name-of-library-file.pl')).

Debugging

A separate lecture is being given on debugging, so you could refer to the notes for that lecture. Before you learn the debugging predicates available to you, you should understand the model of execution and goal satisfaction used by Prolog. Associated with every goal in Prolog are 4 events or ports :

CALL : This event occurs when Prolog starts to satisfy a goal for the first time.
EXIT : This event occurs when Prolog satisfies the goal and tries to satisfy the next goal of the query.
REDO : This event occurs when goals ahead of this goal have failed and Prolog has backtracked and is now trying to re-satisfy this goal.
FAIL : This event occurs when Prolog could not satisfy/re-satisfy this goal and Prolog backtracks to the goal that was satisfied before this goal was reached.

The Prolog system basically offers you two debugging operations :

Choosing the goals for which the Prolog system will report the occurrence of an event.
Choosing the level of interaction with the execution of the program.

1. Choosing when Prolog reports the occurrence of an event :

trace : turn on exhaustive tracing (stop and report events for all goals)
notrace : turn off exhaustive tracing
leash : Parameter indicates the type of events to be reported while tracing :
- full : stop at all 4 events (default)
- tight : stop at CALL, REDO and FAIL
- half : stop at CALL and REDO
- loose : stop at CALL
- off : don't stop, simply report
spy : Set a spy point at the predicate named as the argument. The argument can be a single name (like sort) or a name with the number of arguments of the predicate as well (sort/2) or a list of such names (in which case spypoints are set on all the predicates). Spy points are used below ...
nospy : This removes spy points. Arguments are similar to those of spy.
nodebug : This removes ALL spy points.
debugging : Lists current spy points (and other debugging status information)

2. Choosing the level of interaction with event reporting :

If you're doing some sort of leashed tracing (i.e. leash not set to off), then Prolog will stop after reporting an event and wait for your command. You can type any one of the following single-letter commands :

c : (creep) Carry on with program execution till report of next event
s : (skip) Carry on with program execution, DON'T report any more events unless they occur in the curent predicate.
l : (leap) This is like skip above, except that reporting is suspended till either a SPYPOINT is reached or an event occurs in the current predicate.
f : (fail) Cause current goal to fail
r : (retry) Cause current goal to be re-tried (as if a CALL event is to occur for the first time). Side-effects (like database manipulation) are not undone.
To come back to the Prolog prompt, type Ctrl-C and then type q.