1. Logic Programming & Prolog
A Brief Introduction to Predicate Calculus
Predicate Calculus and Proving Theorems
An Overview of Logic Programming
The Origins of Prolog
The Basic Elements of Prolog
Sebesta Ch. 16

2. Introduction
Logic programming languages and declarative programming languages
Express programs in a form of symbolic logic
Use a logical inferencing process to produce results
Declarative rather that procedural:
only specification of results are stated
not detailed procedures for producing them

3. Introduction to Predicate Calculus
Proposition
A logical statement
May be true or false
Consists of objects and relationships of objects to each other
Examples:
John is a student :
student(john)
Hillary is Bill's wife:
wife(hillary,bill)

4. Introduction to Predicate Calculus
Symbolic logic is a subset of formal logic
expresses propositions
expresses relationships between propositions
describes how new propositions can be inferred from other propositions
Predicate calculus
Form of symbolic logic used for logic programming
Prolog
PL based on predicate calculus

5. Propositions Objects in propositions Constant Variable
either constants or variables
Constant
A symbol that represents an object
In Prolog, starts with a lower case letter
Variable
A symbol that can represent different objects at different times
Instantiated with values during the reasoning process
Different from variables in imperative PLs
In Prolog, starts with an upper case letter or _

6. Atomic Propositions Atomic proposition Compound term
Consist of compound terms
Compound term
An element of a mathematical relation
Written like a mathematical function, e.g., f(x,y)
Can be written as a table
Mathematical function is a mapping
Compound term composed of two parts
Functor
Function symbol that names the relationship
Tuple
Ordered list of parameters

7. Propositions in Prolog
Prolog Examples
Functors:
and, or, not, student, like
Propositions
student(john)
like(mary,mac)
like(nick,windows)
like(kris,linux)

8. Forms of Propositions Propositions can be stated in two forms; as
Fact
proposition that is assumed to be true
Query
whether a proposition is true
Compound proposition
Consists of two or more propositions
Connected by logical operators
and, or, not, etc.

9. Logical Operators 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 ⊂ b
a implies b
b implies a

10. Truth Tables a b
¬ a
a ∩ b
a ∪ b
a ⊃ b
a ⊂ b
a ≡ b T F

11. Quantifiers Examples ∀bird, wings(bird) all birds have wings
Name
Example
Meaning
universal
∀X.P
For all X, P is true
existential
∃X.P
There exists a value of X such that P is true
Examples
∀bird, wings(bird)
all birds have wings
∃bird, blue(wings, bird)
at least one bird has blue wings

12. Clausal Form Too many ways to state the same preposition Clausal form:
Use a standard form
Clausal form:
B1 ∪ B2 ∪…∪ Bn ⊂ A1 ∩ A2 ∩…∩ Am
means if all the As are true, then at least one B is true
Antecedent
right side
I.e., A1 ∩ A2 ∩…∩ Am
Consequent
left side
I.e., B1 ∪ B2 ∪…∪ Bn

13. Predicate Calculus and Theorem Proving
The use of propositions is to discover new theorems
infer them from known axioms and theorems
Resolution
an inference principle
computes inferred propositions from given ones
Example Propositions:
older(joanne, jake)
mother(joanne, jake)
Rule:
older(joanne, jake) ⊂ mother(joanne, jake)
Joanne is older than Jake IF Joanne is the mother of Jake

14. Reasoning with Propositions – Example
Rule: older(joanne, jake) ⊂ mother(joanne, jake)
Joanne is Jake’s mom therefore Joanne is older than Jake
a FACT with constants
Rule: wiser(joanne, jake) ⊂ older(joanne, jake)
Joanne is older than Jake, therefore Joanne is wiser than Jake
To proceed, combine rules using “and” of left side terms, and “and” of right side terms (looks like addition)
A ⊂ B
C ⊂ D
A ∩ C ⊂ B ∩ D
older(joanne, jake) ∩ wiser(joanne, jake)
⊂ mother(joanne, jake) ∩ older(joanne, jake)
Remove the same propositions on both sides
will have no effect on T/F
Result: wiser(joanne, jake) ⊂ mother(joanne, jake)

15. Proof by Contradiction
Hypotheses
A set of pertinent propositions
Goal
Negation of theorem stated as a proposition
Combine
negated unknown goal proposition
with known true propositions
When an inconsistency results
this proves that the unknown propositions are not true
if they were true, inconsistency would not be possible

16. Horn Clauses Theorem broving is basis for logic programming
When propositions used for resolution, only restricted form can be used
Horn clauses - have only two forms
Headed clause
single atomic proposition on left side
propositions on the right connected with “and”
Headless clause
empty left side
used to state facts
Most propositions can be stated as Horn clauses

17. Unification: Resolution with Variables
Instantiation
Assigning temporary values to variables in propositions
Unification
Finding such values for variables so that matching/instantiation to succeeds
When
a variable is instantiated with a value, and then
matching fails
Then
unification needs to backtrack
the variable is instantiated with a different value

18. Semantics of Logic Programming
Declarative semantics
Determining the meaning of each statement is simple
Simpler than the semantics of imperative languages
Programming is nonprocedural
Programs do not state how to compute the result, but what the conditions the result needs to satisfy
Facts and variables
Are bound temporarily
They can't be re-bound unless they are unbound first
Binding and unbinding proceeds automatically

19. Example with Variables
older(A, B) ⊂ mother(A, B) ; mother is older
wiser(C, D) ⊂ older(C, D) ; older is wiser
mother(joanne, jake) ; Joanne is Jake’s mom
A/joanne B/jake instantiation A/joanne B/jake
(1 & 3) older(joanne, jake) ⊂ mother(joanne,jake)
C/joanne D/jake instantiation C/joanne D/jake
(1 & 2) wiser(joanne, jake) ⊂ older(joanne, jake)

20. Example: Sorting a List
Describe the characteristics of a sorted list, not the process of rearranging a list
sort(old_list, new_list) ⊂ permute (old_list, new_list) ∩ sorted (new_list)
sorted (list) ⊂ ∀j such that 1≤j<n, list(j)≤list(j+1)

21. The Origins of Prolog Alain Colmerauer, Philippe Roussel
University of Aix- Marseille, France
Natural language processing
Robert Kowalski
University of Edinburgh, Scotland, U.K.
Automated theorem proving

22. Basic Elements of Prolog
Edinburgh Syntax (most common)
Atom
symbolic value in Prolog
Atom consists of either
a string of letters, digits, and underscores beginning with a lowercase letter {a,b,….z}, e.g., lucky
a string of printable ASCII characters delimited by
apostrophes ',e.g. ,'this is a string'
Constant
an atom or an integer
Variable
a string of letters, digits, and underscores beginning with an uppercase letter, e.g., Lucky

23. Basic Elements of Prolog (cont.)
Term
A constant, variable, or structure
cat(lucky), Cat, sibling(S1,S2)
Structure
Represents atomic proposition
functor(parameter list)
Instantiation
Binding of a variable to a value
Only as long as it takes to satisfy one complete goal

24. Statement of Facts Headless Horn clauses
student(jonathan).
sophomore(ben).
brother(tyler, cj).
Used for true statements, i.e. facts

25. Rule Statements Used for the hypotheses Headed Horn clauses Right side
antecedent (if part)
May be single term or conjunction
Left side
consequent (then part)
Must be single term
Conjunction:
multiple terms separated by implied logical "and"

26. Rule Statements
parent(kim,kathy):- mother(kim,kathy).
Variables (universal objects) are used to generalize meaning
parent(X,Y):- mother(X,Y).
sibling(X,Y):- mother(M,X),
mother(M,Y),
father(F,X),
father(F,Y).

27. Goal Statements Goal statement Headless Horn clause form
Proposition/ theorem we want to prove or disprove
Headless Horn clause form
student(james).
Propositions with variables are legal goals
father(X,joe).
Conjunctive propositions are also legal goals
cat(lucky) ∩ horse(mr_ed).

28. Inferencing Process Query is a Goal
If a goal is a compound proposition, each of the sub-propositions is a sub-goal
To prove a goal is true, must find a chain of inference rules and/or facts. For goal Q:
B :- A
C :- B …
Q :- P
Process of proving a sub-goal is called matching, satisfying, or resolution

29. Inferencing Process Bottom-up resolution, forward chaining
Begin with facts and rules of database and attempt to find sequence that leads to goal
Works well with a large set of possibly correct answers
Top-down resolution, backward chaining
Begin with goal and attempt to find sequence that leads to set of facts in database
Works well with a small set of possibly correct answers
Prolog implementations use backward chaining

30. Top-Down Example (Rule) #1 animal(A) -: cat(A). (Fact) #2 cat(lucky).
Top-down resolution, backward chaining
Is lucky an animal?
Goal: animal(lucky). ???
Find rule to unify with Goal. Rule #1contains animal(A)
# animal(A) -: cat(A).
Unify lucky from Goal with variable A in rule #1, yields:
#1(lucky) animal(lucky) -: cat(lucky).
Fact: Lucky is a cat
# cat(lucky).
Combine #1lucky and #2 (add then remove anything on both sides)
animal(lucky) and cat(lucky) -: cat(lucky).
Proven.
GOAL: animal(lucky).
True if True!

31. Bottom Up Example (Rule) #1 animal(A) -: cat(A). (Fact) #2 cat(lucky).
Top-down resolution, forward chaining
Given: lucky is a cat
#2 cat(lucky)
Given: If A is a cat, A is an animal
# animal(A) -: cat(A).
Unify lucky from #2 with variable A in rule #1, yields:
#1(lucky) animal(lucky) -: cat(lucky).
# cat(lucky).
# animal(lucky) -: True.
Proven: lucky is an animal
GOAL: animal(lucky).

32. Inferencing Process Examples
(Rule) #1 animal(A) -: cat(A).
(Fact) #2 cat(lucky).
Negation by failure
Assume the opposite of what you want to prove
#3 ¬animal(lucky)
To unify with query, Negate Rule
#1 ¬cat(A) -: ¬ animal(A)
unify lucky #3 / A in #1 gives
#4 ¬cat(lucky)
Unify lucky in #4/ lucky in #2
#5 ¬cat(lucky) ∩ cat(lucky)
Contradiction in #5 due to #3
Proves Goal: animal(lucky)

33. Inferencing Process
When goal has more than one sub-goal can use either
Depth-first search
Find a complete proof for the 1st sub-goal then work on others
Breadth-first search
Work on all sub-goals in parallel
Prolog uses depth-first search
Can be done with fewer computer resources

34. Inferencing Process (cont.)
For a goal with multiple sub-goals,
if fails to show truth of one of sub-goals,
then reconsider previous sub-goal(s) to find an alternative solution
backtracking
Begin search where previous search left off
Can take lots of time and space
May find all possible proofs to every sub-goal

35. Simple Arithmetic
Prolog supports integer variables and integer arithmetic
is operator
takes an arithmetic expression as right operand and variable as left operand
A is B / 10 + C
Not the same as an assignment statement!
A temporary binding while processing continues
There can’t be any unbound variables on the right hand side!

36. Example
speed(ford,100). speed(chevy,105). speed(dodge,95). speed(volvo,80). time(ford,20). time(chevy,21). time(dodge,24). time(volvo,24). distance(X,Y) :- speed(X,Speed), time(X,Time), Y is Speed * Time. ?-distance(chevy,D). D = 2205

37. Trace Built-in structure that displays instantiations at each step
Tracing model of execution - four events:
Call
beginning of attempt to satisfy goal
Exit
when a goal has been satisfied
Redo
when backtrack occurs
Fail
when goal fails

38. Example Call Fail likes (jake, X) Exit Redo Call Fail
likes (jake, chocolate).
likes (jake, apricots).
likes (darcie, licorice).
likes (darcie, apricots).
Control flow model for the goal
?-trace.
?-likes(jake,X),likes(darcie,X).
(1) 1 Call: likes(jake,_0)?
(1) 1 Exit: likes(jake,chocolate)
(2) 1 Call: likes(darcie,chocolate)?
(2) 1 Fail: likes(darcie,chocolate)
(1) 1 Redo: likes(jake,_0)?
(1) 1 Exit: likes(jake,apricots)
(2) 1 Call: likes(darcie,apricots)?
(2) 1 Exit: likes(darcie,apricots)
X = apricots
Call
Fail
likes (jake, X)
Exit
Redo
Call
Fail
likes (darcie, X)
Exit
Redo

39. List Structure List is a sequence of any number of elements
Elements can be atoms, atomic propositions, or other terms (including other lists)
[apple, prune, grape, kumquat] []
empty list
[X | Y]
head X and tail Y
X and Y can each be of any length

40. Example: append Definition of append function:
append([], List, List).
append([Head | List_1], List_2, [Head | List_3])
:- append (List_1, List_2, List_3).
appending an empty list does nothing
if List_1+List_2 = List_3 then Head+List_1+List_2 = Head+List_3

41. Example: reverse Definition of reverse function: reverse([], []).
reverse([Head | Tail], List)
:- reverse (Tail, Result),
append (Result, [Head], List).
Lecture-question:
How would you express these two rules in plain English?

42. Broader Issues in Prolog
Resolution order control
Used for efficiency, but violates declarative style
The closed-world assumption
Assume you know everything about the world
The negation problem
Is a proposition FALSE if it can’t be proven TRUE?
Intrinsic efficiency limitations
Not meant for complex numerical calculations

43. Applications of Logic Programming
Relational database management systems
Expert and knowledge-based systems
Natural language processing
Education

44. Conclusions Advantages: Prolog programs based on logic
More logically organized and written (aid readability and writability)
Processing is naturally parallel
Prolog interpreters can take advantage of multiprocessor machines
Programs are concise
Fewer lines of code necessary
Development time is decreased – good for prototyping