Logic Programming I

Programming Languages---Course 66.443

What Is Logic Programming?

Using inference mechanisms to obtain solutions to problem statements.
The ideal: we just write down the problem statement, without any indication of how it should be solved
- the inference mechanisms do all the work of finding the solution.
- not always possible, we sometimes (or often) have to supply procedural hints
Other names:
- declarative programming,
- non-procedural programming
Is functional programming also non-procedural?

The Essence of Logic Programming

Ingredients: objects and their relationships
Activities:
- declare some facts about objects and their relationships
- define some (logic) rules about objects and their relationships
- ask questions about objects and their relationships (whose answers can be deduced from the given facts and rules)
What (other CS discipline) does this remind you of? What's the main difference?

Prolog

A logic programming language first developed in Marseilles (France) in the early 1970's by Alain Colmerauer.
It has been used for many different applications, including
- relational data bases
- mathematical logic
- abstract problem solving
- understanding natural language
- design automation
- symbolic equation solving
- biochemical structure analysis
- many areas of artificial intelligence
This list is from W. F. Clocksin and C. S. Mellish, Programming in Prolog, 2nd Edition, 1984. Prolog is also used in certain areas of software development, including requirements specification, rapid prototyping, and software reengineering.

Key Inference Mechanisms of Prolog

Execution of Prolog programs is based primarily on two key mechanisms:
- unification
- backtracking
Before giving a general definition of these, let's look at some examples.

Queen Victoria's Family

Some facts, in file /public/proglang/queen.pro.

male(albert).
male(edward).
female(alice).
female(victoria).
parents(edward, victoria, albert).
parents(alice,victoria, albert).

Let's fire up prolog:

procyon.cs.rpi.edu% /sw1/prolog/bin/api

Aquarius Prolog version 1.0 top-level (SPARC, SunOS)

| ?- consult('~/public/proglang/queen.pro').

yes
| ?- female(alice).

yes
| ?- female(victoria).

yes
| ?- female(albert).

no
| ?- female(jane).

no

The last answer does not mean the statement is false, just that it cannot be inferred from the given facts.
We can ask for all possibilities, using a variable, X.
```
| ?- female(X).

X = alice ;

X = victoria ;

no
```
Variables can appear anywhere in a query. That is, argument positions in relations don't have to be regarded as inputs or outputs; they can be either at different times. For example we can ask who are the parents of Edward with:
```
| ?- parents(edward,X,Y).

X = victoria,
Y = albert ;

no
```
But we can also ask who is Victoria a parent of (and obtain the father at the same time):
```
| ?- parents(X,victoria,Y).

X = edward,
Y = albert ;

X = alice,
Y = albert ;

no
```

A Rule

The following rule defines the relation that X is a sister of Y.
```
sister_of(X,Y) :- female(X), parents(X,M,F), parents(Y,M,F).
```
That is, X is a sister of Y if X is female and X and Y have the same parents. In Prolog notation, :- means ``if'' and the subgoals on the right are required to be satisfied simultaneously (``anded'' together), with the same assignment to variables, in order for the goal on the left to be satisfied. After adding this rule to our file, we proceed as follows:
```
| ?- reconsult('~/public/proglang/queen.pro').

yes
| ?- sister_of(alice,edward).

yes
| ?- sister_of(alice,X).

X = edward ;

X = alice ;

no
```
Hmmm, this reports that Alice is her own sister. The rule needs another clause:
```
sister_of(X,Y) :- female(X), parents(X,M,F), parents(Y,M,F), X \== Y.
```

Now we try again.

| ?- reconsult('~/public/proglang/queen.pro').

yes
| ?- sister_of(alice,X).

X = edward ;

no

How Is The sister_of(alice, edward) Query Answered?

This example shows a simple case of unification.

| ?- sister_of(alice, edward).                      

sister_of(  X,   Y) :-

     female(X),  parents(X, M, F),  parents(Y, M, F),   X \== Y.



                              male(albert).


                              male(edward).


                              female(alice).


                              female(victoria).


                              parents(edward, victoria, albert).


                              parents(alice, victoria, albert).

How Is The sister_of(alice, X) Query Answered?

This example shows both unification and backtracking.

| ?- sister_of(alice, X).

sister_of(  X,   Y) :-

     female(X),  parents(X, M, F),  parents(Y, M, F),   X \== Y.



                              male(albert).


                              male(edward).


                              female(alice).


                              female(victoria).


                              parents(edward, victoria, albert).


                              parents(alice, victoria, albert).