CPS 343/543, 430/542 Lecture notes: Introduction to PROLOG

(CPS 343/543) [COPL] §§16.4-16.8 (pp. 624-650), [PLPP] §§12.4-12.5 (pp. 552-568), and
(CPS 430/542) [FCDB] §§10.1-10.3 (pp. 463-492)

---

Logic programming

---

• tries to make programming a specification (of solution) activity (called declarative programming), but it falls shorts
• PROLOG (PROgramming LOGic) is a declarative programming language

---

Formalism gone awry

---

• what is the problem with implementing resolution in a computer system?
• how should be search the database: top-down, bottom-up, or neither?
• the goal {} ⊂ legs(horse, 4) led to 2 sub-goals: {} ⊂ mammal(x) ∧ arms(x,0)
• in which order should the system try to prove the sub-goals? left-to-right or right-to-left or neither?
• in this case, the end result (true) is the same, but in other cases in might make a difference (e.g. (see proof tree on p. 559 of [PLPP]),
  ancestor(x,y) ⊂ parent(x,z) ∧ ancestor(z,y).
  ancestor(x,x).
  parent(amy,bob).
  
  {} ⊂ ancestor(x,bob).
  )
  
• therefore: order in which
  • the database, and
  • sub-goals are searched
  is significant
  
  
• an implementation must use a fixed search strategy, and the programmer must be aware of these (unsettling)
• questions
  • how to search the database? top-down or bottom-up or neither?
  • how to search the sub-goals? left-to-right or right-to-left or neither?
• PROLOG search its database top-down and searches sub-goals left-to-right (i.e., using depth-first-search)
• do not confuse backward chaining with bottom-up search
• this violates the defining principle of a declarative language, that is that the programmer need worry only about the logic and leave the control (inference methods used to prove an answer) up to the system (resolution comes for free with PROLOG, programmer need not program it!)
• we have a pure functional programming language (Haskell), can we have a pure logic programming language?
• the answer is yes, but it would be far too inefficient to be practical
• holy grail of logic programming: original goal of logic programming was to make programming a specification activity (i.e., declarative programming!)
• pure logic programming is non-deterministic; programmers should not have to impart control flow
• therefore, PROLOG falls short

---

Summary

---

• find Q as a fact in the database, or
• find Q as a sequence of propositions such that
  P₂ ⊂ P₁.
  P₃ ⊂ P₂.
  ...
  Q ⊂ P_n.

---

Applications of logic programming

---

• logical reasoning
• problem solving
  • cryparithmetic problems (e.g.,

    SEND

    +MORE

    ------------

    MONEY

    )
  • GRE analytical problems
  • puzzles
• artificial intelligence
• specification verification (or rapid prototyping)
• equational logic programming languages (e.g., OBJ3 or Equation Interpreter Project)

---

Essential PROLOG programming

---

• PROLOG programs are built from terms; a term is either a constant, variable, or structure
• assert facts and rules
  • constants and predicates must start with a lower case letter
  • have no intrinsic semantics; they are whatever you want them to mean
• ask questions; variables must start with a CAPITAL LETTER or _
• simple rules; head and body of rule
• in PROLOG, all functions are predicates (i.e., return true or false; have to `fake' returns of other types by passing additional arguments)
• use period (.), not semicolon (;)
• two ways of consulting a database (i.e., compiling a PROLOG program):
  • use the consult predicate (i.e., consult('filename')., or
  • use [filename].)

  ?- consult('movies.pl').
  ?- [movies]. % abbreviated form of the above
      

• use make. to re-consult a file (in SWI-PROLOG)
• use n or ; character to get next solution
• comments
  • % introduces a comment until the end of a line
  • C style comments /* ... */ are also permitted, but unlike in C, in PROLOG these comments can be nested
• halt. or EOF character (e.g., ctrl-D on UNIX, ends session with PROLOG)
• use predicate protocol/1 to log your session with PROLOG (e.g., protocol('diary').)
• backtracking
• tracing and trace/0: allows user to trace the resolutions process, including instantiations, as PROLOG tries to satisfy a goal
• outputting text
  • write
  • writeln
  • nl (newline)
• call/1 is the PROLOG analog of eval in Scheme
• add the following goal

  set_prolog_flag(toplevel_print_options,[quoted(true), portray(true),
  max_depth(0)]).
  

  to a program to prevent PROLOG from abbreviating results with ellipses. Here the value of max depth indicates how deep into the list it will print. By default it is 10; if it is set to 0, then the printing depth limit is turned off.
  
  
• Kowalski's classic formulation of PROLOG strategy: algorithm = logic + control
• contrast with Wirth's formulation of imperative programming: programs = algorithms + data structures

---

Unification examples

---

(ref. [PLPP])

me = me.

me = you.

me = X.

f(a,X) = g(Y,b).

f(a,X) = f(Y,b).

f(X) = g(X).

gcd(U,0,U).
gcd(U,V,W) :- V \=0, R is U mod V, gcd(V,R,W).

---

Lists in PROLOG

---

• uses brackets (like ML and Haskell, but not LISP) to specify lists
• list construction/decomposition in PROLOG vs. Haskell

  -----------------------
  PROLOG          Haskell
  -----------------------
  [X|Y]           X:Y
  .(X,Y)          X:Y
  [X,Y]           X:Y:nil
  [X]             X:nil
  [X,Y|Z]         X:Y:Z
  [X,Y,Z|W]       X:Y:Z:W
  -----------------------
  

• the following expressions are nonsense

  X|Y             
  [X|Y,Z]         
  [X|Y|Z]     
  

---

Simple PROLOG database

---

animal(cow).
animal(dog).
animal(ramsay).
animal(rogerrabbit).
animal(yak).
animal('Emu').

likes(larry,lucy).
likes(lucy,apples).
likes(larry,larry).

cpscourse(cps343).
cpscourse(cps543).
cpscourse(cps430).
wtcourse(wt150).
wtcourse(wt151).
challenging(_x) :- cpscourse(_x).
easy(X) :- wtcourse(X).
easy(cps343).

ihave([pencil,pen,watch]).
ihave([cps343,cps430,cps444,cps350]).
ihave([itall]).
ihave([[toyota,2006,corolla],[2008,honda,civic]]).
ihave([book,[pen1, pen2],[newdollabill]]).
ihave(itall).

---

Simple session with PROLOG

---

?- consult(first).
% animal compiled 0.00 sec, 936 bytes

Yes
?- animal(X).

X = cow 

Yes
?-  animal(X).

X = cow ;

X = dog ;

X = ramsay ;

X = rogerrabbit ;

X = yak ;

X = emu ;

No
?- animal(WhatIwant).

WhatIwant = cow ;

WhatIwant = dog ;

WhatIwant = ramsay ;

WhatIwant = rogerrabbit ;

WhatIwant = yak ;

WhatIwant = emu ;

No
?- animal(whatiwant).

No
?- animal(whatIwant).

No
?- animal(X), animal(Y).

X = cow
Y = cow ;

X = cow
Y = dog ;

X = cow
Y = ramsay ;

X = cow
Y = rogerrabbit ;

X = cow
Y = yak ;

X = cow
Y = emu ;

X = dog
Y = cow ;

X = dog
Y = dog ;

X = dog
Y = ramsay ;

X = dog
Y = rogerrabbit ;

X = dog
Y = yak ;

X = dog
Y = emu ;

X = ramsay 
Y = cow ;

X = ramsay
Y = dog ;

X = ramsay
Y = ramsay ;

X = ramsay 
Y = rogerrabbit ;

X = ramsay
Y = yak ;

X = ramsay
Y = emu ;

X = rogerrabbit
Y = cow ;

X = rogerrabbit
Y = dog ;

X = rogerrabbit
Y = ramsay ;

X = rogerrabbit
Y = rogerrabbit ;

X = rogerrabbit
Y = yak ;

X = rogerrabbit
Y = emu ;

X = yak
Y = cow ;

X = yak
Y = dog ;

X = yak
Y = ramsay ;

X = yak
Y = rogerrabbit ;

X = yak
Y = yak ;

X = yak
Y = emu ;

X = emu
Y = cow ;

X = emu
Y = dog ;

X = emu
Y = ramsay ;

X = emu
Y = rogerrabbit ;

X = emu
Y = yak ;

X = emu
Y = emu ;

No
?- animal(X), animal(Y), X\=Y.

X = cow
Y = dog ;

X = cow
Y = rabbit ;

X = cow
Y = rogerrabbit 

?- likes(larry,X), likes(X,apples).

X = lucy ;

?- cpscourse(X).

X = cps534 ;

X = cps430 ;

X = cps343 ;

No
?- easy(X).

X = cps343 ;

X = wt150 ;

X = wt151 ;

No

?- ihave(X).

X = [pencil,pen,watch] ;

X = [cps343,cps430,cps444,cps350] ;

X = [itall] ;

X = [[toyota,1998,corolla],[1997,honda,civic]] ;

X = [book,[pen1,pen2],[newdollabill]] ;

X = itall ;

No
?- ihave([X|Y]).

X = pencil
Y = [pen,watch] ;

X = cps343
Y = [cps430,cps444,cps350] ;

X = itall
Y = [] ;

X = [toyota,1998,corolla]
Y = [[1997,honda,civic]] ;

X = book
Y = [[pen1,pen2],[newdollabill]] ;

No
?- ihave([X,Y|Z]).

X = pencil
Y = pen
Z = [watch] ;

X = cps343
Y = cps430
Z = [cps444,cps350] ;

X = [toyota,1998,corolla]
Y = [1997,honda,civic]
Z = [] ;

X = book
Y = [pen1,pen2]
Z = [[newdollabill]] ;

No
?- ihave([X,Y]).

X = [toyota,1998,corolla]
Y = [1997,honda,civic] ;

No
?- ihave([X]).

X = itall ;

No
?- ihave([X,Y,Z]).

X = pencil
Y = pen
Z = watch ;

X = book
Y = [pen1,pen2]
Z = [newdollabill] ;

No
?- halt.

---

Simple control

---

• ancestor
  • order of clauses matter
  • left recursion is bad, since PROLOG uses DFS!
• mutual recursion is bad: doesn't cause stack overflow, but infinite loop nevertheless
• backtracking to find alternate solutions

% ref. [PLPP] pp. 558-559
ancestor(X,Y) :- parent(X,Z), ancestor(Z,Y).  % clause 1
ancestor(X,X).                                % clause 2
parent(amy,bob).

analyze search tree:



(ref. [PLPP] Fig. 12.2, p. 559)

/* in ancestor(X,Y), Y is meant to be the ancestor of X */

/* order of predicate definitions matters
   beware of left recursion, as written below
   because PROLOG uses depth-first search
 */
parent(sallie,amy).
parent(amy,marc).

ancestor(X,Y) :- parent(X,Y).
/*
ancestor(X,Y) :- ancestor(X,Z), parent(Z,Y).
 */
/* left recursion is bad */
/* why doesn't left recursion cause a
   problem in reverse?
 */

ancestor(X,Y) :- parent(Z,Y), ancestor(X,Z).
/* the fix
*/

/* have not exhausted stack,
   rather an infinite transfer of control
 */
niceday(X) :- classletsoffearly(X).
classletsoffearly(X) :- niceday(X).

---

List codes written in class

---

isempty([]).

islist([]).
/* only one of the following is required, the first is preferred */
islist([_|_]).
islist([_|T]) :- islist(T).

/* only one of the following is required, the first is preferred */
cons(H,T,[H,T]).
cons(H,T,L) :- L = [H|T].

/* member is built-in */
member(E,[E|_]).
member(E,[_|T]) :- member(E,T).

---

Using append as a primitive to construct some simple list predicates

---

/* predicate to append two lists; */
/* first two are the inputs, last is the appended list */

/* this predicate has a minor bug; */
/* it does not prune duplicates (see below) */
/* fix it */
append([],L,L).
append(L,[],L).
append([H|T],Y,[H|W]) :- append(T,Y,W).

/* predicate to check if X is a member of list List */
member(E,L) :- append(_,[E|_],L).



/* predicate to check if X is a sublist of Y */
sublist(X,Y) :- append(_,X,W), append(W,_,Y).

/* predicate to triple a list
   given [3] produce [3,3,3] as answer
   L when tripled gives list LLL */
triple(L,LLL) :- append(L,L,LL), append(LL,L,LLL).

/* predicate to reverse a list
   give X as input, Y is the reversed X */
reverse([],[]).
/* why isn't left recursion a problem here? */
reverse([H|T],RL) :- reverse(T,RT), append(RT,[H],RL).

/* predicate to do bubblesort
   X when bubblesorted gives Y */
bubblesort(L,SL) :- append(M,[A,B|N],L),
                    A > B,
                    append(M,[B,A|N],S),
                    %bubblesort(S,SL).
                    bubblesort(S,SL), !.
bubblesort(L,L).
/* fix this code yourself, so as to
   not give more answers after the correct one */

---

Paths

---

/* edge(X,Y) means there is a directed edge from X to Y */

edge(a,b).
edge(b,c).
edge(c,a).

/* path(X,Y) is true when there is a
directed path from X to Y */

/* have a third argument that keeps a running tally of nodes visited so far */

path(X,X,_).
path(X,Y,T)  :- edge(X,Z),
                notamember(Z,T),
                append([Z,T,T2),
                path(Z,Y,T2).
/* we can go from X to Y through Z only
if Z was not already visited in T */

notamember(E,[]).
notamember(E,[H|T]) :- E \= H, notamember(E,T).

---

Analogs to relational databases

(primarily for CPS 430/542)

% relation, called predicate in PROLOG
movies1(roger_rabbit,1990,123,paramount).
movies1(get_shorty,1966,122,fox).

movies2(get_shorty,1966,122,fox).

% union
moviesU(X,Y,Z,W) :- movies1(X,Y,Z,W).
moviesU(X,Y,Z,W) :- movies2(X,Y,Z,W).

% intersection
moviesI(X,Y,Z,W) :- movies1(X,Y,Z,W), movies2(X,Y,Z,W).

% difference
moviesD(X,Y,Z,W) :- movies1(X,Y,Z,W), not(movies2(X,Y,Z,W)).

% projection
title(T) :- movies1(T,_,_,_).

% selection
new_movies(T,Y,L,fox) :- movies1(T,Y,L,fox), L >= 121.

% selection followed by a projection
new_movies2(T) :- movies1(T,_,L,fox), L >= 121.

% or
new_movies2(T) :- movies1(T,_,L,S), S = 'fox', L >= 121.

% theta-join
fox_stars(T,Y,L,fox,N) :- movies(T,Y,L,fox), actors(N,T,fox).

% natural join
movies_aug(T,Y,L,S,N) :- movies(T,Y,L,S), stars(N,T,S).