8  Introduction to Logic Programming

What's in This Set of Notes ?

• Introduction
• Predicate Calculus
• Overview of Logic Programming
• Prolog's Basic Constructs
• Abstract Interpreter for Logic Programs

• Approach: express programs in a form of symbolic logic and use a logical inferencing process to produce results
• Logic programs are declarative rather than procedural
• This means that only the specification of the desired results are stated rather detailed procedures for producing them
• Programming that uses a form of symbolic logic as a programming languages is called logic programming
• Languages based on symbolic logic are called logic programming languages or declarative languages.

• Basis for logic programming is formal logic
• Proposition
• a logical statement that may or may not be true
• consists of object and the relationship of objects to each other
• formal logic develop to provide a method for describing propositions, with goal of allowing those propositions to be checked for validity
• Symbolic logic
• used for three basic needs of formal logic:
1. to express propositions
2. to express the relationships between propositions
3. to describe how new propositions can be inferred from others that are assumed to be true
• Particular form of symbolic logic that is used for logic programming is called Predicate Calculus

 

---

Propositions

• Objects in logic programming are represented by simple terms, which are either constant or variables
• Compound Term
• one element of a mathematical relation, written in a form that has the appearance of mathematical function notation
• two parts:
1. functor: names the relation
2. ordered list of parameters
• compound term with single parameter is 1-tuple, e.g. man(jake)
• compound terms with two parameters is 2-tuple, e.g., like(bob, steak)
• Atomic Propositions are simplest propositions and consist of compound terms
like(bob, steak)
like(dog, cat)
• Compound Propositions have two or more atomic propositions connected by logical connectors and quantifiers

 

Name	Symbol	Example	Meaning
negation	¬	¬ a	not a
conjunction	∩	a ∩ b	a and b
disjunction	∪	a ∪ b	a or b
equivalence	≡	a ≡ b	a is equivalent to b
implication	⊃	a ⊃ b	a implies b
	⊂	a ⊂ b	b implies a
universal quantifier	∀	∀ X P	For all X, P is true
existential quantifier	∃	∃ X P	There exists a value of X such that P is true

• ¬ has the highest precedence of operators, ∩,∪, ≡ are at the next level, with ⊃ and ⊂ last
• Examples:

∀ X (woman(X) ⊃ human(X))  For any value of X, if X is a woman, than X is human
∃ X (mother(mary, X) ∩ male(X)) There exists a value of X such that mary is the mother of X and X is male

---

Clausal Form

• Problem, too many different ways of stating propositions that have same meaning
• In order to automated propositions on computerized system we must simplify.
• Need standard form of propositions
• Without loss of generality, all propositions can be expressed in clausal form:

 B1 ∪B2 ∪ B3 ∪.... ∪ Bn ⊂ A1 ∩ A2 ∩  ... ∩ Am

• In which As and Bs are terms.
• The meaning is, If all As are true, than at least one B is true.
• Benefits: no quantifiers, and no other operators other than conjunction and disjunction
• Right side of clausal form is called antecedent
• Left side is called consequent

likes(bob, trout) ⊂ likes(bob, fish) ∩ fish(trout)  If bobs likes fish and a trout is a fish, bob likes trout

---

Proving Theorems

• Resolution is an inference rules that allows inferred propositions to be computed from others.
• Resolution developed for propositions in clausal form

T ⊂ P
Q ⊂ T

• Infer

Q ⊂ P

• Example

older(joanne, jake) ⊂ mother (joanne, jake)
wiser(joanne, jake) ⊂ older (joanne, jake)

• using resolution, infer that

wiser(joanne, jake) ⊂ mother (joanne, jake)

• Resolution is actually more complex, especially when variables are present in propositions
• The process of determining useful values for variables is called unification
• The temporary assigning of values to variables to allow unification is called instantiation
• Resolution places a further restriction on the type of clausal form that can be used
• Only horn clauses are permitted
1. Single proposition on left side, e.g., likes(bob, trout) ⊂ likes(bob, fish) ∩ fish(trout)
2. No proposition on left size, e.g. father(bob, jake)

• Logic programs consist of declarations rather than assignment and control flow statements
• One of essential characteristics of logic programming languages are their semantics, called declarative semantics
• there is a simple way to determine the meaning of each statement and it does not depend on how the statement might be used to solve a problem
• meaning of given proposition can be concisely determined from the statement itself
• in functional or imperative languages, even simple assignment involves examination of local declarations, scoping rules and other runtime information
• Programming in logic programming languages is non-procedural
• we don't care how result is computed, rather we just describe the form of the result
• assume computer system can somehow determine how to get the result.
• A logic program is a set of axioms or rules defining relationships between objects
• A computation of a logic program is a deduction of consequences of the program
• A program defines a set of consequences, which is its meaning
• The art of logic programming is constructing concise and elegant programs that have the desired meanings.
• Algorithm = Logic + Control
Logic = facts and rules
Control = how to apply the rules
• Use logic programming when you application involves pattern matching combined with backtracking search on incomplete information
• Deals with relations not function
• Premise: relations are more flexible than functions because relations treat arguments and results uniformly
• Driven by queries about relations
• Prolog developed in mid-70

Relations

• Concrete view is a table,  n>= 0 columns, and possible an infinite set of rows
• Tuple (A1, A2, ... An) is in relation if Ai appears in appears in column i, 1 <= i <= n of some row

• Relations are also called predicates because the relation name can be thought of as a test of the form: is a given tuple in the relation
• For example, append([a], [b]. [a,b]) id in relation, but append([a], [b], []) is not
• Relations are specified as rules and facts, which are both in the horn clause form
• Rule: P if Q1 and Q2 and ... Qk
• Fact: P, which is just special rule with no conditions

---

Queries

• Logic programming driven by queries about relations
• Simple Query: is tuple member of relation

append([a], [b], [a,b])?

will either generate yes or fail with no answer - not the same as no

• Variable Query

append([a], [b], X )?

will answer yes with X = [a,b]

Note that you can also try this query

append(X, [b], [a,b])?

will answer yes with x = [a]

Term

• Constant: particular individuals such as integers and atoms
• Variable: single but unspecified individual, (UPPERCASE LETTER(S)); e.g. MyVariableName
• Compound Term: functor (relation name) plus a sequence of one or more terms called arguments
• Examples:

 
f(t1, t2, ..., tn )
f(g(X), X, Y, 1)

---

Facts

• simplest construct

likes(john, mary).
 

the name of the relation, likes, is the predicate

john and mary are atoms

• Other facts:
 
female(jane)
add(1, 1, 2)


• The following items are important when writing facts:
1. relation and object names must begin with a lowercase letter
2. the relation must be written first
3. objects are separated by commas
4. objects are enclosed in pair of round brackets
5. period must be at end of fact

 
• Universal Facts
• uses variables
• says it all


likes (dwight, X).  i.e. dwight likes everyone
times(0, X, 0).    i.e. 0 times anything is 0
 

• Collection of facts and rules called a database
• To add fact to Prolog environment use assert predicate

assert(likes(dwight,sue)).
 

• To remove a fact from a Prolog environment use retract predicate

retract(likes(dwight,sue)).
 

• To add facts from file to Prolog

 

consult('c:/database-of-facts.pl').

---

Rules

• A rules is a general statement about objects and their relationships
• Horn Clause Form    A :- B1, B2, ...., Bn, e.g., A is true if B1 and B2 and ... Bn are all true
• Rule has head and a body, connected by :-
• Head describes what fact the rule is intended to define
• Body describes the conjunction of goals that must be satisfied, one after another, for the head to be true.
• Examples:

son(X,Y) :- father(Y,X), male(X).

daughter(X,Y) :- father(Y,X), female(X).

grandfather(X,Z) :- father(X,Y), father(Y,Z).
 

Note, these rules require other facts, or rules that be used to infer them.

You can assert rules too. assert((son(X, Y) :- father(Y, X), male(X))).

To add rules from file to Prolog (don't forget those periods)

consult('c:/database-of-rules.pl').

---

Queries (Questions)

?- likes(dwight, sue).

• with period at end, would have a fact
• ?- at start indicates a query
• A fact P. states the goal P is true
• A query ?- P asks whether the goal P is true.

Variable Query

• When Prolog is asked a question containing a variable, it searches through all facts and rules to find an object that the variable could stand for

?- likes(dwight, X).  i.e., who does dwight like?

• Prolog will give you one answer for X
• If you hit return it will stop looking for more answers.
• If you type ; return, it will look for another answer.
• Prolog marks the database where it finds answers in order to start looking again.

An operational procedure for answer queries

Performs yes/no computations

Input: A query Q and a program P

Output: yes if a proof of Q from P was found, no otherwise

Algorithm:

Initialize the resolvent to Q
While the resolvent A1, ..., An is not empty
Begin

choose a goal Ai, 1 <= i <= n,
search for instance of a rule A ¬ B1, B2, ..., Bk, k>= 0 in P, or a fact A such that A=Ai
If no such clause exists

exit the while loop;

create the new resolvent A1,...,Ai-1, B1, ..., Bk, Ai+1,..., An

end
If the resolvent is empty, output yes; otherwise output no

---

Example

• Consider the following database:

male(jake).
male(ryan).

female(samantha).
female(sue).

father(bill, dwight).
father(dwight, ryan).
father(dwight, samantha).
father(dwight, sue).

son(X,Y) :- father(Y,X), male(X).   (i.e. X is Y's son)

daughter(X,Y) :- father(Y,X), female(X). (i.e. X is Y's daughter)

• Here is a trace of the interpreter for the query ?- son(ryan, dwight).

Input: ?- son(ryan,dwight) and the database

Resolvent is not empty

Choose son(ryan,dwight) the only choice
Search and Find son(ryan,dwight) :- father(dwight,ryan), male(ryan)
New resolvent is ?- father(dwight,ryan), male(ryan).

Resolvent is not empty

Choose father(dwight,ryan)
Search and Find father(dwight,ryan)
New resolvent is ?male(ryan).

Resolvent is not empty

Choose male(ryan).
Search and Find male(ryan).

New Resolvent is empty.

Output: yes