UNIT-II

1. How do local search algorithms help in solving optimization problems in AI-

based communication?

LOCAL SEARCH ALGORITHMS AND OPTIMIZATION PROBLEMS

❖ In many optimization problems, the path to the goal is irrelevant; the
goal state itself is the solution.
❖ For example,in the 8-queens problem,what matters is the final
configuration of queens,not the order in which they are added.

❖ In such cases, we can use local search algorithms. They operate

using a single current state(rather than multiple paths) and generally
move only to neighbors of that state.
❖ The important applications of these class of problems are (a)
integrated-circuit design, (b)Factory-floor layout,(c) job-shop
scheduling,(d)automatic programming, (e)telecommunications
network optimization,(f)Vehicle routing,and (g) portfolio
management.

Key advantages of Local Search Algorithms

(1) They use very little memory – usually a constant amount; and
(2) they can often find reasonable solutions in large or
infinite(continuous) state spaces for which systematic algorithms are
unsuitable.

OPTIMIZATION PROBLEMS
In addition to finding goals, local search algorithms are useful for solving pure
optimization problems, in which the aim is to find the best state according to an
objective function.

State Space Landscape

To understand local search, it is better explained using state space
landscape as shown in figure below.

A landscape has both “location” (defined by the state) and

“elevation”(defined by the value of the heuristic cost function or objective
function).

If elevation corresponds to cost,then the aim is to find the lowest valley – a

global minimum;
 if elevation corresponds to an objective function,then the aim is to find the
highest peak – a global maximum.

Local search algorithms explore this landscape. A complete local search

algorithm always finds a goal if one.

❖ Local search can be used on problems that can be formulated as finding a

solution maximizing a criterion among a number of candidate solutions.

❖ Local search algorithms move from solution to solution in the space of

candidate solutions (the search space) until a solution deemed optimal is
found or a time bound is elapsed.

❖ For example, the travelling salesman problem, in which a solution is a

cycle containing all nodes of the graph and the target is to minimize the
total length of the cycle. i.e. a solution can be a cycle and the criterion to
maximize is a combination of the number of nodes and minimize the
length of the cycle.

❖ A local search algorithm starts from a candidate solution and then

iteratively moves to a neighbor solution.

❖ Terminate on a time bound or if the situation is not improved after number of

steps.

HILL CLIMBING SEARCH

• Continually moves in the direction of increasing value (i.e., uphill).

• Terminates when it reaches a “peak”, no neighbor has a higher value.
• Only records the state and its objective function value.
• Does not look ahead beyond the
immediate. So, it is sometimes
called Greedy Local Search

• Problem: can get stuck in local maxima,

• Its success depends very much on the shape of the state-space land-
scape: if there are few local maxima, random-restart hill climbing will
find a “good” solution very quickly.

The hill-climbing search algorithm, which is the most basic local search
technique.

At each step the current node is replaced by the best neighbor; in this
version, that means the neighbor with the highest VALUE, but if a
heuristic cost estimate h is used, we would find the neighbor with the
lowest h.

Example: 4 queens problem

Put 4 queens on an 4×4 board with no two queens on the same row,
column, or diagonal. Move a queen to reduce number of conflicts. In the
below figures, h represents the heuristic(number of conflicting pairs of
queens).

Example: 8 queens problem

Problems with hill-climbing
Hill-climbing often gets stuck for the following reasons :

Local maxima : a local maximum is a peak that is higher than each of its
neighboring states,but lower than the global maximum. Hill-climbing
algorithms that reach the vicinity

of a local maximum will be drawn upwards towards the peak,but will then be
stuck with nowhere else to go
o Ridges : A ridge is shown in Figure below. Ridges results in a
sequence of local maxima that is very difficult for greedy algorithms to
navigate.
o Plateaux : A plateau is an area of the state space landscape where
the evaluation function is flat. All the neighboring states are same.
Figure : Ridges
SIMULATED ANNEALING
To avoid being stuck in a local maxima, it tries randomly (using a probability
function) to move to another state, if this new state is better it moves into it,
otherwise try another move… and so on.

❖ Terminates when finding an acceptably good solution in a fixed

amount of time, rather than the best possible solution.
❖ Locating a good approximation to the global minimum of a given
function in a large search space.

❖ Widely used in VLSI layout, airline scheduling, etc.

❖ The problem with this approach is that the neighbors of a state are not
guaranteed to contain any of the existing better solutions which means
that failure to find a better solution among them does not guarantee that
no better solution exists.

❖ It will not get stuck to a local optimum.

❖ If it runs for an infinite amount of time, the global optimum will be found.

GENETIC ALGORITHMS
❖ Inspired by evolutionary biology and natural selection, such as inheritance.

❖ Evolves toward better solutions.

❖ A successor state is generated by combining two parent states, rather by

modifying a single state.

❖ Start with k randomly generated states (population), Each state is an individual.

❖ A state is represented as a string over a finite alphabet (often a string of 0s and

1s)
 ❖ Evaluation function (fitness function). Higher values for better states.

❖ Produce the next generation of states by selection, crossover, and mutation.

❖ Commonly, the algorithm terminates when either a maximum number of

generations has been produced, or a satisfactory fitness level has been
reached for the population.

Example
 2. Analyze how game theory influences AI-based decision-making in
communication systems. Provide examples to support your analysis.

Game Theory and AI-Based Decision-Making in Communication Systems

Game theory plays a crucial role in AI-based decision-making in

communication systems by modeling interactions between multiple agents (such
as network nodes, users, or service providers) that have conflicting or
cooperative objectives. By applying game-theoretic principles, AI can optimize
resource allocation, improve network performance, and ensure fair and efficient
communication.

1. Understanding Game Theory in AI-Based Communication Systems

Game theory provides a mathematical framework for analyzing strategic

interactions between autonomous decision-makers in a system. In
communication networks, these decision-makers could be routers, users, or
network operators, each aiming to maximize its own benefit while competing or
collaborating with others.

Key Game Theory Concepts Applied to Communication Systems

 Players: Autonomous decision-making agents (e.g., network nodes,

users, ISPs).
 Strategies: Possible actions players can take (e.g., selecting transmission
power, routing paths).
 Payoff: A measure of reward or cost for each strategy (e.g., data rate,
latency, power consumption).
 Equilibrium: A stable state where no player has an incentive to change
its strategy unilaterally.

2. Game Theory Models in AI-Based Communication Systems

(a) Non-Cooperative Game Theory

Non-cooperative game models are used when players act selfishly, trying to
maximize their individual payoffs. AI algorithms analyze and predict players'
behaviors to optimize decision-making.

Example: Nash Equilibrium in Wireless Spectrum Allocation

 Problem: In wireless networks, multiple users compete for limited

spectrum resources.
 Solution: AI-based reinforcement learning algorithms use Nash
equilibrium concepts to allocate spectrum dynamically, ensuring efficient
spectrum use while minimizing interference.
 Real-World Use Case: Cognitive radio networks use Q-learning (a
reinforcement learning algorithm) to allow AI agents to find the best
spectrum-sharing strategies.

(b) Cooperative Game Theory

Cooperative game models apply when multiple entities work together to achieve
a common goal, often forming coalitions.

Example: Coalition Formation in 5G Networks

 Problem: In 5G networks, different service providers must share

infrastructure efficiently.
 Solution: AI uses coalition game theory to determine the best way for
service providers to share network resources while ensuring fairness and
maximizing performance.
 Real-World Use Case: AI-driven cooperative spectrum sharing among
telecom operators to optimize bandwidth usage.

(c) Repeated Games in Network Security and Trust Management

Repeated games involve interactions that occur multiple times, allowing AI

agents to learn and adapt over time.

Example: Intrusion Detection in Cybersecurity

  Problem: Malicious attackers attempt to breach network security, while
AI-based security systems must decide whether to block or monitor them.
 Solution: AI applies repeated game models where it learns attackers’
behavior over time and dynamically adjusts its defense strategies.
 Real-World Use Case: AI-driven intrusion detection systems (IDS) use
game theory to predict attack patterns and deploy optimal
countermeasures.

(d) Stackelberg Games for Network Pricing and Resource Allocation

Stackelberg games model leader-follower dynamics, where one entity makes a

decision first, influencing others.

Example: Pricing in Cloud Computing Services

 Problem: Cloud service providers (leaders) set prices for resources, and
users (followers) choose service plans accordingly.
 Solution: AI applies Stackelberg game models to determine optimal
pricing strategies that balance profitability and user demand.
 Real-World Use Case: AI-powered dynamic pricing in cloud-based
services like AWS and Google Cloud.

3. AI Techniques Used in Game-Theoretic Communication Systems

 Reinforcement Learning (RL): AI learns optimal strategies by

interacting with the network environment.
 Multi-Agent Systems (MAS): AI agents model multiple players in a
communication network.
 Deep Learning: AI predicts user behavior in strategic interactions (e.g.,
network congestion control).
 Evolutionary Algorithms: AI evolves solutions over multiple iterations
to optimize network decisions.

4. Summary and Future Trends

Game theory enhances AI-based decision-making in communication systems by
enabling intelligent resource allocation, security strategies, and service pricing.
Future advancements will integrate deep reinforcement learning (DRL) with
game-theoretic models for autonomous 6G networks and smart IoT
communication systems.

Here's a Python simulation using game theory and reinforcement learning for
network bandwidth allocation among multiple users. The AI agents (users)
decide how much bandwidth to request, while the network optimizes allocation
using Nash Equilibrium concepts.

import numpy as np
import random

class NetworkGame:
def __init__(self, users, total_bandwidth):
self.users = users # Number of users
self.total_bandwidth = total_bandwidth # Total bandwidth available
self.requests = np.zeros(users) # Bandwidth requested by each user

def random_request(self):
"""Each user makes an initial random bandwidth request."""
self.requests = np.random.randint(1, self.total_bandwidth // 2,
size=self.users)

def payoff(self):
"""Calculate the payoff for each user based on Nash Equilibrium."""
total_requested = np.sum(self.requests)
if total_requested <= self.total_bandwidth:
return self.requests # Users get what they request
else:
return (self.requests / total_requested) * self.total_bandwidth #
Proportional allocation

def optimize_bandwidth(self, iterations=1000, learning_rate=0.1):

"""Users adjust their requests based on previous outcomes
(reinforcement learning)."""
 for _ in range(iterations):
payoffs = self.payoff()
for i in range(self.users):
adjustment = learning_rate * (payoffs[i] - self.requests[i])
self.requests[i] = max(1, self.requests[i] + adjustment) # Avoid
zero request
return self.requests

# Simulating the game

total_bandwidth = 100 # Total network bandwidth
users = 5 # Number of users

network_game = NetworkGame(users, total_bandwidth)

network_game.random_request()
optimized_requests = network_game.optimize_bandwidth()

print("Optimized Bandwidth Allocation:", optimized_requests)

Explanation of the Code

1. Game Setup:
o There are multiple users competing for limited bandwidth.
o Each user requests bandwidth randomly at the start.

2. Game Theory Strategy (Nash Equilibrium):

o If total requests exceed available bandwidth, allocation is
proportional to each user's request.
o AI agents adjust their bandwidth requests over iterations using
reinforcement learning.

3. AI Optimization:
o Users modify their requests based on previous outcomes.
o They gradually learn an optimal allocation that stabilizes.
Expected Output

Each user gets a fair share of the bandwidth based on learning and
competition. The allocation adjusts over iterations to reach a stable Nash
Equilibrium.

3. What are online search agents? How do they operate in unknown

environments like cognitive radio networks?

1. Introduction

Online search agents are intelligent computational entities designed to autonomously explore
and retrieve information from dynamic environments in real time. These agents play a crucial
role in decision-making systems, such as search engines, recommendation systems, and
cognitive radio networks (CRNs).

In unknown environments like Cognitive Radio Networks (CRNs), online search agents
must intelligently sense, learn, and adapt to changes to optimize spectrum utilization while
minimizing interference with primary users.

2. Working of Online Search Agents

Online search agents follow a structured process to operate effectively:

1. Sensing & Perception:

o The agent collects real-time data from the environment, such as available
frequency channels, interference levels, and primary user activities.
2. Exploration & Learning:
o The agent employs AI techniques like Reinforcement Learning (RL) and Q-
learning to explore the environment and build an optimal decision-making
model.
3. Decision-Making & Adaptation:
o Based on learned patterns, the agent selects the best available frequency
channels and transmission strategies to maximize efficiency.
 4. Feedback & Continuous Learning:
o The agent continuously updates its knowledge based on environmental
feedback, ensuring adaptability to dynamic changes.

3. Operation in Unknown Environments (Cognitive Radio Networks - CRNs)

Cognitive Radio Networks are dynamic wireless communication systems that enable
secondary users to opportunistically access unused spectrum bands without interfering with
primary users. Online search agents in CRNs operate as follows:

1. Perception Phase: The agent senses the radio spectrum to detect available and
occupied channels.
2. Decision-Making Phase: Using machine learning models, the agent predicts the best
channels and power levels for communication.
3. Execution Phase: The agent switches to the selected channel, ensuring minimal
interference.
4. Learning Phase: The agent updates its knowledge base using feedback from its
actions and adjusts future decisions.

4. Challenges Faced by Online Search Agents in CRNs

 Partial Observability: The agent does not always have complete information about
spectrum availability.
 Dynamic Environment: The spectrum occupancy changes due to unpredictable
primary user activities.
 Exploration vs. Exploitation Dilemma: The agent must balance between learning
new strategies and using known best strategies.
 Real-Time Constraints: Decisions must be made quickly to prevent spectrum
wastage.
5. Diagram of Online Search Agent in CRN

import numpy as np
import random

# Define environment parameters

num_channels = 5 # Number of available spectrum channels
num_episodes = 1000 # Number of training episodes
alpha = 0.1 # Learning rate
gamma = 0.9 # Discount factor
epsilon = 0.2 # Exploration rate

# Initialize Q-table (State-Action Table)

Q_table = np.zeros((1, num_channels))

# Simulated environment: Random availability of channels

def get_reward(channel):
return random.choice([1, 0]) # 1 for available channel, 0 for occupied

# Q-learning Algorithm
for episode in range(num_episodes):
 if random.uniform(0, 1) < epsilon:
action = random.randint(0, num_channels - 1) # Explore
else:
action = np.argmax(Q_table) # Exploit (Best known action)

reward = get_reward(action) # Observe reward from environment

# Q-value update rule

Q_table[0, action] = Q_table[0, action] + alpha * (reward + gamma * np.max(Q_table) -
Q_table[0, action])

# Display final learned Q-table

print("Final Q-Table:")
print(Q_table)

# Select best channel after learning

best_channel = np.argmax(Q_table)
print(f"Best channel selected: {best_channel}")

6. Conclusion

Online search agents are crucial for optimizing resource allocation in unknown
environments like CRNs. They enable efficient and intelligent spectrum access through real-
time sensing, learning, and adaptation. Despite challenges like uncertainty and real-time
decision-making, advanced AI techniques are making these agents more effective in
managing dynamic networks.

4.How can constraint satisfaction problems (CSP) be applied to optimize

communication networks? Provide examples to illustrate their
implementation.

1. Introduction

Constraint Satisfaction Problems (CSP) provide a mathematical framework for solving

optimization problems in communication networks by ensuring multiple constraints are met
simultaneously. This approach helps in efficient resource allocation, interference
minimization, and performance optimization.

A CSP consists of:

  Variables – Elements to be optimized (e.g., network nodes, frequency channels).
 Domains – Possible values the variables can take.
 Constraints – Rules that must be followed (e.g., avoiding congestion, reducing
interference).

2. Examples and Applications of CSP in Communication Networks

A. Frequency Assignment in Wireless Networks

📌 Application: Cellular Networks, Wi-Fi Channel Allocation

Problem:

 In a cellular network, multiple base stations must be assigned frequency channels.

 Constraint: Adjacent towers cannot use the same frequency to avoid interference.

Example:

Consider three base stations A, B, and C, where A is adjacent to B, and B is adjacent to C.

Base Station Possible Frequencies

A {1, 2, 3}
B {2, 3}
C {1, 3}

Using CSP (Graph Coloring), we can assign:

 A → 1, B → 2, C → 3
 This ensures that no two adjacent stations have the same frequency.

🔹 Solution Method: Graph Coloring, Backtracking Algorithm

B. Network Traffic Routing

📌 Application: Internet Service Provider (ISP) networks, Data Centers

Problem:

 Find the best path for data packets while avoiding congestion.
 Constraints:
o Avoid overloaded network paths.
o Meet Quality of Service (QoS) requirements like low latency and high
throughput.

Example:

Consider a network with multiple paths between Node A (source) and Node B
(destination):

Path Bandwidth Latency (ms)

A → X → B High 10 ms
A → Y → B Medium 15 ms
A → Z → B Low 8 ms

A CSP-based routing algorithm selects A → Z → B (since it has the lowest latency) but
considers congestion in real-time.

🔹 Solution Method: A* Algorithm, Dijkstra’s Algorithm

C. Sensor Scheduling in Wireless Sensor Networks (WSN)

📌 Application: IoT Networks, Smart Grids

Problem:

 Schedule sensor nodes to balance energy consumption and extend network lifetime.
 Constraints:
o Only a subset of nodes can be active at a time.
o Coverage of all monitoring areas must be ensured.
Example:

A smart city uses 50 sensors to monitor air pollution.

 The system uses CSP to activate only 20 sensors at a time, ensuring continuous
monitoring while conserving energy.
 If one sensor fails, the CSP solver finds a replacement.

🔹 Solution Method: Integer Linear Programming (ILP), Constraint Propagation

D. Channel Allocation in Cognitive Radio Networks (CRN)

📌 Application: 5G Networks, Dynamic Spectrum Sharing

Problem:

 Assign channels dynamically to secondary users without interfering with primary

users.
 Constraints:
o A secondary user can only use an idle channel.
o No two secondary users in the same location can share the same channel.

Example:

A CSP-based algorithm ensures that in a 5G network, spectrum resources are dynamically

allocated based on demand, ensuring maximum utilization.

🔹 Solution Method: Reinforcement Learning (RL), Graph-Based CSP

3. Solution Techniques Used in CSP for Network Optimization

 Method Application
Graph Coloring Frequency Assignment in Cellular Networks
A Algorithm* Optimal Routing in ISP Networks
Backtracking Wireless Sensor Scheduling
Linear Programming (LP) Resource Allocation in 5G Networks
Reinforcement Learning Dynamic Spectrum Sharing in Cognitive Radio

4. Conclusion

CSP-based approaches significantly optimize communication networks by solving complex

problems like frequency allocation, traffic routing, and sensor scheduling. These
solutions reduce interference, improve network efficiency, and enhance performance. As
communication networks grow in complexity, AI-driven CSP solvers will become
increasingly vital in next-generation networks like 5G and IoT.

5. How can backtracking search and local search be applied to solve

constraint satisfaction problems (CSP) in machine learning for AI-driven
communication systems? Provide examples of their implementation.

Backtracking Search and Local Search in Solving CSPs for AI-Driven

Communication Systems

1. Introduction

A Constraint Satisfaction Problem (CSP) is a mathematical model used in AI-driven

communication systems to optimize decision-making. In machine learning (ML)-based
communication networks, CSPs help in resource allocation, frequency assignment,
network routing, and dynamic spectrum access.

Two common AI techniques for solving CSPs are:

1. Backtracking Search – A systematic search method that tries to assign values to

variables while ensuring constraints are satisfied.
2. Local Search – A heuristic-based method that starts with a solution and iteratively
improves it.
Both techniques play a crucial role in optimizing communication networks, ensuring
efficiency, minimal interference, and real-time decision-making.

2. Application of Backtracking Search in AI-Driven Communication Systems

A. Frequency Assignment in Wireless Networks

📌 Application: Cellular Networks, Wi-Fi Channel Allocation

Problem:

 Assign frequency channels to different network towers while avoiding interference.

 Constraints: Adjacent towers cannot use the same frequency.

Implementation Using Backtracking:

 The algorithm assigns frequencies to towers, checking constraints at each step.

 If an assignment violates a constraint, it backtracks and tries a different frequency.

Example: (Python Implementation)

python
CopyEdit
def is_valid(assignment, tower, frequency, constraints):
for neighbor in constraints[tower]:
if assignment.get(neighbor) == frequency:
return False
return True

def backtrack(assignment, towers, frequencies, constraints):

if len(assignment) == len(towers):
return assignment # Solution found

tower = [t for t in towers if t not in assignment][0]

 for freq in frequencies:
if is_valid(assignment, tower, freq, constraints):
assignment[tower] = freq
result = backtrack(assignment, towers, frequencies, constraints)
if result:
return result
assignment.pop(tower)

return None # No solution found

# Define towers and constraints

towers = ['A', 'B', 'C']
frequencies = [1, 2, 3]
constraints = {'A': ['B'], 'B': ['A', 'C'], 'C': ['B']}

# Solve CSP using backtracking

solution = backtrack({}, towers, frequencies, constraints)
print("Frequency Assignment:", solution)

🔹 Output Example: {A: 1, B: 2, C: 1}

🔹 How It Works: The algorithm assigns non-conflicting frequencies to each tower
efficiently.

3. Application of Local Search in AI-Driven Communication Systems

A. Network Traffic Routing Optimization

📌 Application: ISP Networks, Cloud Computing

Problem:

 Find an optimal data routing path to minimize congestion and ensure fast delivery.
 Constraints:
o Avoid overloaded network paths.
 o Ensure minimum delay.

Implementation Using Local Search (Hill Climbing):

 Start with an initial routing path.

 Iteratively modify the path by switching connections to find a better solution.

Example: (Python Implementation)

python
CopyEdit
import random

# Define network paths with costs

network_paths = {'A': {'B': 10, 'C': 20}, 'B': {'C': 5, 'D': 15}, 'C': {'D': 10}, 'D': {}}
nodes = list(network_paths.keys())

def path_cost(path):
cost = 0
for i in range(len(path) - 1):
cost += network_paths[path[i]].get(path[i+1], float('inf'))
return cost

def hill_climb(start, goal):

current_path = [start]
while current_path[-1] != goal:
neighbors = list(network_paths[current_path[-1]].keys())
if not neighbors:
break
next_node = min(neighbors, key=lambda x: network_paths[current_path[-1]][x]) #
Choose lowest-cost neighbor
current_path.append(next_node)
return current_path, path_cost(current_path)

# Solve using local search

best_path, cost = hill_climb('A', 'D')
print("Optimized Routing Path:", best_path, "with cost:", cost)

🔹 Output Example: Optimized Routing Path: ['A', 'B', 'C', 'D'] with cost: 25
🔹 How It Works: The algorithm iteratively improves the routing path, ensuring minimum
congestion and delay.

4. Comparison of Backtracking and Local Search in CSP-Based Communication

Systems

Feature Backtracking Search Local Search (Hill Climbing)

Approach Systematic, explores all possibilities Heuristic, iteratively improves

Performance Guarantees an optimal solution May find local optima

Problems with strict constraints (e.g., Large-scale problems (e.g.,

Best for
frequency allocation) routing, scheduling)

Drawback Computationally expensive May not find a global solution

5. Conclusion

Both Backtracking Search and Local Search play critical roles in AI-driven
communication systems:

 Backtracking is effective for structured problems like frequency assignment.

 Local Search is efficient for network routing and real-time optimizations.

By integrating CSP solvers in AI-based networks, communication systems can achieve

optimal resource allocation, improved performance, and dynamic adaptation. These
methods are crucial in 5G networks, cognitive radio systems, and cloud-based
networking.
6.Apply informed and uninformed search strategies to optimize a
communication system. Provide real-world examples to demonstrate their
implementation and effectiveness.swapping of halves of the block

1. Introduction

Search strategies are critical in AI-driven communication systems to optimize routing,

resource allocation, and spectrum management. These strategies can be classified into:

1. Uninformed Search – Explores the search space without additional information

about the goal (e.g., Breadth-First Search, Depth-First Search).
2. Informed Search – Uses heuristics to guide the search towards the best solution
(e.g., A Algorithm, Greedy Best-First Search*).

Applying these strategies in real-world communication networks helps in reducing

congestion, minimizing delays, and improving efficiency.

2. Uninformed Search in Communication Systems

A. Optimizing Packet Routing Using Breadth-First Search (BFS)

📌 Application: Packet Routing in a Computer Network

Problem:

 A router needs to send packets from source A to destination D through multiple

network nodes.
 The router must find the shortest path to ensure minimal latency.
 Constraint: The system does not know link costs beforehand (making it an
uninformed search problem).

Implementation Using BFS

 BFS explores all possible routes level by level, ensuring the shortest path is found.

Example (Python Implementation)

python
CopyEdit
from collections import deque

def bfs(network, start, goal):

queue = deque([[start]])
 visited = set()

while queue:
path = queue.popleft()
node = path[-1]

if node == goal:
return path

if node not in visited:

for neighbor in network.get(node, []):
queue.append(path + [neighbor])
visited.add(node)

return None # No path found

# Define network topology

network_graph = {
'A': ['B', 'C'],
'B': ['D', 'E'],
'C': ['F'],
'D': ['G'],
'E': ['H'],
'F': ['I'],
'G': [],
'H': [],
'I': []
}

# Find shortest path using BFS

shortest_path = bfs(network_graph, 'A', 'H')
print("Optimal Routing Path (BFS):", shortest_path)

🔹 Output Example: Optimal Routing Path (BFS): ['A', 'B', 'E', 'H']
🔹 Effectiveness: BFS guarantees the shortest path in an unweighted network.

3. Informed Search in Communication Systems

A. Network Path Optimization Using A Algorithm*

📌 Application: Optimized Data Routing in an ISP Network

Problem:

 Data packets need to travel from a source to a destination with minimal delay.
 Constraint: Different links have different latencies.
 Solution: The A* algorithm uses heuristics (e.g., estimated distance) to find the
optimal path.

Implementation Using A*

 A* combines BFS (exploration) and Greedy Best-First Search (heuristics).

 It selects paths that minimize: f(n)=g(n)+h(n)f(n) = g(n) + h(n)f(n)=g(n)+h(n) Where:
o g(n) = Actual cost from start to node n
o h(n) = Estimated cost from n to goal (heuristic)

Example (Python Implementation)

python
CopyEdit
import heapq

def a_star(network, start, goal, heuristic):

queue = [(0, start, [])] # (cost, node, path)
visited = set()

while queue:
cost, node, path = heapq.heappop(queue)

if node == goal:
return path + [node]

if node not in visited:

visited.add(node)

for neighbor, weight in network.get(node, {}).items():

heapq.heappush(queue, (cost + weight + heuristic[neighbor], neighbor, path +
[node]))

return None # No path found

# Define network topology with link costs

network_graph = {
'A': {'B': 10, 'C': 20},
'B': {'D': 15, 'E': 25},
'C': {'F': 10},
'D': {'G': 10},
 'E': {'H': 5},
'F': {'I': 5},
'G': {},
'H': {},
'I': {}
}

# Define heuristic estimates (straight-line distance)

heuristic_estimates = {
'A': 50, 'B': 40, 'C': 30, 'D': 20, 'E': 10, 'F': 20,
'G': 5, 'H': 0, 'I': 5
}

# Find optimized routing path using A*

optimal_path = a_star(network_graph, 'A', 'H', heuristic_estimates)
print("Optimized Routing Path (A*):", optimal_path)

🔹 Output Example: Optimized Routing Path (A*): ['A', 'B', 'E', 'H']
🔹 Effectiveness: A* finds the optimal path efficiently by combining cost evaluation and
heuristics.

4. Comparison of Uninformed and Informed Search for Communication Optimization

Feature Uninformed Search (BFS) Informed Search (A)*

Approach Explores all paths level-wise Uses heuristics to guide the search

Performance Slow for large networks Efficient for complex networks

Best for Simple, unweighted networks Large-scale, weighted networks

Guarantees Optimality? Yes Yes (with an admissible heuristic)

Real-World Application Local network routing ISP & cloud-based routing

5. Real-World Applications of Search Strategies in Communication Systems

Application Search Method Real-World Example

Dynamic Frequency Allocation in

Wi-Fi Channel Selection A* Search
5G networks

Network Routing Optimization BFS, A* Search Google Maps, ISP Networks

 Application Search Method Real-World Example

Cognitive Radio Networks Dynamic Spectrum Access in AI-

A* Search
(CRN) driven 6G

Wireless Sensor Networks Local Search (Hill

IoT Networks, Smart Cities
(WSN) Scheduling Climbing)

6. Conclusion

Both uninformed and informed search strategies play a crucial role in AI-driven
communication systems:

 Uninformed Search (BFS) is useful for small-scale problems like local network
routing.
 Informed Search (A)* is ideal for real-time decision-making in large-scale
networks like 5G and cloud computing.

By integrating search-based AI techniques, communication networks can become smarter,

more efficient, and adaptive to real-time demands. These methods are essential for future
innovations in 5G, IoT, and AI-driven networking.