INDEX

S. No. Program Name Date

1 Study of Prolog.

2 Write simple fact for the statements using PROLOG.

Write a program to define the family member
relationship.
i. If (x is father of y) or (x is mother of y) then (x is
parent of Y).
ii. If (x is parent of z) and (z is parent of y) then (x is
grandparent of y).
3
iii. If (y is parent of x) and (x is male) then (x is son
of y).
iv. Cousin.
v. Grandchild
vi. Uncle
vii. Brother and sister.
Write predicates one converts centigrade temperatures to
4 Fahrenheit, the other checks if a temperature is below
freezing.
5 Write a program to solve the Monkey Banana problem.
WAP in turbo prolog for medical diagnosis and show the
6
advantage and disadvantage of green and red cuts.
7 WAP to implement factorial, fibonacci of a given number.

8 Write a program to solve 4-Queen problem.

9 Write a program to solve traveling salesman problem.

10 Write a program to solve water jug problem using LISP

 IEC-CET

Experiment No: 01
1. Study of PROLOG.

PROLOG-PROGRAMMING IN LOGIC:
PROLOG stands for Programming, In Logic — an idea that emerged in the early 1970’s
to use logic as programming language. The early developers of this idea included Robert
Kowaiski at Edinburgh (on the theoretical side), Marrten van Emden at Edinburgh (experimental
demonstration) and Alian Colmerauer at Marseilles (implementation).
David D.H. Warren’s efficient implementation at Edinburgh in the mid -1970’s greatly
contributed to the popularity of PROLOG. PROLOG is a programming language centred on a
small set of basic mechanisms, including pattern matching, tree based data structuring and
automatic backtracking. This Small set constitutes a surprisingly powerful and flexible
programming framework. PROLOG is especially well suited for problems that involve objects-
in particular, structured objects- and relations between them.

SYMBOLIC LANGUAGE:
PROLOG is a programming language for symbolic, non-numeric computation. It is
especially well suited for solving problems that involve objects and relations between objects.
For example, it is an easy exercise in prolog to express spatial relationship between objects, such
as the blue sphere is behind the green one. It is also easy to state a more general rule: if object X
is closer to the observer than object Y. and object Y is closer than Z, then X must be closer than
Z. PROLOG can reason about the spatial relationships and their consistency with respect to the
general rule. Features like this make PROLOG a powerful language for ArtJIcia1 LanguageA1,)
and non- numerical programming.
There are well-known examples of symbolic computation whose implementation in other
standard languages took tens of pages of indigestible code, when the same algorithms were
implemented in PROLOG, the result was a crystal-clear program easily fitting on one page.

FACTS, RULES AND QUERIES:

Programming in PROIOG is accomplished by creating a database of facts and rules about
objects, their properties, and their relationships to other objects. Queries then can be posed about
the objects and valid conclusions will be determined and returned by the program Responses to
user queries are determined through a form of inference control known as resolution.

STUDENT NAME (ROLL NO.) Page 1 of 24

 IEC-CET

FOR EXAIPLE:
a) FACTS:
Some facts about family relationships could be written as:
sister( sue,bill)
parent( ann.sam)
male(jo)
female( riya)

b) RULES:
To represent the general rule for grandfather, we write:
grandfather( X2)
parent(X,Y)
parent( Y,Z)
male(X)
c) QUERIES:
Given a database of facts and rules such as that above, we may make queries by typing after a
query a symbol’?’ statements such as:
?-parent(X,sam) Xann
?grandfather(X,Y)
X=jo, Y=sam

PROLOG IN DISGINING EXPERT SYSTEMS:

An expert system is a set of programs that manipulates encoded knowledge to solve
problems in a specialized domain that normally requires human expertise. An expert system’s
knowledge is obtained from expert sources such as texts, journal articles, databases etc. and
encoded in a form suitable for the system to use in its inference or reasoning processes. Once a
sufficient body of expert knowledge has been acquired, it must be encoded in some form, loaded
into knowledge base, then tested, and refined continually throughout the life of the system
PROLOG serves as a powerful language in designing expert systems because of its following
features.
a. Use of knowledge rather than data
b. Modification of the knowledge base without recompilation of the control programs.
c. Capable of explaining conclusion.
d. Symbolic computations resembling manipulations of natural language.

STUDENT NAME (ROLL NO.) Page 2 of 24

 IEC-CET

e. Reason with meta-knowledge.

Key Features:
a. Unification: The basic idea is, can the given terms be made to represent the same structure.
b. Backtracking: When a task fails, prolog traces backwards and tries to satisfy previous task.
c. Recursion: Recursion is the basis for any search in program.

META PROGRAMMING:
A meta-program is a program that takes other programs as data. Interpreters and
compilers are examples of meta-programs. Meta-interpreter is a particular kind of meta-program:
an interpreter for a language written in that language. So a PROLOG interpreter is an interpreter
for PROLOG, itself written in PROLOG. Due to its symbol- manipulation capabilities,
PROLOG is a powerful language for meta-programming. Therefore, it is often used as an
implementation language for other languages. PROLOG is particularly suitable as a language for
rapid prototyping where we are interested in implementing new ideas quickly. New ideas are
rapidly implemented and experimented with.

Advantages:
a. Easy to build database. Doesn’t need a lot of programming effort.
b. Pattern matching is easy. Search is recursion based.
c. It has built in list handling. Makes it easier to play with any algorithm involving lists.

Disadvantages:
a. LISP (another logic programming language) dominates over prolog with respect to I/O
features.
b. Sometimes input and output is not easy.

Applications:
Prolog is highly used in artificial intelligence (AI). Prolog is also used for pattern matching
over natural language parse trees.

OUTCOME: Students will get the basic idea of how to program in prolog and its working
environment.

STUDENT NAME (ROLL NO.) Page 3 of 24

 IEC-CET

Experiment No: 02

2. Write simple fact for the statements using PROLOG.

Simple Facts
In Prolog we can make some statements by using facts. Facts either consist of a
particular item or a relation between items. For example we can represent the fact that it is sunny
by writing the program:
sunny.
We can now ask a query of Prolog by asking

?- sunny.
?- is the Prolog prompt. To this query, Prolog will answer yes. sunny is true because (from

above) Prolog matches it in its database of facts.

Facts have some simple rules of syntax. Facts should always begin with a lowercase letter and
end with a full stop. The facts themselves can consist of any letter or number combination, as
well as the underscore _ character. However, names containing the characters -, +, *, /, or other
mathematical operators should be avoided.

Examples of Simple Facts

Here are some simple facts about an imaginary world. /* and */ are comment

delimiters john_is_cold. /* john is cold */

raining. /* it is raining */

john_Forgot_His_Raincoat. /* john forgot his raincoat */

fred_lost_his_car_keys. /* fred lost is car keys */

peter_footballer. /* peter plays football */

likes(ram ,mango) /* Ram likes mango*/

girl(seema) /* Seema is a girl */

likes(bill ,cindy) /* Bill likes Cindy */

OUTCOME: Student will understand how to write simple facts using prolog.

STUDENT NAME (ROLL NO.) Page 4 of 24

 IEC-CET

Experiment No: 03

3. Write a program to define the family member relationship.

i. If (x is father of y) or (x is mother of y) then (x is parent of Y).
ii. If (x is parent of z) and (z is parent of y) then (x is grandparent of y).
iii. If (y is parent of x) and (x is male) then (x is son of y).
iv. Cousin.
v. Grandchild
vi. Uncle
vii. Brother and sister.

LOGIC:
In domain section declare variable say x, y, z, A,N of type string.
Establish the relationship as below>-
1)
parent(x,y):-
father(x,y).
parent(x,y):-
mother(x,y).

2)
grandparent(x,y):-
parent(x,z).
parent(z,y).

3)
son(x,y):-
male(x).
parent(y,x).

4)
uncle(x,y):-
parent(z,y).

STUDENT NAME (ROLL NO.) Page 5 of 24

 IEC-CET

brother(x,y).

5)
brother(x,y):-
male(X).
parent(z,x).
parent(z,y).

6)
cousins(x,y):-
uncle(z,y).
parent(z,x).

7)
grandchild(x,y):-
son(x,z).
son(z,y).

8)
sister(x,y):-
female(x).
parent(z,x).
parent(z,y).

Now create database in the form of the fact as below:

father(jhon,smith).
father(mohit,meera).
mother(sheela,sunil).
mother(reeta,mee(a).
male(jhon).
male(smith).

STUDENT NAME (ROLL NO.) Page 6 of 24

 IEC-CET

male(mohit).
male(sunil).
female(sheela).
female(meera).
female(reeta).

CONCLUSION: The goal is successfully-achieved for family relationship

STUDENT NAME (ROLL NO.) Page 7 of 24

 IEC-CET

Experiment No: 04

4. Write predicates one converts centigrade temperature to Fahrenheit,

the other checks if a temperature is below freezing.

Program:
Production rules:
Arithmetic:

c_to_f → f is c * 9 / 5

+32 freezing → f < = 32

Rules:
c_to_f(C,F) :-
F is C * 9 / 5 + 32.
freezing(F) :-
F =< 32.
Output:
Queries:
?- c_to_f(100,X).
X = 212
Yes
?- freezing(15)
.Yes
?- freezing(45).
No

OUTCOME: Student will understand how to write a program using the rules.

STUDENT NAME (ROLL NO.) Page 8 of 24

 IEC-CET

Experiment No: 05

5. Write a program to solve the Monkey Banana problem.

Imagine a room containing a monkey, chair and some bananas. That have been hanged from the
centre of ceiling. If the monkey is clever enough he can reach the bananas by placing the chair
directly below the bananas and climb on the chair .The problem is to prove the monkey can
reach the bananas. The monkey wants it, but cannot jump high enough from the floor. At the
window of the room there is a box that the monkey can use. The monkey can perform the
following actions:-

1) Walk on the floor.

2) Climb the box.

3) Push the box around (if it is beside the box).

4) Grasp the banana if it is standing on the box directly under the banana.

Production Rules

can_reach → clever,close.

get_on: → can_climb.

under → in room,in_room, in_room,can_climb.

Close → get_on,under| tall

Parse Tree

STUDENT NAME (ROLL NO.) Page 9 of 24

 IEC-CET

Clauses:

in_room(bananas).

in_room(chair).

in_room(monkey).

clever(monkey).

can_climb(monkey, chair).

tall(chair).

can_move(monkey, chair, bananas).

can_reach(X, Y):-

clever(X),close(X, Y).

get_on(X,Y):-

can_climb(X,Y). under(Y,Z):-

in_room(X),in_room(Y),in_room(Z),can_climb(X,Y,Z).

close(X,Z):-get_on(X,Y),

under(Y,Z);

tall(Y).

Output:

Queries:

?- can_reach(A, B).

A = monkey.

B = banana.

?- can_reach(monkey, banana).Yes.

OUTCOME: Student will understand how to solve monkey banana problem using rules in
prolog.

STUDENT NAME (ROLL NO.) Page 10 of

24
 IEC-CET

Experiment No: 06

6. WAP in turbo prolog for medical diagnosis and show the advantage and
disadvantage of green and red cuts.

Program:

Domains:

disease,indication=symbol

name-string

Predicates:

hypothesis(name,disease)

symptom(name,indication)

response(char)

go

goonce

clauses

go:-

goonce

write("will you like to try again (y/n)?"),

response(Reply),

Reply='n'.

go.

goonce:-

write("what is the patient's name"),nl,

readln(Patient),

hypothesis(Patient,Disease),!,

STUDENT NAME (ROLL NO.) Page 11 of

24
 IEC-CET

write(Patient,"probably has",Disease),!,

goonce:-

write("sorry, i am not ina position to diagnose"),

write("the disease").

symptom(Patient,fever):-

write("does",Patient,"has a fever (y/n)?"),nl,

response(Reply),

Reply='y',nl.

symptom(Patient,rash):-

write ("does", Patient,"has a rash (y/n)?" ),nl,

response(Reply),

Reply='y',

symptom(Patient_body,ache):-

write("does",Patient,"has a body ache (y/n)?"),nl,

response(Reply).

Reply='y',nl.

symptom(Patient,runny_nose):-

write("does",Patient,"has a runny_nose (y/n)?"),

response(Reply),

Reply='y'

hypothesis(Patient,flu):-

symptom(Patient,fever),

symptom(Patient,body_ache),

hypothesis(Patient,common_cold):-

symptom(Patient,body_ache),
STUDENT NAME (ROLL NO.) Page 12 of
24
 IEC-CET

Symptom(Patient,runny_nose).

response(Reply):-

readchar(Reply),

write(Reply).

Output:

makewindow(1,7,7"Expert Medical Diagnosis",2,2,23,70),

go.

OUTCOME: Student will understand how to create a expert system using prolog.

STUDENT NAME (ROLL NO.) Page 13 of

24
 IEC-CET

Experiment No: 07

7. WAP to implement factorial, fibonacci of a given number.

Program:

Factorial:

factorial(0,1).

factorial(N,F) :-

N>0,

N1 is N-1,

factorial(N1,F1),

F is N * F1.

Output:

Goal:

?- factorial(4,X).

X=24

Fibonacci:

fib(0, 0).

fib(X, Y) :- X > 0, fib(X, Y, _).

fib(1, 1, 0).

fib(X, Y1, Y2) :-

X > 1,

X1 is X - 1,

fib(X1, Y2, Y3),

Y1 is Y2 + Y3.

Output:
STUDENT NAME (ROLL NO.) Page 14 of
24
 IEC-CET

Goal:

?-fib(10,X).

X=55

OUTCOME: Student will understand the implementation of Fibonacci and factorial series
using prolog.

STUDENT NAME (ROLL NO.) Page 15 of

24
 IEC-CET

Experiment No: 08

8. Write a program to solve 4-Queen problem.

Program:

In the 4 Queens problem the object is to place 4 queens on a chessboard in such a way that no
queens can capture a piece. This means that no two queens may be placed on the same row,
column, or diagonal.

The n Queens Chessboard.

domains

queen = q(integer, integer)

queens = queen*

freelist = integer*

board = board(queens, freelist, freelist, freelist, freelist)

predicates

nondeterm placeN(integer, board, board)

nondeterm place_a_queen(integer, board, board)

nondeterm nqueens(integer)

nondeterm makelist(integer, freelist)

nondeterm findandremove(integer, freelist, freelist)

STUDENT NAME (ROLL NO.) Page 16 of

24
 IEC-CET

nextrow(integer, freelist, freelist)

clauses

nqueens(N):-

makelist(N,L),

Diagonal=N*2-1,

makelist(Diagonal,LL),

placeN(N,board([],L,L,LL,LL),Final),

write(Final).

placeN(_,board(D,[],[],D1,D2),board(D,[],[],D1,D2)):-!.

placeN(N,Board1,Result):-

place_a_queen(N,Board1,Board2),

placeN(N,Board2,Result).

place_a_queen(N,

board(Queens,Rows,Columns,Diag1,Diag2),

board([q(R,C)|Queens],NewR,NewC,NewD1,NewD2)):-

nextrow(R,Rows,NewR),

findandremove(C,Columns,NewC),

D1=N+C-R,findandremove(D1,Diag1,NewD1),

D2=R+C-1,findandremove(D2,Diag2,NewD2).

findandremove(X,[X|Rest],Rest).

findandremove(X,[Y|Rest],[Y|Tail]):-

findandremove(X,Rest,Tail).

makelist(1,[1]).

makelist(N,[N|Rest]) :-

N1=N-1,makelist(N1,Rest).
STUDENT NAME (ROLL NO.) Page 17 of
24
 IEC-CET

nextrow(Row,[Row|Rest],Rest).

Output:

Goal:

?-nqueens(4),nl. board([q(1,2),q(2,4),q(3,1),q(4,3),[],[],[7,4,1],

[7,4,1])

yes

OUTCOME: Student will implement 4-Queen problem using prolog.

STUDENT NAME (ROLL NO.) Page 18 of

24
 IEC-CET

Experiment No: 09

9. Write a program to solve traveling salesman problem.

The following is the simplified map used for the prototype:

Program:

Production Rules:-

route(Town1,Town2,Distance) road(Town1,Town2,Distance).

route(Town1,Town2,Distance)
road(Town1,X,Dist1),route(X,Town2,Dist2),Distance=Dist1+Dist2,

domains

town = symbol

distance = integer

predicates

nondeterm road(town,town,distance)

nondeterm

route(town,town,distance) clauses

road("tampa","houston",200).
STUDENT NAME (ROLL NO.) Page 19 of
24
 IEC-CET

road("gordon","tampa",300).

road("houston","gordon",100).

road("houston","kansas_city",120).

road("gordon","kansas_city",130).

route(Town1,Town2,Distance):-

road(Town1,Town2,Distance).

route(Town1,Town2,Distance):-

road(Town1,X,Dist1),

route(X,Town2,Dist2),

Distance=Dist1+Dist2,!.

Output:

Goal:

route("tampa", "kansas_city", X),

write("Distance from Tampa to Kansas City is ",X),nl.

Distance from Tampa to Kansas City is 320

X=320

OUTCOME: Student will implement travelling salesmen problem using prolog.

STUDENT NAME (ROLL NO.) Page 20 of

24
 IEC-CET

Experiment No: 10

10. Write a program to solve water jug problem using LISP.

Program:

;returns the quantity in first jug

(defun get-first-jug (state) (car state))

;returns the quantity in second jug

(defun get-second-jug (state) (cadr state))

;returns the state of two jugs

(defun get-state (f s) (list f s))

;checks whether a given state is a goal

; GOAL IS TO GET 4 IN SECOND JUG

(defun is-goal (state)

(eq (get-second-jug state) 4))

;returns all possible states that can be derived

;from a given state

(defun child-states

(state) (remove-null

(list

(fill-first-jug state)

(fill-second-jug state)

(pour-first-second state)

(pour-second-first state)

(empty-first-jug state)

(empty-second-jug state))))
STUDENT NAME (ROLL NO.) Page 21 of
24
 IEC-CET

;remove the null states

(defun remove-null (x)

(cond

((null x) nil)

((null (car x)) (remove-null (cdr x)))

((cons (car x) (remove-null (cdr x))))))

;return the state when the first jug is filled (first jug can hold 3)

(defun fill-first-jug (state)

(cond

((< (get-first-jug state) 3) (get-state 3 (get-second-jug state))))))

;returns the state when the second jug is filled (second jug can hold 5)

(defun fill-second-jug (state)

(cond

((< (get-second-jug state) 5) (get-state (get-first-jug state) 5))))

;returns the state when quantity in first

;is poured to second jug

(defun pour-first-second (state)

(let ( (f (get-first-jug state))

(s (get-second-jug state)))

(cond

((zerop f) nil) ; first jug is empty

((= s 5) nil) ; Second jug is full

((<= (+ f s) 5)

(get-state 0 (+ f s)))

(t ; pour to first from second

STUDENT NAME (ROLL NO.) Page 22 of
24
 IEC-CET

(get-state (- (+ f s) 5) 5)))))

;returns the state when second jug is poured to first

(defun pour-second-first (state)

(let ( (f (get-first-jug state))

(s (get-second-jug state)))

(cond

((zerop s) nil) ; second jug is empty

((= f 3) nil) ; second jug is full

((<= (+ f s) 3)

(get-state (+ f s) 0))

(t ;pour to second from first

(get-state 3 (- (+ f s) 3))))))

;returns the state when first jug is emptied

(defun empty-first-jug (state)

(cond

((> (get-first-jug state) 0) (get-state 0 (get-second-jug state)))))

;returns the state when second jug is emptied

(defun empty-second-jug (state)

(cond

((> (get-second-jug state) 0) (get-state (get-first-jug state) 0))))

;;;MAIN FUNCTION

(defun dfs (start-state depth lmt)

(setf *node* 0)

(setf *limit* lmt)

(dfs-node start-state depth)

STUDENT NAME (ROLL NO.) Page 23 of
24
 IEC-CET

;dfs-node expands a node and calls dfs-children to recurse on it

(defun dfs-node (state depth)

(setf *node* (+ 1 *node*))

(cond

((is-goal state) (list state))

((zerop depth) nil)

((> *node* *limit*) nil)

((let ((goal-child (dfs-children (child-states state) (- depth 1))))

(and goal-child (cons state goal-child)))) ;for back-tracking if the branch don't have a goal state

))

;dfs-children expands each node recursively and give it

;to dfs-node to process

(defun dfs-children (states depth)

(cond

((null states) nil)

((dfs-node (car states) depth))

((dfs-children (cdr states)

depth))))

(print "ENTER YOUR INPUT AS")

(print "(dfs start_state depth limit)")

OUTCOME: Student will implement water-jug problem using LISP.

STUDENT NAME (ROLL NO.) Page 24 of

24