Prolog -- Structural Organization and Control Structures

COMPUTING SCIENCE 370
Programming Languages

Prolog -- Structural Organization and Control Structures

Structural Organization

A Prolog program is constructed from a number of clauses, the general form of which is

There are three forms of clauses based on this general pattern:

facts (hypotheses, unit clauses) <head>.
E.g.,
```
  father( john, mary ).
```

rules (conditions, inferences) <head> :- <body>.
E.g.,

  sister( X, Y ) :-
      female( X ),
      parents( X, Ma, Pa ),
      parents( Y, Ma, Pa ).

questions (goals) ?- <body>.
E.g.,
```
  ?- sister( alice, victoria ).
```

Horn clauses: Prolog allows at most one atomic expression (predication) in the head of a clause, but any number in the body.
- Conjunction (^, and) is expressed by separating predications with ','.
- Disjunction (V, or) is expressed by multiple clauses.
- A goal is essentially a headless clause, but the symbol ?- is more suggestive of a question than a leading :- would be.
Interpreted environment -- A user enters clauses into the Prolog environment and they are interpreted.
- If asked for confirmation of a fact such as
```
  ?- sister( alice, victoria ).
```
  the system responds yes or no.
- Closed world assumption -- no means the goal could not be proved on the basis of the rules and facts provided.
- If a goal contains variable(s), the system responds with one possible set of bindings. The user enters ';' to prompt for another solution (set of bindings).

Control Structures

No user-defined control structures.
Unification -- The interpreter uses a depth-first search strategy with backtracking to find some mapping of variables to constants (instantiation or unifier) which matches the body of the goal with the heads of clauses, resolving the bodies of these clauses as sub-goals.
Clauses are checked using lexical pattern matching.
- An uninstantiated variable will match any object.
- An atom will match only itself.
- A structure will match another structure with the same functor and number of arguments (arity) if all corresponding arguments match.
E.g.,
```
  father( john, mary ).
  mother( sue, mary ).
  female( mary ).
  daughter( Child, Parent ) :-
      father( Parent, Child ),
      female( Child ).
  daughter( Child, Parent ) :-
      mother( Parent, Child ),
      female( Child ).
  ?- father( john, mary ).
  yes
  ?- mother( john, mary ).
  no
  ?- daughter( mary, john ).
  yes
```
The last goal unifies with the head of the fourth clause, establishing the bindings mary / Child and john / Parent, which in turn establishes the subgoals
```
  ?- father( john, mary ).
  ?- female( mary ).
```
which both succeed (due to clauses 1 and 3), so the main goal succeeds.
Backtracking
- If the two clauses with the predicate daughter in the head had been listed in the opposite order, the goal
```
  ?- daughter( mary, john ).
```
  would have been unified with the head of
```
  daughter( Child, Parent ) :-
      mother( Parent, Child ),
      female( Child ).
```
  Bindings: mary / Child and john / Parent
  Sub-goals:
```
  ?- mother( john, mary ).
  ?- female( mary ).
```
- The first sub-goal would fail to unify with the head of any clause, and would report failure.
- Since the unification
  failed, the interpreter would backtrack and attempt to unify the goal with the head of the next clause
```
  daughter( Child, Parent ) :-
      father( Parent, Child ),
      female( Child ).
```
  which, as we have seen, will succeed.
- In a pure logic language, the order of execution does not affect correctness, only efficiency. In Prolog, however, one must bear in mind the order in which Prolog searches a database.
  E.g.,
```
  person( X ) :-
      person( Y ),
      mother( X, Y ).
  person( adam ).
  ?- person( X ).
```
  results in infinite recursion.
- In order to backtrack, Prolog has to fail after trying the first possibility.

Alternate solutions -- Prolog interpreters may be asked to continue unifying the goal with the rest of the clauses after they succeed in proving a goal. The user prompts for additional solutions with ';' (or some other method, depending on the system).
E.g.,

  father( john, mary ).
  father( john, carol ).
  mother( sue, mary ).
  female( mary ).
  female( carol ).
  daughter( Child, Parent ) :-
      father( Parent, Child ),
      female( Child ).
  daughter( Child, Parent ) :-
      mother( Parent, Child ),
      female( Child ).
  ?- daughter( Who, john ).
  Who = mary;
  Who = carol;
  no

Parameters are modeless -- A given argument may be an in-parameter or an out-parameter.
E.g.,
```
  daughter( mary, Who ).
  Who = john;
  Who = sue;
  no
```
- A logic program may be run "forwards" or "backwards".
- We may pose a goal with no input parameters.
  E.g.,
```
  daughter( X, Y ).
  X = mary, Y = john;
  X = carol, Y = john;
  X = mary, Y = sue;
  no
```
- We may use an anonymous ("don't care") variable -- an underscore matches anything.
  E.g.,
```
  daughter( X, _ ).
```
  EXERCISE: What is the result?
A mechanism is provided to control backtracking: ! (cut) succeeds and cannot be resatisfied.
- A cut commits the system to all choices made since the parent goal was invoked; all other alternatives are discarded.
- Uses:
  1. To signal that the correct goal has been found (and there are no others).
    E.g.,
```
  sum_to( N, 1 ) :- N =< 1, !.
  sum_to( N, R ) :-
      N1 is N - 1,
      sum_to( N1, R1 ),
      R is R1 + N.
```
    - The cut causes this construct to behave like an if-then-else. It ensures that if N is 1 or less, the result 1 should be returned and no other rules should be tried. It is possible to write this set of clauses without a cut.
    - The is operator instantiates the variable on the left to the value of the arithmetic expression on the right (which is evaluated numerically). If the variable on the left is already instantiated, then is behaves like a comparison instead of like an assignment.
  2. To terminate the generation of alternative solutions.
    E.g., tic-tac-toe
```
  forced_move( Board, Square ) :- 
      aline( Squares ),
      threatening( Squares, Board, Sq ), !.
```
    - The first clause of the body generates a line of squares; the second tests of the opponent is threatening the line.
    - If the opponent is threatening to claim a line, only the first such forced move is needed, so the cut halts the generation of alternatives.
  3. With fail, to cause a goal to fail immediately without trying alternatives.
    E.g.,
```
  not( P ) :- call( P ), !, fail.
  not( P ).
```
    E.g.,
```
  nonsibling( X, Y ) :- sibling( X, Y ), !, fail.
  nonsibling( X, Y ).
```
    which is equivalent to
```
  nonsibling( X, Y ) :- not( sibling( X, Y )).
```
    The predicate not is predefined in early versions of Prolog. Newer versions use \+ (which is a typewriter analog for the "not provable" symbol of formal logic) to mean "not" or "cannot-prove" (negation as failure), typically retaining not as a synonym for backward compatibility.

Nonmonotonic logic

Predicate logic is monotonic -- deduction never causes true propositions to become false, or vice versa.
The real world is nonmonotonic due to temporal relationships -- statements are true or false at a particular time, but may change later.
E.g., now:
```
  alive( sam ).
```
later:
```
  dead( sam ).
```
E.g., furnace control -- now:
```
  temp( 21 ).
```
later:
```
  temp( 18 ).
```

Prolog provides functors to update the database.

`assert( C )`	Clause `C` is inserted at the end of the database.
`asserta( C )`	Same, but at the start of the database.
`assertz( C )`	Synonym for `assert`.
`retract( C )`	The first clause matching `C` is removed from the database.

To assert a rule, the entire rule must be enclosed in an extra set of parentheses.

Negation as unsatisfiability requires procedural rather than declarative understanding.
E.g., given father( john, mary ). and goal ?- father( john, X ), write( X )., the result is the writing of atom mary
but goal ?- not( not( father( john, X ))), write( X ). results in writing a representation of an uninstantiated variable.
Why?
1. father goal succeeds, instantiating X to mary.
2. Inner not goal fails because its argument succeeded, so all variables become uninstantiated.
3. Outer not succeeds, but X is still uninstantiated.
4. write succeeds, printing something like _v123.

Comparisons, equality, and unification

= uses term equality.
- Two atomic terms are equal iff. they are denoted by the same string.
- Two compound terms are equal if they have the same functor and the same number of arguments (arity), and corresponding arguments are equal.
  E.g.,
```
  ?- one = one.
  yes
  ?- one = two.
  no
  ?- same( this, that ) = same( this, that ).
  yes
```
- The process of evaluation will instantiate variables.
  E.g.,
```
  ?- one = Two.
  Two = one
  yes
  ?- same( this, That ) = same( This, that ).
  That = that
  This = this
  yes
```
- Matching two uninstantiated variables makes them share the same internal representation.
  E.g.,
```
  ?- same( One, thing ) = same( Two, thing ).
  One = _G129
  Two = _G129
  yes
```

X \= Y means "X cannot be made equal to Y" (not unifiable; equivalent to \+ X = Y).
E.g.,

  can_marry( X, Y ) :- 
     X \= Y,
     \+ sibling( X, Y ),
     \+ cousin( X, Y ).
  ?- can_marry( sammy, Someone ).
  no

Most versions of Prolog provide other equality operators to avoid some problems with = and \=.

== tests for literal equality without instantiating variables ("is already equal to", not "is unifiable").
E.g.,

  ?- one == Two.
  no

Two uninstantiated variables are == only if they are already sharing.
E.g.,

  ?- This == This.
  This = _G248
  yes
  ?- This == That.
  no
  ?- This = That, This == That.
  This = _G249
  That = _G249
  yes
  ?- same( X, Y ) == same( P, Q ).
  no

\== is more appropriate than \= for specifying that two objects must be different.

  can_marry( X, Y ) :- 
     X \== Y,
     \+ sibling( X, Y ),
     \+ cousin( X, Y ).
  ?- can_marry( sammy, Someone ).
  Someone = susie;
  Someone = sally;
  no

=:= tests for equality of arithmetic values. It will not instantiate variables, and fails if either expression contains an uninstantiated variable.
E.g.,
```
  ?- X+2 =:= X+2.
  ERROR: Arguments are not sufficiently instantiated.
  ?- A = 5, A =:= a.
  ERROR: Arithmetic 'a' is not a function.
```

is forces arithmetic evaluation.
E.g.,

  check( Sum ) :- Sum is 3 + 4.
  ?- check( 7 ).
  yes
  ?- check( What ).
  What = 7

The last example illustrates that is will instantiate an uninstantiated variable on the left side unlike =.
E.g.,

  test( Sum ) :- Sum = (3 + 4).
  ?- test( 7 ).
  no

is requires that there be no uninstantiated variable in the expression to its right, so rules using it are limited in the roles of input or output parameters.
E.g.,

  factorial( 0, 1 ).
  factorial( N, Value ) :-
     N > 0,
     Prev is N - 1,
     factorial( Prev, Prevfact ),
     Value is Prevfact * N.
  ?- factorial( 3, Value ).
  Value = 6
  ?-factorial( N, 6 ).
  ERROR: Arguments are not sufficiently instantiated.

COMPUTING SCIENCE 370 Programming Languages