Department of Computer Science &

Engineering
NATIONAL INSTITUTE OF TECHNOLOGY SRINAGAR,
HAZARATBAL(J&K)

ARTIFICIAL INTELLIGENCE
(CSL353)
Lab File

(2020 – 2024)
For
6th Semester
Submitted To : Submitted By :
Dr. Ranjeet Kumar Rout Mr. Amir Shabir
Department of CSE 2020BCSE034
B.Tech CSE(6th Sem)
Lab-01 2020BCSE034

Implement the Depth First Search (BFS) Algorithm.

Breadth-first search is the process of traversing each node of the
graph, a standard BFS algorithm traverses each vertex of the graph
into two parts:

1)Visited 2) Not Visited. So, the purpose of the algorithm is to visit all
the vertex while avoiding cycles.

BFS starts from a node, then it checks all the nodes at distance one from
the beginning node, then it checks all the nodes at distance two, and so
on. So as to recollect the nodes to be visited, BFS uses a queue.

The steps of the algorithm work as follow:

1. Start by putting any one of the graph’s vertices at the back

of the queue.
2. Now take the front item of the queue and add it to the visited list.
3. Create a list of that vertex's adjacent nodes. Add those which are
not within the visited list to the rear of the queue.
4. Keep continuing steps two and three till the queue is empty.

BFS pseudocode
The pseudocode for BFS in python goes as below:
create a queue Q
mark v as visited and put v into Q
while Q is non-empty

remove the head u of Q

mark and enqueue all (unvisited) neighbors of u

 Code:- 2020BCSE034

Output:-
Lab-01 2020BCSE034
Implement the Depth First Search (DFS) Algorithm.

Depth-first search (DFS) is an algorithm for traversing or

searching tree or graph data structures. The algorithm starts at
the root node (selecting some arbitrary node as the root node
in the case of a graph) and explores as far as possible along
each branch before backtracking. A standard Depth-First Search
implementation puts every vertex of the graph into one in all 2
categories: 1) Visited 2) Not Visited.

The only purpose of this algorithm is to visit all the vertex of the
graph avoiding cycles.

The DSF algorithm follows as:

1. We will start by putting any one of the graph's vertex on top of

the stack.
2. After that take the top item of the stack and add it to the visited list
of the vertex.
3. Next, create a list of that adjacent node of the vertex. Add the
ones which aren't in the visited list of vertexes to the top of the
stack.
4. Lastly, keep repeating steps 2 and 3 until the stack is empty.

DFS pseudocode
The pseudocode for Depth-First Search in python goes as below:

DFS(G, u)

for each v ∈
u.visited = true

G.Adj[u] if v.visited
== false DFS(G,v)

For each u ∈ G
init() {

For each u ∈ G
u.visited = false

DFS(G, u)

}
Code:- 2020BCSE034

Output:-
Lab-02 2020BCSE034
Implement the n-Queen problem in python.

N - Queens problem is to place n - queens in such a manner on

an n x n chessboard that no queens attack each other by
being in the same row, column or diagonal.
The n- queens problem is a problem in which we figure out a way to put n-
queens on an n×n chessboard in such a way that no queen should attack the
other. For basic info about the queen in a chess game, we should know that a
queen can move in any direction ( vertically, horizontally, and diagonally) and
to any number of places.
In the figure below you can see how to place 8-queens on a 8×8 chessboard.
Similarly, we have to place 4 queens on an 4×4 chessboard. We will use
backtracking to solve this interesting problem(puzzle). Here, we use
backtracing.
One possible solution for 8-queens problem is shown in fig:

One possible solution for 4-queens problem is shown in fig:

Code:- 2020BCSE034

Output:-
Lab-03 2020BCSE034
Implement the 8-puzzle problem in python.
Definition:

“It has set off a 3x3 board having 9 block spaces out of which 8
blocks having tiles bearing number from 1 to 8. One space is left
blank. The tile adjacent to blank space can move into it. We
have to arrange the tiles in a sequence for getting the goal
state”.

Rules of solving puzzle

Instead of moving the tiles in the empty space we can visualize
moving the empty space in place of the tile.
The empty space can only move in four directions (Movement of
empty space)

1. Up
2. Down
3. Right or
4. Left

The empty space cannot move diagonally and can take only one
step at a time.
Code:- 2020BCSE034

Output:-
Lab-04 2020BCSE034

Implement A* Algorithm with suitable example.

A* search is the most commonly known form of best-first search. It uses
heuristic function h(n), and cost to reach the node n from the start state g(n).
A* search algorithm finds the shortest path through the search space using the
heuristic function. This search algorithm expands less search tree and provides
optimal result faster.
Time complexity is O(b^d), where b is the branching factor.
In A* search algorithm, we use search heuristic as well as the cost to reach the
node. Hence we can combine both costs as following:

Algorithm of A* search:
Step1: Place the starting node in the OPEN list.
Step 2: Check if the OPEN list is empty or not, if the list is empty then
return failure and stops.

Step 3: Select the node from the OPEN list which has the smallest value
of evaluation function (g+h), if node n is goal node then return success
and stop, otherwise

Step 4: Expand node n and generate all of its successors, and put n into
the closed list. For each successor n', check whether n' is already in the
OPEN or CLOSED list, if not then compute evaluation function for n' and
place into Open list.

Step 5: Else if node n' is already in OPEN and CLOSED, then it should be
attached to the back pointer which reflects the lowest g(n') value.
Step 6: Return to Step 2.

Advantages:

o A* search algorithm is the best algorithm than other search algorithms.

o A* search algorithm is optimal and complete.
Example: 2020BCSE034
In this example, we will traverse the given graph using the A* algorithm.
The heuristic value of all states is given in the below table so we will
calculate the f(n) of each state using the formula f(n)= g(n) + h(n), where
g(n) is the cost to reach any node from start state.
Here we will use OPEN and CLOSED list.

Solution:

Initialization: {(S, 5)}

Iteration1: {(S--> A, 4), (S-->G, 10)}
Iteration2: {(S--> A-->C, 4), (S--> A-->B, 7), (S-->G, 10)}
Iteration3: {(S--> A-->C--->G, 6), (S--> A-->C--->D, 11), (S--> A-->B, 7), (S--
>G, 10)}
Iteration 4 will give the final result, as S--->A--->C--->G it provides the
optimal path with cost 6.
Lab-04 2020BCSE034

Implement AO* Algorithm with suitable example.

The AO* search Algorithm is based on problem decomposition (Breakdown
problem into small pieces) When a problem can be divided or decomposed
into a set of sub problems, where each sub problem can be solved separately
and for each subproblem , sub solution is evaluated and a combination of
these sub solutions will be a whole solution, AND OR graphs or AND OR trees
are used for representing this solution. · AO* is informed search algorithm
,work based on heuristic.
We already know about the divide and conquer strategy, a solution to a
problem can be obtained by decomposing it into smaller sub-problems. · Each
of this sub-problem can then be solved to get its sub solution. These sub
solutions can then recombined to get a solution as a whole. That is called is
Problem Reduction.
AND-OR graphs or AND – OR trees are used for representing the solution. · This
method generates arc which is called as AND-OR arcs. One AND arc may point
to any number of successor nodes, all of which must be solved in order for an
arc to point to a solution. AND-OR graph is used to represent various kind of
complex problem solutions. · AO* search algo. is based on AND-OR graph so ,it
is called AO* search algo.
AND-OR Graph :

The figure shows an AND-OR graph

1. To pass any exam, we have two options, either cheating or hard

work.
2. In this graph we are given two choices, first do cheating
or (The red line) work hard and (The arc) pass.
3. When we have more than one choice and we have to pick
one, we apply OR condition to choose one.(That's what we
did here).
4. Basically the ARC here denote AND condition.
 2020BCSE034

5. Here we have replicated the arc between the work hard and
the pass because by doing the hard work possibility of
passing an exam is more than cheating.

How AO* works

Let's try to understand it with the following diagram:

Procedure:

1. In the above diagram we have two ways from A to D or A to B-C

(because of and condition). calculate cost to select a path
2. F(A-D)= 1+10 = 11 and F(A-BC) = 1 + 1 + 6 +12 = 20
3. As we can see F(A-D) is less than F(A-BC) then the algorithm
choose the path F(A-D).
4. Form D we have one choice that is F-E.
5. F(A-D-FE) = 1+1+ 4 +4 =10
6. Basically 10 is the cost of reaching FE from D. And Heuristic value
of node D also denote the cost of reaching FE from D. So, the new
Heuristic value of D is 10.
7. And the Cost from A-D remain same that is 11.

Suppose we have searched this path and we have got the Goal State,
then we will never explore the other path.
Lab-05 2020BCSE034

Implement CryptArithmatic problem with suitable example.

Cryptarithmetic Problem is a type of constraint satisfaction problem
where the game is about digits and its unique replacement either
with alphabets or other
symbols. In cryptarithmetic problem, the digits (0-9) get substituted
by some possible alphabets or symbols. The task in cryptarithmetic
problem is to substitute each digit with an alphabet to get the result
arithmetically correct.
We can perform all the arithmetic operations on a given
cryptarithmetic problem.
The rules or constraints on a cryptarithmetic problem are as follows:

 There should be a unique digit to be replaced with a unique

alphabet.
 The result should satisfy the predefined arithmetic rules,
i.e., 2+2 =4, nothing else.
 Digits should be from 0-9 only.
 There should be only one carry forward, while performing
the addition operation on a problem.
 The problem can be solved from both sides, i.e., lefthand side
(L.H.S), or righthand side (R.H.S)

Let’s understand the cryptarithmetic problem as well its constraints

better with the help of an example:

 Given a cryptarithmetic problem, i.e., S E N D + M O R E = M O N E Y

Follow the below steps to understand the given problem by breaking it

into its subparts:

 Starting from the left hand side (L.H.S) , the terms are S and
M. Assign a digit which could give a satisfactory result. Let’s
assign S->9 and M-
>1.
2020BCSE034

Hence, we get a satisfactory result by adding up the terms

and got an assignment for O as O->0 as well.
Now, move ahead to the next terms E and O to get N as its output.

Adding E and O, which means 5+0=0, which is not possible

because according to cryptarithmetic constraints, we cannot assign
the same digit to two letters. So, we need to think more and assign
some other value.

Note: When we will solve further, we will get one carry, so after applying
it, the answer will be satisfied.
Further, adding the next two terms N and R we get,

But, we have already assigned E->5. Thus, the above result does
not satisfy the values
because we are getting a different value for E. So, we need
to think more.
Again, after solving the whole problem, we will get a carryover on this
term, so our answer will be satisfied.

where 1 will be carry forward to the above term

Let’s move ahead. 2020BCSE034
Again, on adding the last two terms, i.e., the rightmost terms D
and E, we get Y as its result.

where 1 will be carry forward to the above term

 Keeping all the constraints in mind, the final resultant is as follows:

Lab-06 2020BCSE034

Implement Graph Coloring problem with suitable example.

Graph coloring problem is to assign colors to certain elements of a
graph subject to certain constraints.
Vertex coloring is the most common graph coloring problem. The
problem is, given m colors, find a way of coloring the vertices of a
graph such that no two adjacent vertices are colored using same
color. The other graph coloring problems like Edge Coloring (No
vertex is incident to two edges of same color) and Face Coloring
(Geographical Map Coloring) can be transformed into vertex
coloring.
Chromatic Number: The smallest number of colors needed to color a
graph G is called its chromatic number. For example, the following
can be colored minimum 2 colors.

Chromatic Number: The smallest number of colours needed to

colour a graph G is called its chromatic number.
For example, in the above image, vertices can be coloured using a
minimum of 2 colours.
Hence the chromatic number of the graph is 2.

Applications of Graph Colouring:

 Map Coloring
 Scheduling the tasks
 Preparing Time Table
 Assignment
 Conflict Resolution
 Sudoku
Lab-07 2020BCSE034

Implement Min-Max with suitable example.

Min-Max Algorithm in Artificial Intelligence
o Mini-max algorithm is a recursive or backtracking algorithm which is
used in decision-making and game theory. It provides an optimal
move for the player assuming that opponent is also playing
optimally.
o Mini-Max algorithm uses recursion to search through the game-tree.
o Min-Max algorithm is mostly used for game playing in AI. Such as
Chess, Checkers, tic-tac-toe, go, and various tow-players game. This
Algorithm computes the minimax decision for the current state.
o In this algorithm two players play the game, one is called MAX and
other is called MIN.
o Both the players fight it as the opponent player gets the minimum
benefit while they get the maximum benefit.
o Both Players of the game are opponent of each other, where MAX
will select the maximized value and MIN will select the minimized
value.
o The minimax algorithm performs a depth-first search algorithm for
the exploration of the complete game tree.
o The minimax algorithm proceeds all the way down to the terminal
node of the tree, then backtrack the tree as the recursion.

Working of Min-Max Algorithm:

o The working of the minimax algorithm can be easily described using
an example. Below we have taken an example of game-tree which is
representing the two-player game.
o In this example, there are two players one is called Maximizer and
other is called Minimizer.
o Maximizer will try to get the Maximum possible score, and Minimizer
will try to get the minimum possible score.
o This algorithm applies DFS, so in this game-tree, we have to go all
the way through the leaves to reach the terminal nodes.
 o At the terminal node, the terminal values are given so we will
compare those value and backtrack the tree until the initial state
occurs. Following are the main steps involved in solving the two-
player game tree:

Example:

Suppose maximizer takes first turn which has worst-case initial value =-
infinity, and minimizer will take next turn which has worst-case initial
value = +infinity.

o For node D max(-1,- -∞) => max(-1,4)= 4

o For Node E max(2, -∞) => max(2, 6)= 6
o For Node F max(-3, -∞) => max(-3,-5) = -3
o For node G max(0, -∞) = max(0, 7) = 7

o For node B= min(4,6) = 4

o For node C= min (-3, 7) = -3
o For node A max(4, -3)= 4

Time complexity of Min-Max algorithm is O(bm), where b is branching

factor of the game-tree, and m is the maximum depth of the tree.
2019BCSE067
Lab-07 2020BCSE034

Implement Alpha-Beta pruning with suitable example.

Alpha-Beta Pruning
o Alpha-beta pruning is a modified version of the minimax algorithm.
It is an optimization technique for the minimax algorithm.
o As we have seen in the minimax search algorithm that the number
of game states it has to examine are exponential in depth of the
tree. Since we cannot eliminate the exponent, but we can cut it to
half. Hence there is a technique by which without checking each
node of the game tree we can compute the correct minimax
decision, and this technique is called pruning. This involves two
threshold parameter Alpha and beta for future expansion, so it is
called alpha- beta pruning. It is also called as Alpha-Beta
Algorithm.
o Alpha-beta pruning can be applied at any depth of a tree, and
sometimes it not only prune the tree leaves but also entire sub-tree.
o The two-parameter can be defined as:
1. Alpha: The best (highest-value) choice we have found so far
at any point along the path of Maximizer. The initial value of
alpha is -∞.
2. Beta: The best (lowest-value) choice we have found so far at
any point along the path of Minimizer. The initial value of beta
is +∞.
o The Alpha-beta pruning to a standard minimax algorithm returns the
same move as the standard algorithm does, but it removes all the
nodes which are not really affecting the final decision but making
algorithm slow. Hence by pruning these nodes, it makes the
algorithm fast.

Condition for Alpha-beta pruning:

The main condition which required for alpha-beta pruning
is: (α>=β)
Key points about alpha-beta pruning:
o The Max player will only update the value of alpha.
o The Min player will only update the value of beta.
o While backtracking the tree, the node values will be passed to
upper nodes instead of values of alpha and beta.
o We will only pass the alpha, beta values to the child nodes.
Working of Alpha-Beta Pruning: 2020BCSE034

Let's take an example of two-player search tree to understand the

working of Alpha-beta pruning:

Step 1: At the first step the, Max player will start first move from node A
where α= -∞ and β= +∞, these value of alpha and beta passed down to
node B where again α= -∞ and β= +∞, and Node B passes the same value
to its child D.

Step 2: value of α at node D and node value will also 3.

Step 3: at node B now α= -∞, and β= 3.

Step 4: at node E α= 5 and β= 3, where α>=β,

Step 5: At node C, α=3 and β= +∞, and the same values will be passed on to
node F.

Step 6: Now at C, α=3 and β= 1

Step 7: C now returns the value of 1 to A here the best value for A is max
(3, 1)= 3.Hence the optimal value for the maximizer is 3 for this example.

Time Complexity in ideal ordering is O(bd/2), where d is the depth.

Lab-07 2020BCSE034

Implement Fuzzy-logic(First-Order prolog) with suitable

example.
o First-order logic is another way of knowledge
representation in artificial intelligence. It is an extension
to propositional logic.
o FOL is sufficiently expressive to represent the natural
language statements in a concise way.

• First-order logic (FOL) models the world in terms of

– Objects, which are things with individual identities

– Properties of objects that distinguish them from other objects

– Relations that hold among sets of objects

– Functions, which are a subset of relations where there is only one “value”
for any given “input”

Examples:

– Objects: Students, lectures, companies, cars ...

– Relations: Brother-of, bigger-than, outside, part-of, has-color, occurs-after,

owns, visits, precedes, ...

– Properties: blue, oval, even, large, ...

– Functions: father-of, best-friend, second-half, one-more-than ...

FOL Provides :-

• Variable symbols – E.g., x, y, foo

• Connectives – Same as in PL: not (), and (), or (), implies (), if and only if
(biconditional )

• Quantifiers – Universal x or (Ax) – Existential x or (Ex)

Prolog: 2020BCSE034

 Prolog stands for Programming in logic. It is used in artificial

intelligence programming.
 Prolog is a declarative programming language.

Program-1):- Find min-max value of two numbers by prolog.

Program-2):- Towers of Hanoi.

Lab-08 2020BCSE034

Implement Expert System(Mamdani fuzzy model) with

suitable example.
Mamdani Fuzzy Inference System:

This system was proposed in 1975 by Ebhasim Mamdani.

Basically, it was anticipated to control a steam engine and
boiler combination by synthesizing a set of fuzzy rules
obtained from people working on the system.
Mamdani-type inference, expects the output membership functions to be fuzzy
sets. After the aggregation process, there is a fuzzy set for each output variable
that needs defuzzification.
Original Goal: Control a steam engine & boiler combination by a set of
linguistic control rules obtained from experienced human operators.
The Mamdani-style fuzzy inference process is performed in four steps:
1. Fuzzification of the input variables,
2. Rule evaluation;
3. Aggregation of the rule outputs, and finally
4. De-fuzzification.

Operation of Fuzzy System

Steps for Computing the 2020BCSE034
Output:
Following steps need to be followed to compute the output from
this FIS
−
 Step 1 − Set of fuzzy rules need to be determined in this
step.
 Step 2 − In this step, by using input membership
function, the input would be made fuzzy.
 Step 3 − Now establish the rule strength by
combining the fuzzified inputs according to fuzzy
rules.
 Step 4 − In this step, determine the consequent of
rule by
combining the rule strength and the output
membership function.
 Step 5 − For getting output distribution combine all
the
consequents.
 Step 6 − Finally, a defuzzified output distribution is
obtained. Following is a block diagram of Mamdani Fuzzy
Interface System.
Lab-09 2020BCSE034

Implement PSO(Particle Swarm Optimization).

Particle swarm optimization (PSO) is an artificial intelligence (AI)
technique that can be used to find approximate solutions to
extremely difficult or impossible numeric maximization and
minimization problems.
 Uses a number of agents (particles) that constitute a swarm moving
around in the search space looking for the best solution
 Each particle in search space adjusts its “flying” according to its own
flying experience as well as the flying experience of other particles.
 Each particle has three parameters position, velocity, and previous best
position, particle with best fitness value is called as global best position.
 Collection of flying particles (swarm) - Changing solutions Search area -
Possible solutions
 Movement towards a promising area to get the global optimum.
 Each particle adjusts its travelling speed dynamically corresponding to
the flying experiences of itself and its colleagues.
 Each particle keeps track: its best solution, personal best, pbest. the
best value of any particle, global best, gbest.
 Each particle modifies its position according to:
• its current position
• its current velocity
• the distance between its current position and pbest.
• the distance between its current position and gbest.

Particle Swarm Optimization (PSO) Algorithm:

f: Objective function, Vi: Velocity of the particle or agent, A:

Population of agents, W: Inertia weight, C1: cognitive constant,
U1, U2: random numbers, C2: social constant, Xi: Position of the
particle or agent, Pb: Personal Best, gb: global Best.
The actual algorithm goes as below : 2020BCSE034

1. Create a ‘population’ of agents (particles) which is uniformly distributed

over X.

2. Evaluate each particle’s position considering the objective function.

3. If a particle’s present position is better than its previous best position,

update it.

4. Find the best particle (according to the particle’s last best places).

5. Update particles’ velocities.

6. Move particles to their new positions.

7. Go to step 2 until the stopping criteria are satisfied.

In PSO, the focus in on a group of birds. This group of birds is

referred to as a ‘swarm‘. Let’s try to understand the Particle Swarm
Optimization from the following scenario.
Example: Suppose there is a swarm (a group of birds). Now, all the
birds are hungry and are searching for food. These hungry birds
can be correlated with the tasks in a computation system which are
hungry for resources. Now, in the locality of these birds, there is
only one food particle. This food particle can be correlated with a
resource. As we know, tasks are many, resources are limited. So
this has become a similar condition as in a certain computation
environment. Now, the birds don’t know where the food particle is
hidden or located. In such a scenario, how the algorithm to find the
food particle should be designed. If every bird will try to find the
food on its own, it may cause havoc and may consume a large
amount of time. Thus on careful observation of this swarm, it was
realized that though the birds don’t know where the food particle is
located, they do know their distance from it. Thus the best
approach to finding that food particle is to follow the birds which
are nearest to the food particle. This behavior of birds is simulated
in the computation environment and the algorithm so designed is
termed as Particle Swarm Optimization Algorithm.
Lab-10 2020BCSE034

Implement AND & OR Gate in Neural Network.

AND Gate:

From our knowledge of logic gates, we know that an AND

logic table is given by the diagram below:

First, we need to understand that the output of an AND

gate is 1 only if both inputs (in this case, x1 and x2) are 1.
So, following the steps listed above;
Row 1:
 From w1x1+w2x2+b, initializing w1, w2, as 1 and b as -1, we get;
 x1(1)+x2(1)-1
 Passing the first row of the AND logic table (x1=0, x2=0), we get;
 0+0–1 = -1
 From the Perceptron rule, if Wx+b<0, then y`=0. Therefore, this
row is correct, and no need for Backpropagation.

Row 2
 Passing (x1=0 and x2=1), we get;
  0+1–1 = 0 2020BCSE034
 From the Perceptron rule, if Wx+b >=0, then y`=1. This row
is incorrect, as the output is 0 for the AND gate.
 So we want values that will make the combination of x1=0
and x2=1 to give y` a value of 0. If we change b to -1.5, we
have;
 0+1–1.5 = -0.5
 From the Perceptron rule, this works (for both row 1, row 2
and 3).
Row 4
 Passing (x1=1 and x2=1), we get;
 1+1–1.5 = 0.5
 Again, from the perceptron rule, this is still valid.
 Therefore, we can conclude that the model to achieve an
AND gate, using the Perceptron algorithm is;
 x1+x2–1.5

OR Gate:
 2020BCSE034

From the diagram, the OR gate is 0 only if both inputs are

0.

Row 1
 From w1x1+w2x2+b, initializing w1, w2, as 1 and b as -1, we get;
 x1(1)+x2(1)-1
 Passing the first row of the OR logic table (x1=0, x2=0), we get;
 0+0–1 = -1
 From the Perceptron rule, if Wx+b<0, then y`=0. Therefore, this
row is correct.
Row 2
 Passing (x1=0 and x2=1), we get;
 0+1–1 = 0
 From the Perceptron rule, if Wx+b >=0, then y`=1. This row
is again, correct (for both row 1, row 2 and 3).
Row 4
 Passing (x1=1 and x2=1), we get;
 1+1–1 = 1
 Again, from the perceptron rule, this is still valid. Quite Easy!
 Therefore, we can conclude that the model to achieve an
OR gate, using the Perceptron algorithm is;
 x1+x2–1

2020BCSE034_AMIR SHABIR
 INDEX
LAB-01):- BFS and DFS
LAB-02):- N-Queen problem
LAB-03):- 8-puzzle proble
LAB-04):- A* and AO* algorithm
LAB-05):- Crypt Arithmatic
LAB-06):- Graph Coloring
LAB-07):- Min-Max and Alpha-Beta
pruning
LAB-08):- Fuzzy Logic (First-order
Prolog)
LAB-09):- Expert system (Mamdani
fuzzy model)
LAB-10):- AND and OR Gate in
Neural Network