Prolog_labsheet 683k24

LAB#1 UNDERSTAND BASIC OF PROLOG Getting computers to communicate with us in human languages like English, either by printing on a computer terminal, understanding things we type on a computer terminal, generating speech, or understanding our speech (natural language); Getting computers to complicated interrelated facts, and draw conclusions from them. If we want computers to act intelligent, we must help them. We must tell them all the commonsense knowledge. Now there are many different kinds of knowledge. Without getting deep into philosophy (or specifically epistemology, the theory of knowledge), there are two main kinds: facts and reasoning procedures. Facts are things true about the world, and reasoning procedures (or inferences) are ways to follow reasoning chains between facts. Since facts are easier to represent than procedures. The program logic of Prolog is expressed in of relations, represented as facts and rules. A computation is initiated by running a query over these relations. HOW MANY FACTS DO WE NEED? Infinity of facts is true about the world. How then do we decide, which to tell a computer? Generally, we must decide that what we want from computer to do, then make sure to tell the computer every fact that might be relevant to that behavior. “Libraries” of useful facts for particular subjects will help. But smarter you want the computer to be, more facts you must tell it. SEMANTIC NETWORKS Pictures can make a complicated set of facts a lot clearer. There’s a simple pictorial way (labeled directed graph) to show the predicate expressions. We’ve been discussing the semantic network. But there is one restriction on it: semantic networks can only directly represent predicates of two arguments (so type predicate must be in two –argument form). EXAMPLE: a_kind_of(khaiber, ship). a_kind_of(tipu_sultan, ship). part_of(khaiber, pak_navy). part_of(tipu_sultan, pak_navy). part_of(pak_navy,pak_government). a_kind_of(pak_govrnment,government). color (ship, gray). location(khaiber, 15n35e). has(pak_government, civil_service_system).

1 | Page

EXAMPLE OF SEMANTIC NETWORK

OBJECT: Draw a semantic network representing the following facts, and implement following fact using Prolog: Ships are things. Carriers are ships. Ships have a position. Ships have a crew. Carriers have planes. Planes are things. A crew consists of people. People are things.

2 | Page

LAB#2 TEST THE EVALUATION OF GOALS, USING UNIFICATION AND BACKTRACKING Unification is the process of matching two predicates and asg free variables to make the predicates identical. This mechanism is necessary so that Prolog can identify which clauses to call and bind values to variables. These are the major points about matching (Unification) presented in this session. When a new call is made, a search for a match to that call also begins at the top of the program When a call has found a successful match, the call is said to return, and the next sub goal in turn can be tried. Once a variable has been bound in a clause, the only way to free that binding is through backtracking. Backtracking is the mechanism that instructs Prolog where to go to look for solutions to the program. This process gives Prolog the ability to search through all known facts and rules for a solution. There are four basic principles of backtracking given in this session: Sub goals must be satisfied in order, from top to bottom. Predicate clauses are tested in the order they appear in the program, from top to bottom. When a sub goal matches the head of a rule, the body of that rule must be satisfied next. The body of the rule then constitutes a new set of sub goals to be satisfied. A goal has been satisfied when a matching fact is found for each of the extremities (leave) of the goal tree. A call that can produce multiple solutions is non-deterministic, while a call that can produce one and only one solution is deterministic. Example 1: factorial(0,1). factorial(X,Y) :-

X1 is X - 1, factorial(X1,Z), Y is Z*X,!. Decomposition (factorial(4,Fact)): X1 is 3, (X1 is 2, (X1 is 1, (X1 is 0, (Z=1), Y ==1 is X==1 * Z==1), Y==2 is X==2 * Z==1), Y==6 is X==3 * Z==2), Y==24 is X==4 * Z==6) X is decreasing step by step Each Y has the value of Z form previous step.

3 | Page

Example 2: talks_about(A,B):-knows(A,B). talks_about(P,R):-knows(P,Q),talks_about(Q,R). Example 3: Facts: parent(john,paul). /* John is Paul's parent */ parent(paul,tom). /* Paul is Tom's parent */ parent(tom,mary)./* Tom is Mary's parent */ Rules: ancestor(X,Y) :- parent(X,Y). ancestor(X,Y) :- parent(X,Z), ancestor(Z,Y).

Query: Execution scheme for the query “ancestor(john,tom).” CALL ancestor(john,tom). CALL parent(john,tom). FAIL parent(john,tom). CALL parent(john,Z). TRY Z=paul (Unification) CALL ancestor(paul,tom). CALL parent(paul,tom). (Recursion) SUCCEEDS parent(paul,tom). SUCCEEDS ancestor(paul,tom). SUCCEEDS with Z=paul SUCCEEDS ancestor(john,tom). GOAL: Name of few countries with population is given, define a general rule that Print the name of countries having population greater than 10 million. c o u n t r 4 | Page

y ( e n g l a n d , 3 e 7 ) . c o u n t r y ( f r a n c e , 2 . 3 e 7 ) . c o u n t r y ( g 5 | Page

e r m a n y , 1 . 6 e 7 ) . c o u n t r y ( d e n m a r k , 2 . 4 e 6 ) . c o u n t r y ( c a n 6 | Page

a d a , 7 . 3 e 6 ) .

7 | Page

LAB#3 TO TEST A SIMPLE DISEASE DIAGNOSIS SYSTEM – A CASE STUDY go :write(‘What is the name of Patient?’), read(Patient),nl, hypo(Patient, Disease), write(Patient),write(‘ probably has ’),write(Disease),nl. go:write(‘Sorry I am unable to diagnose the Disease.’),nl. hypo(Patient,flu):-sym(Patient,fever), sym(Patient,cough). hypo(Patient,headche):-sym(Patient,bodypain). sym(Patient,fever):write(‘ Does ’),write(Patient),write(‘ has fever (y/n)?’), res(R),R=’y’. sym(Patient,cough):write(‘Does ’),write(Patient),write(‘ has cough (y/n)?’), res(R),R=’y’. sym(Patient,bodypain):write(‘Does ’),write(Patient),write(‘ has bodypain (y/n)?’), res(R),R=’y’. res(R):-read(R),nl.

LAB#4 WORKING WITH DEFINED FUNCTIONS Function1: cube :read(X), calc(X).

/* read X then query calc(X). */

calc(stop) :- !. /* if X = stop then it ends */ calc(X) :- C is X * X * X, write(C),cube. /* calculate C and write it then ask again cube. */ Function2: evaluate(Expression, Answer :- Answer is Expression). Query: ?- evaluate(2*9,Ans). Ans = 18 Yes Function3: Loops: (equivalent to While – Do like C) test :- repeat, write('Please enter a number'), read(X),

(X=:=42). In this example the program will ask you to enter a number until you enter 42. Fabonacii Series: go(N):- write(0),nl, write(1),nl, go(0,1,N). go(_,_,0):- !. go(A,B,C):- A1 is A,B1 is B,

C1 is A1+B1, write(C1),nl, NewC is C-1, go(B1,C1,NewC). fab:- write('Input No. : '), read(N), go(N).

OBJECT : Make a rule for generating palindrome numbers 1, 11, 22, 33, 44, 55, 66, 77, 88, 99, …..

LAB#5 TO WORK WITH THE IMPLEMENTATION OF PROLOG DATABASE (I.E., FACTS AND RULES WHICH MAKE RELATIONAL DATABASE) Databases in Prolog are bit different from other (procedural) databases. In Prolog there are two types of databases: static databases and dynamic database. A static database is one whose component’s (field records) information, as well as rules about their relationships is stored in memory at run time. A dynamic database is composed of facts gathered by the during program execution. These facts re stored in a separate (dynamic) database. A dynamic database is stored in memory along with a static database; more memory is needed here. You can name facts section (which creates a corresponding internal domain). Your program can have multiple facts sections, but each one must have a unique name. With the standard predicates assert, asserta, assertz, and consult, you can add facts to the facts section at run time. You can remove such facts at run time with the standard predicates. You can remove such facts at run time with the standard predicates retract and retractall. You can save predicates from facts’ section to a file and can consult or reconsult it in program. You can create or edit such a fact file with an editor, and then insert facts from the file into your running program with consult. You can call database predicates in your program just like you call other predicates.

You can handle facts as when using the domain internally, generated for a database section. It is simple to build queries using references and relationships. Example: Suppose department of an educational institute stores this information for each student. student number, last name, first name, street, city, state, major, minor, class taken, time, class credit hours, class meeting time, class grade, total credit hours, total honor points, and honor point average a database system should be able to handle queries about any combination of fields pertaining to an individual student; which Prolog can do very well. The above attributes are divided into three relations (tables): student, class, and major, having the formats following and with key fields indicated by all capital letters. 1 – NF OF DATABASE: student( STUDENT_NUMBER, Last_name, First_name, Street_address, City, State) class(CLASS_NAME, STUDENT_NUMBER, Credit_hours, Meeting_time, Grade) major(STUDENT_NAME, Major_subject, Minor_subject)

RECORDS: student(1001, student(1022, student(1099, student(2000, student(3022, student(4001, student(5000, student(5055, student(6000, student(6087, student(7001, student(7555, student(8005,

brown, sam, happy_way,marquette, mi). andrews, andy, kin_olaf_st, marquette, mi). cummings, maria, gray_rd, marquette, mi). xylon, fed, greenview_ave, lansing, mi). franklin, georgia, burrow_way, detroit, mi). green, nancy, greenview_rd, mt_pleasant, mi). green, sam, greenview_rd, mt_pleasant, mi). pershing, xerexes, happy_way, marquette, mi). petersen, olaf, blackstone_blvd, detroid, mi). sklarson, bill, center_blvd, milwaukee, wi). timmons, timmy, twin_st, minneapolis, mn). young, chiquita, felton_st, philadelphia, pa). herring, cremora, briggs_blvd, Detroit, mi).

class(elem_math, 1001, 3, m900). class(elem_math, 2000, 3, m900). class(elem_math, 4001, 3, m900). class(elem_math, 7555, 3, m900). class(elem_math, 8005, 3, m900). class(intro_comp, 1001, 3, m1100). class(intro_comp, 2000, 3, m1100). class(intro_comp, 5000, 3, m1100). class(intro_comp, 6087, 3, m1100). class(intro_comp, 7555, 3, m1100). class(english_comp, 3022, 4, t800). class(english_comp, 4001, 4, t800). class(english_comp, 5000, 4, t800). class(english_comp, 6000, 4, t800). class(english_comp, 6087, 4, t800). class(english_comp, 7001, 4, t800). class(english_comp, 8005, 4, t800). class(intro_bus, 1001, 3, t1200). class(intro_bus, 4001, 3, t1200). class(intro_bus, 5000, 3, t1200). class(intro_bus, 6000, 3, t1200). class(intro_bus, 7001, 3, t1200). class(intro_bus, 7555, 3, t1200).

major(1001, major(1022, major(1099, major(2000, major(3022, major(4001, major(5000, major(5055, major(6006, major(6087,

business, economics). business, economics). business, economics). computer_sci, math). ing, business). business, ing). computer_sci, bussiness). computer_sci, economics). economics, ing). economics, computer_sci).

major(7001, ing, economics). major(7555, ing, business). major(8005, economics, ing).

OBJECTS: 1. Find the complete address (street, city, state) of student Sam Brown. Find the student number of student Xeroxed Pershin. 2. Find Olaf Petersen’s major and minor fields. 3. List the names off all students living in Michigan (MI). 4. List the student numbers of all Lower Peninsula students (i.e., students living in Michigan, but not in Marquette). 5. List the student numbers of all students taking elem_math. List the names of all students taking elem_math. 6. List the names of all students with business as their major field. 7. List the names and address of all students with economics as their minor field. 8. List the names of all students taking a class at noon on Tuesdays (t1200).

QUERIES FOR ABOVE OBJECTS: 1. student(_, brown, sam, Street, City, State). student(Student_number, pershing xerxes, _, _, _). 2. student(Student_number, petersen, olaf, _, _, _), major(Student_number, Major, Minor). 3. student(_, Lastname, Frstname, _, _, mi). 4. student(Student_number, _, _, _, City, mi), City /= marquette. Or student(Student_number, _, _,_ , City, mi), not(City = marquette). 5. class(elem_math, Student_number, _, _). class(elem_math, Student_number, _, _), student(Student_number, Lastname, Firstname, _, _, _). 6. student(Student_number, Lastname, Firstname, Street, City, State), major(Student_number, business, _). 7. student(Student_number, Lastname, Firstname, Street, City , State), major(Student_number, _, economics). 8. class(_, Student_number, , t1200), major(Student_number, Lastname, Firstname, _, _, _).

LAB#6 TO UPDATE/ DELETE RECORDS ON RUN-TIME USING ASSERT AND RETRACT.

Make a fact file for update/ delete operations and consult it, then assert a fact which is being used in the program which is to be updated i.e., class (_, _, _); at console to make it to use dynamically at run – time. This operation defines a dynamic rule. Example: ?- assert(class(1001, umer, g)). ?- assert(class(1002, ali, g)). ?- assert(class(1003, mariam, g)). ?- assert(class(1004, zia, g)). ?- retract(class(1001,umer,g)). ?- asserta(class(1005,ali,g)). ?- retractall(class(_,ali,_)).

OBJECT: assign_grade:write('Enter Student\'s number: '),read(ID),nl,class(X,ID,Y,Z), write('current record'),nl, write('--------------'),nl, write('Course Name:'),tab(5),write(X),nl, write('Credit hour:'),tab(5),write(Y),nl, write('Class Timing:'),tab(5),write(Z),nl, write('Enter new credit hour: '),read(Grade), call(retract(class(X,ID,Y,Z))), call(assert(class(X,ID,Grade,Z))),nl, class(Name,ID,NewGrade,Z), write('updated record'),nl, write('--------------'),nl, write('Name: '),tab(5),write(Name),nl, write('New Credit hour: '),tab(5),write(NewGrade). Hint: Add built in function :-dynamic class/4 before defining facts ‘class’.

LAB#7 TO WORK WITH FILES FOR READING AND WRITING. Files can be handled in Prolog using following built-in predicates. see(F)

/* File F becomes the current input stream. */

seeing(F) seen tell(F) telling(F) told close(F) rename(F,N)

/* F is unified with the name of the current input file. */ /* Closes current input stream. */ /* File F becomes the current output stream. */ /* F is unified with the name of the current output file. */ /* Closes the current output stream. */ /* File F, currently open for input or output, is closed. */ /* If file F is currently open, it is closed and renamed to N. If N is '[]', the file is deleted. */

Some extra file operations: delete_file rename_file size_file Cd make_directory delete_directory rename_directory Example 1: seeing(File) see(File) read(Data) seen File='' will select the keyboard for the input source

Example 2: browse(File) :seeing(Old), see(File), repeat, read(Data), process(Data), seen, see(Old), !

/* save for later */ /* open this file */ /* read from File */ /* close File */ /* previous read source */ /* stop now */

process(end-of-file) :- !. process(Data) :- write(Data), nl, fail.

LAB#8 TO USE PROLOG LISTS AND LIST MANIPULATION. List Construction: The construction of a list is the reverse: take a variable bound to any old list i.e., X=[r, e, d] and add the element, say, b at the front with: Result_Wanted = [b|X] List Destruction: First, we show how to remove the first element from a list. [X|Y] = [f,r,e,d] will result in X=f // The first element of the list is known as the HEAD of the list. Y=[r,e,d] Recursion using LIST: print_a_list([]). print_a_list([H|T]):-

write(H), print_a_list(T).

Lists, for now, can be regarded as special Prolog structures that can be used to represent an ordered sequence of Prolog . For example, here are some legal lists: [ice_cream, coffee, chocolate] [a, b, c, c, d, e] [] [dog(fido), cat(rufus), goldfish(jimmy)] [happy(fred),[ice_cream,chocolate],[1,[2],3]]

// a list with three elements (all atoms) // a list with six elements (all atoms) // a list with no elements in it (it is an atom) // a list with three elements (all Prolog ) // a list with three elements!

The last example is a little difficult to decipher: the first element is happy(fred), the second is [ice_cream,chocolate], a list, and the third is [1,[2],3], another list. Member: member(X,[X|R]). member(X,[Y| R]) :- member(X,R). One can read the clauses the following way, respectively: X is a member of a list whose first element is X. X is a member of a list whose tail is R if X is a member of R. This program can be used in numerous ways. One can test hip: ?- member(2,[1,2,3]). Yes

EXAMPLES: One can generate of a list: ?- member(X,[1,2,3]). X=1; X=2; X= 3 ; No Here is a derivation tree showing how this last goal generated all of the answers.

Each left branch corresponds to a match (unification) against the first clause for 'member' and each right branch corresponds to a match against the second clause. The sub goal 'member(X,[])' on the lowest right branch will not match the head of any 'member' clause. In particular '[]' will not unify with a pattern of the form '[X|R]' because the latter represents a list with at least one element. We will find many other uses for 'member'. This example query. ?- member([3,Y], [[1,a],[2,m],[3,z],[4,v],[3,p]]). Y=z; Y = p ; No Suggests a use where one intends to search in order to find elements paired with a specified element. Here is another, finding elements of a list which satisfy some constraint: ?- member(X,[23,45,67,12,222,19,9,6]), Y is X*X, Y < 100. X = 9 Y = 81 ; X = 6 Y = 36 ; No The definition for 'member' is usually written member(X,[X|_]). member(X,[_|R]) :- member(X,R). where '_' (underscore) designates a "don't-care" variable, usually called anonymous variables. In general, such variables have names whose first character is the underscore. In effect, they match any Prolog term, but no variable binding results from the free match. Notice that this is consistent with the original intentions of the definition of 'member'. Not having to bind values to anonymous variables saves a little run-space and run-time

W ri tin g li s t: w r i t el is t ([ ] ) . w r i t el is t ([ H |T ] ): - w r i t e( H ), nl , w ri t el is t ( T ) . W ri tin g revers e li s t: Method #1 : rev_list([ ]) . rev_list ([H |T] ):-rev_list(T),n l,write(H) . Method #2 : reverse([X|Y ],Z,W ):-reverse(Y,[X|Z],W ). reverse([ ],X ,X ) . This program illustrates Prolog's approach to an important strategy using an accumulating parameter (the middle variable). To accumulate a list answer until the computation is finished. For example, consider the following (partial) derivation tree. ? - reverse([ 1, 2 ,3] , [ ] , A ) | reverse([ 2 ,3] ,[ 1] ,A ) | reverse([ 3] ,[ 2 , 1] ,A ) | reverse([ ] ,[ 3, 2 ,1] ,A ) | true A = [ 3 ,2 , 1] OBJECT: Do these unify? If yes what is the value of free variable after unification? ???????????-

A= [a,d,z,c], A = [H|T]. A=[a,b,c], A= [a|Rest]. A=[pear,grape,orange],A=[C,grape|Rest]. A=[pear,grape,orange],A=[C,orange|Rest]. [a,[]] = [A,B|Rest]. [a]=[One]. A=[a,b,c,d],A=[a,b,X]. A=[a,b,c,d],A=[a,b,X,Y]. [a,b,c,d]=[a,b,X,Y]. [a,[aa,b]] = [A,B|Rest]. [a,[aa,b],c] = [A,B|Rest].

LAB#9 TO WORK WITH MEDICAL DIAGNOSIS USING LISTS Theory:

cause(disease1, cause(disease2, cause(disease3, cause(disease4, cause(disease5, cause(disease6, cause(disease7,

[symptom1]). [symptom2]). [symptom3]). [symptom1, symptom2]). [symptom1, symptom3]). [symptom2, symptom]). [symptom1, symptom2, symptom3]).

diagnose(Person, Disease):suffers_from(Person, Symptoms), cause(Disease, Symptoms).

suffers_from(Person, Symptoms):write(‘ Patient name ? ‘), read(Patient), write(‘ Give list of symptoms ‘), read(Symptoms). hi_doctor:diagnose(Person, Disease), write(Person),nl, write(Disease),nl.

LAB#10 TO STUDY SENTENCE PARSING Sentence parsing architecture:

Sentence

Noun Phrase

Article

Verb Phrase

Noun

Verb

Noun Phrase

Article The

man

likes

A PROLOG APPLICATION: (%% Rule base:) parseSentence(X) :- sentence(X,[]). sentence(Start, End) :- nounphrase(Start, Rest), verbphrase(Rest, End). nounphrase([Noun|End],End) :- noun(Noun). nounphrase([Article, Noun|End],End) :article(Article), noun(Noun). verbphrase([Verb|End], End) :- verb(Verb). verbphrase([Verb|Rest],End) :- verb(Verb), nounphrase(Rest, End).

%% Facts/ Knowledge base: article(a). article(the). noun(man). noun(horse). verb(likes).

the

Noun horse

%% Queries: ?- parseSentence([the,man,likes,the,horse]). Yes ?- parseSentence ([the,man,likes,the,X]). X = man ; X = horse Yes

?- parseSentence ([a,likes,the,X]). No Parsing a f unction : parse( X , Y ):-parse( X,Y,_). parse( X , Y, A ):-Z= . . [X,Y,A],call(Z) . :-arithmetic_function(hi/1) . hi(A,C):-C is A*60,print(C ) .

definition in .pl fil e

? - parse(hi,2).120 query Yes

LAB#11 TO STUDY THE GENERATION OF A TRUTH TABLE – A CASE STUDY Truth table maker: The purpose of this section is to develop a Prolog program for calculating and displaying truth tables

for Boolean expressions involving 'and', 'or', and 'not'. We seek the following kind of program behavior: ?- tt(x or (not y and z)). [x,y,z] x or (not y and z) ----------------------------------[0,0,0] 0 [0,0,1] 1 [0,1,0] 0 [0,1,1] 0 [1,0,0] 1 [1,0,1] 1 [1,1,0] 1 [1,1,1] 1 ----------------------------------So, the program will be required to do the following things: ! ! ! ! !

recognize infix Boolean expressions involving Boolean operations 'and', 'or', and 'not' find the variables in a Boolean expression generate an initial truth assignment for as many variables as there is in the expression evaluate the expression at a particular truth assignment generate the next truth assignment in binary count-up order

In order to use 'and' and 'or' as infix operators, declarations such as the following will suffice :- op(1000,xfy,'and'). :- op(1000,xfy,'or'). The 'not' operator may already be recognized by Prolog (as negation as failure), but if not, then the declaration :- op(900,fy,'not'). will make 'not' bind more tightly than 'and' and 'or'. Generally, it will probably be better to use parentheses in the Boolean expressions, rather than trying to figure out a fool-proof precedence scheme that the program needs to know about. To find the variables in a Boolean expression, we propose a Prolog definition whose profile is find_vars(+The_Expression,+Previously_Found_Variables,-Answer) indicating that the expression and the previously found variables are supplied on a call, and that the answer gets "bound" by the program. find_vars(N,V,V) :- member(N,[0,1]),!. /* Boolean constants in expression */ find_vars(X,Vin,Vout) :- atom(X), (member(X,Vin) -> Vout = Vin ; /* already have */ Vout = [X|Vin]). /* include */ find_vars(X and Y,Vin,Vout) :- find_vars(X,Vin,Vtemp), find_vars(Y,Vtemp,Vout). find_vars(X or Y,Vin,Vout) :- find_vars(X,Vin,Vtemp), find_vars(Y,Vtemp,Vout). find_vars(not X,Vin,Vout) :- find_vars(X,Vin,Vout). For example,

?- find_vars(x and (y or x), [], V). V = [y,x] Notice that find_vars will produce a list of variables in their right-to-left occurrence order in the original expression. Why? We will reverse this list of variables in the main program. To generate the initial truth assignment, use the list of variables as a guide: initial_assign([],[]). initial_assign([X|R],[0|S]) :- initial_assign(R,S). For example, ?- initial_assign([w,x,y,z],A). A = [0,0,0,0] The program to generate the successor truth assignment is as follows: successor(A,S) :- reverse(A,R), next(R,N), reverse(N,S).

For example, what is proposed should work like this? [0,1,0,1] == reverse ==> [1,0,1,0] ==next==> [0,1,1,0] ==reverse==>[0,1,1,0] where the point of reversing is that it would be easier to describe binary addition to the front of a list, rather than to the end of a list. The predicate 'next' will be a recursive N-bit binary adder, where N is the number of variables in the Boolean expression. next([0|R],[1|R]). next([1|R], [0|S]) :- next(R,S).

Now, to evaluate the Boolean expression, a recursive-descent evaluator should be easy to define. We propose the following profile: truth_value(+Expression,+Variable_List,+Assign_List,-Truth_Value) so that we can expect to be able to use this in the following way. ?- truth_value(not x or y, [x,y],[1,0],V. V=0 Here is a definition for 'truth_value'. truth_value(N,_,_,N) :- member(N,[0,1]). truth_value(X,Vars,A,Val) :- atom(X), lookup(X,Vars,A,Val).

truth_value(X and Y,Vars,A,Val) :- truth_value(X,Vars,A,VX), truth_value(Y,Vars,A,VY), boole_and(VX,VY,Val). truth_value(X or Y,Vars,A,Val) :- truth_value(X,Vars,A,VX), truth_value(Y,Vars,A,VY), boole_or(VX,VY,Val). truth_value(not X,Vars,A,Val) :- truth_value(X,Vars,A,VX), boole_not(VX,Val).

The 'lookup' predicate uses positional association. lookup(X,[X|_],[V|_],V). lookup(X,[_|Vars],[_| A],V) :- lookup(X,Vars,A,V).

Now we need the driver to force the generation of the entire truth table. The intention is to construct the truth table by means of first finding the variables (already discussed), calculating an initial truth assignment (also already discussed), and then filling out the table row-by-row, or, in a picture tt(E) :- find_vars(E,[],V), reverse(V,Vars), initial_assign(Vars,A), write(' '), write(Vars), write(' '), write(E), nl, write('-----------------------------------------'), nl, write_row(E,Vars,A), write('-----------------------------------------'), nl. where write-row will call itself to write the next row of the truth table (if there should be a next row in the table). write_row(E,Vars,A) :- write(' '), write(A), write(' '), truth_value(E,Vars,A,V), write(V), nl, (successor(A,N) -> write_row(E,Vars,N) ; true).

The 'write_row' definition relies of the failure of successor when A == [1,1,1,...,1]. Lastly, we supply the truth tables. boole_or(0,0,0). boole_not(0,1). boole_or(0,1,1). boole_not(1,0). boole_or(1,0,1). boole_and(0,0,0). boole_or(1,1,1). boole_and(0,1,0). boole_and(1,0,0). boole_and(1,1,1). OBJECT: Add the Boolean operations 'nand', 'nor', and 'xor' to the program.

LAB#12 TO WORK WITH arithmetic_fuction/{arity-1} AND op/1 PARSING IN PROLOG Making defined functions: Example 1: :-arithmetic_function(myFunction/1). myFunction(A,B):-B is A+1. OPERATOR OVERLOADING: op(Priority,Appearence,Name)

| |

|

-- xfy, yfx, xfx, fx, fy, xf, yf -- the higher number the priority has, the lower priority op(1200,xfx,':-'). op(1200,fx,[:-,?-]). op(1100,xfy,';'). op(1000,xfy,','). op(700,xfx,[=,is,<,>,=<,>=,==,=:=]). op(500,yfx,[+.-]). op(500,fx, [+,-,not]). op(400,yfx,[*,/,div]). op(300,xfx,mod). Instead of explaining the meaning of above definition, look at the following example. op(400,yfx,'*'). % a*b*c means ((a*b)*c) op(500,yfx,'+'). op(500,yfx,'-'). % be careful a-b-c means ((a-b)-c) op(700,xfx,'=') % it is not possible to write a=b=c Example 3: ?- op(100,yfx,'+'). Yes ?- op(200,yfx,'*'). Yes ?- Y is 2+2*2. Y=8 Yes

Example 4: ?op(9,yf,'-'). Yes - (A,B) : - S is A - B. [Definition in .pl file] ?- -(4,3). Yes ?- X is -(4,3). X=1 Yes ?- X is -(4,-(2,0)). X=2 Yes ?- X is -(-(2,0),(3,4)). X = 3 Yes Example 5: ?- op(100,xfx,'plus'). ?- Asserta( (X plus Y :- Z is X+Y,write(Z)) ). ?- 2 plus 4. 6 Yes Example 6: :- op(25,xf,[minutes]). :- arithmetic_function(minutes/1). minutes(M,S) :-S is M * 60. Query: ?- Time is 3 minutes. Time = 180 yes. Example 7: ?- op(100,yfx,'+'). Yes

Example 8: ?- op(200,yfx,'*'). Yes ?- Y is 2+2*2. Y=8 Yes

Example 9: ?- op(100,xfx,'plus'). ?- Asserta( (X plus Y :- Z is X+Y,write(Z)) ). ?- 2 plus 4. 6 Yes Example 10: ?op(11,yf,'*'). ?op(11,yf,'+'). ?- I is *(4 , +(3,3)). I = 24 Yes

Example 11: : :

- op ( 2 5,x f ,[ m in ute s ] ) . - ar it hm eti c _ fu n ct i on ( mi nu t es/ 1 ) . m i nu t es ( M ,S ) : - S i s M * 6 0 . E x a mpl e1 2: ? - T i m e is 3 mi n ut e s . T i m e = 18 0 yes STRINGIZING AND TOKEN PASTING: Token: Token is the smallest unit in a program which can’t be broken up more into its components by the program. #

include<stdio.h > #define VAR(i,j) (i##j) define paster(n) printf("token" #n "= %d", token##n)

#

void main(void) { int z1=2; int a =VAR(z,1); int tokeni=3; paster(i);

}

( = . . ' uni v' ) cross converts for term and list . ?- P =.. [a,b,c]. P = a(b, c) Yes ?[a,b,c] =.. P. P = ['.', a, [b, c]] Yes ?- a(b, c) =..P. ------Making tokens from predicates P = [a, b, c] Yes ? X i s h i ( 2 ) , [ X , a ] = . . S . 1 2 0 X = 120 S = ['.', 120, [a]] Yes ?

------- Making predicates from tokens ------- list to list( categorizing predicate name, arity list and period ’.’)

p a r e n t ( a , X ) = . . L . L = [ p a r e n t , a , _ X 0

0 1 ] ? P = . . [ p a r e n t , j a c k , m a r y ] . P = p a r e n t ( j a c k , m a r y

) ? - yes = .. L . L = [ yes ] ? P = . . [ f a c t ] . P = f a c t MAKING PREDICATES USING TOKENS AND SEPARATED P = . . [ h i , 2 ] , c a l

l ( C i s P ) . 1 2 0 P = h i ( 2 ) C = 1 2 0 Y e s Parsing a function : : - arithmetic_function(hi /1) . file hi(A,C):-C is A*6 0, print(C). parse( X , Y ) : - parse( X , Y , _ ) . parse( X , Y, A ) : - Z= . . [ X, Y , A] , call(Z) . ? - parse( hi ,2 ) . 1 2 0 query

d e f i ni ti o n

in . p l

Y es ? - A =2,B=3,[A,B]=..C,C=[X|Y],Z=Y,M = . .[Y],Y=[N|O], write(N),w r i t e ( O ) .

US I NG Q UOTE S (“ “ O R ‘ ’) ? - w rit e ( "S e co nd s") . [ 32 , 8 3 , 1 01 , 9 9 , 1 1 1 , 1 10 , 1 0 0, 115 ] yes ? - w rit e ( ‘ S ec on ds’ ) . S eco nd s Yes Arithmetic Comparison Operators The arithmetic comparison operators are :<=<>>==:=/= X Y True if X is greater than Y. X>= True if X is greater than or equal to Y. X=:=Y True if X is equal to Y. X=/=Y True if the values of X and Y are not equal unlike unification theses operators cannot be used to give values to a variable. The can only be valuated when every term on each side have been instantiated. Term Comparison comparison There is an order on the Prolog . The operators of comparison are :@<@=<@>@>= X@ Y The term X is greater than Y X@>=Y The term X is greater or equal to Y

The term order from the lowest to the highest is : 1. Variables. 2. Floating point numbers. 3. Integers. 4. Atoms in the alphabetical order.