Page1

Krishna Engineering College

Practical File

Artificial Intelligence Lab (RCS752)

Submitted By:
Name: Kunal Singh Solanki
Date: 08/02/2024
Roll No: 1716110101
Branch: CSE
Year: 4th
Submitted To:
Index

INDEX
EXPERIMMENT
S NO. DATE REMARKS
Study of prolog
1.

Write simple facts for the

2. statements using
PROLOG.
Write predicates. One
converts centigrade
temperatures to
3.
Fahrenheit, the other
checks if a temperature is
below freezing.
Write a program to solve
the Monkey banana
4.
problem.

WAP in turbo prolog for

medical diagnosis and
5. show the advantage and
disadvantage of green and
red cuts.
WAP to implement
factorial, Fibonacci of a
6.
given number.

Write a program to solve

7.
the 4-Queen problem.
Write a program to solve
traveling salesman
8.
problem.

Write a program to solve

water jug problem using
9.
LISP
 Practical: - 01
Objective: - Study of prolog.

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), Marten van Emden at Edinburgh (experimental
demonstration) and Alian Colmer Auer 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 centered around 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.
FOR EXAMPLE:
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:
grand f.gher( 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
Use••offeatures.
following knowledge
Modification
Capable
Symbolic ofrather
ofcomputations
explaining than
the knowledgedata
basemanipulations
conclusion.
resembling without recompilation
of naturaloflanguage.
the control programs.
➢
Reason with meta-knowledge.

META PROGRAMMING
A meta-program is a program that takes other programs as data. Interpreters and compilers
are examples of mela-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.
 Practical: - 02
Objective: - Write simple fact for the statements using PROLOG.

Software Requirement: SWI-Prolog and OS.

Statements:
1. The Cakes are delicious.
2. The Chicken is delicious.
3. The Chicken is spicy.
4. Priya relishes coffee.
5. Priya likes food if they are delicious.
6. Prakash likes food if they are spicy and delicious.

Statements in Prolog:
1. delicious(cakes).
2. delicious(chicken).
3. spicy(chicken).
4. relishes(priya, coffee).
5. likes(priya, Food) if delicious(Food). %Here Food is a variable
6. likes(prakash,Food) if spicy(Food) and delicious(Food).

Program Clauses:
delicious(cakes).
delicious(chicken).
spicy(chicken).
relishes(priya, coffee).
likes(priya, Food):-delicious(Food).
likes(prakash, Food):- spicy(Food), delicious(Food).

Goal 1: Which food items are delicious.

Output:
Goal 2: What does food Priya like.

Output:

Goal 3: What does food Prakash like.

 Practical: - 05
Objective: - WAP in turbo prolog for medical diagnosis and show the advantage and
disadvantage of green and red cuts.

Software Requirement: SWI-Prolog and OS.

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.
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.
 Practical: - 06
Objective: WAP to implement Factorial, Fibonacci of a given number.

Software Requirement: SWI-Prolog and OS.

Factorial Program:

factorial(0,1).
factorial(N,F):-
N>0,
N1 is N-1,
factorial(N1,F1),
F is N * F1.

Output:

Fibonacci Program:

fib(0, 1) :- !.
fib(1, 1) :- !.
fib(N, F) :-
N>1,
N1 is N-1,
N2 is N-2,
fib(N1, F1),
fib(N2, F2),
F is F1+F2.

Output:
 Practical: - 03
Objective: Write predicates one converts Centigrade temperatures to Fahrenheit, the other
checks if a temperature is below freezing.

Software Requirement: SWI-Prolog and OS.

Program:

c_to_f(C,F) :-F is C * 9 / 5 + 32.

freezing (F) :-F =< 32. % here freezing point is less than 32 Fahrenheit

Output:
 Practical:- 04

Objective: Write a program to solve the Monkey Banana problem.

Software Requirement: SWI-Prolog and OS.

Explanation: Assume that a room containing a Monkey, a Table and a Banana. The Banana is
hanging from the ceiling of the room. Table is not below the banana. Monkey is anywhere in the
room. In this program/problem we will prove that monkey can grasp the banana. If the monkey is
clever he can grasp the banana by placing the table below the banana. Monkey only can reach the
banana if he jumps from the table, otherwise he cannot reach to banana by jumping from floor or
anywhere in room (except table). Monkey (strong monkey) can push the table.

Program:

on(floor,monkey).
on(fllor,box).
in(room,monkey).
in(room,box).
in(room,banana).
at(ceiling,banana).
strong(monkey).
grasp(monkey).
climb(monkey,box).
push(monkey,box):-strong(monkey).
under(banana,box):-push(monkey,box).
canreach(banana,monkey):-at(floor,banana);
at(ceiling,banana),under(banana,box),climb(monkey,box).
canget(banana,monkey):-canreach(banana,monkey),grasp(monkey).

Output:
 Practical: - 07
Objective: Write a program to solve traveling salesman problem.

Software Requirement: SWI-Prolog and OS.

Program:

road("A","B",200).
road("C","A",300).
road("B","C",100).
road("B","D",120).
road("C","D",130).
route(Town1 , Town2 , Distance):-road(Town1, Town2 , Distance).
route(Town1 , Town2 , Distance):-road(Town1, X , Distance1),route(X , Town2 , Distance2) ,
Distance is Distance1+Distance2,!.

Output:

Find the distance between A and B:

Find the distance between A and D:

 Practical: - 06
Objective: Write a program to solve 4-Queen problem.

Software Requirement: SWI-Prolog and OS.

Program:

queen = q(integer, integer)

queens = queen*
freelist = integer*
board = board(queens, freelist, freelist, freelist, freelist)
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)
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).
nextrow(Row,[Row|Rest],Rest).

Output:

?-nqueens(4),nl.
board([q(1,2),q(2,4),q(3,1),q(4,3),[],[],[7,4,1],[7,4,1])
yes
 Practical: - 09
Objective: Write a program to solve water jug problem using LISP.

Software Requirement: SWI-Prolog and OS.

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

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