CS 363 Comparative Programming Languages

1
CS 363 Comparative Programming Languages

• Logic Programming Languages

2
Chapter 16 Topics

• An Overview of Logic Programming
• The Origins of Prolog
• The Basic Elements of Prolog
• Applications of Logic Programming

3
Introduction

• Logic (declarative) programming languages express
  programs in a form of symbolic logic
• Runtime system uses a logical inferencing process
  to produce results
• Declarative rather that procedural
• only specification of results are stated (not
  detailed procedures for producing them)

4
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) ? for all j, 1? j list (j1)

5
Overview of Logic Programming

• Declarative semantics
• There is a simple way to determine the meaning of
  each statement
• Simpler than the semantics of imperative
  languages
• Programming is nonprocedural
• Programs do not state now a result is to be
  computed, but rather the form of the result
• Based on Propositional logic

6
Propositional Logic

• A proposition is formed using the following
  rules
• Constants true and false are propositions
• Variables (p,q,r,) which have values true or
  false are propositions
• Operators , v, ?, , and (conjunction,
  disjunction, implication, equilivance and
  negation) are used to form more complex
  propositions.

p v q r ? s v t
7
Predicate Logic Expressions

• Include
• Propositions
• Variables in domains such as integer, real
• Boolean valued functions
• Ex prime(n), 0
• Quantifiers (forall, exists)

8
Properties of Predicate Logic Expressions
9
Horn Clauses

• A Horn clause has a head h (which is a
  predicate), and a body, which is a list of
  predicates p1, p2, , pn.
• Predicate p is true only if p1, p2, , pn are
  all true.
• Meaning p1 p2 pn ? h
• Many, but not all predicates can be translated
  into Horn clauses using predicate logic
  expression properties.

10
The Origins of Prolog

• University of Aix-Marseille
• Natural language processing
• University of Edinburgh
• Automated theorem proving

11
The Basic Elements of Prolog

• Edinburgh Syntax
• Term a constant, variable, or structure
• Constant an atom or an integer
• Atom symbolic value of Prolog
• Atom consists of either
• a string of letters, digits, and underscores
  beginning with a lowercase letter
• a string of printable ASCII characters delimited
  by apostrophes

12
The Basic Elements of Prolog

• Variable any string of letters, digits, and
  underscores beginning with an uppercase letter
• Instantiation binding of a variable to a value
• Lasts only as long as it takes to satisfy one
  complete goal
• Structure represents atomic proposition
• functor(parameter list)

13
Fact Statements

• Used for the hypotheses (assumed information)
• Ex
• student(jonathan).
• sophomore(ben).
• brother(tyler, cj).

14
Rule Statements

• Give the rules of implication
• Consequence - antecedent_expression
• Right side antecedent (if part)
• May be single term or conjunction
• Conjunction multiple terms separated by logical
  AND operations (implied)
• Left side consequent (then part)
• Must be single term

15
Rule Statements

• Can use variables (universal objects) to
  generalize meaning
• parent(X,Y)- mother(X,Y).
• parent(X,Y)- father(X,Y).
• sibling(X,Y)- mother(M,X), mother(M,Y),father(F,X
  ), father(F,Y).

16
Example

• mother(Susan,Emily).
• mother(Susan,Lucy).
• mother(Anne,Susan).
• mother(Anne,Mary).
• father(Jim,Emily).
• father(Jim,Lucy).
• father(Russell,Susan).
• father(Russell,Mary).
• parent(X,Y)-mother(X,Y).
• parent(X,y)-father(X,y).
• sibling(X,Y)-mother(M,X),mother(M,Y),
  father(F,X),father(F,Y).

Facts
Rules
17
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.

Facts
Rules
18
Goal Statements

• For theorem proving, theorem is in form of
  proposition that we want system to prove or
  disprove goal statement
• Same format as facts
• student(james).
• Conjunctive propositions and propositions with
  variables also legal goals
• father(X,joe).

19
Example

• mother(Susan,Emily).
• mother(Susan,Lucy).
• mother(Anne,Susan).
• mother(Anne,Mary).
• father(Jim,Emily).
• father(Jim,Lucy).
• father(Russell,Susan).
• father(Russell,Mary).
• parent(X,Y)-mother(X,Y).
• parent(X,y)-father(X,y).
• sibling(X,Y)-mother(M,X),mother(M,Y),
  father(F,X),father(F,Y).
• mother(Anne,Mary).
• T
• mother(Anne,Emily).
• No
• father(Jim,X).
• X Emily, X Lucy

Facts
Rules
Goals (queries)
20
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! For
  example, k is k 1 is not solvable.

21
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(ford,S).
• S 2000

Facts
Rules
Goal
22
Inferencing Process of Prolog

• Queries are called goals
• If a goal is a compound proposition, each of the
  facts is a subgoal
• 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 subgoal called matching,
  satisfying, or resolution

23
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

24
Inferencing Process

• When goal has more than one subgoal, can use
  either
• Depth-first search find a complete proof for
  the first subgoal before working on others
• Breadth-first search work on all subgoals in
  parallel
• Prolog uses depth-first search
• Can be done with fewer computer resources

25
Inferencing Process

• With a goal with multiple subgoals, if fail to
  show truth of one of subgoals, reconsider
  previous subgoal to find an alternative solution
  backtracking
• Begin search where previous search left off
• Can take lots of time and space because may find
  all possible proofs to every subgoal

26
Example

• mother(Susan,Emily).
• mother(Susan,Lucy).
• mother(Anne,Susan).
• mother(Anne,Mary).
• father(Jim,Emily).
• father(Jim,Lucy).
• father(Russell,Susan).
• father(Russell,Mary).
• parent(X,Y)-mother(X,Y).
• parent(X,y)-father(X,y).
• sibling(X,Y)-mother(M,X),mother(M,Y),
  father(F,X),father(F,Y).
• sibling(Emily,Y).
• Y Lucy
• Sibling(Susan,Anne).
• no

Facts
Rules
Goals (queries)
27

• sibling(Emily,Y).
• mother(M,Emily),mother(M,Y),father(F,Emily),
  father(F,Y).
• After searching the db
• mother(Susan,Emily),mother(Susan,Y),
  father(Jim,Emily),father(Jim,Y).
• Searching again
• mother(Susan,Emily),mother(Susan,Lucy),
  father(Jim,Emily),father(Jim,Lucy)
• So Y Lucy

28

• sibling(Susan,Anne).
• mother(M,Susan),mother(M,Anne),
  father(F,Susan),father(F,Anne).
• If we choose M Anne, we cant resolve the
  second mother clause (similar problem with
  father) ? fail

29
List Structures

• Other basic data structure (besides atomic
  propositions we have already seen) list
• 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)

30
Example

• Definition of member function
• member(Elem,Elem _ ).
• member(Elem, _ List) -
• member (Elem,List).

Anonymous variable
31

• member(a,b,c,d).
• member(a,b,c,d)
• member(a,c,d)
• member(a,d)
• member(a,) ? fails

32
Example

• Definition of append function
• append(, List, List).
• append(Head List_1, List_2, Head List_3)
  -
• append (List_1, List_2, List_3).

33
How append works

• append(a,b,c,d,X).
• append(ab,c,d,_).
• append(b,c,d,_).
• append(,c,d,c,d). ? first rule!
• append(b,c,d,b,c,d).
• append(a,b,c,d,a,b,c,d).
• X a,b,c,d

34
Example

• Definition of reverse function
• reverse(, ).
• reverse(Head Tail, List) -
• reverse (Tail, Result),
• append (Result, Head, List).

35
Cut Operator (!)

• Explicit control of backtracking
• ! Is a goal that always succeeds but cannot be
  resatisified by backtracking
• a,b,!,c,d if a and b succeed, but c fails, the
  whole goal fails.

36
Deficiencies of Prolog

• Resolution Order control
• Prolog always starts at the beginning of DB when
  searching
• Prolog always starts trying to resolve the
  leftmost subgoal (depth first)
• ? rule/definition order can affect performance!

37
Deficiencies of Prolog

• Easy to write infinite loops (due to resolution
  order)
• ancestor(X,X).
• ancestor(X,Y) - ancestor(Z,y),parent(X,Z).

Reversing rules fixes the problem
38
Deficiencies of Prolog

• Closed World assumption Prolog can only prove
  things to be true (based on the info) but it
  cannot be used to prove a goal is false
• Leads to a problem with negation

39
Deficiencies of Prolog

• Problems with negation
• Given parent(bill,jake). parent(bill, shelley).
• sibling(X,Y) - parent(M,X),parent(M,Y).
• For goal sibling(X,y).
• Prolog will respond with Xjake, Yjake
• sibling(X,Y) - parent(M,X),parent(M,Y),not(XY).

40
Deficiencies of Prolog

• Problems with negation
• Need to write the rule using negation
• sibling(X,Y) - parent(M,X),parent(M,Y),not(XY).
• However, must be done carefully not(not(goal))
  is not the same as goal.

41
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)

42
Applications of Logic Programming

• Relational database management systems
• Expert systems
• Natural language processing
• Education

43
Conclusions

• Advantages
• Prolog programs based on logic, so likely to be
  more logically organized and written
• Processing is naturally parallel, so Prolog
  interpreters can take advantage of
  multi-processor machines
• Programs are concise, so development time is
  decreased good for prototyping