Chapter: Problem Solving Basics

Introduction
Problem solving is at the heart of artificial intelligence (AI). It involves
finding a sequence of actions to achieve a specific goal starting from an
initial situation. This chapter explores the foundational concepts of problem
solving, including how problems are defined, how solutions are searched,
and the systems used to model these processes. By understanding these
basics, students will gain insight into how AI systems tackle complex tasks
like playing chess, solving puzzles, or planning routes.

1. Problems, Problem Spaces, and Search

Understanding Problems

In AI, a problem is a task that requires finding a way to reach a goal state
from an initial state. For example, in a game like the 8-puzzle, the initial
state is a scrambled tile configuration, and the goal state is the solved
puzzle.

Problem Spaces

A problem space is the conceptual environment containing all possible

states of a problem and the actions (or operators) that transition between
them. Think of it as a map where each point is a state, and each path is an
action.

• Example: In a maze, the problem space includes every position in the

maze (states) and possible moves (up, down, left, right) as operators.

Search

To solve a problem, AI systems search through the problem space to find a

path from the initial state to the goal state. Search strategies determine the
order in which states are explored: - Breadth-First Search (BFS):
Explores all states at the current depth before moving deeper. - Depth-First
Search (DFS): Explores one path as far as possible before backtracking.

Note from the Book: "The problem space is often represented as

a graph, with nodes as states and edges as operators. The
challenge is to find a path through this graph efficiently." (Rich et
al., 2009)
2. Defining the Problem as a State Space
Search
What is State Space Search?

A state space search represents a problem as a graph where: - Nodes

represent states (specific configurations of the problem). - Edges represent
operators (actions that change states). - The goal is to find a path from the
initial state to the goal state.

Components of State Space

1. Initial State: The starting configuration (e.g., the starting position in a

chess game).
2. Goal State: The desired end configuration (e.g., checkmate in chess).
3. Operators: Rules or actions that transform one state into another (e.g.,
moving a chess piece).
4. Path Cost: A measure of the cost of actions (e.g., number of moves or
time taken).

Example: 8-Puzzle

• Initial State: A 3x3 grid with tiles 1–8 and one blank space in a
random order.
• Goal State: Tiles arranged in order (1, 2, 3, 4, 5, 6, 7, 8, blank).
• Operators: Move the blank space up, down, left, or right.
• Path: A sequence of moves to rearrange tiles from initial to goal state.

Why Use State Space Search?

It provides a structured way to explore all possible solutions systematically,

ensuring that no potential solution is missed.

Note from the Book: "State space search is a powerful technique

because it allows us to model a wide variety of problems, from
puzzles to planning, in a uniform way." (Rich et al., 2009)

3. Problem Characteristics
Not all problems are the same. Understanding their characteristics helps
choose the right search strategy. Key characteristics include:

1. Decomposable: Can the problem be broken into independent

subproblems?

◦ Example: Solving a jigsaw puzzle by grouping edge pieces first.

◦ Non-decomposable problems (e.g., chess) require considering the
whole state.
 Recoverable (Ignorable): Can incorrect moves be undone?
2.
◦ Recoverable: In the 8-puzzle, you can move tiles back.
◦ Non-recoverable: In some games, moves are permanent (e.g.,
cutting a rope in a puzzle).

3. Predictable (Certain vs. Uncertain): Are action outcomes known?

◦ Predictable: In a puzzle, moving a tile has a certain result.

◦ Unpredictable: In card games, drawing a card is uncertain.

4. Solution Steps: Are steps obvious or exploratory?

◦ Known Steps: Problems like tower-building have clear steps.

◦ Exploratory: Mazes require trial and error.

Why Analyze Characteristics?

These properties guide the choice of algorithms. For example, BFS is

suitable for recoverable, predictable problems, while heuristic searches
work better for complex, non-decomposable problems.

Note from the Book: "Understanding the characteristics of a

problem is crucial for selecting an appropriate solution strategy, as
no single approach works for all problems." (Rich et al., 2009)

4. Production Systems
What is a Production System?

A production system is a problem-solving framework that uses a set of

rules (called productions) to transform states. It mimics how humans apply
knowledge to solve problems.

Components of a Production System

1. Rule Set: A collection of if-then rules (productions).

◦ Example: In a medical diagnosis system, a rule might be: If fever
and cough, then suspect flu.
2. Working Memory: Stores the current state or facts (e.g., symptoms in
a diagnosis system).
3. Control Strategy: Decides which rule to apply if multiple rules match
(e.g., prioritize rules based on specificity).
4. Inference Engine: Executes the rules by matching conditions to
working memory and applying actions.

Example: Blocks World

• Problem: Stack blocks to achieve a specific configuration.

 • Rules:
◦ If block A is on table and clear, then move A to block B.
◦ If block A is on block B, then move A to table.
• Working Memory: Current block positions.
• Control Strategy: Choose rules to minimize moves.

Applications

Production systems are used in expert systems, game playing, and

automated reasoning.

Note from the Book: "Production systems are versatile because

they separate knowledge (rules) from the mechanism that applies
it (control strategy)." (Rich et al., 2009)

5. Production System Characteristics

Production systems have unique properties that affect their design and
performance:

1. Monotonicity:

◦ Monotonic: Adding new facts doesn’t invalidate previous

conclusions (e.g., theorem proving).
◦ Non-monotonic: New facts can retract earlier conclusions (e.g.,
updating beliefs in a dynamic environment).

2. Modularity:

◦ Rules are independent, so new rules can be added without

changing existing ones.
◦ Advantage: Easy to update or extend the system.

3. Granularity:

◦ Fine-grained: Specific rules for detailed actions (e.g., individual

chess moves).
◦ Coarse-grained: General rules for broader actions (e.g., strategic
goals in chess).
◦ Fine-grained rules increase precision but slow processing.

4. Control Strategies:

◦ Data-driven (Forward Chaining): Start with facts and apply

rules to reach conclusions (e.g., diagnosing from symptoms).
◦ Goal-driven (Backward Chaining): Start with the goal and work
backward to find supporting facts (e.g., proving a theorem).

Why Study These Characteristics?

They help design efficient systems tailored to specific problems.

 Note from the Book: "The flexibility of production systems comes
from their ability to use different control strategies, making them
suitable for both forward and backward reasoning." (Rich et al.,
2009)

6. Issues in the Design of Search Programs

Designing effective search programs is challenging due to several factors:

1. Size of Search Space:

◦ Large state spaces (e.g., Go has ~10^170 states) cause

combinatorial explosion.
◦ Solution: Use pruning (e.g., alpha-beta pruning in games) or
heuristics.

2. Representation:

◦ How states and operators are encoded affects efficiency.

◦ Example: In chess, bitboards (binary representations) are faster
than arrays.

3. Search Strategy:

◦ Uninformed Search: BFS or DFS, which explore blindly, can be

slow.
◦ Informed Search: Heuristic-based methods (e.g., A* search)
prioritize promising paths.
◦ Choosing the right strategy depends on problem characteristics.

4. Heuristics:

◦ Heuristics estimate the cost to the goal (e.g., Manhattan distance

in the 8-puzzle).
◦ Challenge: Designing accurate heuristics that are also
computationally cheap.

5. Optimality vs. Efficiency:

◦ Optimal solutions (e.g., shortest path) may require exploring all

states (slow).
◦ Non-optimal but faster solutions may suffice for real-time
applications.

6. Dead Ends:

◦ Some states have no valid moves (e.g., a blocked path in a maze).

◦ Solution: Backtracking or pruning dead-end states early.

7. Memory Management:

◦ Large searches require storing many states.

 ◦ Solution: Use iterative deepening or limited memory algorithms
like RBFS.

Practical Considerations

Balancing these issues requires trade-offs based on the problem’s needs and
available resources.

Note from the Book: "The design of search programs must

balance the trade-off between completeness (finding a solution if
one exists), optimality (finding the best solution), and
computational efficiency." (Rich et al., 2009)

Summary
Problem solving in AI involves defining problems as state spaces, searching
for solutions, and using systems like production systems to model reasoning.
By understanding problem characteristics and addressing design challenges,
we can develop efficient AI solutions. These concepts form the foundation
for advanced topics like game playing, planning, and machine learning.

Key Terms
• Problem Space
• State Space Search
• Operators
• Production System
• Heuristics
• Control Strategy

Review Questions
1. Explain the difference between breadth-first and depth-first search with
examples.
2. How does a production system model human problem-solving?
3. Why are heuristics important in informed search?
4. Discuss the trade-offs in designing a search program for a large state
space.