You will be running SICStus Prolog on the undergraduate SUN servers. The preferred way to run Prolog is from within emacs, as then your output is in an emacs window, which can be manipulated as text.
Use a two window (i.e., buffer) emacs environment, which encourages an interactive style of editing and running Prolog programs. The upper window is used primarily for editing of facts and rules. The lower window (which is running the shell) is used for executing programs; it keeps a running record of your execution. Thus, you can save the results of a Prolog session by saving this lower window using the usual emacs file saving commands (e.g., Control-x Control-w).
After you execute this command, you type into the emacs buffer exactly as you would at the system level. After you end the Prolog session by typing ?- halt., you can save your output buffer to a file.
We expect you to run as follows:
Infinite loops in Prolog programs, usually caused by poorly written recursive rules (e.g., a base case entered *after* the recursive rule, or a leftmost recursive subgoal on the rhs of a rule), are easy to notice: if the interpreter produces no output to the screen for a while, your program is probably in an infinite loop. When running Prolog, Control-c Control-c (yes, it's two of them) interrupts execution and results in the Prolog prompt for help. If you reply to the prompt h, thus asking for help, these are some of the choices open to you:
spy(). -- causes a trace of the execution of the specified clause only. During execution, once that clause is reached, the trace is presented and several options are possible:
Return -- single step trace
l -- leap trace (allows you to skip over subgoals)
? -- help
g -- shows the ancestor list of current goals not yet satisfied
The following program was run on remus and traced as shown below, to give you an idea of what the trace output means. The annotations which follow the % on the right, as well as the indentation were inserted after the run of the program. Note that Head [j->k] p(...) indicates that the j-th rule for predicate p is being tried currently, and then the k-th rule will be tried next. Head [j] p(...) means there are no more rules to try for p.
\% mem(X,List) --X is member of list L mem(A,[A|B]). %rule 1 for mem: standard base case mem(A,[C|B]) :- mem(A,B),fail. %rule 2 for mem (useless- just to show trace) diff(X,Y):- \+(X=Y). %mixed in definition of diff/2 mem(A,[C|X]) :- diff(C,A), mem(A,X). %rule 3 for mem.
| ?- trace. [trace] | ?- mem(a,[b,a]). (1) 0 Call: mem(a,[b,a]) ? (1) 1 Head [1->2]: mem(a,[b,a]) ? %try rule 1 (rule 2 is next) (1) 1 Head [2->3]: mem(a,[b,a]) ? %try rule 2 (rule 3 is next) (2) 1 Call: mem(a,[a]) ? (2) 2 Head [1->2]: mem(a,[a]) ? %try rule 1 (rule 2 is next) (2) 1 Exit: mem(a,[a]) ? %1. succeeded (2) 1 Redo: mem(a,[a]) ? % fail kicked back (2) 2 Head [2->3]: mem(a,[a]) ? %try rule 2 (rule 3 is next) (3) 2 Call: mem(a,[]) ? (3) 3 Head [1->2]: mem(a,[]) ? %try rule 1 (rule 2 is next) (3) 3 Head [2->3]: mem(a,[]) ? %try rule 2 (rule 3 is next) (3) 3 Head [3]: mem(a,[]) ? %try rule 3 (3) 2 Fail: mem(a,[]) ? %ran out of choices (2) 2 Head [3]: mem(a,[a]) ? %try rule 3 (4) 2 Call: diff(a,a) ? (4) 3 Head [1]: diff(a,a) ? (4) 2 Fail: diff(a,a) ? (2) 1 Fail: mem(a,[a]) ? %ran out of choices after redo (1) 1 Head [3]: mem(a,[b,a]) ? %try rule 3 (5) 1 Call: diff(b,a) ? %first goal of rule %3 (5) 2 Head [1]: diff(b,a) ? (5) 1 Done: diff(b,a) ? (6) 1 Call: mem(a,[a]) ? %second rule of rule 3 (6) 2 Head [1->2]: mem(a,[a]) ? %quick recursion (6) 1 Exit: mem(a,[a]) ? (1) 0 Exit: mem(a,[b,a]) ? Yes