Introduction to Prolog

1
Introduction to Prolog

• What if all we could do was to make assertions
  (statements) about the world?
• Example family tree
• parent(linda, simon). male(simon).
• parent(linda, sharon). female(sharon).
• parent(sam, simon). male(sam).
• parent(sam, sharon). female(linda).
• parent(bertha, sam).
• female(bertha).
• parent(alfred, linda). male(alfred).

2
We also want to ask questions about
facts -bash-4.0 gprolog ?-
consult(levytree). open levytree.P ?-
female(sharon). Is Sharon female? yes ?-
parent(Who, simon). variables in
upper-case! Who linda Anyone else? Who
sam Anyone else? no ?- halt. -bash-4.0
3
Finally, we need rules to relate
facts mother(M,C) - parent(M,C),
female(M). sister(S,X) - parent(P,S),
parent(P,X), female(S). ?-
sister(Who, simon). Who sharon Who
sharon Why twice? no ?-
4

• This paradigm (approach) is called logic
  programming or logic-oriented programming.
• Obviously useful for databases!
• But also Turing-equivalent e.g.
• fac(0, 1).
• fac(N, F) -
• N gt 0,
• N1 is N-1, like let N1 N-1
• fac(N1, F1),
• F is N F1.

5
Prolog Under the Hood

• Prolog non-determinism (guessing) with
  backtracking
• (back up to where you made the wrong guess)
• Recall family-tree example
• parent(linda, simon).
• parent(sam, simon).
• male(sam).
• father(F, C) - parent(F, C), male(F).
• Consider the query
• ?- father(Who, simon).

6
1) father(Who, simon) expands to the goals
parent(Who, simon) and male(Who). 2)
parent(Who, simon) is satisfied by
parent(linda, simon), with Who bound to linda. 3)
So male(Who) becomes male(linda), the next
goal. 4) But the database doesn't contain this
fact, so we assume it's false negation by
failure (closed-world hypothesis).
7
5) So we unbind Who from linda, and back-track
to the rule immediately after parent(linda,simon).
6) This rule is parent(sam, simon), so we
continue with Who bound to sam. 7) So male(Who)
becomes male(sam), the next goal. 8) This goal is
eventually satisfied, completing the proof of
father(Who, simon), with Who bound to sam. Recall
unification algorithm for type inference (Chapter
4)
8
Unification check-equal-type!(t1,t2)

• If t1 and t2 are same Scheme value (e.g., 7),
  succeed with unspecified return value.
• If t1 (t2) is a type var, check that it is the
  same variable type as t2 (t1) (and bind to
  constant if possible)
• If t1 and t2 are atomic types (bool, int),
  suceed if they have the same name else fail.
• If t1 and t2 are procedure types, check of
  args equal and recur on args.
• Otherwise, fail.

9
Unification Prolog

• If t1 and t2 are same value (e.g., linda ),
  succeed.
• If t1 (t2) is a variable, bind it to the value
  of t2 (t1) .
• If t1 and t2 are predicates , check of args
  equal and recur on predicates and args.
• Otherwise, fail.

?- f(A,B) f(3,4). A 3 B 4 yes