BABU BANARSI DAS UNIVERSITY

LUCKNOW, U.P.

Lab Manual
on
Artificial Intelligence (BCS 3751)
For
B.Tech 4thYear (Sem. 7th)

Session (2024-25)

Page 1 of 16
 Babu Banarasi Das University

Subject: AI Lab (BCS3751) Program: B.Tech, CSE IV Year (Sem-VII)

INDEX
S.No. Practical’s Name Page Date Remark
No.
1. Write simple fact for the statements using PROLOG. 3
2. Write predicates one converts centigrade temperatures to 4
Fahrenheit, the other checks if a temperature is below
freezing.
3. Write a program to solve the Monkey Banana problem. 5-6
4. WAP in turbo prolog for medical diagnosis and show the 7-8
advantage and disadvantage of green and red cuts.
5. WAP to implement factorial, Fibonacci of a given number. 9
6. Write a program to solve 4-Queen problem. 10-11`
7. Write a program to solve traveling salesman 12-13
problem.
8. Write a program to solve water jug problem using 14-16
LISP.

Page 2 of 16
 Program No.: 1

OBJECTIVE: Write simple fact for the statements using PROLOG.

a) Ram likes mango.

b) Seema is a girl.
c) Bill likes Cindy.
d) Rose is red.
e) John owns gold.

Program:

Clauses
likes(ram, mango).
girl(seema).
red(rose).
likes(bill, cindy).
owns(john, gold).

Output:

Goal
queries
?--likes(ram,What).
What=mango
?-likes(Who,cindy).
Who=cindy
?-red(What).
What=rose
?-owns(Who,What).
Who=john
What=gold.

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

Page 3 of 16
 Program No.: 2

OBJECTIVE: Write predicates one converts centigrade temperatures 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.

Page 4 of 16
 PROGRAM No. : 3

OBJECTIVE: 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

Page 5 of 16
 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.

Page 6 of 16
 PROGRAM No. : 4

OBJECTIVE: WAP in turbo prolog for medical diagnosis and show t he

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),!,
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.

Page 7 of 16
 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),
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.

Page 8 of 16
 PROGRAM No. : 5

OBJECTIVE: 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:
Goal:
?-fib(10,X).
X=55

OUTCOME: Student will understand the implementation of Fibonacci and factorial

series using prolog.

Page 9 of 16
 PROGRAM No. : 6

OBJECTIVE: 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) 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)):-!.

Page 10 of 16
 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).
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.

Page 11 of 16
 PROGRAM No. : 7

OBJECTIVE: 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).
road("gordon","tampa",300).
road("houston","gordon",100).
road("houston","kansas_city",120).

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

Page 12 of 16
 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.

Page 13 of 16
 PROGRAM No. : 8

OBJECTIVE: 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))))

;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)

Page 14 of 16
(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
(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))))

Page 15 of 16
;;;MAIN FUNCTION
(defun dfs (start-state depth lmt)
(setf *node* 0)

(setf *limit* lmt)

(dfs-node start-state depth)
)

;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.

Page 16 of 16