DAYANANDA SAGAR ACADEMY OF TECHNOLOGY &

MANAGEMENT
Udayapura, Kanakapura Road, Bengaluru - 560082, Karnataka.

DEPARTMENT OF ARTIFICIAL INTELLIGENCE & MACHINE

LEARNING

Academic Year: 2022-2023

Lab Manual
Artificial Intelligence Laboratory
18AIL57

Prepared By:
Mrs. Sowbhagya M P
Asst. Prof. Dept. of AI&ML
 Content

Sl. No. Programs Page No.

1 Implement and Demonstrate Depth First Search Algorithm 3
on Water Jug Problem,Import collections.
2 Implement and Demonstrate Best First Search Algorithm on any AI 7
problem
3 14
Implement AO* Search algorithm.
4 17
Solve 8-Queens Problem with suitable assumptions.
5 19
Implementation of TSP using heuristic approach.
6 23
Implementation of the problem-solving strategies: either
using Forward Chaining or Backward chaining.
7 Implement resolution principle on FOPL related problems. 28
8 Implement any Game and demonstrate the Game playing strategies. 36
9 Viva-Questions 40

DSATM, Bangalore Page I

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

ARTIFICIAL INTELLIGENCE LABORATORY

Subject Code 18AIL57 CIE Marks 40
Number of Contact hours/Week 0:2:2 SEE Marks 60
Total Number of Lab Contact Hours Exam Hours 3 Hrs

******************************************************************************
Course Learning Objectives: This course will enable students to:
 Implement and evaluate AI algorithms in Python programming language.

Descriptions (if any):

Installation procedure of the required software must be demonstrated, carried out in groups
and documented in the journal.
Programs List:
Practicing Problems in Python (Students can be encouraged to practice good number of
practice problems, some practice problems are listed here)
1. (a) Write a python program to print the multiplication table for the given number
(b) Write a python program to check whether the given number is prime or not?
(c) Write a python program to find factorial of the given number?
2. (a) Write a python program to implement List operations (Nested List, Length,Concatenation, Membership,
Iteration, Indexing and Slicing)
(b) Write a python program to implement List methods (Add, Append, Extend & Delete).
3. Write a python program to implement simple Chatbot with minimum 10 conversations
4. Write a python program to Illustrate Different Set Operations
5. (a)Write a python program to implement a function that counts the number of times a string(s1) occurs in
another string(s2)
(b)Write a program to illustrate Dictionary operations([],in,traversal)and methods: keys(),values(),items()

DSATM, Bangalore Page 1 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

*****************************************************************************
****AI Problems to be implemented in Python****
*****************************************************************************
1. Implement and Demonstrate Depth First Search Algorithm on Water Jug Problem,
Import collections.
2. Implement and Demonstrate Best First Search Algorithm on any AI problem.
3. Implement AO* Search algorithm.
4. Solve 8-Queens Problem with suitable assumptions.
5. Implementation of TSP using heuristic approach.
6.Implementation of the problem-solving strategies: either using Forward Chaining or
Backward Chaining.
7.Implement resolution principle on FOPL related problems.
8.Implement any Game and demonstrate the Game playing strategies.

Laboratory Outcomes: The student should be able to:

 Implement and demonstrate AI algorithms.
 Evaluate different algorithms.

Conduct of Practical Examination:

Experiment distribution
 For laboratories having only one part: Students are allowed to pick one experiment from the
lot with equal opportunity.
 For laboratories having PART A and PART B: Students are allowed to pick one experiment
from PART A and one experiment from PART B, with equal opportunity.
 Change of experiment is allowed only once and marks allotted for procedure to be made
zero of the changed part only.
 Marks Distribution (Subjected to change in accordance with university regulations)

i) For laboratories having only one part – Procedure + Execution + Viva-Voce: 15+70+15 = 100
Marks

j) For laboratories having PART A and PART B

i. Part A – Procedure + Execution + Viva = 6 + 28 + 6 = 40 Marks
ii. Part B – Procedure + Execution + Viva = 9 + 42 + 9 = 60 Marks

DSATM, Bangalore Page 2 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

****AI Problems to be implemented in Python****

*****************************************************************************
1. Implement and Demonstrate Depth First Search Algorithm on Water Jug Problem.
import queue
import time
import random

dfsq = queue.Queue()

class node:
def init (self, data):
self.x = 0
self.y = 0
self.parent = data

def printnode(self):
print("(", self.x, ",", self.y, ")")

def generateAllSuccessors(cnode):
list1 = []
list_rule = []
while len(list_rule) < 8:
rule_no = random.randint(1, 8)
if (not rule_no in list_rule):
list_rule.append(rule_no)
nextnode = operation(cnode, rule_no)
if nextnode != None and not IsNodeInlist(nextnode, visitednodelist):
list1.append(nextnode)
"""for rule in range (1,9):
nextnode = operation(cnode,rule) #current node
if nextnode != None :
list1.append(nextnode)"""
return list1

def operation(cnode, rule):

x = cnode.x
y = cnode.y
if rule == 1:c
if x < maxjug1:
x = maxjug1
else:
return None
elif rule == 2:
if y < maxjug2:

DSATM, Bangalore Page 3 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

y = maxjug2
else:
return None
elif rule == 3:
if x > 0:
x=0
else:
return None
elif rule == 4:
if y > 0:
y=0
else:
return None
elif rule == 5:
if x + y >= maxjug1:
y = y - (maxjug1 - x)
x = maxjug1
else:
return None
elif rule == 6:
if x + y >= maxjug2:
x = x - (maxjug2 - y)
y = maxjug2
else:
return None
elif rule == 7:
if x + y < maxjug1:
x=x+y
y=0
else:
return None
elif rule == 8:
if x + y < maxjug2:
x=0
y=x+y
else:
return None
if (x == cnode.x and y == cnode.y):
return None
nextnode = node(cnode)
nextnode.x = x
nextnode.y = y
nextnode.parent = cnode
return nextnode

DSATM, Bangalore Page 4 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

def pushlist(list1):
for m in list1:
dfsq.put(m)

def popnode():
if (dfsq.empty()):
return None
else:
return dfsq.get()

def isGoalNode(cnode, gnode):

if (cnode.x == gnode.x and cnode.y == gnode.y):
return True
return False

visitednodelist = []

def dfsMain(initialNode, GoalNode):

dfsq.put(initialNode)
while not dfsq.empty():
visited_node = popnode()
print("Pop node:")
visited_node.printnode()
if isGoalNode(visited_node, GoalNode):
return visited_node
successor_nodes = generateAllSuccessors(visited_node)
pushlist(successor_nodes)
return None

def IsNodeInlist(node, list1):

for m in list1:
if (node.x == m.x and node.y == m.y):
return True
return False

def printpath(cnode):
temp = cnode
list2 = []
while (temp != None):
list2.append(temp)

DSATM, Bangalore Page 5 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

temp = temp.parent
list2.reverse()
for i in list2:
i.printnode()
print("Path Cost:", len(list2))

if name == ' main ':

list2 = []
maxjug1 = int(input("Enter value of maxjug1:"))
maxjug2 = int(input("Enter value of maxjug2:"))
initialNode = node(None)
initialNode.x = 0
initialNode.y = 0
initialNode.parent = None
GoalNode = node(None)
GoalNode.x = int(input("Enter value of Goal in jug1:"))
GoalNode.y = 0
GoalNode.parent = None
start_time = time.time()
solutionNode = dfsMain(initialNode, GoalNode)
end_time = time.time()
if (solutionNode != None):
print("Solution can Found:")
else:
print("Solution can't be found.")
printpath(solutionNode)
diff = end_time - start_time
print("Execution Time:", diff * 1000, "ms")

Output:
Enter value of maxjug1:5
Enter value of maxjug2:3
Enter value of Goal in jug1:4
Solution can Found:
(0,0)
(0,3)
(3,0)
(3,3)
(5,1)
(0,1)
(1,0)
(1,3)
(4,0)
Path Cost: 9

DSATM, Bangalore Page 6 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

2. Implement and Demonstrate Best First Search Algorithm on any AI problem-Missionaries

(M) and Cannibals (C).
import copy

# The problem starts with 3 Missionaries (M) and 3 Cannibals (C) in the left side of a river
(leftCoast) trying to
# cross with a boat(B) going to the right side (rightCoast) with the restriction that never the
number of Cannibals
# will outnumber the Missionaries on either side

class CoastState:

def init (self, c, m):

self.cannibals = c
self.missionaries = m

# This is an intermediate state of Coast where the missionaries have to outnumber the
cannibals
def valid_coast(self):
if self.missionaries >= self.cannibals or self.missionaries == 0:
return True
else:
return False

def goal_coast(self):
if self.cannibals == 3 and self.missionaries == 3:
return True
else:
return False

class GameState:

def init (self, data):

self.data = data
self.parent = None

# Creating the Search Tree

def building_tree(self):
children = []
coast = ""
across_coast = ""
temp = copy.deepcopy(self.data)

DSATM, Bangalore Page 7 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

if self.data["boat"] == "left":
coast = "left"
across_coast = "right"
elif self.data["boat"] == "right":
coast = "right"
across_coast = "left"

# MOVING 2 CANNIBALS (CC)

if temp[coast].cannibals >= 2:
temp[coast].cannibals = temp[coast].cannibals - 2
temp[across_coast].cannibals = temp[across_coast].cannibals + 2
temp["boat"] = across_coast
if temp[coast].valid_coast() and temp[across_coast].valid_coast():
child = GameState(temp)
child.parent = self
children.append(child)

temp = copy.deepcopy(self.data)
# MOVING 2 MISSIONARIES (MM)
if temp[coast].missionaries >= 2:
temp[coast].missionaries = temp[coast].missionaries - 2
temp[across_coast].missionaries = temp[across_coast].missionaries + 2
temp["boat"] = across_coast
if temp[coast].valid_coast() and temp[across_coast].valid_coast():
child = GameState(temp)
child.parent = self
children.append(child)

temp = copy.deepcopy(self.data)
# MOVING 1 CANNIBAL (C)
if temp[coast].cannibals >= 1:
temp[coast].cannibals = temp[coast].cannibals - 1
temp[across_coast].cannibals = temp[across_coast].cannibals + 1
temp["boat"] = across_coast
if temp[coast].valid_coast() and temp[across_coast].valid_coast():
child = GameState(temp)
child.parent = self
children.append(child)

temp = copy.deepcopy(self.data)
# MOVING 1 MISSIONARY (M)
if temp[coast].missionaries >= 1:
temp[coast].missionaries = temp[coast].missionaries - 1
temp[across_coast].missionaries = temp[across_coast].missionaries + 1
temp["boat"] = across_coast
if temp[coast].valid_coast() and temp[across_coast].valid_coast():

DSATM, Bangalore Page 8 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

child = GameState(temp)
child.parent = self
children.append(child)

temp = copy.deepcopy(self.data)
# MOVING 1 CANNIBAL AND 1 MISSIONARY (CM && MM)
if temp[coast].missionaries >= 1 and temp[coast].cannibals >= 1:
temp[coast].missionaries = temp[coast].missionaries - 1
temp[across_coast].missionaries = temp[across_coast].missionaries + 1
temp[coast].cannibals = temp[coast].cannibals - 1
temp[across_coast].cannibals = temp[across_coast].cannibals + 1
temp["boat"] = across_coast
if temp[coast].valid_coast() and temp[across_coast].valid_coast():
child = GameState(temp)
child.parent = self
children.append(child)
return children

def breadth_first_search():
left = CoastState(3, 3)
right = CoastState(0, 0)
root_data = {"left": left, "right": right, "boat": "left"}

explored = []
nodes = []
path = []
nodes.append(GameState(root_data))

while len(nodes) > 0:

g = nodes.pop(0)
explored.append(g)
if g.data["right"].goal_coast():
path.append(g)
return g
else:
next_children = g.building_tree()
for x in next_children:
if (x not in nodes) or (x not in explored):
nodes.append(x)
return None

def print_path(g):

path = [g]

DSATM, Bangalore Page 9 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

while g.parent:
g = g.parent
path.append(g)
print(" " + "Left Side" + " " + "Right Side" + " " + "Boat ")
print(
" Cannibals" + " Missionaries" + " " + "Cannibals" + " Missionaries" + "
Boat Position")
counter = 0
for p in reversed(path):
print("State " + str(counter) + " Left C: " + str(p.data["left"].cannibals) + ". Left M: " +
str(
p.data["left"].missionaries) + ". | Right C: " + str(
p.data["right"].cannibals) + ". Right M: " + str(p.data["right"].missionaries) + ". |
Boat: " + str(
p.data["boat"]))
counter = counter + 1
print("End of Path!")

def main():
solution = breadth_first_search()
print("Missionaries and Cannibals AI Problem Solution using Breath - First Search:")
print_path(solution)

if name == " main ":

main()

Output:

Graph - 1
HEURISTIC VALUES : {'A': 1, 'B': 6, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 5, 'H': 7, 'I': 7, 'J': 1}
SOLUTION GRAPH : {}
PROCESSING NODE : A
-
10 ['B', 'C']
HEURISTIC VALUES : {'A': 10, 'B': 6, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 5, 'H': 7, 'I': 7, 'J': 1}
SOLUTION GRAPH : {}
PROCESSING NODE : B
-
6 ['G']
HEURISTIC VALUES : {'A': 10, 'B': 6, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 5, 'H': 7, 'I': 7, 'J': 1}
SOLUTION GRAPH : {}
PROCESSING NODE : A
-
10 ['B', 'C']

DSATM, Bangalore Page 10 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

HEURISTIC VALUES : {'A': 10, 'B': 6, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 5, 'H': 7, 'I': 7, 'J': 1}
SOLUTION GRAPH : {}
PROCESSING NODE : G
-
8 ['I']
HEURISTIC VALUES : {'A': 10, 'B': 6, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 8, 'H': 7, 'I': 7, 'J': 1}
SOLUTION GRAPH : {}
PROCESSING NODE : B
-
8 ['H']
HEURISTIC VALUES : {'A': 10, 'B': 8, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 8, 'H': 7, 'I': 7, 'J': 1}
SOLUTION GRAPH : {}
PROCESSING NODE : A
-
12 ['B', 'C']
HEURISTIC VALUES : {'A': 12, 'B': 8, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 8, 'H': 7, 'I': 7, 'J': 1}
SOLUTION GRAPH : {}
PROCESSING NODE : I
-
0 []
HEURISTIC VALUES : {'A': 12, 'B': 8, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 8, 'H': 7, 'I': 0, 'J': 1}
SOLUTION GRAPH : {'I': []}
PROCESSING NODE : G
-
1 ['I']
HEURISTIC VALUES : {'A': 12, 'B': 8, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 1, 'H': 7, 'I': 0, 'J': 1}
SOLUTION GRAPH : {'I': [], 'G': ['I']}
PROCESSING NODE : B
-
2 ['G']
HEURISTIC VALUES : {'A': 12, 'B': 2, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 1, 'H': 7, 'I': 0, 'J': 1}
SOLUTION GRAPH : {'I': [], 'G': ['I'], 'B': ['G']}
PROCESSING NODE : A
-
6 ['B', 'C']
HEURISTIC VALUES : {'A': 6, 'B': 2, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 1, 'H': 7, 'I': 0, 'J': 1}
SOLUTION GRAPH : {'I': [], 'G': ['I'], 'B': ['G']}
PROCESSING NODE : C
-
2 ['J']
HEURISTIC VALUES : {'A': 6, 'B': 2, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 1, 'H': 7, 'I': 0, 'J': 1}
SOLUTION GRAPH : {'I': [], 'G': ['I'], 'B': ['G']}
PROCESSING NODE : A
-
6 ['B', 'C']
HEURISTIC VALUES : {'A': 6, 'B': 2, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 1, 'H': 7, 'I': 0, 'J': 1}

DSATM, Bangalore Page 11 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

SOLUTION GRAPH : {'I': [], 'G': ['I'], 'B': ['G']}

PROCESSING NODE : J
-
0 []
HEURISTIC VALUES : {'A': 6, 'B': 2, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 1, 'H': 7, 'I': 0, 'J': 0}
SOLUTION GRAPH : {'I': [], 'G': ['I'], 'B': ['G'], 'J': []}
PROCESSING NODE : C
-
1 ['J']
HEURISTIC VALUES : {'A': 6, 'B': 2, 'C': 1, 'D': 12, 'E': 2, 'F': 1, 'G': 1, 'H': 7, 'I': 0, 'J': 0}
SOLUTION GRAPH : {'I': [], 'G': ['I'], 'B': ['G'], 'J': [], 'C': ['J']}
PROCESSING NODE : A
-
5 ['B', 'C']
FOR GRAPH SOLUTION, TRAVERSE THE GRAPH FROM THE START NODE: A

{'I': [], 'G': ['I'], 'B': ['G'], 'J': [], 'C': ['J'], 'A': ['B', 'C']}

Graph - 2
HEURISTIC VALUES : {'A': 1, 'B': 6, 'C': 12, 'D': 10, 'E': 4, 'F': 4, 'G': 5, 'H': 7}
SOLUTION GRAPH : {}
PROCESSING NODE : A
-
11 ['D']
HEURISTIC VALUES : {'A': 11, 'B': 6, 'C': 12, 'D': 10, 'E': 4, 'F': 4, 'G': 5, 'H': 7}
SOLUTION GRAPH : {}
PROCESSING NODE : D
-
10 ['E', 'F']
HEURISTIC VALUES : {'A': 11, 'B': 6, 'C': 12, 'D': 10, 'E': 4, 'F': 4, 'G': 5, 'H': 7}
SOLUTION GRAPH : {}
PROCESSING NODE : A
-
11 ['D']
HEURISTIC VALUES : {'A': 11, 'B': 6, 'C': 12, 'D': 10, 'E': 4, 'F': 4, 'G': 5, 'H': 7}
SOLUTION GRAPH : {}
PROCESSING NODE : E
-
0 []
HEURISTIC VALUES : {'A': 11, 'B': 6, 'C': 12, 'D': 10, 'E': 0, 'F': 4, 'G': 5, 'H': 7}
SOLUTION GRAPH : {'E': []}
PROCESSING NODE : D
-
6 ['E', 'F']
HEURISTIC VALUES : {'A': 11, 'B': 6, 'C': 12, 'D': 6, 'E': 0, 'F': 4, 'G': 5, 'H': 7}
SOLUTION GRAPH : {'E': []}

DSATM, Bangalore Page 12 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

PROCESSING NODE : A
-
7 ['D']
HEURISTIC VALUES : {'A': 7, 'B': 6, 'C': 12, 'D': 6, 'E': 0, 'F': 4, 'G': 5, 'H': 7}
SOLUTION GRAPH : {'E': []}
PROCESSING NODE : F
-
0 []
HEURISTIC VALUES : {'A': 7, 'B': 6, 'C': 12, 'D': 6, 'E': 0, 'F': 0, 'G': 5, 'H': 7}
SOLUTION GRAPH : {'E': [], 'F': []}
PROCESSING NODE : D
-
2 ['E', 'F']
HEURISTIC VALUES : {'A': 7, 'B': 6, 'C': 12, 'D': 2, 'E': 0, 'F': 0, 'G': 5, 'H': 7}
SOLUTION GRAPH : {'E': [], 'F': [], 'D': ['E', 'F']}
PROCESSING NODE : A
-
3 ['D']
FOR GRAPH SOLUTION, TRAVERSE THE GRAPH FROM THE START NODE: A

{'E': [], 'F': [], 'D': ['E', 'F'], 'A': ['D']}

DSATM, Bangalore Page 13 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

3. Implement AO* Search algorithm.

class Graph:
def init (self, graph, heuristicNodeList, startNode): #instantiate graph object with graph
topology, heuristic values, start node
self.graph = graph
self.H=heuristicNodeList
self.start=startNode
self.parent={}
self.status={}
self.solutionGraph={}

def applyAOStar(self): # starts a recursive AO* algorithm

self.aoStar(self.start, False)

def getNeighbors(self, v): # gets the Neighbors of a given node

return self.graph.get(v,'')

def getStatus(self,v): # return the status of a given node

return self.status.get(v,0)

def setStatus(self,v, val): # set the status of a given node

self.status[v]=val

def getHeuristicNodeValue(self, n):

return self.H.get(n,0) # always return the heuristic value of a given node

def setHeuristicNodeValue(self, n, value):

self.H[n]=value # set the revised heuristic value of a given node

def printSolution(self):
print("FOR GRAPH SOLUTION, TRAVERSE THE GRAPH FROM THE START
NODE:",self.start)
print(" ")
print(self.solutionGraph)
print(" ")

def computeMinimumCostChildNodes(self, v): # Computes the Minimum Cost of child nodes

of a given node v
minimumCost=0

DSATM, Bangalore Page 14 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

costToChildNodeListDict={}
costToChildNodeListDict[minimumCost]=[]
flag=True
for nodeInfoTupleList in self.getNeighbors(v): # iterate over all the set of child node/s
cost=0
nodeList=[]
for c, weight in nodeInfoTupleList:
cost=cost+self.getHeuristicNodeValue(c)+weight
nodeList.append(c)
if flag==True: # initialize Minimum Cost with the cost of first set of child node/s
minimumCost=cost
costToChildNodeListDict[minimumCost]=nodeList # set the Minimum Cost child
node/s
flag=False
else: # checking the Minimum Cost nodes with the current Minimum Cost
if minimumCost>cost:
minimumCost=cost
costToChildNodeListDict[minimumCost]=nodeList # set the Minimum Cost child
node/s
return minimumCost, costToChildNodeListDict[minimumCost] # return Minimum Cost
and Minimum Cost child node/s

def aoStar(self, v, backTracking): # AO* algorithm for a start node and backTracking status
flag
print("HEURISTIC VALUES :", self.H)
print("SOLUTION GRAPH :", self.solutionGraph)
print("PROCESSING NODE :", v)
print(" ")
if self.getStatus(v) >= 0: # if status node v >= 0, compute Minimum Cost nodes of v
minimumCost, childNodeList = self.computeMinimumCostChildNodes(v)
print(minimumCost, childNodeList)
self.setHeuristicNodeValue(v, minimumCost)
self.setStatus(v,len(childNodeList))
solved=True # check the Minimum Cost nodes of v are solved
for childNode in childNodeList:
self.parent[childNode]=v
if self.getStatus(childNode)!=-1:
solved=solved & False
if solved==True: # if the Minimum Cost nodes of v are solved, set the current node status
as solved(-1)

DSATM, Bangalore Page 15 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

self.setStatus(v,-1)
self.solutionGraph[v]=childNodeList # update the solution graph with the solved nodes
which may be a part of solution
if v!=self.start: # check the current node is the start node for backtracking the current
node value
self.aoStar(self.parent[v], True) # backtracking the current node value with
backtracking status set to true
if backTracking==False: # check the current call is not for backtracking
for childNode in childNodeList: # for each Minimum Cost child node
self.setStatus(childNode,0) # set the status of child node to 0(needs exploration)
self.aoStar(childNode, False) # Minimum Cost child node is further explored with
backtracking status as false

#for simplicity we ll consider heuristic distances given

print ("Graph - 1")
h1 = {'A': 1, 'B': 6, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 5, 'H': 7, 'I': 7, 'J': 1}
graph1 = {
'A': [[('B', 1), ('C', 1)], [('D', 1)]],
'B': [[('G', 1)], [('H', 1)]],
'C': [[('J', 1)]],
'D': [[('E', 1), ('F', 1)]],
'G': [[('I', 1)]]
}

G1= Graph(graph1, h1, 'A')

G1.applyAOStar()
G1.printSolution()

print ("Graph - 2")

h2 = {'A': 1, 'B': 6, 'C': 12, 'D': 10, 'E': 4, 'F': 4, 'G': 5, 'H': 7} # Heuristic values of Nodes
graph2 = { # Graph of Nodes and Edges
'A': [[('B', 1), ('C', 1)], [('D', 1)]], # Neighbors of Node 'A', B, C & D with repective weights
'B': [[('G', 1)], [('H', 1)]], # Neighbors are included in a list of lists
'D': [[('E', 1), ('F', 1)]] # Each sublist indicate a "OR" node or "AND" nodes
}

G2 = Graph(graph2, h2, 'A') # Instantiate Graph object with graph, heuristic values and start
Node
G2.applyAOStar() # Run the AO* algorithm
G2.printSolution() # Print the solution graph as output of the AO* algorithm search

DSATM, Bangalore Page 16 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

4. Solve 8-Queens Problem with suitable assumptions

#Number of queens
print ("Enter the number of queens")
N = int(input())

#chessboard
#NxN matrix with all elements 0
board = [[0]*N for _ in range(N)]

def is_attack(i, j):

#checking if there is a queen in row or column
for k in range(0,N):
if board[i][k]==1 or board[k][j]==1:
return True
#checking diagonals
for k in range(0,N):
for l in range(0,N):
if (k+l==i+j) or (k-l==i-j):
if board[k][l]==1:
return True
return False

def N_queen(n):
#if n is 0, solution found
if n==0:
return True
for i in range(0,N):
for j in range(0,N):
'''checking if we can place a queen here or not
queen will not be placed if the place is being attacked

DSATM, Bangalore Page 17 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

or already occupied'''
if (not(is_attack(i,j))) and (board[i][j]!=1):
board[i][j] = 1
#recursion
#wether we can put the next queen with this arrangment or not
if N_queen(n-1)==True:
return True
board[i][j] = 0

return False

N_queen(N)
for i in board:
print (i)
Output:

Enter the number of queens

Output:

[1, 0, 0, 0, 0, 0, 0, 0]

[0, 0, 0, 0, 1, 0, 0, 0]

[0, 0, 0, 0, 0, 0, 0, 1]

[0, 0, 0, 0, 0, 1, 0, 0]

[0, 0, 1, 0, 0, 0, 0, 0]

[0, 0, 0, 0, 0, 0, 1, 0]

[0, 1, 0, 0, 0, 0, 0, 0]

[0, 0, 0, 1, 0, 0, 0, 0]

DSATM, Bangalore Page 18 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

5. Implementation of TSP using heuristic approach.

#5:Implementation of TSP using heuristic approach .

# Traveling Salesman Problem using

# Branch and Bound.
import math
maxsize = float('inf')

# Function to copy temporary solution

# to the final solution
def copyToFinal(curr_path):
final_path[:N + 1] = curr_path[:]
final_path[N] = curr_path[0]

# Function to find the minimum edge cost

# having an end at the vertex i
def firstMin(adj, i):
min = maxsize
for k in range(N):
if adj[i][k] < min and i != k:
min = adj[i][k]
return min
# function to find the second minimum edge
# cost having an end at the vertex i
def secondMin(adj, i):
first, second = maxsize, maxsize
for j in range(N):
if i == j:
continue
if adj[i][j] <= first:
second = first
first = adj[i][j]

elif(adj[i][j] <= second and

adj[i][j] != first):
second = adj[i][j]
return second
# function that takes as arguments:
# curr_bound -> lower bound of the root node
# curr_weight-> stores the weight of the path so far
# level-> current level while moving
# in the search space tree
# curr_path[] -> where the solution is being stored

DSATM, Bangalore Page 19 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

# which would later be copied to final_path[]

def TSPRec(adj, curr_bound, curr_weight,
level, curr_path, visited):
global final_res

# base case is when we have reached level N

# which means we have covered all the nodes once
if level == N:
# check if there is an edge from
# last vertex in path back to the first vertex
if adj[curr_path[level - 1]][curr_path[0]] != 0:

# curr_res has the total weight

# of the solution we got
curr_res = curr_weight + adj[curr_path[level - 1]]\
[curr_path[0]]
if curr_res < final_res:
copyToFinal(curr_path)
final_res = curr_res
return
# for any other level iterate for all vertices
# to build the search space tree recursively
for i in range(N):
# Consider next vertex if it is not same
# (diagonal entry in adjacency matrix and
# not visited already)
if (adj[curr_path[level-1]][i] != 0 and
visited[i] == False):
temp = curr_bound
curr_weight += adj[curr_path[level - 1]][i]

# different computation of curr_bound

# for level 2 from the other levels
if level == 1:
curr_bound -= ((firstMin(adj, curr_path[level - 1]) +
firstMin(adj, i)) / 2)
else:
curr_bound -= ((secondMin(adj, curr_path[level - 1]) +
firstMin(adj, i)) / 2)

# curr_bound + curr_weight is the actual lower bound

# for the node that we have arrived on.
# If current lower bound < final_res,
# we need to explore the node further
if curr_bound + curr_weight < final_res:
curr_path[level] = i

DSATM, Bangalore Page 20 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

visited[i] = True

# call TSPRec for the next level

TSPRec(adj, curr_bound, curr_weight,
level + 1, curr_path, visited)

# Else we have to prune the node by resetting

# all changes to curr_weight and curr_bound
curr_weight -= adj[curr_path[level - 1]][i]
curr_bound = temp

# Also reset the visited array

visited = [False] * len(visited)
for j in range(level):
if curr_path[j] != -1:
visited[curr_path[j]] = True

# This function sets up final_path

def TSP(adj):
# Calculate initial lower bound for the root node
# using the formula 1/2 * (sum of first min +
# second min) for all edges. Also initialize the
# curr_path and visited array
curr_bound = 0
curr_path = [-1] * (N + 1)
visited = [False] * N

# Compute initial bound

for i in range(N):
curr_bound += (firstMin(adj, i) +
secondMin(adj, i))
# Rounding off the lower bound to an integer
curr_bound = math.ceil(curr_bound / 2)
# We start at vertex 1 so the first vertex
# in curr_path[] is 0
visited[0] = True
curr_path[0] = 0
# Call to TSPRec for curr_weight
# equal to 0 and level 1
TSPRec(adj, curr_bound, 0, 1, curr_path, visited)
# Driver code
# Adjacency matrix for the given graph
adj = [[0, 4, 12, 7],
[5, 0, 0, 18],
[11, 0, 0, 6],
[10, 2, 3, 0]]

DSATM, Bangalore Page 21 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

N=4
# final_path[] stores the final solution
# i.e. the // path of the salesman.
final_path = [None] * (N + 1)
# visited[] keeps track of the already
# visited nodes in a particular path
visited = [False] * N
# Stores the final minimum weight
# of shortest tour.
final_res = maxsize
TSP(adj)
print("Minimum cost :", final_res)
print("Path Taken : ", end = ' ')
for i in range(N + 1):
print(final_path[i], end = ' ')

Output:
Minimum cost : 25
Path Taken : 0 2 3 1 0

DSATM, Bangalore Page 22 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

6.Implementation of the problem-solving strategies: either using Forward Chaining or

Backward Chaining.

#6:Implementation of the problem solving strategies: using Forward Chaining

from collections import deque
import copy
file=open(input('file:'))
line=file.readlines()
line=list(map(lambda s: s.strip(),line)) #A lambda function can take any number of arguments,
# but can only have one expression.

R=[]
for i in range(len(line)):
k=i+1
if line[i]=='1) Rules':
while line[k] != '2) Facts':
r = deque(line[k].split())
rhs = r.popleft()
r.append(rhs)
R.append(list(r))
k=k+1
elif line[i]=='2) Facts':
Fact=line[k].split()
elif line[i]=='3) Goal':
Goal=line[k]

#
print('PART1. Data')
print(' 1)Rules')
for i in range(len(R)):
print(' R', i+1, ': ', end='')
for j in range(len(R[i])-1):
print(R[i][j], end= ' ')
print('->', R[i][-1])

print()
print(' 2)Facts')
print(' ', end='')
for i in Fact:
print(i,' ',end='')
print();print()

print(' 3)Goal')
print(' ', Goal)

DSATM, Bangalore Page 23 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

#
Path=[]
Flag=[]
origin_fact = copy.deepcopy(Fact)

print('PART2. Trace')

# Set initial value

count=0
Yes = False
while Goal not in Fact and Yes==False: #fact When the final element is added to or when it
doesn't work even after finishing it.
count += 1
print(' ', end='')
print('ITERATION',count)
K=-1
apply = False
while K<len(R)-1 and not apply: #until it finds one applicable rule.
K=K+1
print(' R', K + 1, ': ', end='')
for i, v in enumerate(R[K]): # Print Kth rule (R[K])
if i < len(R[K]) -1:
print(v, '', end='')
else:
print('->',v, end='')

if str(K+1) in Flag: #if there is a flag

b = Flag.index(str(K+1)) +1
if Flag[b]==[1]:
print(', skip, because flag1 raised')
elif Flag[b]==[2]:
print(', skip, because flag2 raised')

else: #no flag

for i, v in enumerate(R[K]): # Are all the left sides of the kth rule present?
if i == len(R[K]) -1:
continue

if v in Fact:
if R[K][-1] in Fact: # If the right-hand side already exists
print(' not applied, because RHS in facts. Raise flag2')
Flag.append(str(K + 1)); Flag.append([2])
break
elif v == R[K][-2]:
apply = True
P=K+1

DSATM, Bangalore Page 24 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

break
else:
print(', not applied, because of lacking ', v)
break

if apply:
Fact.append(R[P-1][-1])
Flag.append(str(P)); Flag.append([1])
Path.append(P)
print(', apply, Raise flag1. Facts ', end='')
for i in Fact:
print(i,' ', end='')
print()
elif K== len(R)-1:
Yes=True
print()
print('PART3. Results')
if Goal in origin_fact:
print(' ', end='')
print('Goal A in facts. Empty path.')
else:
if Goal in Fact:
print(' ',end='')
print('1) Goal',Goal,'achieved')
print(' ', end='')
print('2) Path:', end='')
for i in Path:
print('R', i, ' ', end='')
else:
print('1) Goal',Goal,' not achieved')

## Input & Output

- Input: A text file that contains rules, fact and goal to deal with.

Example of Input - Testcase 1

```
Test 1. Initial fact in right hand side
1) Rules
LA
K L
AD
MD
ZFB
FCD

DSATM, Bangalore Page 25 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

DA
2) Facts
ABC
3) Goal
Z

- Output : Data, Trace and Results

Example of Output - Testcase 1

```
forwardChaining.py
file: test1.txt

PART1. Data

1)Rules
R 1 : A -> L
R 2 : L -> K
R 3 : D -> A
R 4 : D -> M
R 5 : F B -> Z
R 6 : C D -> F
R 7 : A -> D

2) Facts
A B C

3) Goal
Z

PART2. Trace
ITERATION 1
R 1 :A -> L, apply, Raise flag1. Facts A B C L
ITERATION 2
R 1 :A -> L, skip, because flag1 raised
R 2 :L -> K, apply, Raise flag1. Facts A B C L K
ITERATION 3
R 1 :A -> L, skip, because flag1 raised
R 2 :L -> K, skip, because flag1 raised
R 3 :D -> A, not applied, because of lacking D
R 4 :D -> M, not applied, because of lacking D
R 5 :F B -> Z, not applied, because of lacking F
R 6 :C D -> F, not applied, because of lacking D
R 7 :A -> D, apply, Raise flag1. Facts A B C L K D
ITERATION 4

DSATM, Bangalore Page 26 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

R 1 :A -> L, skip, because flag1 raised

R 2 :L -> K, skip, because flag1 raised
R 3 :D -> A not applied, because RHS in facts. Raise flag2
R 4 :D -> M, apply, Raise flag1. Facts A B C L K D M
ITERATION 5
R 1 :A -> L, skip, because flag1 raised
R 2 :L -> K, skip, because flag1 raised
R 3 :D -> A, skip, because flag2 raised
R 4 :D -> M, skip, because flag1 raised
R 5 :F B -> Z, not applied, because of lacking F
R 6 :C D -> F, apply, Raise flag1. Facts A B C L K D M F
ITERATION 6
R 1 :A -> L, skip, because flag1 raised
R 2 :L -> K, skip, because flag1 raised
R 3 :D -> A, skip, because flag2 raised
R 4 :D -> M, skip, because flag1 raised
R 5 :F B -> Z, apply, Raise flag1. Facts A B C L K D M F Z

PART3. Results
1) Goal Z achieved
2) Path:R 1 R 2 R 7 R 4 R 6 R 5
Process finished with exit code 0

```

DSATM, Bangalore Page 27 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

7.Implement resolution principle on FOPL related problems

#7: Implement resolution principle on FOPL related problems

import time
start_time = time.time()
import re
import itertools
import collections
import copy
import queue

p=open("input4.txt","r")
data=list()
data1= p.readlines()
count=0

n=int(data1[0])
queries=list()
for i in range(1,n+1):
queries.append(data1[i].rstrip())
k=int(data1[n+1])
kbbefore=list()

def CNF(sentence):
temp=re.split("=>",sentence)
temp1=temp[0].split('&')
for i in range(0,len(temp1)):
if temp1[i][0]=='~':
temp1[i]=temp1[i][1:]
else:
temp1[i]='~'+temp1[i]
temp2='|'.join(temp1)
temp2=temp2+'|'+temp[1]
return temp2

variableArray = list("abcdefghijklmnopqrstuvwxyz")
variableArray2 = [ ]
variableArray3 = [ ]
variableArray5 = [ ]
variableArray6 = [ ]
for eachCombination in itertools.permutations(variableArray, 2):
variableArray2.append(eachCombination[0] + eachCombination[1])

DSATM, Bangalore Page 28 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

for eachCombination in itertools.permutations(variableArray, 3):

variableArray3.append(eachCombination[0] + eachCombination[1] + eachCombination[2])
for eachCombination in itertools.permutations(variableArray, 4):
variableArray5.append(eachCombination[0] + eachCombination[1] + eachCombination[2]+
eachCombination[3])
for eachCombination in itertools.permutations(variableArray, 5):
variableArray6.append(eachCombination[0] + eachCombination[1] + eachCombination[2] +
eachCombination[3] + eachCombination[4])
variableArray = variableArray + variableArray2 + variableArray3 + variableArray5 +
variableArray6
capitalVariables = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
number=0

def standardizationnew(sentence):
newsentence=list(sentence)
i=0
global number
variables=collections.OrderedDict()
positionsofvariable=collections.OrderedDict()
lengthofsentence=len(sentence)
for i in range(0,lengthofsentence-1):
if(newsentence[i]==',' or newsentence[i]=='('):
if newsentence[i+1] not in capitalVariables:
substitution=variables.get(newsentence[i+1])
positionsofvariable[i+1]=i+1
if not substitution :
variables[newsentence[i+1]]=variableArray[number]
newsentence[i+1]=variableArray[number]
number+=1
else:
newsentence[i+1]=substitution
return "".join(newsentence)

def insidestandardizationnew(sentence):
lengthofsentence=len(sentence)
newsentence=sentence
variables=collections.OrderedDict()
positionsofvariable=collections.OrderedDict()
global number
i=0
while i <=len(newsentence)-1 :
if(newsentence[i]==',' or newsentence[i]=='('):
if newsentence[i+1] not in capitalVariables:
j=i+1
while(newsentence[j]!=',' and newsentence[j]!=')' ):
j+=1

DSATM, Bangalore Page 29 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

substitution=variables.get(newsentence[i+1:j])
if not substitution :
variables[newsentence[i+1:j]]=variableArray[number]
newsentence=newsentence[:i+1]+variableArray[number]+newsentence[j:]
i=i+len(variableArray[number])
number+=1
else:
newsentence=newsentence[:i+1]+substitution+newsentence[j:]
i=i+len(substitution)
i+=1
return newsentence

def replace(sentence,theta):
lengthofsentence=len(sentence)
newsentence=sentence
i=0
while i <=len(newsentence)-1 :
if(newsentence[i]==',' or newsentence[i]=='('):
if newsentence[i+1] not in capitalVariables:# This operator is used to check whether an
element is not present in the passed list or not
j=i+1
while(newsentence[j]!=',' and newsentence[j]!=')' ):
j+=1
nstemp=newsentence[i+1:j]
substitution=theta.get(nstemp)
if substitution :
newsentence=newsentence[:i+1]+substitution+newsentence[j:]
i=i+len(substitution)
i+=1
return newsentence

repeatedsentencecheck=collections.OrderedDict()

def insidekbcheck(sentence):
lengthofsentence=len(sentence)
newsentence=pattern.split(sentence)
newsentence.sort()
newsentence="|".join(newsentence)
global repeatedsentencecheck
i=0
while i <=len(newsentence)-1 :
if(newsentence[i]==',' or newsentence[i]=='('):
if newsentence[i+1] not in capitalVariables:
j=i+1
while(newsentence[j]!=',' and newsentence[j]!=')' ):
j+=1

DSATM, Bangalore Page 30 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

newsentence=newsentence[:i+1]+'x'+newsentence[j:]
i+=1
repeatflag=repeatedsentencecheck.get(newsentence)
if repeatflag :
return True
repeatedsentencecheck[newsentence]=1
return False

for i in range(n+2,n+2+k):
data1[i]=data1[i].replace(" ","")
if "=>" in data1[i]:
data1[i]=data1[i].replace(" ","")
sentencetemp=CNF(data1[i].rstrip())
kbbefore.append(sentencetemp)
else:
kbbefore.append(data1[i].rstrip())
for i in range(0,k):
kbbefore[i]=kbbefore[i].replace(" ","")

kb={}
pattern=re.compile("\||&|=>") #we can remove the '\|'' to speed up as 'OR' doesnt come in the KB
pattern1=re.compile("[(,]")
for i in range(0,k):
kbbefore[i]=standardizationnew(kbbefore[i])
temp=pattern.split(kbbefore[i])
lenoftemp=len(temp)
for j in range(0,lenoftemp):
clause=temp[j]
clause=clause[:-1]
predicate=pattern1.split(clause)
argumentlist=predicate[1:]
lengthofpredicate=len(predicate)-1
if predicate[0] in kb:
if lengthofpredicate in kb[predicate[0]]:
kb[predicate[0]][lengthofpredicate].append([kbbefore[i],temp,j,predicate[1:]])
else:
kb[predicate[0]][lengthofpredicate]=[kbbefore[i],temp,j,predicate[1:]]
else:
kb[predicate[0]]={lengthofpredicate:[[kbbefore[i],temp,j,predicate[1:]]]}

for qi in range(0,n):
queries[qi]=standardizationnew(queries[qi])

def substituevalue(paramArray, x, y):

for index, eachVal in enumerate(paramArray):
if eachVal == x:

DSATM, Bangalore Page 31 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

paramArray[index] = y
return paramArray

def unificiation(arglist1,arglist2):
theta = collections.OrderedDict()
for i in range(len(arglist1)):
if arglist1[i] != arglist2[i] and (arglist1[i][0] in capitalVariables) and (arglist2[i][0] in
capitalVariables):
return []
elif arglist1[i] == arglist2[i] and (arglist1[i][0] in capitalVariables) and (arglist2[i][0] in
capitalVariables):
if arglist1[i] not in theta.keys():
theta[arglist1[i]] = arglist2[i]
elif (arglist1[i][0] in capitalVariables) and not (arglist2[i][0] in capitalVariables):
if arglist2[i] not in theta.keys():
theta[arglist2[i]] = arglist1[i]
arglist2 = substituevalue(arglist2, arglist2[i], arglist1[i])
elif not (arglist1[i][0] in capitalVariables) and (arglist2[i][0] in capitalVariables):
if arglist1[i] not in theta.keys():
theta[arglist1[i]] = arglist2[i]
arglist1 = substituevalue(arglist1, arglist1[i], arglist2[i])
elif not (arglist1[i][0] in capitalVariables) and not (arglist2[i][0] in capitalVariables):
if arglist1[i] not in theta.keys():
theta[arglist1[i]] = arglist2[i]
arglist1 = substituevalue(arglist1, arglist1[i], arglist2[i])
else:
argval=theta[arglist1[i]]
theta[arglist2[i]]=argval
arglist2 = substituevalue(arglist2, arglist2[i], argval)
return [arglist1,arglist2,theta]

def resolution():
global repeatedsentencecheck
answer=list()
qrno=0
for qr in queries:
qrno+=1
repeatedsentencecheck.clear()
q=queue.Queue()
query_start=time.time()
kbquery=copy.deepcopy(kb)
ans=qr
if qr[0]=='~':
ans=qr[1:]
else:
ans='~'+qr

DSATM, Bangalore Page 32 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

q.put(ans)
label:outerloop
currentanswer="FALSE"
counter=0
while True:
counter+=1
if q.empty():
break
ans=q.get()
label:outerloop1
ansclauses=pattern.split(ans)
lenansclauses=len(ansclauses)
flagmatchedwithkb=0
innermostflag=0
for ac in range(0,lenansclauses):
insidekbflag=0
ansclausestruncated=ansclauses[ac][:-1]
ansclausespredicate=pattern1.split(ansclausestruncated)
lenansclausespredicate=len(ansclausespredicate)-1
if ansclausespredicate[0][0]=='~':
anspredicatenegated=ansclausespredicate[0][1:]
else:
anspredicatenegated="~"+ansclausespredicate[0]
x=kbquery.get(anspredicatenegated,{}).get(lenansclausespredicate)
if not x:
continue
else:
lenofx=len(x)
for numofpred in range(0,lenofx):
insidekbflag=0
putinsideq=0
sentenceselected=x[numofpred]

thetalist=unificiation(copy.deepcopy(sentenceselected[3]),copy.deepcopy(ansclausespredicate[1:
]))
if(len(thetalist)!=0):
for key in thetalist[2]:
tl=thetalist[2][key]
tl2=thetalist[2].get(tl)
if tl2:
thetalist[2][key]=tl2
flagmatchedwithkb=1
notincludedindex=sentenceselected[2]
senclause=copy.deepcopy(sentenceselected[1])
mergepart1=""
del senclause[notincludedindex]

DSATM, Bangalore Page 33 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

ansclauseleft=copy.deepcopy(ansclauses)
del ansclauseleft[ac]
for am in range(0,len(senclause)):
senclause[am]=replace(senclause[am],thetalist[2])
mergepart1=mergepart1+senclause[am]+'|'
for remain in range(0,len(ansclauseleft)):
listansclauseleft=ansclauseleft[remain]
ansclauseleft[remain]=replace(listansclauseleft,thetalist[2])
if ansclauseleft[remain] not in senclause:
mergepart1=mergepart1+ansclauseleft[remain]+'|'
mergepart1=mergepart1[:-1]
if mergepart1=="":
currentanswer="TRUE"
break
ckbflag=insidekbcheck(mergepart1)
if not ckbflag:
mergepart1=insidestandardizationnew(mergepart1)
ans=mergepart1
temp=pattern.split(ans)
lenoftemp=len(temp)
for j in range(0,lenoftemp):
clause=temp[j]
clause=clause[:-1]
predicate=pattern1.split(clause)
argumentlist=predicate[1:]
lengthofpredicate=len(predicate)-1
if predicate[0] in kbquery:
if lengthofpredicate in kbquery[predicate[0]]:

kbquery[predicate[0]][lengthofpredicate].append([mergepart1,temp,j,argumentlist])
else:

kbquery[predicate[0]][lengthofpredicate]=[[mergepart1,temp,j,argumentlist]]
else:

kbquery[predicate[0]]={lengthofpredicate:[[mergepart1,temp,j,argumentlist]]}
q.put(ans)
if(currentanswer=="TRUE"):
break
if(currentanswer=="TRUE"):
break
if(counter==2000 or (time.time()-query_start)>20):
break
answer.append(currentanswer)
return answer

DSATM, Bangalore Page 34 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

if name == ' main ':

finalanswer=resolution()
o=open("output.txt","w+")
wc=0
while(wc < n-1):
o.write(finalanswer[wc]+"\n")
wc+=1
o.write(finalanswer[wc])
o.close()

input1.txt
1
Ancestor(Liz,Bob)
6
Mother(Liz,Charley)
Father(Charley,Billy)
~Mother(x,y) | Parent(x,y)
~Father(x,y) | Parent(x,y)
~Parent(x,y) | Ancestor(x,y)
Parent(x,y) & Ancestor(y,z) => Ancestor(x,z)

Input2.txt
6
F(Bob)
H(John)
~H(Alice)
~H(John)
G(Bob)
G(Tom)
14
A(x) => H(x)
D(x,y) => ~H(y)
B(x,y) & C(x,y) => A(x)
B(John,Alice)
B(John,Bob)
D(x,y) & Q(y) => C(x,y)
D(John,Alice)
Q(Bob)
D(John,Bob)
F(x) => G(x)
G(x) => H(x)
H(x) => F(x)
R(x) => H(x)
R(Tom)

Output.txt TRUE

DSATM, Bangalore Page 35 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

8.Implement any Game and demonstrate the Game playing strategies

#8:Implement any Game and demonstrate the Game playing strategies.

#Implementation of Two Player Tic-Tac-Toe game in Python.

''' We will make the board using dictionary

in which keys will be the location(i.e : top-left,mid-right,etc.)
and initialliy it's values will be empty space and then after every move
we will change the value according to player's choice of move. '''

theBoard = {'7': ' ' , '8': ' ' , '9': ' ' ,
'4': ' ' , '5': ' ' , '6': ' ' ,
'1': ' ' , '2': ' ' , '3': ' ' }

board_keys = []

for key in theBoard:

board_keys.append(key)

''' We will have to print the updated board after every move in the game and
thus we will make a function in which we'll define the printBoard function
so that we can easily print the board everytime by calling this function. '''

def printBoard(board):
print(board['7'] + '|' + board['8'] + '|' + board['9'])
print('-+-+-')
print(board['4'] + '|' + board['5'] + '|' + board['6'])
print('-+-+-')
print(board['1'] + '|' + board['2'] + '|' + board['3'])

# Now we'll write the main function which has all the gameplay functionality.
def game():

turn = 'X'
count = 0

for i in range(10):
printBoard(theBoard)
print("It's your turn," + turn + ".Move to which place?")

move = input()

if theBoard[move] == ' ':

theBoard[move] = turn
count += 1

DSATM, Bangalore Page 36 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

else:
print("That place is already filled.\nMove to which place?")
continue

# Now we will check if player X or O has won,for every move after 5 moves.
if count >= 5:
if theBoard['7'] == theBoard['8'] == theBoard['9'] != ' ': # across the top
printBoard(theBoard)
print("\nGame Over.\n")
print(" **** " +turn + " won. ****")
break
elif theBoard['4'] == theBoard['5'] == theBoard['6'] != ' ': # across the middle
printBoard(theBoard)
print("\nGame Over.\n")
print(" **** " +turn + " won. ****")
break
elif theBoard['1'] == theBoard['2'] == theBoard['3'] != ' ': # across the bottom
printBoard(theBoard)
print("\nGame Over.\n")
print(" **** " +turn + " won. ****")
break
elif theBoard['1'] == theBoard['4'] == theBoard['7'] != ' ': # down the left side
printBoard(theBoard)
print("\nGame Over.\n")
print(" **** " +turn + " won. ****")
break
elif theBoard['2'] == theBoard['5'] == theBoard['8'] != ' ': # down the middle
printBoard(theBoard)
print("\nGame Over.\n")
print(" **** " +turn + " won. ****")
break
elif theBoard['3'] == theBoard['6'] == theBoard['9'] != ' ': # down the right side
printBoard(theBoard)
print("\nGame Over.\n")
print(" **** " +turn + " won. ****")
break
elif theBoard['7'] == theBoard['5'] == theBoard['3'] != ' ': # diagonal
printBoard(theBoard)
print("\nGame Over.\n")
print(" **** " +turn + " won. ****")
break
elif theBoard['1'] == theBoard['5'] == theBoard['9'] != ' ': # diagonal
printBoard(theBoard)
print("\nGame Over.\n")
print(" **** " +turn + " won. ****")
break

DSATM, Bangalore Page 37 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

# If neither X nor O wins and the board is full, we'll declare the result as 'tie'.
if count == 9:
print("\nGame Over.\n")
print("It's a Tie!!")

# Now we have to change the player after every move.

if turn =='X':
turn = 'O'
else:
turn = 'X'

# Now we will ask if player wants to restart the game or not.

restart = input("Do want to play Again?(y/n)")
if restart == "y" or restart == "Y":
for key in board_keys:
theBoard[key] = " "

game()

if name == " main ":

game()

Output:
||
-+-+-
||
-+-+-
||
It's your turn,X.Move to which place?

4
||
-+-+-
X| |
-+-+-
||
It's your turn,O.Move to which place?

3
||
-+-+-
X| |
-+-+-

DSATM, Bangalore Page 38 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

| |O
It's your turn,X.Move to which place?

2
||
-+-+-
X| |
-+-+-
|X|O
It's your turn,O.Move to which place?

5
||
-+-+-
X|O|
-+-+-
|X|O
It's your turn,X.Move to which place?

6
||
-+-+-
X|O|X
-+-+-
|X|O
It's your turn,O.Move to which place?

7
O| |
-+-+-
X|O|X
-+-+-
|X|O

Game Over.

**** O won. ****

Do want to play Again?(y/n)

DSATM, Bangalore Page 39 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

Viva Questions
1) What is Artificial Intelligence?
Artificial Intelligence is an area of computer science that emphasizes the creation of intelligent machine that work and
reacts like humans.
2) What is an artificial intelligence Neural Networks?
Artificial intelligence Neural Networks can model mathematically the way biological brain works, allowing the
machine to think and learn the same way the humans do- making them capable of recognizing things like speech,
objects and animals like we do.
3) What are the various areas where AI (Artificial Intelligence) can be used?
Artificial Intelligence can be used in many areas like Computing, Speech recognition, Bio-informatics, Humanoid
robot, Computer software, Space and Aeronautics’s etc.
4) Which is not commonly used programming language for AI?
Perl language is not commonly used programming language for AI
5) What is Prolog in AI?
In AI, Prolog is a programming language based on logic.
6) Give an explanation on the difference between strong AI and weak AI?
Strong AI makes strong claims that computers can be made to think on a level equal to humans while weak AI simply
predicts that some features that are resembling to human intelligence can be incorporated to computer to make it more
useful tools.
7) Mention the difference between statistical AI and Classical AI ?
Statistical AI is more concerned with “inductive” thought like given a set of pattern, induce the trend etc. While,
classical AI, on the other hand, is more concerned with “ deductive” thought given as a set of constraints, deduce a
conclusion etc.
8) What is alternate, artificial, compound and natural key?
Alternate Key: Excluding primary keys all candidate keys are known as Alternate Keys.
Artificial Key: If no obvious key either stands alone or compound is available, then the last resort is to, simply create
a key, by assigning a number to each record or occurrence. This is known as artificial key.
Compound Key: When there is no single data element that uniquely defines the occurrence within a construct, then
integrating multiple elements to create a unique identifier for the construct is known as Compound Key.
Natural Key: Natural key is one of the data element that is stored within a construct, and which is utilized as the
primary key.
9) What does a production rule consist of?
The production rule comprises of a set of rule and a sequence of steps.
10) Which search method takes less memory?
The “depth first search” method takes less memory.
11) Which is the best way to go for Game playing problem?
Heuristic approach is the best way to go for game playing problem, as it will use the technique based on intelligent
guesswork. For example, Chess between humans and computers as it will use brute force computation, looking at
hundreds of thousands of positions.
12) A* algorithm is based on which search method?
A* algorithm is based on best first search method, as it gives an idea of optimization and quick choose of path, and
all characteristics lie in A* algorithm.
13) What does a hybrid Bayesian network contain?
A hybrid Bayesian network contains both a discrete and continuous variables.
14) What is agent in artificial intelligence?
Anything perceives its environment by sensors and acts upon an environment by effectors are known as Agent. Agent
includes Robots, Programs, and Humans etc.
15) What does Partial order or planning involve?
In partial order planning , rather than searching over possible situation it involves searching over the space of possible
plans. The idea is to construct a plan piece by piece.
16) What are the two different kinds of steps that we can take in constructing a plan?
a) Add an operator (action)
b) Add an ordering constraint between operators
17) Which property is considered as not a desirable property of a logical rule-based system?

DSATM, Bangalore Page 40 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

“Attachment” is considered as not a desirable property of a logical rule based system.

18) What is Neural Network in Artificial Intelligence?
In artificial intelligence, neural network is an emulation of a biological neural system, which receives the data, process
the data and gives the output based on the algorithm and empirical data.
19) When an algorithm is considered completed?
An algorithm is said completed when it terminates with a solution when one exists.
20) What is a heuristic function?
A heuristic function ranks alternatives, in search algorithms, at each branching step based on the available information
to decide which branch to follow.
21) What is the function of the third component of the planning system?
In a planning system, the function of the third component is to detect when a solution to problem has been found.
22) What is “Generality” in AI ?
Generality is the measure of ease with which the method can be adapted to different domains of application.
23) What is a top-down parser?
A top-down parser begins by hypothesizing a sentence and successively predicting lower level constituents until
individual pre-terminal symbols are written.
24) Mention the difference between breadth first search and best first search in artificial intelligence?
These are the two strategies which are quite similar. In best first search, we expand the nodes in accordance with the
evaluation function. While, in breadth first search a node is expanded in accordance to the cost function of the parent
node.
25) What are frames and scripts in “Artificial Intelligence”?
Frames are a variant of semantic networks which is one of the popular ways of presenting non-procedural knowledge
in an expert system. A frame which is an artificial data structure is used to divide knowledge into substructure by
representing “stereotyped situations’. Scripts are similar to frames, except the values that fill the slots must be
ordered. Scripts are used in natural language understanding systems to organize a knowledge base in terms of the
situation that the system should understand.
26) What is FOPL stands for and explain its role in Artificial Intelligence?
FOPL stands for First Order Predicate Logic, Predicate Logic provides
a) A language to express assertions about certain “World”
b) An inference system to deductive apparatus whereby we may draw conclusions from such assertion
c) A semantic based on set theory
27) What does the language of FOPL consists of
a) A set of constant symbols
b) A set of variables
c) A set of predicate symbols
d) A set of function symbols
e) The logical connective
f) The Universal Quantifier and Existential Qualifier
g) A special binary relation of equality
28) For online search in ‘Artificial Intelligence’ which search agent operates by interleaving computation and
action?
In online search, it will first take action and then observes the environment.
29) Which search algorithm will use a limited amount of memory in online search?
RBFE and SMA* will solve any kind of problem that A* can’t by using a limited amount of memory.
30) In ‘Artificial Intelligence’ where you can use the Bayes rule?
In Artificial Intelligence to answer the probabilistic queries conditioned on one piece of evidence, Bayes rule can be
used.
31) For building a Bayes model how many terms are required?
For building a Bayes model in AI, three terms are required; they are one conditional probability and two unconditional
probability.
32) While creating Bayesian Network what is the consequence between a node and its predecessors?
While creating Bayesian Network, the consequence between a node and its predecessors is that a node can be
conditionally independent of its predecessors.
33) To answer any query how the Bayesian network can be used?
If a Bayesian Network is a representative of the joint distribution, then by summing all the relevant joint entries, it can
solve any query.

DSATM, Bangalore Page 41 of 42

 Artificial Intelligence Laboratory 18AIL57 5th Sem Dept. Of AI & ML

34) What combines inductive methods with the power of first order representations?
Inductive logic programming combines inductive methods with the power of first order representations.
35) In Inductive Logic Programming what needed to be satisfied?
The objective of an Inductive Logic Programming is to come up with a set of sentences for the hypothesis such that
the entailment constraint is satisfied.
36) In top-down inductive learning methods how many literals are available? What are they?
There are three literals available in top-down inductive learning methods they are
a) Predicates
b) Equality and Inequality
c) Arithmetic Literals
37) Which algorithm inverts a complete resolution strategy?
‘Inverse Resolution’ inverts a complete resolution, as it is a complete algorithm for learning first order theories.
38) In speech recognition what kind of signal is used?
In speech recognition, Acoustic signal is used to identify a sequence of words.
39) In speech recognition which model gives the probability of each word following each word?
Biagram model gives the probability of each word following each other word in speech recognition.
40) Which algorithm is used for solving temporal probabilistic reasoning?
To solve temporal probabilistic reasoning, HMM (Hidden Markov Model) is used, independent of transition and
sensor model.
41) What is Hidden Markov Model (HMMs) is used?
Hidden Markov Models are a ubiquitous tool for modelling time series data or to model sequence behaviour. They
are used in almost all current speech recognition systems.
42) In Hidden Markov Model, how does the state of the process is described?
The state of the process in HMM’s model is described by a ‘Single Discrete Random Variable’.
43) In HMM’s, what are the possible values of the variable?
‘Possible States of the World’ is the possible values of the variable in HMM’s.
44) In HMM, where does the additional variable is added?
While staying within the HMM network, the additional state variables can be added to a temporal model.
45) In Artificial Intelligence, what do semantic analyses used for?
In Artificial Intelligence, to extract the meaning from the group of sentences semantic analysis is used.
46) What is meant by compositional semantics?
The process of determining the meaning of P*Q from P,Q and* is known as Compositional Semantics.
47) How logical inference can be solved in Propositional Logic?
In Propositional Logic, Logical Inference algorithm can be solved by using
a) Logical Equivalence
b) Validity
c) Satisfying ability
48) Which process makes different logical expression looks identical?
‘Unification’ process makes different logical expressions identical. Lifted inferences require finding substitute which
can make a different expression looks identical. This process is called unification.
49) Which algorithm in ‘Unification and Lifting’ takes two sentences and returns a unifier?
In ‘Unification and Lifting’ the algorithm that takes two sentences and returns a unifier is ‘Unify’ algorithm.
50) Which is the most straight forward approach for planning algorithm?
State space search is the most straight forward approach for planning algorithm because it takes account of everything
for finding a solution.

DSATM, Bangalore Page 42 of 42