Download - CS 363 Comparative Programming Languages Logic Programming Languages.

CS 363 Comparative Programming Languages

Logic Programming Languages

CS 363 Spring 2005 GMU 2

Chapter 16 Topics

• An Overview of Logic Programming

• The Origins of Prolog

• The Basic Elements of Prolog

• Applications of Logic Programming


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)


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 < n, list(j) list (j+1)


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


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


Predicate Logic Expressions

Include:– Propositions– Variables in domains such as integer, real– Boolean valued functions

• Ex: prime(n), 0 <= x + y,

– Quantifiers (forall, exists)


Properties of Predicate Logic Expressions

Property MeaningCommutativity p v q ≡ q v p p ^ q ≡ q ^ p

Associativity (p v q) v r ≡ p v (q v r ) (p ^ q) ^ r ≡ p ^ (q ^ r )

Distributivity (p v q) ^ r ≡ (p ^ r ) v (q ^ r) (p ^ q) v r ≡ (p v r ) ^ (q v r)

Idempotence p v p ≡ p p ^ p ≡ p

Identity p v ⌐ p ≡ true p ^ ⌐ p ≡ false

deMorgan ⌐(p v q) ≡ ⌐p ^ ⌐q ⌐(p ^ q) ≡ ⌐p v ⌐q

Implication p q ≡ ⌐ p v q

Quantification ⌐ forall x P(x) ≡ exists x ⌐ P(x)

⌐ exists x P(x) ≡ forall x ⌐ P(x)


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.


The Origins of Prolog

• University of Aix-Marseille– Natural language processing

• University of Edinburgh– Automated theorem proving


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


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 propositionfunctor(parameter list)


Fact Statements

• Used for the hypotheses (assumed information):

• Ex:

student(jonathan).

sophomore(ben).

brother(tyler, cj).


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


Rule StatementsCan 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).


Examplemother(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


Examplespeed(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


Goal Statements

• For theorem proving, theorem is in form of proposition that we want system to prove or disprove – goal statement

• Same format as factsstudent(james).

• Conjunctive propositions and propositions with variables also legal goals

father(X,joe).


Examplemother(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). Tmother(Anne,Emily). Nofather(Jim,X). X = Emily, X = Lucy

Facts

Rules

Goals (queries)


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.


Examplespeed(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


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


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


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


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


Examplemother(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 = LucySibling(Susan,Anne).> no

Facts

Rules

Goals (queries)


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


sibling(Susan,Anne).mother(M,Susan),mother(M,Anne),

father(F,Susan),father(F,Anne).

If we choose M = Anne, we can’t resolve the second mother clause (similar problem with father) fail


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)


Example

• Definition of member function:

member(Elem,[Elem | _ ).

member(Elem,[ _ | List]) :-

member (Elem,List).

Anonymous variable


member(a,[b,c,d]).

member(a,[b,c,d])

member(a,[c,d])

member(a,[d])

member(a,[]) fails


Example

• Definition of append function:

append([], List, List).

append([Head | List_1], List_2, [Head | List_3]) :-

append (List_1, List_2, List_3).


How append works

append([a,b],[c,d],X).

append([a|b],[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]


Example

• Definition of reverse function:

reverse([], []).

reverse([Head | Tail], List) :-

reverse (Tail, Result),

append (Result, [Head], List).


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.


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!



• 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



• 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



• 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: X=jake, Y=jake– sibling(X,Y) :- parent(M,X),parent(M,Y),not(X=Y).



• Problems with negation:Need to write the rule using negation:– sibling(X,Y) :- parent(M,X),parent(M,Y),not(X=Y).

However, must be done carefully – not(not(goal)) is not the same as goal.


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)


Applications of Logic Programming

• Relational database management systems

• Expert systems

• Natural language processing

• Education


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