Simple Problem-Solving-Agent

Agent Algorithm

Blind (Uninformed)
Search

(Where we systematically explore

alternatives)

1.
2.
3.
4.
5.

R&N: Chap. 3, Sect. 3.35

s0 sense/read initial state

GOAL? select/read goal test
Succ read successor function
solution search(s0, GOAL?, Succ)
perform(solution)

Search Tree

Search Nodes and States

8 2
3 4 7

State graph

Search tree

Note that some states may

be visited multiple times

5 1

6
8

8 4

8 2
3 4 7
5 1

Search Nodes and States

Data Structure of a Node

8 2

8 2

3 4 7

3 4 7
5 1

6
4

5 1

STATE

PARENT-NODE

6
BOOKKEEPING
CHILDREN

If states
states are
are allowed
allowed to
to be
be revisited,
revisited,
If
the search
search tree
tree may
may be
be infinite
infinite even
even
the
when the
the state
state space
space is
is finite
finite
when

6
8

8 4

2
7

...

8 2
3 4 7
5 1

6
5

Action

Right

Depth

Path-Cost 5
Expanded

yes

Depth of a node N
= length of path from root to N
(depth of the root = 0)

Node expansion

The expansion of a node N of the

search tree consists of:
1) Evaluating the successor
function on STATE(N)
2) Generating a child of N for
each state returned by the
function

Fringe of Search Tree

The fringe is the set of all search nodes

that havent been expanded yet
8 2
3 4 7
5 1 6

node generation node expansion

8

8 4

8 2 7
3 4
5 1 6

8 2
3 4 7
5 1

6
7

8
2
3 4 7
5 1 6

8 2
3 4 7
5 1 6

8 4 2
3
7
5 1 6

8 2
3 4 7
5 1 6

Search Strategy
The fringe is the set of all search nodes
that havent been expanded yet
The fringe is implemented as a priority
queue FRINGE
INSERT(node,FRINGE)
REMOVE(FRINGE)

Is it identical
to the set of
leaves?

The ordering of the nodes in FRINGE

defines the search strategy
9

Search Algorithm #1

10

Performance Measures

SEARCH#1
1. If GOAL?(initial-state) then return initial-state
2. INSERT(initial-node,FRINGE)
3. Repeat:
a. If empty(FRINGE) then return failure
Expansion of N
b. N REMOVE(FRINGE)
c. s STATE(N)
d. For every state s in SUCCESSORS(s)
i. Create a new node N as a child of N
ii. If GOAL?(s) then return path or goal state
iii. INSERT(N,FRINGE)
11

Completeness

A search algorithm is complete if it finds a

solution whenever one exists
[What about the case when no solution exists?]

Optimality

A search algorithm is optimal if it returns a

minimum-cost path whenever a solution exists

Complexity

It measures the time and amount of memory

required by the algorithm
12

Blind vs. Heuristic Strategies

Example

Blind (or un-informed) strategies do not

exploit state descriptions to order
FRINGE. They only exploit the positions
of the nodes in the search tree
Heuristic (or informed) strategies
exploit state descriptions to order
FRINGE (the most promising nodes
are placed at the beginning of FRINGE)

For a blind strategy, N1 and N2

are just two nodes (at some
position in the search tree)

STATE

N1

STATE

N2

Goal state

13

14

Example
8

1
4
7

For a heuristic strategy counting

the number of misplaced tiles,
N2 is more promising than N1

N1

3
STATE

5
8

STATE

Remark

N2

Some search problems, such as the (n2-1)puzzle, are NP-hard

One cant expect to solve all instances of
such problems in less than exponential
time (in n)
One may still strive to solve each instance
as efficiently as possible
This is the purpose of the search strategy

Goal state
15

16

Blind Strategies

Breadth-First Strategy

Breadth-first

New nodes are inserted at the end of FRINGE

Bidirectional

Depth-first

Arc cost = 1

Depth-limited
Iterative deepening

Arc cost
(variant of breadth-first) = c(action) > 0

FRINGE = (1)

3
5

Uniform-Cost

17

18

Breadth-First Strategy

Breadth-First Strategy

New nodes are inserted at the end of FRINGE

New nodes are inserted at the end of FRINGE

2
4

FRINGE = (2, 3)

3
5

FRINGE = (3, 4, 5)

3
5

19

20

Breadth-First Strategy

Important Parameters

New nodes are inserted at the end of FRINGE

1) Maximum number of successors of any state

branching factor b of the search tree

1
2
4

2) Minimal length ( cost) of a path between

the initial and a goal state

FRINGE = (4, 5, 6, 7)

3
7

depth d of the shallowest goal node in the

search tree
21

Evaluation

22

Evaluation

b: branching factor
d: depth of shallowest goal node
Breadth-first search is:
Complete? Not complete?
Optimal? Not optimal?

b: branching factor
d: depth of shallowest goal node
Breadth-first search is:
Complete
Optimal if step cost is 1
Number of nodes generated:
???

23

24

Evaluation

Evaluation

b: branching factor
d: depth of shallowest goal node
Breadth-first search is:
Complete
Optimal if step cost is 1
Number of nodes generated:
1 + b + b2 + + bd = ???

b: branching factor
d: depth of shallowest goal node
Breadth-first search is:
Complete
Optimal if step cost is 1
Number of nodes generated:
1 + b + b2 + + bd = (bd+1-1)/(b-1) = O(bd)
Time and space complexity is O(bd)
25

Big O Notation

Time and Memory Requirements

g(n) = O(f(n)) if there exist two positive

constants a and N such that:
for all n > N:

26

g(n) af(n)

27

d
2
4
6
8
10
12
14

# Nodes
111
11,111
~106
~108
~1010
~1012
~1014

Time
.01 msec
1 msec
1 sec
100 sec
2.8 hours
11.6 days
3.2 years

Assumptions: b = 10; 1,000,000 nodes/sec; 100bytes/node

28

Remark

Time and Memory Requirements

d
2
4
6
8
10
12
14

# Nodes
111
11,111
~106
~108
~1010
~1012
~1014

Time
.01 msec
1 msec
1 sec
100 sec
2.8 hours
11.6 days
3.2 years

Memory
11 Kbytes
1 Mbyte
100 Mb
10 Gbytes
1 Tbyte
100 Tbytes
10,000 Tbytes

If a problem has no solution, breadth-first may

run for ever (if the state space is infinite or
states can be revisited arbitrary many times)

Memory
11 Kbytes
1 Mbyte
100 Mb
10 Gbytes
1 Tbyte
100 Tbytes
10,000 Tbytes

Assumptions: b = 10; 1,000,000 nodes/sec; 100bytes/node

29

10

11

12

13

14

15

10

11

12

13

15

14
30

Bidirectional Strategy

Depth-First Strategy

2 fringe queues: FRINGE1 and FRINGE2

New nodes are inserted at the front of FRINGE

1

2
4

FRINGE = (1)

Time and space complexity is O(bd/2) << O(bd)

if both trees have the same branching factor b
Question: What happens if the branching factor
is different in each direction?

31

32

Depth-First Strategy

Depth-First Strategy

New nodes are inserted at the front of FRINGE

New nodes are inserted at the front of FRINGE

1
2
4

FRINGE = (2, 3)

1
3

FRINGE = (4, 5, 3)

33

34

Depth-First Strategy

Depth-First Strategy

New nodes are inserted at the front of FRINGE

New nodes are inserted at the front of FRINGE

1
2
4

1
3

35

3
5

36

Depth-First Strategy

Depth-First Strategy

New nodes are inserted at the front of FRINGE

New nodes are inserted at the front of FRINGE

1
2
4

1
3

3
5

37

38

Depth-First Strategy

Depth-First Strategy

New nodes are inserted at the front of FRINGE

New nodes are inserted at the front of FRINGE

1
2
4

1
3

3
5

39

40

Depth-First Strategy

Depth-First Strategy

New nodes are inserted at the front of FRINGE

New nodes are inserted at the front of FRINGE

1
2
4

1
3

41

3
5

42

Evaluation

Evaluation

b: branching factor
d: depth of shallowest goal node
m: maximal depth of a leaf node
Depth-first search is:

Complete?
Optimal?

b: branching factor
d: depth of shallowest goal node
m: maximal depth of a leaf node
Depth-first search is:

Complete only for finite search tree

Not optimal

Number of nodes generated (worst case):

1 + b + b2 + + bm = O(bm)
Time complexity is O(bm)
Space complexity is O(bm) [or O(m)]

[Reminder: Breadth-first requires O(bd) time and space]

43

Depth-Limited Search

44

Iterative Deepening Search

Provides the best of both breadth-first
and depth-first search

Depth-first with depth cutoff k (depth

at which nodes are not expanded)

Main idea:

Three possible outcomes:

Totally horrifying !

IDS
For k = 0, 1, 2, do:
Perform depth-first search with
depth cutoff k

Solution
Failure (no solution)
Cutoff (no solution within cutoff)

(i.e., only generate nodes with depth k)

45

Iterative Deepening

46

Iterative Deepening

47

48

Iterative Deepening

Performance
Iterative deepening search is:
Complete
Optimal if step cost =1

Time complexity is:

(d+1)(1) + db + (d-1)b2 + + (1) bd = O(bd)

Space complexity is: O(bd) or O(d)

49

Number of Generated Nodes

Calculation
(d-1)b2

(Breadth-First & Iterative Deepening)

d = 5 and b = 2

db +
+ + (1)
= bd + 2bd-1 + 3bd-2 + + db
= (1 + 2b-1 + 3b-2 + + db-d)bd

bd

(i=1,, ib(1-i))bd = bd (b/(b-1))2

51

Number of Generated Nodes

d = 5 and b = 10
ID
6
50
400
3,000
20,000
100,000
123,456

BF
1
2
4
8
16
32
63

ID
1x6=6
2 x 5 = 10
4 x 4 = 16
8 x 3 = 24
16 x 2 = 32
32 x 1 = 32
120

120/63 ~ 2

52

Comparison of Strategies

(Breadth-First & Iterative Deepening)

BF
1
10
100
1,000
10,000
100,000
111,111

50

Breadth-first is complete and optimal,

but has high space complexity
Depth-first is space efficient, but is
neither complete, nor optimal
Iterative deepening is complete and
optimal, with the same space complexity
as depth-first and almost the same time
complexity as breadth-first
123,456/111,111 ~ 1.111
53

Quiz: Would IDS + bi-directional search

be a good combination?

54

Revisited States
No

Few

Avoiding Revisited States

Many

Requires comparing state descriptions

Breadth-first search:

1 2 3
search tree is finite search tree is infinite
4 5
7 8 6

8-queens

assembly
planning

Store all states associated with generated

nodes in VISITED
If the state of a new node is in VISITED,
then discard the node

8-puzzle and robot navigation

55

56

Avoiding Revisited States

Avoiding Revisited States

Depth-first search:

Requires comparing state descriptions

Breadth-first search:

Solution 1:
Store all states associated with nodes in
current path in VISITED
If the state of a new node is in VISITED, then
discard the node
??

Store all states associated with generated

nodes in VISITED
If the state of a new node is in VISITED,
then discard the node
Implemented as hash-table
or as explicit data structure with flags
57

58

Avoiding Revisited States

Depth-first search:

Solution 1:
Store all states associated with nodes in
current path in VISITED
If the state of a new node is in VISITED, then
discard the node
Only avoids loops
Solution 2:
Store all generated states in VISITED
If the state of a new node is in VISITED, then
discard the node
59
Same space complexity as breadth-first !

Uniform-Cost Search
Each arc has some cost c > 0
The cost of the path to each node N is
g(N) = costs of arcs
The goal is to generate a solution path of minimal cost
The nodes N in the queue FRINGE are sorted in
increasing g(N)
S
A
S

5 B

15

10
5 G

1
11

Need to modify search algorithm

B
G

15

10
60

10

Avoiding Revisited States in

Uniform-Cost Search

Search Algorithm #2
The goal test is applied

SEARCH#2
to a node when this node is
1. INSERT(initial-node,FRINGE) expanded, not when it is
generated.
2. Repeat:
a. If empty(FRINGE) then return failure
b. N REMOVE(FRINGE)
c. s STATE(N)
d. If GOAL?(s) then return path or goal state
e. For every state s in SUCCESSORS(s)
i. Create a node N as a successor of N
ii. INSERT(N,FRINGE)
61

For any state S, when the first node N such that

STATE(N) = S is expanded, the path to N is the
best path from the initial state to S
So:
When a node is expanded, store its state into
CLOSED

When a new node N is generated:

If STATE(N) is in CLOSED, discard N

If there exits a node N in the fringe such that
STATE(N) = STATE(N), discard the node N or N
with the highest-cost path
62

11