Uninformed Search

Exploring AI Search Strategies Without Domain Knowledge

Dr. Dhaval Patel • 2025

What We'll Learn Today

Today's lecture will cover the fundamentals of uninformed search strategies in AI, providing you with essential knowledge for problem-solving.

Understanding states and knowledge representation
Components of atomic agents and search problems
Why search is crucial in AI with practical examples
Evaluation criteria for search strategies
Core uninformed search algorithms
Complexity analysis and performance comparison

                    By the end of this lecture, you'll understand how AI agents find solutions without using domain-specific knowledge.
                

Fundamentals

States & Knowledge Representation

What is a State?

A state represents a complete description of the world or problem situation at any given moment.

State Definition:
A state captures all relevant information needed to:

Determine what actions are possible
Evaluate whether the goal has been reached
Understand the current situation completely
Predict the outcome of actions

Key Point: States are not just snapshots - they're comprehensive representations that enable decision-making and goal achievement in AI systems.

Think of a state as answering: "What is the complete current situation that matters for solving this problem?"

Agent's Knowledge: Vacuum World Example

Vacuum World Visualization

🤖

Room A
DIRTY

Room B
CLEAN

Current State: (Agent-A, A-Dirty, B-Clean)

Possible Actions:
• Suck (clean room A)
• Move-Right (go to room B)

State Space Analysis

Agent Position: A or B (2 options)
Room A Status: Clean or Dirty (2 options)
Room B Status: Clean or Dirty (2 options)
Total States: 2 × 2 × 2 = 8 states

Actions Available:
• Move-Right
• Move-Left
• Suck

Goal State: Both rooms clean, regardless of agent location (2 winning states out of 8 total).

Atomic Agent Input Components

Every search problem requires four essential components to be well-defined:

1. Set of States
All possible configurations of the world
Example: In vacuum world, all 8 possible combinations of (Agent-Position, Room-A-Status, Room-B-Status)

2. Operators (Actions) and Costs
Available actions and their associated costs
Example: Move-Left (cost=1), Move-Right (cost=1), Suck (cost=1)

3. Start State
The initial configuration where the agent begins
Example: (Agent-A, A-Dirty, B-Dirty)

4. Goal State (Test)
Condition or test that defines success
Example: Both rooms are clean

                    These components define the "search space" - the landscape of all possible paths from start to goal.
                

Why Search?

Real-World Applications & Examples

Example 1: The 8-Puzzle

Start State

1

3

4

2

6

7

5

8

→

Goal State

1

2

3

4

5

6

7

8

Problem Analysis

States: 9!/2 = 181,440 configurations
Actions: Slide tile into empty space (Up, Down, Left, Right)
Goal: Arrange numbers 1-8 in order with empty space at bottom-right
Challenge: Find shortest sequence of moves

Why Search?
With 181,440 possible states, we need systematic exploration to find the optimal solution!

Example 2: Romania Travel Problem

Problem: Find shortest path from Arad to Bucharest

Search Problem Setup

States: Cities (Arad, Oradea, Sibiu, Brasov, Bucharest, etc.)
Actions: Drive from one city to a connected city
Costs: Distance between cities (in km)
Goal: Reach Bucharest from Arad

Multiple Paths Exist:
• Arad → Sibiu → Brasov → Bucharest
• Arad → Oradea → ... → Bucharest
Which is shortest?

Example 3: N-Queens Problem

4-Queens Solution

♛

✓ No queens attack each other!

Problem Complexity

Goal: Place N queens on N×N board so none attack each other
States: Arrangements of queens on board
Actions: Place or move queens
Constraints: No two queens in same row, column, or diagonal

Search Space:
• 4-Queens: 2 solutions
• 8-Queens: 92 solutions
• But millions of possible arrangements to check!

Strategy Evaluation

How Do We Judge Search Algorithms?

Search Strategy Evaluation Criteria

A search strategy is defined by the order of node expansion. We evaluate strategies along five key dimensions:

1. Completeness: Does it always find a solution if one exists?
Will the algorithm eventually find the goal, or might it get lost?

2. Time Complexity: Number of nodes generated/explored
How much computation time does it take?

3. Space Complexity: Maximum number of nodes stored in memory
How much memory does it require?

4. Optimality: Does it always find the least-cost solution?
Is the solution the best possible?

5. Systematicity: Does it visit each state at most once?
Does it avoid redundant work?

                    Complexity Measures:

                    • b: maximum branching factor (max children per node)

                    • d: depth of least-cost solution

                    • m: maximum depth (may be ∞)

Uninformed Search

Strategies Using Only Problem Definition

Uninformed Search Strategies

Uninformed search strategies use only the information available in the problem definition - no domain-specific knowledge!

Breadth-First Search (BFS): Expand shallowest nodes first
Depth-First Search (DFS): Expand deepest nodes first
Depth-Limited Search: DFS with maximum depth limit
Iterative Deepening Search: Gradually increase depth limit
Bidirectional Search: Search from both start and goal

Also called "blind search" - they don't know if one non-goal state is more promising than another.

Each strategy makes different trade-offs between time, space, completeness, and optimality.

Breadth-First Search (BFS) Visualization

BFS Expansion Order: Level by Level

S

A

B

C

D

E

F

G

H

...

Order: S → A, B, C → D, E, F, G, H → ...

BFS Characteristics

Strategy: Expand all nodes at depth d before depth d+1
Complete: ✓ Yes (if b is finite)
Optimal: ✓ Yes (if step costs are equal)
Time: O(b^d)
Space: O(b^d) - stores entire frontier

Key Insight: BFS guarantees shortest path but uses exponential memory!

Depth-First Search (DFS) Visualization

DFS Expansion Order: Depth First

S

A

B

C

D

E

F

G

H

I

J

...

Order: S → A → D → I → J → ... (backtrack) → E → ...

DFS Characteristics

Strategy: Expand deepest node first, backtrack when stuck
Complete: ✗ No (can get lost in infinite paths)
Optimal: ✗ No (finds any solution, not necessarily shortest)
Time: O(b^m)
Space: O(bm) - only stores path

Key Insight: DFS uses much less memory but may never find the optimal solution!

Breadth-First vs Depth-First Search

Breadth-First Search

Strategy: Expand all nodes at depth d before any nodes at depth d+1

                        ✓ Complete & Optimal

                        ✓ Finds shortest path

                        ✗ High memory usage O(b^d)

                        ✗ Slow if solution is deep

Use when: Solutions are shallow, optimality is crucial, memory is available

Depth-First Search

Strategy: Expand deepest node first, backtrack when needed

✓ Low memory usage O(bm)
✓ Fast if many solutions exist
✗ Not optimal
✗ May get stuck in infinite paths
✗ Not complete

Use when: Memory is limited, any solution is acceptable, search space is finite

VS

Time and Space Complexity: BFS Example

Breadth-First Search Complexity Analysis

Depth	Nodes	Time	Memory
2	110	milliseconds	11 kilobytes
4	11,110	milliseconds	11 megabytes
6	10⁶	seconds	1.1 gigabytes
8	10⁸	minutes	100 gigabytes
10	10¹⁰	hours	10 terabytes
12	10¹²	days	1 petabyte
14	10¹⁴	years	100 petabytes
16	10¹⁶	years	10 exabytes

Assumptions: Branching factor b = 10, 1 million nodes/second, 1000 bytes/node.

Critical Insight: Memory becomes the limiting factor much faster than time! This exponential growth shows why we need smarter strategies for complex problems. Notice how memory requirements become impossible to satisfy well before time does.

Iterative Deepening Search Visualization

Iterative Deepening: Gradually Increase Depth Limit

Depth Limit = 0

S

Depth Limit = 1

S

A

B

Depth Limit = 2

S

A

B

G

C

D

✓ Goal Found at Depth 2!

How It Works

Step 1: Try DFS with depth limit 0
Step 2: Try DFS with depth limit 1
Step 3: Try DFS with depth limit 2
Continue: Until solution found

                    Benefits:

                    ✓ Complete & Optimal

                    ✓ Memory efficient O(bd)

                    ✓ Not much slower than BFS

Why It Works: Most work is at the deepest level, so repeating shallow searches is negligible!

Bidirectional Search Visualization

Bidirectional: Two Searches Meet in the Middle

→ FORWARD →

S

Start: Expand from S

vs

Step 1

← BACKWARD ←

G

Goal: Expand from G

→ FORWARD →

S

A

B

Explore: A, B

vs

Step 2

← BACKWARD ←

G

Y

Z

Explore: Y, Z

→ FORWARD →

S

A

B

X

C

⚡

COLLISION!

🎯

Node X Found

🏆 SUCCESS!

← BACKWARD ←

G

Y

Z

X

W

🛤️ Final Path: S → A → X ← Y ← G

Total Path Length: 4 steps | Nodes Explored: ~10 | vs Normal BFS: ~1000+ saved!

Why It's Powerful

Exponential Speedup: O(b^d) → O(b^(d/2))
Early Termination: Stop as soon as searches meet
Symmetric Exploration: Both directions contribute equally
Optimal Path: Combines shortest segments from both sides

                    Complexity Example:

                    • Normal BFS: 10¹⁰ nodes

                    • Bidirectional: 2 × 10⁵ nodes

                    • 50,000x faster!

Requirements:
• Reversible operators
• Explicit goal state
• Same search strategy both ways

Advanced Uninformed Strategies Summary

Iterative Deepening Search

Best general-purpose uninformed search:

Combines BFS completeness with DFS memory efficiency
Complete and optimal
Space complexity: O(bd)
Time complexity: O(b^d)

When to Use:
• Don't know solution depth
• Want optimal solution
• Memory is limited
• General-purpose choice

Bidirectional Search

Most efficient when applicable:

Exponential speedup: O(b^d) → O(b^(d/2))
Complete and optimal
Requires reversible operators
Need explicit goal state

When to Use:
• Can work backwards from goal
• Large search spaces
• Solution depth is large
• Want maximum efficiency

Summary: Choosing the Right Strategy

Each uninformed search strategy has its place depending on the problem characteristics:

Use Breadth-First Search when:
• Solution depth is small (d ≤ 12)
• You need the optimal solution
• Memory is not a constraint
• Step costs are uniform

Use Depth-First Search when:
• Memory is severely limited
• Solutions are deep but plentiful
• Any solution is acceptable (not necessarily optimal)
• Search space is finite

Use Iterative Deepening when:
• You want BFS optimality with DFS memory efficiency
• Search space has uniform cost
• Best general-purpose uninformed search
• Don't know the solution depth in advance

                    Key Insight: Uninformed search teaches us the fundamental trade-offs in AI: time vs. space vs. optimality. Understanding these prepares us for informed search strategies that use domain knowledge to do much better!
                

Questions & Discussion

Understanding Uninformed Search