PROGRAMMING LANGUAGES:

LOGIC PROGRAMMING

2

SLIDES REFERENCES

Kenneth C. Louden, Functional Programming, Programming Languages: Principles and Practice, Ch4.

COMP313A Programming Languages, University of Waikato, New Zealand.

Philip O’Keefe, Logic Programming, Memorial University, Canada

3

INTRODUCTION

As we mentioned before, paradigms of programming languages are:ImperativeFunctionalObject-orientedDeclarative (Logical)

4

HISTORY

Logic Programming can be traced back to 1958 by John McCarthy

He proposed a hypothetical computer program named advice taker

Probable first proposal to represent information as logic for a program

John McCarthy (1927-2011)• A computer scientist @ Stanford Uni• Received Turing award for contributions

in Artificial Intelligence• Inventor of the LISP

5

ARTIFICIAL INTELLIGENCE (AI)

Knowledge representation is one of the most important subareas of AI

For an entity to behave intelligently it must be supplied sufficient knowledge

This mean an unambiguous language capable of expressing this knowledge must be used

This information must be able to be manipulated to answer queries

A declarative language fits these requirements well

6

LOGIC PROGRAMMING

Uses a set of logical assertions (i.e. statements that are either true or false), as a program (the facts).

Execution is initiated by a query or goal, which the system attempts to prove true or false, based on the existing set of assertions.

For this reason, logic programming systems are sometimes called deductive databases.

Two main "weirdnesses": no explicit functions, no explicit execution control.

7

LOGIC AND LOGIC PROGRAMMING First-order predicate calculus

Logic statements

ExamplesJohn is a man. man(John).John is a human. human(John).Tristan is the son of Margaret. son(Margaret,Tristan).0 is a natural number . natural(0).

Mammals have four legs and no arms or two legs and two arms.For all X, mammal (x) -> legs(x,4) and arms(x,0) or legs(x,2)

and arms(x,2).Humans have two legs and two arms.For all X, human(x) -> legs(x,2) and arms(x,2).If x is a natural number then so is the successor of x.For all x, natural(x) -> natural(successor(x)).

8

EXAMPLES Computing ancestors:

A parent is an ancestor.If A is an ancestor of B, and B is an ancestor of C, then A is an ancestor of C. (a typical relation: called ??)A mother is a parent.A father is a parent.Bill is the father of Jill.Jill is the mother of Sam.Bob is the father of Sam.

Computing the factorial function:The factorial of 0 is 1.If m is the factorial of n - 1, then n * m is the factorial of n.

9

EXAMPLES Computing ancestors:

A parent is an ancestor.If A is an ancestor of B, and B is an ancestor of C, then A is an ancestor of C. (a typical relation: called ??)A mother is a parent.A father is a parent.Bill is the father of Jill.Jill is the mother of Sam.Bob is the father of Sam.

Computing the factorial function:The factorial of 0 is 1.If m is the factorial of n - 1, then n * m is the factorial of n.

12

EXAMPLES WRITTEN IN PRED. CALC.: Ancestors:

For all X and Y, parent(X,Y) ancestor(X,Y). For all A, B, and C, ancestor(A,B) and ancestor(B,C) ancestor(A,C). For all X and Y, mother(X,Y) parent(X,Y).For all X and Y, father(X,Y) parent(X,Y).Father(Bill,Jill).Mother(Jill,Sam).Father(Bob,Sam).

Factorials:Factorial(0,1).For all n and m, factorial(n-1,m) factorial(n,n*m).

13

HORN CLAUSES A clause (i.e., a disjunction of literals) is called a Horn clause

if it contains at most one positive literal. Horn clauses are usually written as

L1,...,Ln=>L(=¬L1 v ... v ¬Ln v L) or L1,...,Ln=>(=¬L1 v ... v ¬Ln), where n>=0 and L is the

only positive literal. Drop the quantifiers ( , ). i.e., assume them implicitly.

Distinguish variables from constants, predicates, and functions by upper/lower case:parent(X,Y) ancestor(X,Y). ancestor(A,B) and ancestor(B,C) ancestor(A,C). mother(X,Y) parent(X,Y).father(X,Y) parent(X,Y).father(bill,jill).mother(jill,sam).father(bob,sam).

factorial(0,1).factorial(N-1,M) factorial(N,N*M).

14

PROLOGModified Horn clause syntax: write the clauses

backward, with :- as the (backward) arrow, comma as "and" and semicolon as "or":ancestor(X,Y) :- parent(X,Y).ancestor(X,Y) :- ancestor(X,Z), ancestor(Z,Y).

parent(X,Y) :- mother(X,Y).parent(X,Y) :- father(X,Y).father(bill,jill).mother(jill,sam).father(bob,sam).factorial(0,1).factorial(N,N*M) :- factorial(N-1,M).

15

UNFORTUNATE ERRORS:?- ancestor(bill,sam).

Yes.

?- ancestor(bill,X).

X = jill ;

X = sam ;

ERROR: Out of local stack

?- ancestor(X,bob).

ERROR: Out of local stack

?- factorial(2,2).

No

?- factorial(0,X).

X = 1 ;

ERROR: Out of global stack

16

WHAT'S WRONG????

ancestor(X,Y) :- parent(X,Y).ancestor(X,Y) :- ancestor(X,Z), ancestor(Z,Y).

parent(X,Y) :- mother(X,Y).parent(X,Y) :- father(X,Y).father(bill,jill).mother(jill,sam).father(bob,sam).factorial(0,1).factorial(N,N*M) :- factorial(N-1,M).

Immediate recursion

No arithmetic is actually computed

17

ARITHMETIC Easy to fix - arithmetic expressions must

be explicitly forced:?- 2*3 = 6.No?- 2*3 = 2*3.Yes?- 6 is 2*3.Yes?- 2*3 is 6.No

Rewrite factorial like this:factorial(0,1).factorial(N,P) :- N1 is N-1, factorial(N1,M), P is M*N.

"is" forces its right-hand argument

But not its left-hand argument

18

STACK PROBLEMS A BIT HARDER: Stack problems still exist for factorial:?- factorial(7,X).X = 5040 ;ERROR: Out of local stack

To figure this out, we must understand the procedural interpretation of Horn clauses:a :- b, c, d.represents the definition of a (boolean) function named a. The body of a is given by the clauses on the right hand side: b, then c, then d.

Note similarity to recursive-descent parsing! Also note sequencing!

19

PROLOG'S EXECUTION STRATEGY Given a query or goal, Prolog tries to

pattern match the goal with the left-hand sides of all clauses, in a sequential top-down fashion.

Any lhs that matches causes the rhs terms to be set up sequentially as subgoals, which Prolog immediately tries to match in turn with lhs terms.

Thus, Prolog's execution path is top-down, left-to-right, depth-first. All intermediate results are kept for backtracking purposes.

20

SOLVING THE STACK PROBLEMS

For the ancestor problem, just remove the left recursion:ancestor(X,Y) :- parent(X,Y).ancestor(X,Y) :- ancestor(X,Z), ancestor(Z,Y). parent(X,Z)

For the factorial problem, it involves preventing reuse of the recursive rule:factorial(0,1).factorial(N,P) :- not(N=0), N1 is N-1, factorial(N1,M), P is M*N.

21

LISTS Prolog uses almost the same list syntax

as Haskell or ML: [1,2,3] Head and tail pattern syntax is different:

[H|T] versus (h:t) in Haskell or (h::t) in ML Also, as many elements as desired can

be written using commas before the bar:[1,2,3|[4]] is the list [1,2,3,4].

Example:?- [1,2,3] = [X,Y|_].X = 1Y = 2

22

PATTERN MATCHING

Pattern matching is more general in Prolog than it is in Haskell: variables can be repeated in patterns, implying

that they must be the same value:?- [1,1] = [X,X].X = 1?- [1,2] = [X,X].No

Other operations can be more general too.

23

PROLOG STRUCTURE

Prolog facts – a database of predicates and associations.

Prolog rules – define new predicates by using Prolog facts.

Note: Prolog considers capital letters to denote

variables, not predicates.

24

PROLOG STRUCTURE – QUERIES

A query searches the database for the first fact that satisfies its goal.

If a fact is found then it either unifies the variable with a constant or Prolog returns yes.

If a fact is not found that meets that condition then Prolog returns no.

25

PROLOG STRUCTURE – DISJUNCTION AND CONJUNCTION. Use a semi-colon to request subsequent

answers.

In other words, a semi-colon signifies disjunction.

A comma signifies conjunction.

26

HOW PROLOG WORKS: EXAMPLE 1

Example of data base:instructor (louden, ee271)

instructor (louden, ee171)

instructor (louden, ee478)

enrolled (alan-cheng, ee475)

enrolled (matthew, ee171)

enrolled (alan-cheng,ee171)

enrolled (alan-cheng,ee271)

enrolled (chris-clark,ee271)

enrolled (edison-tsai, ee171)

enrolled (chris-clark, ee171)

This is the database of Prolog facts.

27

HOW PROLOG WORKS, CONT.

Prolog rules:teaches (P,S) :- instructor (P,C), enrolled (S,C)

This is to say that an instructor only teaches if he teaches a class and students are enrolled in that class.

teaches (Professor, Student) :- instructor (Professor, Class), enrolled (Student,Class)

teaches (Professor, Student) instructor (Professor, Class), enrolled (Student,Class)

instructor (Professor, Class), enrolled (Student,Class) teaches (Professor, Student)

28

HOW PROLOG WORKS, CONT. Prolog answers queries based off of the

database that has been given.?enrolled (chris-clark, ee271) yes

?enrolled (X, ee271)alan-chengchris-clark

?teaches (X, alan-cheng)louden

?teaches (X, chris-clark)loudenJeskegreenwood

29

parent(X,Y) :- father(X,Y).parent(X,Y) :- mother(X,Y).grandparent(X,Z) :- parent(X,Y), parent(Y,Z).ancestor(X,Z) :- parent(X,Z).ancestor(X,Y) :- parent(X,Y), ancestor(Y,Z).sibling(X,Y) :- mother(M,X), mother(M,Y), father(F,X), father(F,Y), X \= Y.cousin(X,Y) :- parent(U,X), parent(V,Y), sibling(U,V).

father(albert, jeffrey).mother(alice, jeffrey).father(albert, george).mother(alice, george).father(john, mary).mother(sue, mary).father(george, cindy).mother(mary, cindy).father(george, victor).mother(mary, victor).`

FAMILY DATA BASE

30

?- [kinship].% kinship compiled 0.00 sec, 3,016 bytesYes

?- ancestor(X, cindy), sibling(X, jeffrey).X = george Yes

?- grandparent(albert, victor).Yes

?- cousin(alice, john).No

?- sibling(A,B).A = jeffrey, B = george ; A = george, B = jeffrey ; A = cindy, B = victor ; A = victor, B = cindy ; No

SWI Prolog

31

1. Process of making one predicate same as another.

2. A query resolves by unifying all of its elements.

3. A constant unifies with itself and any variable.

4. Scope is limited to the rule in which a variable occurs.

5. When a variable is unified with a constant in a rule, all instances of that variable in that rule are unified to that constant.

PROLOG STRUCTURE - UNIFICATION

32

Example of Unification

33

PROLOG STRUCTURE - BACKTRACKING

1. In more complex examples, Prolog uses backtracking to find possible solutions.

2. Prolog will attempt to resolve the first fact of its rule, unifying any variables with the first constant that satisfies that fact

3. It then attempts to resolve the rest of that rules facts.

4. If it is unable to do so under those conditions it “backs up” and tries again with the next available unifying constant.

34

CLAUSES

Programs are constructed from A number of

clauses: <head> :- <body>

Clauses have three forms:

hypotheses (facts)

conditions (rules)

goals

Both <head> and <body> are composed of

relationships (also called predications or

literals)

assertions (database)

questions

35

RELATIONSHIPS

Represent properties of and relations among the individuals

A relationship is application of a predicate to one or more terms

Terms:atoms (or constants): john, 25, …variables (begin with uppercase letters): X, …

compoundsHorn clause form: At most one

relationship in <head>

36

A SMALL EXAMPLE

We write:

likes(ann,X) :- toy(X), plays(ann,X).toy(doll). toy(train).plays(ann,train).likes(john,Y) :- likes(ann,Y).

37

A SMALL EXAMPLE – WHAT IT MEANS

There are three important logical symbols

:- if

, and

; or

X and Y are variables ann, john, doll and train are constants likes, toy and plays are predicate symbols

38

A SMALL EXAMPLE – WHAT IT MEANS

For example:

likes(ann,X) :- toy(X), plays(ann,X).

<---Head---> <-------Body------->

39

PROLOG LISTS: CONCEPT Lists are a collection of terms inside [ and ]

[ bmw, ford, benz]

loc_list([apple, orange, cake], kitchen). loc_list([desk, computer], office). loc_list([flashlight, envelope], desk). loc_list([stamp, key], envelope). loc_list(['washing

machine'], cellar). loc_list([nani], 'washing machine'). loc_list([], hall)

40

PROLOG LISTS: MEMBER AND APPEND

List functions [H|T]

separate list into head and tail member

test if X is a member of a list append

append two lists to form a third list

41

PROLOG LISTS: HEAD AND TAIL

Head and Tail of a List Syntax

[H|T] Examples ?- [a|[b,c,d]] = [a,b,c,d]. %We check identity

yes ?- [a|b,c,d] = [a,b,c,d].

no

42

PROLOG LISTS: MORE ON HEAD AND TAIL

More Examples?- [H|T] = [apple, orange, refrigerator].

H = apple T = [orange, refrigerator]

?- [H|T] = [a, b, c, d, e]. H = a T = [b, c, d, e]

?- [H|T] = [apples, bananas]. H = apples T = [bananas]

43

PROLOG LISTS: MORE ON HEAD, TAIL AND LIST STRUCTURE More Examples

?- [One, Two | T] = [apple, sprouts, fridge, milk]. One = apple Two = sprouts T = [fridge, milk]

?- [a|[b|[c|[d|[]]]]] = [a,b,c,d]. yes

44

PROLOG LISTS: MEMBER

Testing if an element is in a list. Syntax

member(X, L). Example

member(apple, [apple, orange, cake]). member(X, CarList).

Full Predicate defined as:member(H,[H|T]). member(X,[H|T]) :- member(X,T).

45

PROLOG LISTS: APPEND

Appending two lists to form a third. Syntax

append(L1, L2, L3). Example

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

Full predicate defined as:append([],X,X). append([H|T1],X,[H|T2]) :- append(T1,X,T2).

46

PROLOG IS MUCH MORE THAN JUST INFORMATION: LISTS AND TREES Prolog rules can also be used write

programs that do more than find the answers to simple database queries. append([], L, L). append([H|T], L, [H|L1]) :- append(T, L, L1).

This will append a list to another list recursively.

A binary tree can be defined as follows tree(nil). tree(node(_ , Left, Right) :- tree(left),

tree(right).

47

COMMENTS IN PROLOG

Single line comments use the “%” character

Multi-line comments use /* and */

48

SIMPLE INPUT-OUTPUT IN PROLOG

Simple I/O in Prolog Use the write statement

write(‘hello’) write(‘Hello’), write(‘World’)

Use a Newline write(‘hello’), nl, write(‘World’)

49

READING AND WRITING IN PROLOG

Reading a value from stdin

Prolog Syntax: read(X)

Exampleread(X), write(X).

50

ARITHMETIC IN PROLOG

Using Arithmetic Different to what you may have seen with other

languages. Operators

< <= == != => > + - * /

Arithmetic is done via evaluation then unification

51

ARITHMETIC

Arithmetic Example

X is Y compute Y then unify X and Y

X is Y * 2 N is N - 1

52

THE DIFFERENCE BETWEEN IDENTITY RELATION AND UNIFICATION

X == YThis is the identity relation. In order for

this to be true, X and Y must both be identical variables (i.e. have the same name), or both be identical constants, or both be identical operations applied to identical terms

X = YThis is unification It is true if X is unifiable with Y

53

DIFFERENT “ASSIGNMENT” OPERATORS IN PROLOG

X=:=YThis means “compute X, compute Y, and

see if they both have the same value”both X and Y must be arithmetic

expressions

X is YThis means compute Y and then unify X

and YY must be an arithmetic expressionX can either be an arithmetic expression

(of the same form), or a variable

54

COMPARISON OF ASSIGNMENTS

Arithmetic Exercises1. X = 2, Y is X+1 2. X = 2, Y = X+1 3. X = 2, Y == X+1 4. X = 2, Y =:= X+1 5. X = 2, 3 =:= X+1

Check these on the Prolog system.

55

Arithmetic Examples: GCD

gcd(X,X,X). gcd(X,Y,Z) :- X<Y, Y1 is Y-X, gcd(X,Y1,Z).gcd(X,Y,Z) :- X>Y, X1 is X-Y, gcd(X1,Y,Z).

RECURSION IN PROLOG

56

EXAMPLE: FACTORIAL

fact(0,1).

fact(X,F) :- X>0, X1 is X-1, fact(X1,F1), F is X*F1.

57

CONTROL STRUCTURES IN PROLOG

Looping…Repeat until user enters “end”

command_loop:- repeat, write('Enter command (end to exit): '), read(X), write(X), nl, % new lineX = end.

58

PRIMITIVES AND CONSTRUCTORS

Few primitives and No constructors.

Data types and data structures are defined implicitly by their properties.

59

EXAMPLE (DATATYPE)

Natural number arithmetic

sum(succ(X), Y, succ(Z)) :- sum(X,Y,Z).sum(0,X,X).dif(X,Y,Z) :- sum(Z,Y,X).

:-sum(succ(succ(0)),succ(succ(succ(0))),A).A = succ(succ(succ(succ(succ(0)))))

Very inefficient! Use of ‘is’ operator (unidirectional)

60

PRINCIPLES OF LOGIC PROGRAMMING LANGUAGES

Simplicity Small number of built-in data types and

operations

Regularity Uniform treatment of all data types as predicates

and terms

61

DATA STRUCTURES FROM OTHER LANGUAGES

Compound terms can represent data structures

Example: Lists in LISP

(car (cons X L)) = X(cdr (cons X L)) = L(cons (car L) (cdr L)) = L, for nonnull L

62

LISP IN PROLOG

Using compound terms:car( cons(X,L), X).cdr( cons(X,L), L).list(nil).list(cons(X,L)) :- list(L).null(nil).

What about null(L)?

How to accomplish (car (cons ‘(a b) ‘(c d)))?

63

COMPONENT SELECTION IN PROLOG

Implicitly done by pattern matching (unification).append( [ ], L, L).append( X.P, L, X.Q) :- append(P,L,Q).

Compare with Scheme append:(define append (M L) (if (null M) L (cons (car M) (append (cdr M) L)) ))

64

CUT!

‘!’: Discard choice points of parent frame and frames created after the parent frame.

Always is satisfied. Used to guarantee termination or control

execution order.

i.e. in the goal :- p(X,a), ! Only produce the 1st answer to X Probably only one X satisfies p and trying to find another

one leads to an infinite search!

i.e. in the rule color(X,red) :- red(X), !. Don’t try other choices of red (mentioned above) and

color if X satisfies red Similar to then part of a if-then-elseif

Fisher, J.R., Prolog Tutorial, http://www.csupomona.edu/~jrfisher/www/prolog_tutorial/contents.html