1.

Write a Program to Implement Breadth First Search using

Python.

Program:

graph = {
'A' : ['B','C'],
'B' : ['D', 'E'],
'C' : ['F'],
'D' : [],
'E' : ['F'],
'F' : []
}
visited = [] # List to keep track of visited nodes.
queue = [] #Initialize a queue
def bfs(visited, graph, node):
visited.append(node)
queue.append(node)
while queue:
s = queue.pop(0)
print (s, end = " ")
for neighbour in graph[s]:
if neighbour not in visited:
visited.append(neighbour)
queue.append(neighbour)
# Driver Code
bfs(visited, graph, 'A')

Output:-
A
B
D
E
F
C
2. Write a Program to Implement Depth First Search using Python.

Program:
graph = {
'A' : ['B','C'],
'B' : ['D', 'E'],
'C' : ['F'],
'D' : [],
'E' : ['F'],
'F' : []
}
visited = set() # Set to keep track of visited nodes.
def dfs(visited, graph, node):
if node not in visited:
print (node)
visited.add(node)
for neighbour in graph[node]:
dfs(visited, graph, neighbour)
# Driver Code
dfs(visited, graph, 'A')

Output:
A
B
 D
E
F
C

3.Write a Program to Implement an 8-Puzzle problem using Python.

Program:
class Solution:
def solve(self, board):
state_dict = {}
flatten = []

# Flatten the board into a tuple

for i in range(len(board)):
flatten += board[i]
flatten = tuple(flatten)

# Initialize the dictionary with the starting state

state_dict[flatten] = 0

# If the initial state is the goal state, return 0

if flatten == (0, 1, 2, 3, 4, 5, 6, 7, 8):
return 0

return self.get_paths(state_dict)

def get_paths(self, state_dict):

cnt = 0
while True:
# Find nodes at the current distance cnt
 current_nodes = [x for x in state_dict if state_dict[x] == cnt]

if len(current_nodes) == 0:
return -1

for node in current_nodes:

next_moves = self.find_next(node)
for move in next_moves:
if move not in state_dict:
state_dict[move] = cnt + 1
if move == (0, 1, 2, 3, 4, 5, 6, 7, 8):
return cnt + 1
cnt += 1

def find_next(self, node):

moves = {
0: [1, 3],
1: [0, 2, 4],
2: [1, 5],
3: [0, 4, 6],
4: [1, 3, 5, 7],
5: [2, 4, 8],
6: [3, 7],
7: [4, 6, 8],
8: [5, 7],
}

results = []
pos_0 = node.index(0)
for move in moves[pos_0]:
new_node = list(node)
# Swap the 0 with the target position
 new_node[move], new_node[pos_0] = new_node[pos_0],
new_node[move]
results.append(tuple(new_node))

return results

# Test the solution with a sample matrix

ob = Solution()
matrix = [
[3, 1, 2],
[4, 7, 5],
[6, 8, 0]
]
print(ob.solve(matrix))

Output:-
4

4. Write a program to implement best first search algorithm using

Python

Program:
import heapq

class Node:
def __init__(self, position, g=0, h=0):
self.position = position
self.g = g # Cost from start node
 self.h = h # Heuristic cost to end node
self.f = g + h # Total cost (f = g + h)
self.parent = None

def __lt__(self, other):

return self.f < other.f

def a_star(maze, start, end):

# Define the movement options: Up, Down, Left, Right
directions = [(0, -1), (0, 1), (-1, 0), (1, 0)]

# Set up the start and end nodes

start_node = Node(start)
end_node = Node(end)

# Priority queue for open list and set for closed list
open_list = []
closed_set = set()

# Add the start node to the priority queue

heapq.heappush(open_list, start_node)

# Store all visited nodes to avoid duplicate processing

all_nodes = {}
 while open_list:
# Get the node with the lowest f value
current_node = heapq.heappop(open_list)
closed_set.add(current_node.position)

# Check if we have reached the goal

if current_node.position == end_node.position:
path = []
while current_node:
path.append(current_node.position)
current_node = current_node.parent
return path[::-1] # Return reversed path

# Generate neighbors
for direction in directions:
neighbor_pos = (current_node.position[0] + direction[0],
current_node.position[1] + direction[1])

# Check bounds and if the position is walkable

if (0 <= neighbor_pos[0] < len(maze)) and (0 <=
neighbor_pos[1] < len(maze[0])) and
maze[neighbor_pos[0]][neighbor_pos[1]] == 0:

# Skip if the neighbor is already in the closed set

 if neighbor_pos in closed_set:
continue

# Calculate costs
g_cost = current_node.g + 1
h_cost = abs(neighbor_pos[0] - end_node.position[0]) +
abs(neighbor_pos[1] - end_node.position[1])
f_cost = g_cost + h_cost

# Check if we have already seen this node with a lower cost

if neighbor_pos in all_nodes and all_nodes[neighbor_pos].g
<= g_cost:
continue

# Create or update the node

neighbor_node = Node(neighbor_pos, g_cost, h_cost)
neighbor_node.parent = current_node
all_nodes[neighbor_pos] = neighbor_node

# Add the node to the open list

heapq.heappush(open_list, neighbor_node)

return None # No path found

# Example usage
maze = [
[0, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 1, 1, 0],
[0, 1, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 1, 0],
[1, 1, 0, 1, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0]
]

start = (0, 0)
end = (5, 6)

path = a_star(maze, start, end)

print("Path found:", path)

Output:
Path found: [(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (3, 2), (4, 2), (5, 2), (5, 3),
(5, 4), (5, 5), (5, 6)]

5. Write a program to implement the A* serach algorithm using

Python
Program:
from queue import PriorityQueue
v = 14
graph = [[] for i in range(v)]

# Function For Implementing Best First Search

# Gives output path having lowest cost
def best_first_search(actual_Src, target, n):
visited = [False] * n
pq = PriorityQueue()
pq.put((0, actual_Src))
visited[actual_Src] = True

while pq.empty() == False:

u = pq.get()[1]
# Displaying the path having lowest cost
print(u, end=" ")
if u == target:
break

for v, c in graph[u]:
if visited[v] == False:
visited[v] = True
pq.put((c, v))
print()
# Function for adding edges to graph
def addedge(x, y, cost):
graph[x].append((y, cost))
graph[y].append((x, cost))
# The nodes shown in above example(by alphabets) are
# implemented using integers addedge(x,y,cost);
addedge(0, 1, 3)
addedge(0, 2, 6)
addedge(0, 3, 5)
addedge(1, 4, 9)
addedge(1, 5, 8)
addedge(2, 6, 12)
addedge(2, 7, 14)
addedge(3, 8, 7)
addedge(8, 9, 5)
addedge(8, 10, 6)
addedge(9, 11, 1)
addedge(9, 12, 10)
addedge(9, 13, 2)
source = 0
target = 9
best_first_search(source, target, v)
Output:
013289

6. Write a python program to Implement Propositional Model

checking Algorithm.
Program:

import re
class Literal:
# Class Literal, it has attributes name and sign to denote whether
the literal is positive or negative in use
def __init__(self, name, sign=True):
self.name = str(name)
self.sign = sign

def __neg__(self):
# Returns a new literal with the same name but the opposite
sign of its parent literal
return Literal(self.name, False)

def __str__(self):
return str(self.name)

def __repr__(self):
 # Returns the string of the literal name, or the string with a
negative sign each time the instance of the literal is called
if self.sign:
return '%r' % str(self.__str__())
else:
return '%r' % str("-" + self.__str__())

def CNFconvert(KB):
# This function converts the KB from a list of sets to a list of lists for
easier computing
storage = []
for i in KB:
i = list(i)
for j in i:
j = str(j)
storage.append(i)
return storage

def VariableSet(KB):
# This function finds all the used literals in the KB, to assist with
running the DPLL
KB = eval((CNFconvert(KB).__str__()))
storage = []
for obj in KB:
for item in obj:
 if item[0] == '-' and item[1:] not in storage:
storage.append(str(item[1:]))
elif item not in storage and item[0] != '-':
storage.append(str(item))
return storage

def Negativeofx(x):
# This function holds the negative form of the literal, for use in the
DPLL algorithm
check = re.match("-", str(x))
if check:
return str(x[1:])
else:
return "-" + str(x)

def pickX(literals, varList):

# This function picks a literal from the variable set and works with
it as a node in the tree
for x in varList:
if x not in literals:
break
return x

def splitFalseLiterals(cnf, x):

 holder = []
for item in cnf:
if x in item:
item.remove(x)
holder.append(item)
return holder

def splitTrueLiteral(cnf, x):

holder = []
for item in cnf:
if x in item:
continue
else:
holder.append(item)
return holder

def unitResolution(clauses):
literalholder = {} # Dictionary for holding the literal holder and
their boolean values
i=0
# This part of the code goes through each and every clause until all
literals in the KB are resolved
while i < len(clauses): # For each clause
newClauses = []
 clause = clauses[i]
# Picks a clause to work on
if len(clause) == 1:
literal = str(clause[0])
pattern = re.match("-", literal)
# Populates the dictionary
if pattern:
nx = literal[1:]
literalholder[nx] = False
else:
nx = "-" + literal
literalholder[literal] = True
# Checks for all other appearances of the literal or its opposite
in the KB
for item in clauses:
if item != clauses[i]:
if nx in item:
item.remove(nx)
newClauses.append(item)
i=0
clauses = newClauses
# No unit clause
else:
i += 1
 return literalholder, clauses

def dpll(clauses, varList):

# Recursively performs the DPLL algorithm
literals, cnf = unitResolution(clauses)
if cnf == []:
return literals
elif [] in cnf:
return "notsatisfiable"
else:
# Pick a literal which isn't set yet but has an impact on the KB,
and then work on it recursively
while True:
x = pickX(literals, varList)
x = str(x)
nx = Negativeofx(x)
ncnf = splitTrueLiteral(cnf, x)
ncnf = splitFalseLiterals(ncnf, nx)
if ncnf == cnf:
varList.remove(x)
else:
break
# Does the same DPLL recursively, but follows the true path for
that variable
 case1 = dpll(ncnf, varList)
if case1 != "notsatisfiable":
copy = case1.copy()
copy.update(literals)
copy.update({x: True})
return copy
# Does the DPLL recursively, but follows the false path for that
variable
case1 = dpll(ncnf, varList)
if not case1:
copy = case1.copy()
copy.update(literals)
copy.update({x: False})
return copy
else:
return "notsatisfiable"

def DPLL(KB):
# Finally restructures the output to fit the required output by the
assignment description
KB = eval((CNFconvert(KB).__str__()))
varList = VariableSet(KB)
result = dpll(KB, varList)
if result == 'notsatisfiable':
 return False
else:
for i in varList:
if i in result and result[i] == True:
result[i] = 'true'
elif i in result and result[i] == False:
result[i] = 'false'
else:
result[i] = 'free'
return [True, result]

A = Literal('A')
B = Literal('B')
C = Literal('C')
D = Literal('D')
KB = [{A, B}, {A, -C}, {-A, B, D}]
print(DPLL(KB))

Output:
[True, {'B': 'true', 'A': True, 'C': 'free', 'D': 'free'}]

7. Write a program for first order logic using Python.

Program:
class KnowledgeBase:
def __init__(self):
self.facts = []
self.rules = []

def tell(self, fact):

self.facts.append(fact)

def ask(self, query):

if query in self.facts:
return True
for rule in self.rules:
if rule.can_apply(query, self):
return True
return False

def add_rule(self, rule):

self.rules.append(rule)

class Predicate:
def __init__(self, name, *args):
self.name = name
self.args = args
 def __eq__(self, other):
return self.name == other.name and self.args == other.args

def __hash__(self):
return hash((self.name, self.args))

def __repr__(self):
return f"{self.name}({', '.join(map(str, self.args))})"

class Rule:
def __init__(self, antecedent, consequent):
self.antecedent = antecedent # List of conditions
self.consequent = consequent

def can_apply(self, query, kb):

if query.name != self.consequent.name:
return False

# Create a mapping of variables to their values

substitution = {}
for arg_query, arg_rule in zip(query.args, self.consequent.args):
if isinstance(arg_rule, str) and arg_rule.islower(): # Check for a
variable
substitution[arg_rule] = arg_query
 elif arg_query != arg_rule:
return False

# Substitute the variables in the antecedent

substituted_antecedent = [
Predicate(cond.name, *[substitution.get(arg, arg) for arg in
cond.args])
for cond in self.antecedent
]

# Check if all conditions in the antecedent are true

for cond in substituted_antecedent:
if not kb.ask(cond):
return False

kb.tell(query)
return True

# Define individuals
Socrates = "Socrates"

# Define predicates
Human = lambda x: Predicate("Human", x)
Mortal = lambda x: Predicate("Mortal", x)
# Create a knowledge base
kb = KnowledgeBase()

# Tell the knowledge base some facts

kb.tell(Human(Socrates))

# Add rules (for example, "All humans are mortal")

kb.add_rule(Rule([Human("x")], Mortal("x")))

# Query the knowledge base

query = Mortal(Socrates)
if kb.ask(query):
print(f"{query} is True")
else:
print(f"{query} is False")

Output:
Mortal(Socrates) is True

8. Write a program to implement forward chaining algorithm using

Python

Program:
class KnowledgeBase:
def __init__(self):
self.rules = []
self.facts = set()

def tell(self, fact):

self.facts.add(fact)

def add_rule(self, antecedent, consequent):

self.rules.append((antecedent, consequent))

def forward_chain(self):
new_inferences = True

while new_inferences:
new_inferences = False
for antecedent, consequent in self.rules:
# Check if all conditions in the antecedent are true
if all(self.fact_match(cond) for cond in antecedent):
if consequent not in self.facts:
self.tell(consequent)
new_inferences = True

def fact_match(self, fact):

 for f in self.facts:
bindings = self.match(fact, f)
if bindings is not None:
return True
return False

def match(self, pattern, fact):

if pattern == fact:
return {}
if isinstance(pattern, str) and isinstance(fact, str):
if pattern[0].islower(): # Variable match
return {pattern: fact}
return None

def main():
kb = KnowledgeBase()

# Add facts to the knowledge base

kb.tell("Enemy(Nono, America)")
kb.tell("Owns(Nono, M1)")
kb.tell("Missile(M1)")
kb.tell("American(West)")

# Add rules to the knowledge base

 kb.add_rule(["Missile(x)"], "Weapon(x)")
kb.add_rule(["Missile(x)", "Owns(Nono, x)"], "Sells(West, x,
Nono)")
kb.add_rule(["Enemy(x, America)"], "Hostile(x)")
kb.add_rule(["American(x)", "Weapon(y)", "Sells(x, y, z)",
"Hostile(z)"], "Criminal(x)")

# Perform forward chaining

kb.forward_chain()

# Check the result for a specific query

query = "Criminal(West)"
if query in kb.facts:
print(f"{query} is True based on the knowledge base.")
else:
print(f"{query} cannot be proven with the current knowledge
base.")

if __name__ == "__main__":
main()

Output:
Criminal(West) is True based on the knowledge base.
9. Write a program to implement backward chaining algorithm
using Python
Program:
class KnowledgeBase:
def __init__(self):
self.rules = []
self.facts = set()

def tell(self, fact):

self.facts.add(fact)

def add_rule(self, antecedent, consequent):

self.rules.append((antecedent, consequent))

def backward_chain(self, query):

# If the query is already known to be true
if query in self.facts:
return True

# Check all rules to see if we can infer the query

for antecedent, consequent in self.rules:
bindings = self.match(consequent, query)
if bindings is not None:
 substituted_antecedent = [self.substitute(cond, bindings) for
cond in antecedent]
if all(self.backward_chain(cond) for cond in
substituted_antecedent):
self.tell(query) # Cache the result
return True

return False

def match(self, pattern, fact):

if pattern == fact:
return {}
if isinstance(pattern, str) and isinstance(fact, str):
if pattern[0].islower(): # Variable match
return {pattern: fact}
return None

def substitute(self, expression, bindings):

if isinstance(expression, str) and expression[0].islower():
return bindings.get(expression, expression)
if isinstance(expression, (list, tuple)):
return type(expression)(self.substitute(e, bindings) for e in
expression)
return expression
def main():
kb = KnowledgeBase()

# Add facts to the knowledge base

kb.tell("Enemy(Nono, America)")
kb.tell("Owns(Nono, M1)")
kb.tell("Missile(M1)")
kb.tell("American(West)")

# Add rules to the knowledge base

kb.add_rule(["Missile(x)"], "Weapon(x)")
kb.add_rule(["Missile(x)", "Owns(Nono, x)"], "Sells(West, x,
Nono)")
kb.add_rule(["Enemy(x, America)"], "Hostile(x)")
kb.add_rule(["American(x)", "Weapon(y)", "Sells(x, y, z)",
"Hostile(z)"], "Criminal(x)")

# Define the query

query = "Criminal(West)"

# Perform backward chaining

result = kb.backward_chain(query)

# Print the result

 if result:
print(f"{query} is True based on the knowledge base.")
else:
print(f"{query} cannot be proven with the current knowledge
base.")

if __name__ == "__main__":
main()

Output:
Criminal(West) is True based on the knowledge base.

10. Write a simple python program to create a chatbot.

Program:
import re

class SimpleChatBot:
def __init__(self):
self.responses = {
"hello": "Hi there! How can I help you today?",
"hi": "Hello! What can I do for you?",
"how are you": "I'm just a program, but I'm here to help you!",
 "what is your name": "I'm a simple chatbot created in Python.
What's your name?",
"bye": "Goodbye! Have a great day!",
"default": "I'm sorry, I don't understand that. Could you please
rephrase?"
}

def get_response(self, message):

message = message.lower()

# Check for exact matches first

if message in self.responses:
return self.responses[message]

# Check for matches based on keywords

for pattern in self.responses:
if re.search(pattern, message):
return self.responses[pattern]

# Default response if no match found

return self.responses["default"]

def main():
bot = SimpleChatBot()
 print("Chatbot: Hello! I am a simple chatbot. Type 'bye' to exit.")

while True:
user_message = input("You: ")
if user_message.lower() == "bye":
print("Chatbot: " + bot.get_response(user_message))
break

response = bot.get_response(user_message)
print("Chatbot: " + response)

if __name__ == "__main__":
main()

Output:
Chatbot: Hello! I am a simple chatbot. Type 'bye' to exit.
You: Hello
Chatbot: Hi there! How can I help you today?
You: What is your name
Chatbot: I'm a simple chatbot created in Python. What's your name?
You: Harry
Chatbot: I'm sorry, I don't understand that. Could you please
rephrase?
You: My name is Harry
Chatbot: I'm sorry, I don't understand that. Could you please
rephrase?
You: Bye
Chatbot: Goodbye! Have a great day!