PROgramming in LOGic. Part II. By Forrest Pepper 12/7/07

Transcription

1 PROgramming in LOGic Part II By Forrest Pepper 12/7/07

2 Anatomy of a Program We discussed the three main constructs of a Prolog program Facts contain a property or state a relationship between two or more objects. These are considered always true. parents(jim,jane,john). Its cold!. Rules allow us to infer that a property or relationship hold based on preconditions. child(x,y) :- parents(y,_,x). child(x,y) :- parents(_,y,x). Queries ask question that causes an answer to be deduced from the facts and rules given in the program.?- child(john,jane). Yes

3 Predicate Logic Rules and facts use predicate definitions In a given clause from Prolog: parent(larry,john). the predicate is defined as the label in front of the parentheses. In this case, parents is the predicate. The predicate defines a property about the given constants or variables. This property is similar to predicates in the English language: the predicate is verb that states something about its subject. Parent defines a parent - child relationship to the given information. Predicate logic allows for all relationships to be used inductively. grandparent(x,y) :- parent(x,z), parent(z,y).

4 Predicates need Clauses A predicate definition uses clauses. All clauses have a Head and/or Body. Every clause has a Head, but not every clause has a Body. Facts are constant and therefore only have a body. Whereas Rules have a Head that contains the predicate and a Body that contains the actual Rule. (left side of the :- is the Head, right side is the body. Fact: parent(jim,john). %has a head Rule: child(x,y):- parent(y,x). %has head and body

5 Arguments Arguments can be found within the Head as the subject to the predicate or the objects listed in parentheses and separated by commas. Arguments found in the Body can be a constant, or a variable, or reference another predicate. child(jackie,jane). parent(x,y) :- child(y,x). parent(x,y) :- parent(child(z,y),x). Arguments would be: jackie, jane, X, Y, Z, child(z,y). The following can be arguments: All Types Variables Predicates

6 Types Weakly typed: Types are never declared in Prolog. Integers and Floating Points: 5, 87, -15, Non-numeric types or atoms: must start with a lowercase letter and can contain any characters afterwards with the exception of a space. parent, youngest_child. String: can be defined as any combination of letters, spaces, or characters between apostrophes. Anything goes here 12@#$*

7 Variables Variables start with an upper case alphabetic character or an underscore. Other than the first character they can be made up of any mixture of letters, digits, and underscores. e.g. X, Index, _7blah41, _any_thing_here There are no types for variables (or constants) a variable can take any value. All Prolog variables have a local scope: they only keep the same value within a clause; the same variable used outside of a clause does not change to the new value.

8 Arity The number of arguments given defines the arity of a function or predicate in Prolog. parents(jim,jane,john). % arity = 3 parent(jane,john). % arity = 2 child(john). % arity=1

9 Unification When one term instantiates another as the same they are considered unified. (i.e. the two are congruent)?- parent(jane,x) = parent(y,jackie). X = jackie, Y = jane yes Terms that won t unify fred = jim. Hey you = Hey me. frou(frou) = f(frou). foo(bar) = foo(bar,bar). foo(n,n) = foo(bar,rab). Unified terms Outcome fred = fred. yes. Hey you = Hey you. yes fred=x. X=fred. X=Y. Y = X. foo(x) = foo(bar). X=bar. foo(n,n) = foo(bar,x). N=bar, X=bar. foo(foo(bar)) = foo(x) X = foo(bar)

10 Have a conversation Using predicates and the write and read commands, the user can create conversation with the program. Program hello :- write( Hi, what is your name? ), nl, read(x), write( Nice to meet you ), write(x). Command Line?- hello. Hi, what is your name? : forrest. Nice to meet you forrest

11 Recursion Prolog does not use loops in its language but instead relies on recursive calls to the original predicate. While recursion is not as efficient, the code is very concise and intuitive. Using tail recursion increases the efficiency. Base case is defined by a fact, b/c facts are always true. A rule must also be written using the same predicate. The rule would then execute a boolean and a set of commands including a call back to its own predicate.

12 Base_two This recursive function returns 2 to the power of X degree. base_two(0,1). base_two(x,y) :- X > 0, X2 is X-1, base_two(x2,y2), Y is 2 * Y2.?- base_two(3,y). Y=8

13 Factorial! factorial(0,1). factorial(x,y) :- X > 0, X2 is X-1, factorial(x2,y2), Y is X *Y2.?- factorial(3,y). Y = 6

14 Homework 1. Use class_ex.pl from class on Wednesday. Complete the rule for cousins. (this may require editing other rules) 2. Write a recursive function for the fibonacci sequence.