Solving Problems by
Searching
Foundations for Uninformed
Search Methods
Literature



S. Russell and P. Norvig. Artificial Intelligence: A
Modern Approach, chapter 3. Prentice Hall, 2nd
edition, 2003.
S. Amarel. On Representations of Problems of
Reasoning about Actions. In: D. Michie ,editor,
Machine Intelligence 3, pages 131-171, Edinburgh
University Press, 1968. Reprinted in: B. Webber and
N. Nilsson ,editors, Readings in Artificial Intelligence,
pages 2-22, Tioga, 1981.
N. Nilsson. Principles of Artificial Intelligence,
chapters 1-2. Springer, 1982.
Solving Problems by Searching
2
Overview






Characterizing Search Problems
Searching for Solutions
Uninformed Search Strategies
Avoiding Repeated States
The Problem of Representation
Search in AND/OR-Graphs
Searching with Partial Information
Solving Problems by Searching
3
Problems of
Reasoning about Actions


aim: find a course of actions that
satisfies a number of specified
conditions
examples:
• planning an airplane trip
• planning a dinner party
Solving Problems by Searching
4
Toy Problems vs.
Real-World Problems
Toy Problems
•
•
•
Real-World Problems
concise and exact
description
used for illustration
purposes (e.g. here)
used for performance
comparisons
•
•
no single, agreedupon description
people care about the
solutions
Solving Problems by Searching
5
Toy Problem:
Missionaries and Cannibals
On one bank of a river are three
missionaries (black triangles) and
three cannibals (red circles). There is
one boat available that can hold up
to two people and that they would
like to use to cross the river. If the cannibals ever
outnumber the missionaries on either of the river’s banks,
the missionaries will get eaten.
How can the boat be used to safely carry all the
missionaries and cannibals across the river?
Solving Problems by Searching
6
Search Problems




initial state
set of possible actions/applicability conditions
•
•
•
successor function: state  set of <action, state>
successor function + initial state = state space
path (solution)
goal
•
goal test function or goal state
path cost function
•
•
assumption: path cost = sum of step costs
for optimality
Solving Problems by Searching
7
Missionaries and Cannibals:
Initial State and Actions

initial state:
•

all missionaries, all
cannibals, and the
boat are on the left
bank
5 possible actions:
•
•
•
•
•
one missionary crossing
one cannibal crossing
two missionaries
crossing
two cannibals crossing
one missionary and one
cannibal crossing
Solving Problems by Searching
8
Missionaries and Cannibals:
Successor Function
state
set of <action, state>
(L:3m,3c,b-R:0m,0c)  {<2c, (L:3m,1c-R:0m,2c,b)>,
<1m1c, (L:2m,2c-R:1m,1c,b)>,
<1c, (L:3m,2c-R:0m,1c,b)>}
(L:3m,1c-R:0m,2c,b)  {<2c, (L:3m,3c,b-R:0m,0c) >,
<1c, (L:3m,2c,b-R:0m,1c)>}
(L:2m,2c-R:1m,1c,b)  {<1m1c, (L:3m,3c,b-R:0m,0c) >,
<1m, (L:3m,2c,b-R:0m,1c)>}
Solving Problems by Searching
9
Missionaries and Cannibals:
State Space
1c
1c
2c
1m
1c
2c
1m
1m
2c
2c
1m
1c
1c
1c
1c
1c
2m
2m
1m
1c
Solving Problems by Searching
10
Missionaries and Cannibals:
Goal State and Path Cost

goal state:
•

all missionaries, all
cannibals, and the
boat are on the right
bank.
path cost
•
•

step cost: 1 for each
crossing
path cost: number of
crossings = length of
path
solution path:
•
•
4 optimal solutions
cost: 11
Solving Problems by Searching
11
Real-World Problem:
Touring in Romania
Oradea
71
Neamt
Zerind
87
151
75
Iasi
Arad
140
Sibiu
92
Fagaras
99
118
Vaslui
80
Rimnicu Vilcea
Timisoara
97
211
142
Pitesti
111
Lugoj
101
146
70
85
98
Hirsova
Urziceni
Bucharest
86
Mehadia
138
90
75
Dobreta
Eforie
120
Giurgiu
Craiova
Solving Problems by Searching
12
Goal Formulation



performance measure
•
assigns a “happiness value” to all possible world
states
goal
•
a condition that either is or is not satisfied in a given
world state; a set of world states
goal formulation
•
find a goal that must be true in all desirable world
states, i.e. all situations in which the performance
measure is high
Solving Problems by Searching
13
Problem Formulation

problem formulation
•
•

process of deciding what actions and states to
consider
granularity/abstraction level
assumptions about the environment:
•
•
•
•
static
observable
discrete
deterministic
Solving Problems by Searching
14
Touring in Romania:
Search Problem Definition




initial state:
•
In(Arad)
possible Actions:
•
DriveTo(Zerind), DriveTo(Sibiu), DriveTo(Timisoara),
etc.
goal state:
•
In(Bucharest)
step cost:
•
distances between cities
Solving Problems by Searching
15
Overview






Characterizing Search Problems
Searching for Solutions
Uninformed Search Strategies
Avoiding Repeated States
The Problem of Representation
Search in AND/OR-Graphs
Searching with Partial Information
Solving Problems by Searching
16
Search


An agent with several immediate options of
unknown value can decide what to do by first
examining different possible sequences of
actions that lead to states of known value,
and then choosing the best sequence.
search (through the state space) for
•
•
•
a goal state
a sequence of actions that leads to a goal state
a sequence of actions with minimal path cost that
leads to a goal state
Solving Problems by Searching
17
Search Trees


search tree: tree structure defined by initial
state and successor function
Touring Romania (partial search tree):
In(Arad)
In(Zerind)
In(Arad)
In(Sibiu)
In(Oradea)
In(Timisoara)
In(Fagaras)
In(Sibiu)
In(Rimnicu Vilcea)
In(Bucharest)
Solving Problems by Searching
18
Search Nodes


search nodes: the nodes in the search tree
data structure:
•
•
•
•
•
state: a state in the state space
parent node: the immediate predecessor in the search
tree
action: the action that, performed in the parent node’s
state, leads to this node’s state
path cost: the total cost of the path leading to this
node
depth: the depth of this node in the search tree
Solving Problems by Searching
19
Expanding a Search Node
function expand(node, problem)
successors  { }
for each <action, result> in problem.successorFn(node.state) do
s  new searchNode(result)
s.parentNode  node
s.action  action
s.pathCost  node.pathCost +
problem.stepCost(action, node.state)
s.depth  node.depth + 1
successors  successors + s
return successors
Solving Problems by Searching
20
Expanded Search Nodes
in Touring Romania Example
In(Arad)
In(Zerind)
In(Arad)
In(Sibiu)
In(Oradea)
In(Timisoara)
In(Fagaras)
In(Sibiu)
In(Rimnicu Vilcea)
In(Bucharest)
Solving Problems by Searching
21
Fringe Nodes
in Touring Romania Example
fringe nodes: nodes that have not been
expanded
In(Arad)
In(Zerind)
In(Arad)
In(Sibiu)
In(Oradea)
In(Timisoara)
In(Fagaras)
In(Sibiu)
In(Rimnicu Vilcea)
In(Bucharest)
Solving Problems by Searching
22
Search (Control) Strategy

search or control strategy: an effective method
for scheduling the application of the successor
function to generate new states
•
•
•

selects the next node to be expanded from the fringe
determines the order in which nodes are expanded
aim: produce a goal state as quickly as possible
examples:
•
•
LIFO-queue for fringe nodes
alphabetical ordering
Solving Problems by Searching
23
General Tree Search Algorithm
function treeSearch(problem, strategy)
fringe  { new
searchNode(problem.initialState) }
loop
if empty(fringe) then return failure
node  selectFrom(fringe, strategy)
if problem.goalTest(node.state) then
return pathTo(node)
fringe  fringe + expand(problem, node)
Solving Problems by Searching
24
Key Features of the General
Search Algorithm

systematic
• guaranteed to not generate the same state
•

infinitely often
guaranteed to come across every state
eventually
incremental
• attempts to reach a goal state step by step
(rather than guessing it all at once)
Solving Problems by Searching
25
Possible Outcomes

algorithm terminates with:

algorithm does not terminate
• failure: no solution could be found
• success: solution path was found
Solving Problems by Searching
26
General Search Algorithm:
Touring Romania Example
In(Arad)
In(Zerind)
In(Arad)
In(Sibiu)
In(Oradea)
In(Timisoara)
In(Fagaras)
In(Sibiu)
In(Rimnicu Vilcea)
In(Bucharest)
fringe
selected
Solving Problems by Searching
27
Measuring
Problem-Solving Performance




completeness
•
Is the algorithm guaranteed to find a solution when
there is one?
optimality
•
Does the strategy find the optimal solution?
time complexity
•
How long does it take to find a solution?
space complexity
•
How much memory is need to perform the search?
Solving Problems by Searching
28
Search Problem
Complexity Measures

in theoretical Computer Science:

in Artificial Intelligence:
• size of the state space graph
• branching factor: maximum number of
•
•
successors per node
depth of the shallowest goal node
maximum length of any path in the state
space
Solving Problems by Searching
29
Problem-Solving Performance:
Examples
Touring Romania Missionaries and
Cannibals
size of state
space
20
16
branching factor
4
3
3
11
16
13
shallowest goal
depth
maximum path
length
Solving Problems by Searching
30
Search Cost vs. Total Cost

search cost:

total cost:

optimal trade-off point:
• time (and memory) used to find a solution
• search cost + path cost of solution
• further computation to find a shorter path
becomes counterproductive
Solving Problems by Searching
31
Overview






Characterizing Search Problems
Searching for Solutions
Uninformed Search Strategies
Avoiding Repeated States
The Problem of Representation
Search in AND/OR-Graphs
Searching with Partial Information
Solving Problems by Searching
32
Uninformed vs. Informed Search

uninformed search (blind search)
• no additional information about states beyond
•

problem definition
only goal states and non-goal states can be
distinguished
informed search (heuristic search)
• additional information about how “promising”
a state is available
Solving Problems by Searching
33
Breadth-First Search

strategy:
• expand root node
• expand successors of root node
• expand successors of successors of root
•

node
etc.
implementation:
• use FIFO queue to store fringe nodes in
general tree search algorithm
Solving Problems by Searching
34
depth = 3
depth = 2
depth = 1
depth = 0
Breadth-First Search:
Missionaries and Cannibals
Solving Problems by Searching
35
Time and Space Complexity for
Breadth-First Search


assumptions:
•
•
every search node has exactly b successors (b finite)
shallowest goal node is at finite depth d
analysis:
•
•
worst case: goal node last node at depth d
bn successors at depth n


 
b  b 2  b3    b d  b d 1  b  O b d 1
•
•
time complexity: O(bd+1)
space complexity: O(bd+1)
Solving Problems by Searching
36
Breadth-First Search: Evaluation
completeness
yes
optimality
shallowest
time complexity
O(bd+1)
space complexity
O(bd+1)
Solving Problems by Searching
37
Exponential Complexity
Depth Nodes
Time
Memory
2
1100 0.11 seconds 1 megabyte
4
111100 11 seconds 106 megabytes
6
107
19 minutes
10 gigabytes
8
109
31 hours
1 terabyte
10
1011
129 days
101 terabytes
12
1013
35 years
10 petabytes
14
1015
3523 years
1 exabyte
Solving Problems by Searching
38
Exponential Complexity:
Important Lessons



memory requirements are a bigger problem for
breadth-first search than is the execution time
time requirements are still a major factor
exponential-complexity search problems
cannot be solved by uninformed methods for
any but the smallest instances
Solving Problems by Searching
39
Uniform-Cost Search

breadth-first search is optimal when all
step costs are equal

uniform-cost search:
• always expand the fringe node with lowest
path cost first
Solving Problems by Searching
40
Uniform-Cost Search:
Touring Romania
Timisoara
(268)
Oradea
(296)
Arad
(292)
Oradea
(291)
Fagaras
(239)
Zerind
(217)
Zerind
(225)
Arad
(300)
Arad
(280)
Sibiu
(297)
Rimnicu Vilcea
(220)
Sibiu
(300)
Craiova
(346)
Pitesti
(317)
Arad
(236)
Lugoj
(229)
Timisoara
(340)
d=2
Oradea
(146)
Timisoara
(118)
Mehadia
(299)
Oradea
(288)
d=4
Arad
(150)
Sibiu
(140)
d=3
Zerind
(75)
d=1
Arad
(0)
selected
Sibiu
(290)
d=0
fringe
Solving Problems by Searching
41
Time and Space Complexity for
Uniform-Cost Search


assumptions:
•
•
•
every search node has exactly b successors (b finite)
every step has cost ≥ ε for some positive constant ε
let C* be the cost of an optimal solution
analysis:
•
•
time complexity: O(b1+⌊C*/ε⌋)
space complexity: O(b1+⌊C*/ε⌋)
Solving Problems by Searching
42
Uniform-Cost Search: Evaluation
completeness
yes
optimality
yes
time complexity
O(b1+⌊C*/ε⌋)
space complexity
O(b1+⌊C*/ε⌋)
Solving Problems by Searching
43
Depth-First Search

strategy:
•
•

always expand the deepest node in the current fringe
first
when a sub-tree has been completely explored, delete
it from memory and “back up”
implementation:
•
•
use LIFO queue (stack) to store fringe nodes in
general tree search algorithm
alternative: recursive function that calls itself on each
of its children in turn
Solving Problems by Searching
44
depth = 3
depth = 2
depth = 1
depth = 0
Depth-First Search:
Missionaries and Cannibals
Solving Problems by Searching
45
Recursive Implementation of
Depth-First Search
function depthFirstSearch(problem)
return recursiveDFS(
new searchNode(problem.initialState, problem)
function recursiveDFS(node, problem)
if problem.goalTest(node.state) then return pathTo(node)
for each successor in expand(node, problem) do
result  recursiveDFS(successor, problem)
if result ≠ failure then return result
return failure
Solving Problems by Searching
46
Time and Space Complexity for
Depth-First Search

assumptions:
• every search node has exactly b successors
•

(b finite)
depth of the deepest node in the tree is m
analysis:
• time complexity: O(bm)
• space complexity: O(bm)
Solving Problems by Searching
47
Depth-First Search: Evaluation
completeness
no
optimality
no
time complexity
O(bm)
space complexity
O(bm)
Solving Problems by Searching
48
Depth-First Search:
Finding the Optimal Path


first solution discovered may not be
optimal  must keep searching
continued search:
• assumption: non-decreasing path costs
• remember path cost of cheapest path found
•
so far
do not expand nodes for which path cost
exceeds cheapest found so far
Solving Problems by Searching
49
Backtracking Search

a variant of depth-first search
• generate only one successor at a time
• each node remembers which successor to
generate next
• space complexity: O(m)
• generate successors by modifying current
state representation
• must be able to undo modifications
• may use even less memory (and time)
Solving Problems by Searching
50
Depth-Limited Search

strategy:
• always expand the deepest node in the
•

current fringe first (like depth-first search)
treat nodes at a given depth l as if they have
no successors
implementation:
• like depth-first search, but test for depth limit
before expanding a node
Solving Problems by Searching
51
Recursive Implementation of
Depth-Limited Search
function depthLimitedSearch(problem, limit)
return recursiveDLS(
new searchNode(problem.initialState), problem, limit)
function recursiveDLS(node, problem, limit)
cutoffOccured  false
if problem.goalTest(node) then return pathTo(node)
if node.depth = limit then return cutoff
for each successor in expand(node, problem) do
result  recursiveDLS(successor, problem, limit)
if result = cutoff then cutoffOccured  true
else if result ≠ failure then return result
if cutoffOccured then return cutoff else return failure
Solving Problems by Searching
52
Time and Space Complexity for
Depth-Limited Search

assumptions:
• every search node has exactly b successors
•

(b finite)
the given depth limit is l
analysis:
• time complexity: O(bl)
• space complexity: O(bl)
Solving Problems by Searching
53
Depth-Limited Search:
Evaluation
completeness
no
optimality
no
time complexity
O(bl)
space complexity
O(bl)
Solving Problems by Searching
54
How to Choose the Depth Limit?


example: Touring Romania
•
•
there are 20 cities on the map. Thus, choose l=19.
the longest distance between two cities on the map is 9
steps; thus, choose l=9.
in general:
•
•
the diameter of a search space is the longest distance
between two nodes in the search space
choose the diameter as the depth limit to guarantee
completeness
Solving Problems by Searching
55
Iterative Deepening Search

strategy:
• based on depth-limited (depth-first) search
• repeat search with gradually increasing depth
limit until a goal state is found

implementation:
for depth  0 to ∞ do
result  depthLimitedSearch(problem, depth)
if result ≠ cutoff then return result
Solving Problems by Searching
56
depth = 3
depth = 2
depth = 1
depth = 0
Iterative Deepening Search:
Missionaries and Cannibals
Solving Problems by Searching
57
Time and Space Complexity for
Iterative Deepening Search

assumptions:
• every search node has exactly b successors
•

(b finite)
the shallowest goal node is at depth d
analysis:
• time complexity:
•
(d)b + (d-1)b2 + … + (2)b(d-1) + (1)bd ∈ O(bd)
space complexity: O(bd)
Solving Problems by Searching
58
Iterative Deepening Search:
Evaluation
completeness
yes
optimality
shallowest
time complexity
O(bd)
space complexity
O(bd)
Solving Problems by Searching
59
Iterative Lengthening Search



iterative analogue of uniform-cost search
strategy:
•
•
based on cost-limited (depth-first) search
repeat search with gradually increasing path cost limit
until a goal state is found
problem: How to increase the path cost limit?
•
•
use minimum: substantial overhead
use fixed step size: no optimality
Solving Problems by Searching
60
Bidirectional Search

idea: run two simultaneous searches:
• one forward from the initial state,
• one backward from the goal state,
until the two fringes meet.
The solution path must cross the meeting point.
Start
Goal
Solving Problems by Searching
61
Bidirectional Search: Caveats

What search strategy for forward/backward
search?
•

How to check whether a node is in the other
fringe?
•


breadth-first search
hash table
must know goal state for backward search
must be able to compute predecessors and
successors for a given state
Solving Problems by Searching
62
Bidirectional Search: Evaluation
completeness
yes
optimality
shallowest
time complexity
O(bd/2)
space complexity
O(bd/2)
Solving Problems by Searching
63
Comparing Uninformed Search
Strategies
BreadthFirst
UniformCost
DepthFirst
DepthLimited
Iterative
Deepening
Bidirectional
Breadth-F.
complete?
Yes
Yes
No
No
Yes
Yes
optimal?
Yes
Yes
No
No
Yes
Yes
time
complexity
O(bd+1)
O(b1+⌊C*/ε⌋)
O(bm)
O(bl)
O(bd)
O(bd/2)
space
complexity
O(bd+1)
O(b1+⌊C*/ε⌋)
O(bm)
O(bl)
O(bd)
O(bd/2)
Solving Problems by Searching
64
Overview






Characterizing Search Problems
Searching for Solutions
Uninformed Search Strategies
Avoiding Repeated States
The Problem of Representation
Search in AND/OR-Graphs
Searching with Partial Information
Solving Problems by Searching
65
Repeated States


problem:
repeated states waste time and memory
by expanding states that have already
been encountered, i.e. repeating work
solution:
formulate the problem in such a way that
repeated states are not generated
Solving Problems by Searching
66
Discovering Repeated States:
Potential Savings
infinite search tree ⇒ finite search tree
finite search tree ⇒ exponential reduction
state space graph
•
•
search tree

sometimes repeated states are unavoidable,
resulting in infinite search trees
checking for repeated states:
state space graph

Solving Problems by Searching
67
Discovering Repeated States



compare node about to be expanded to
all previously expanded nodes
if there was a match, one node can be
discarded
issues:
• storing the nodes: hash table
• matching: usually equality testing
Solving Problems by Searching
68
General Graph Search Algorithm
function graphSearch(problem, strategy)
closed  { }
fringe  { new searchNode(problem.initialState) }
loop
if empty(fringe) then return failure
node  selectFrom(fringe, strategy)
if problem.goalTest(node.state) then
return pathTo(node)
if node.state ∉ closed
closed  closed + node
fringe  fringe + expand(problem, node)
Solving Problems by Searching
69
Repeated States and
Depth-First Search


problem:
depth-first search keeps only nodes on the
current path and their siblings in memory
two approaches:
• test only against the above nodes:
•
avoids only loops, not all repeated states
remember all closed nodes:
may increase space complexity of depth-first
search to O(bd)
Solving Problems by Searching
70
Optimality and Graph Search

function graphSearch always discards newly
discovered path to the same state which may
be shorter
•
•
•
retains optimality for (bidirectional) breadth-first search
or uniform-cost search with constant step costs
depth-first and depth-limited search are not optimal
anyway
iterative deepening search may become non-optimal:
• loop testing only: remains optimal
• testing all states: not optimal; requires extension
Solving Problems by Searching
71
Representing Sets of States:
Splitting


idea: instead of individual states,
represent (implicit) sets of states
actions: splitting into subsets
• disjoint subsets avoid repeated states
• will reach goal state (set with one state
eventually)

example: N-queens problem
Solving Problems by Searching
72
Toy Problem: N-Queens Problem
Place n queens
on an n by n
chess board such
that none of the
queens attacks
any of the others.
Solving Problems by Searching
73
Problem Formulation:
N-Queens Problem


complete-state formulation:
•
•
•
•
states: any arrangement of 8 queens on the chess board
initial state: any arrangement of 8 queens on the board
actions: move a queen on the board
goal test: no queen attacks another
constructive formulation:
•
•
•
•
states: any arrangement of 0 to 8 queens on the board
initial state: no queens on the board
actions: place a queen on the board (next free row!)
goal test: 8 queens on board, none attacks another
constructive problem formulations lend
themselves to systematic search
Solving Problems by Searching
74
Overview






Characterizing Search Problems
Searching for Solutions
Uninformed Search Strategies
Avoiding Repeated States
The Problem of Representation
Search in AND/OR-Graphs
Searching with Partial Information
Solving Problems by Searching
75
Representation and Efficiency



there usually is a choice of representation
during problem formulation
there is a relationship between the chosen
representation and the efficiency with which a
problem-solving system can be expected to
solve the problem
understanding this relationship is a prerequisite
for designing good representations
Solving Problems by Searching
76
Generalized Missionaries and
Cannibals (GM&C) Problem
On one bank of a river are N missionaries and
N cannibals. There is one boat available that
can hold up to K people and that they would
like to use to cross the river. If the cannibals
ever outnumber the missionaries on either of
the river’s banks or in the boat, the
missionaries will get eaten.
How can the boat be used to safely carry all the
missionaries and cannibals across the river?
Solving Problems by Searching
77
Toy Problem:
Sliding-Block Puzzle
7
2
5
8
3
4
1
2
6
3
4
5
1
6
7
8
the 8-Puzzle
Solving Problems by Searching
78
Other Real-World Problems






Route-Finding Problem
Touring Problem (TSP)
VLSI Layout
Robot Navigation
Automatic Assembly Sequencing
Internet Searching
Solving Problems by Searching
79
Systems of Production

a system of production provides a
framework for formally representing
search problems
• more restrictive approach than what we have
•
•
seen so far
generic problem solver can solve any problem
specified in the framework
opens the door for reasoning about the
representation
Solving Problems by Searching
80
Systems of Production:
N-State Languages

states of nature (N-states) consist of

an N-state language L0 is a tuple (U0, P0)
where:
• entities that exist in this state
• properties of these entities
• relations between the entities
• U0 is a non-empty set of entities called the basic
universe and
• P0 is a non-empty set of basic predicates
defined for elements of U0
Solving Problems by Searching
81
Example: N-State Language for
the GM&C Problem


the basic universe U0 contains:
•
•
•
•
N individuals m1, …, mN representing missionaries
N individuals c1, …, cN representing cannibals
the boat b (with capacity K)
two places pL and pR representing the left and right
river bank
the set of predicates P0 contains:
•
•
at(x, y): asserts that the entity x (a person or the boat)
is at place y (pL or pR)
on(x, b): asserts that the person x is aboard b
Solving Problems by Searching
82
Systems of Production:
Derived Description Languages

N-states also require:
• additional entities for defining legal states and actions
• additional properties and relations for defining legal
states and actions

a derived description language L1 is a tuple (U1, P1)
where:
• U1 ⊇ U0 is a non-empty set of entities called the
extended universe and
• P1 is a non-empty set of basic predicates defined for
elements of U1
Solving Problems by Searching
83
Example: Derived Description
Language for the GM&C Problem

the extended universe U1 additionally
contains:
•
•
•

{m}L, {m}R, {m}b, {c}L, {c}R, {c}b: the subsets of
missionaries/cannibals on the right/left river bank or on
the boat
ML, MR, Mb, CL, CR, Cb: the respective set sizes
1, …, N: numbers for representing these sizes
the set of predicates P1 additionally contains:
•
=, <, > (relations for comparing numbers)
Solving Problems by Searching
84
Production Systems:
Configurations

a configuration is a finite set (possibly empty) of
expressions in an N-state language.
•
•


The empty configuration will be written Λ (upper case
lambda).
The set union of two configurations α and β is again a
configuration and it is written “α, β”
configurations list the basic features of a situation at
one point in time
logical interpretation: conjunction of the true
assertions made by the component expressions,
true proposition
Solving Problems by Searching
85
Example: Configurations in
the GM&C Problem
configurations in the N-state language L0:
 for the initial state of the GM&C problem
{ at(m1, pL),…, at(mN, pL), at(c1, pL), …,
at(cN, pL), at(b, pL) }
 for the goal state of the GM&C problem
{ at(m1, pR),…, at(mN, pR), at(c1, pR), …,
at(cN, pR), at(b, pR) }
Solving Problems by Searching
86
Production Systems:
Descriptions of N-States



a basic description, s, of an N-state is a
configuration from which all true statements
about the N-state (that can be expressed in
terms of the N-state language) can be directly
obtained or derived
a derived description, d(s), associated with an
N-state is a configuration from which all true
statements about the N-state (that can be
expressed in terms of the derived description
language) can be directly obtained or derived
in a mixed description s’ = s;d(s), s is a basic
description and d(s) its associated derived
description
Solving Problems by Searching
87
Example: Descriptions in
the GM&C Problem

mixed description for the goal state of
the GM&C problem:
{ at(m1, pR),…, at(mN, pR), at(c1, pR), …,
at(cN, pR), at(b, pR) } };
{ {m}L={}, {m}R ={m1…mN}, {m}b ={},
{c}L ={}, {c}R ={c1…cN}, {c}b ={}, ML=0,
MR=N, Mb=0, CL=0, CR=N, Cb=0 }
Solving Problems by Searching
88
Production Systems:
Rules of Action

Let A be an action and let (A) denote the
corresponding rule of action which must
have the form:
(A): sa;d(sa)  sb;d(sb)

The application of A in sa is permissible if
both, d(sa) and d(sb) are satisfied.
Solving Problems by Searching
89
Example: Rules of Action in
the GM&C Problem
let α denote an arbitrary configuration and x an individual
(missionary or cannibal)




action (LBL): load boat at left, one individual at a time:
α, at(b, pL), at(x, pL); (Mb+Cb ≤ K-1) 
α, at(b, pL), on(x, b); Λ
action (MBLR): move boat across river from left to right:
α, at(b, pL); (Mb+Cb > 0)  α, at(b, pR); Λ
action (UBR): load boat at left, one individual at a time:
α, at(b, pR), on(x, b); Λ  α, at(b, pR), at(x, pR); Λ
actions: (LBR), (MBRL), (UBL) by swapping pL and pR
Solving Problems by Searching
90
Production Systems:
Trajectories

An N-state sb is directly attainable from an N-state sa
(written sa↦sb) if there exists an applicable rule of
action (A) that transforms sa into sb.

A trajectory from an N-state sa to an N-state sb is a
sequence of N-states (s1,…, sm) where
•
•
•

sa= s1 and
sb= sm and
for each i, 1<i≤m, si is directly attainable from si-1
An N-state sb is attainable from an N-state sa (written
sa⇒sb) if there exists a trajectory from sa to sb.
Solving Problems by Searching
91
Task of a Production System
given:
• an N-state language
• an extended description language
• a set of rules of actions
• an initial N-state and a terminal N-state
find the shortest trajectory from the initial
N-state to the terminal N-state
Solving Problems by Searching
92
From Verbal to Formal
Representations


given: verbal formulation
formalization – choice points:
• extended universe U1
• extended set of predicates P1
• set of actions
these choices determine the efficiency with
which problems can be solved.
Solving Problems by Searching
93
Macro Actions



macro actions: sequences of primitive actions
level of abstraction: such that all constraints in
the problem specification can still be verified
GM&C example: load boat; cross and unload
transfer r individuals from left to right (1≤r≤K):
(LBL), (LBL), …, (LBL) (MBLR) (UBR), (UBR), …, (UBR)
r times
r times
Solving Problems by Searching
94
Example: Specifying Macro
Actions for the GM&C Problem
Let α denote an arbitrary configuration and x1, …, xr a set of
individuals (missionaries and/or cannibals)
 macro action (LrBL): load empty boat at left with r individuals,
1≤r≤K :
α, at(b, pL), at(x1, pL), …, at(xr, pL); (Mb+Cb=0) 
α, at(b, pL), on(x1, b), …, on(xr, b);
((ML=0) ∨ (ML≥CL)), ((Mb=0) ∨ (Mb≥Cb))
 macro action (MBLR+ UrBR): move boat (loaded with r
individuals) across river from left to right and unload all
passengers at right:
α, at(b, pL), on(x1, b), …, on(xr, b); (Mb+Cb=r) 
α, at(b, pR), at(x1, pR), …, at(xr, pR); ((MR=0) ∨ (MR≥CR))
 macro actions: (LrBR), (MBRL+UrBL) by swapping pL and pR
Solving Problems by Searching
95
Dropping the Non-Cannibalism
Condition for the Boat

Theorem: If at both, the beginning and the end of a
transfer, the non-cannibalism conditions (ML=0) ∨ (ML≥CL)
and (MR=0) ∨ (MR≥CR) are satisfied for the two river banks,
then the non-cannibalism condition for the boat, i.e.
(Mb=0) ∨ (Mb≥Cb), is also satisfied.

Proof:
•
•
(ML=0) ∨ (ML=N) ∨ (ML=CL) must hold before and after each
transfer
For each transfer from a configuration satisfying one of the three
disjuncts to a configuration satisfying one (possibly the same) of
the three disjuncts, the non-cannibalism condition on the boat must
be satisfied.
Solving Problems by Searching
96
Distinguishing Individuals


individuals:
•
•
verbal formulation: N cannibals, N missionaries
representation: distinguish only those individuals that
are distinguishable
states:
•
vector (ML=i1, CL=i2, BL=i3) where
•
examples: initial state: (N, N, 1), goal state: (0, 0, 0)
• ML/CL missionaries/cannibals on left river bank
• MR/CR determined by ML+MR=CL+CR=N
• BL=1 if at(b,pL), BL=0 if at(b,pR)
Solving Problems by Searching
97
Parameterized Actions

add parameters to actions to simplify representation

macro action (TLR Mb Cb): transfer safely a mix (Mb Cb) from left
to right:
(ML, CL, 1); Λ  (ML-Mb, CL-Cb, 0);
((ML-Mb=0) ∨ (ML-Mb≥CL-Cb)),
((N-(ML-Mb)=0) ∨ (N-(ML-Mb)≥N-(CL-Cb)))
macro action (TRL Mb Cb): transfer safely a mix (Mb Cb) from
right to left:
(ML, CL, 0); Λ  (ML+Mb, CL+Cb, 1);
((ML+Mb=0) ∨ (ML+Mb≥CL-Cb)),
((N-(ML+Mb)=0) ∨ (N-(ML+Mb)≥N-(CL+Cb)))

Solving Problems by Searching
98
An Alternative View:
Reduction Systems

search the space of P-states: S=(sa⇒sb)
(read sb is attainable from sa)
•


Example: GM&C initial state: S0=((N, N, 1) ⇒(0, 0, 0))
successors: Let (sa⇒sb) be a P-state and (A)
an action that is applicable in sa. Let sc be the
result of applying (A) in sa. Then (sc⇒sb) is a
successor of (sa⇒sb).
goal state: (sb⇒sb)
Solving Problems by Searching
99
Problem Reduction:
GM&C with N=3 and b=2
(331)⇒(000)
(310)⇒(000)
(320)⇒(000)
(000)⇒(000)
(021)⇒(000)
(220)⇒(000)
(321)⇒(000)
(111)⇒(000)
(010)⇒(000)
(300)⇒(000)
(031)⇒(000)
(311)⇒(000)
(110)⇒(000)
(020)⇒(000)
(221)⇒(000)
Solving Problems by Searching
100
Problem Reduction:
GM&C with N=5 and b=3
(551)⇒(000)
(540)⇒(000)
(440)⇒(000) (520)⇒(000) (530)⇒(000)
(541)⇒(000)
(531)⇒(000)
(000)⇒(000)
(111)⇒(000) (021)⇒(000) (031)⇒(000)
(010)⇒(000)
(330)⇒(000) (510)⇒(000) (500)⇒(000)
(041)⇒(000)
(441)⇒(000) (521)⇒(000) (511)⇒(000)
(030)⇒(000)
(220)⇒(000)
(020)⇒(000)
(051)⇒(000)
(331)⇒(000)
Solving Problems by Searching
101
Symmetry in the Search Space

consider states (311) in normal direction and (020) in
reverse direction:
•
•



Reached by (TLR 0 1) and (TRL 0 1) respectively
Applicable actions: (TLR 2 0) and (TRL 2 0) respectively
Definition: sa↤sb if and only if sb↦sa
Definition: Let σ be the N-state space partially ordered
under the relation ↦, and let σ’ be the dual space (i.e. the
same elements partially ordered under the relation ↤).
Then we define the function Θ: σ  σ’ for the GM&C
problem as:
Θ: (ML, CL, BL)  (N-ML, N-CL, 1-BL)
Note: Θ(Θ(s))=s
Solving Problems by Searching
102
Attainability and Symmetry


Theorem: For any pair of N-states sa,
sb the following equivalence holds:
sa↦sb ≡ Θ(sa)↤Θ(sb)
or equivalently:
sa↦sb ≡ Θ(sb)↦Θ(sa)
Corollary: For any pair of N-states sa,
sb the following equivalence holds:
sa⇒sb ≡ Θ(sb)⇒Θ(sa)
Solving Problems by Searching
sa
Θ
Θ(sa)
↦
sb
Θ
↤
Θ(sb)
↦
103
Exploiting Symmetry in
the Search Space
Let s0 be the initial state and st=Θ(s0) the
terminal state. Let sf be the set of fringe nodes
during a search process. If there exist two nodes
s,s’∈sf such that s=Θ(s’) or s↦s’ then s0⇒st.
Θ(sf)
sf
=
s0
or
st
↦
Solving Problems by Searching
104
Exploiting Symmetry in
the Search Space: Example
(331)⇒(000)
(310)⇒(000)
(320)⇒(000)
Problem:
{(331)} ⇒ {(000)}
(011)⇒(000)
(000)⇒(000)
(021)⇒(000)
(220)⇒(000)
{(310) (220) (320)} ⇒ {(011) (021) (111)}
(321)⇒(000)
(010)⇒(000)
{(321)} ⇒ {(010)}
{(300)} ⇒ {(031)}
(300)⇒(000)
(311)⇒(000)
{(311)} ⇒ {(020)}
(111)⇒(000)
(031)⇒(000)
(020)⇒(000)
{(110)} ⇒ {(221)}
(110)⇒(000)
(221)⇒(000)
{(110)} ↦ {(221)}
Solving Problems by Searching
105
Global View of the N-State
Space of the M&C Problem
ML
BL=1
BL=0



CL
state space: 2(N+1)2
states in two planes
permissible states
(white): noncannibalism condition
not violated
potential actions:
subject to boat
conditions (examples
shown)
Solving Problems by Searching
106
Solution to the M&C Problem in
the Collapsed N-State Space
collapsed N-state space :
ML
3
LTR transfers
2
1
RTL transfers
0
0
Solving Problems by Searching
1
2
3
CL
107
General Shape of
the Collapsed N-State Space
permissible territory:

permissible territory:
Z-shaped:
(ML=0) ∨ (ML=N) ∨ (ML=CL)



initial state: top right
goal state: bottom left
possible actions:
depend on boat capacity
Solving Problems by Searching
108
Solution Patterns for
the GM&C Problem


boat capacity k ≥ 4
sliding along the
diagonal directly
•
repeat
• (TLR 2 2)
• (TRL 1 1)


boat capacity k ≤ 3
4 main steps
•
•
•
•
slide along top leg
jump to diagonal
jump to bottom leg
slide along bottom leg
Solving Problems by Searching
109
Global Movements for
the GM&C Problem






(H1): sliding along the ML=N line:
(N, CL, 1); 0<CL<N, k≥2  (N, N, 1)
(H1,J1): slide and jump to diagonal:
(N, CL, 1); 0<CL<N, k≥2  (N-k+1, N-k+1, 1)
(D): sliding along diagonal:
(ML, CL, 1); 0<CL=ML<N, k≥4  (0, 0, 0)
(J2): jump to the ML=0 line:
(ML, CL, 1); 0<CL=ML≤k  (0, CL, 0)
(D,J2): slide and jump to the ML=0 line:
(ML, CL, 1); CL=ML>k≥4  (0, k, 0)
(H2): sliding along the ML=0 line:
(0, CL, 0); 0≤CL<N, k≥2  (0, C’L, 0); 0≤C’L<N, CL≠C’L
Solving Problems by Searching
110
Global Movements: Example
(911)⇒(080)

problem:
(H1)-[6]
• N=9, k=4
• Initial state:
•
(9, 1, 1)
Goal state:
(0, 8, 0)
(H1,J1)-[6]
(991)⇒(080)
(661)⇒(080)
(D,J2)-[11] (D)-[9]
(D)-[15]
(D,J2)-[5]
(000)⇒(080)
(040)⇒(080)
(H2)-[6]
(H2)-[4]
(080)⇒(080)
Solving Problems by Searching
111
High-Level and Low-Level
Search Space


high-level space is a subset of the low-level space
regions of the search space:
•
•
•


search spaces can divided into regions
•
example: M&C search space: top line, diagonal line, and
bottom line of the Z-shape
movements within a region are relatively easy
transitions between regions are difficult
high-level search space provides an abstraction that
focuses on the transition points
problems: defining the regions and transition points
Solving Problems by Searching
112
Overview






Characterizing Search Problems
Searching for Solutions
Uninformed Search Strategies
Avoiding Repeated States
The Problem of Representation
Search in AND/OR-Graphs
Searching with Partial Information
Solving Problems by Searching
113
The Counterfeit Coin Problem


Given 12 gold coins of which
one is known to be counterfeit,
use a two-pan scale to identify
the counterfeit coin and
determine whether it is heavy or
light in no more than three tests.
solution: a weighing strategy – a
tree of tests (depth ≤ 3,
branching factor = 3)
Solving Problems by Searching
coin
coin
coin
coin
coin coin coin
coin
coin
coin
coin coin
114
AND/OR-Graphs: Example
OR
1
1
2
2
3
3
4
4
5
5
6
6
alternative
tests
AND
1
1
1
1
1
alternative
outcomes
reoccurring
sub-problem
1
1
Solving Problems by Searching
1
alternative
tests
115
AND/OR-Graphs

an AND/OR-graph is a hypergraph G=(N, C)
where:
•
•
N is a set of nodes
C ⊆ N x ℙ(N) is a set of connectors
• 1-connector: (n, s) ∈ C and |s|=1
•


for OR-connections
k-connector: (n, s) ∈ C and |s|=k
for AND-connections
nodes with outgoing 1-connectors: OR-nodes
nodes with outgoing k-connectors: AND-nodes
Solving Problems by Searching
116
Solution Graphs for
AND/OR-Graphs

a solution graph G’=(N’, C’) for an
AND/OR-graph G=(N, C) is a sub-graph
for which:
• the start node is contained in N’
• every node n’∈N’ that has no outgoing
•
connectors must be a terminal node
if n’∈N’ and there exists a c’=(n, s) ∈ C’ with
n’∈s then s ⊆ N’ must hold.
Solving Problems by Searching
117
Hypergraphs and
Solution Graphs: Examples
hypergraph:
solution graph 1:
solution graph 2:
start node
terminal node
Solving Problems by Searching
118
Labelling Nodes in an
AND/OR-Graph as Solved

a node in an AND/OR graph can be
considered solved if one of the following
conditions holds:
• it is a terminal node
• it is a non-terminal node with
• at least one outgoing k-connector for which
• all descendants (the nodes the k-connector points
to) are solved
Solving Problems by Searching
119
Search Algorithms for
AND/OR Graphs



adaptation of breadth-first or depth-first search
main difference: termination condition
•
•
previously: goal is property of single node
AND/OR graph: set of solved nodes collectively
constitutes a solution
approach:
•
whenever a terminal node is reached
•
until the root node can be labelled solved/unsolvable
• label the node accordingly
• propagate the label the all ancestors (as far as possible)
Solving Problems by Searching
120
Searching AND/OR-Graphs:
Example
S
U
S
U
U
S
U
S
S
U
S
S
U
Solving Problems by Searching
S
U
121
Appropriateness of
AND/OR-Graphs

good for problems
•
in which the solution takes the form of a graph or tree
•
that are decomposable
•

• example: counterfeit coin problem
• example: symbolic integration
in which the solution is a set of partially ordered
actions
not good for problems
•
in which sub-goals interact strongly
• example: sliding-tile puzzles
Solving Problems by Searching
122
Sub-Goal Interaction:
Towers of Hanoi
A


B
C
aim: transfer disks from peg A to peg B
best representation: decompose into
sub-goals (despite sub-goal interference)
Solving Problems by Searching
123
Overview






Characterizing Search Problems
Searching for Solutions
Uninformed Search Strategies
Avoiding Repeated States
The Problem of Representation
Search in AND/OR-Graphs
Searching with Partial Information
Solving Problems by Searching
124
Assumptions

environment

actions
• fully observable
• deterministic
• all effects are known
Not very realistic!
Solving Problems by Searching
125
Three Types of Problems
with Partial Information

Sensorless Problems:
unknown initial state due to lack of
perception
Contingency Problems:

Exploration Problems:

• environment only partially observable or
• actions with uncertain outcomes
• neither states nor actions are known
Solving Problems by Searching
126
Toy Problem:
Vacuum World
R
L
R
L
S
S
R
R
R
L
L
L
L
S
S
S
S
R
R
L
R
L
S
S
Solving Problems by Searching
127
Sensorless Problem



reason about sets of states rather than single
states
belief state:
a set of states representing an agent’s current
belief about the possible physical states it
might be in.
coercion:
perform actions that result in a belief state that
contains only one physical state
Solving Problems by Searching
128
Belief State Space: Vacuum World
L
R
L
R
S
S
S
L
R
S
S
R
R
L
L
R
L
S
L
S
R
Solving Problems by Searching
129
Non-Deterministic Actions

non-deterministic actions:
• actions may have several possible outcomes
• without sensors, agent cannot tell which
outcome occurred

approach:
• unchanged, reason about belief states
• add all possible outcomes of an action to the
belief state representing the outcome of the
action
Solving Problems by Searching
130
Example: Murphy’s Law World

like Vacuum World except:
action S (suck dirt) sometimes deposits
dirt on the carpet, but only if there is no
dirt there already
• two possible outcomes for some actions
• renders Vacuum World unsolvable
Solving Problems by Searching
131
Belief State Space:
Murphy’s Law World
L
R
L
S
R
S
Solving Problems by Searching
S
132
Contingency Problems


the agent can obtain new information
from its sensors after acting
solution more complex: often tree
structure
• branching point is decision point
• decision depends on perception at the time

example: Murphy’s Law World with
perception
Solving Problems by Searching
133
Algorithms for
Contingency Problems


contingency problems cannot be solved
with the search techniques described
here
interleaving problem-solving (search)
and execution of action
• more realistic approach for many real world
problems and some toy problems
Solving Problems by Searching
134
Overview







Characterizing Search Problems
Searching for Solutions
Uninformed Search Strategies
Avoiding Repeated States
The Problem of Representation
Search in AND/OR-Graphs
Searching with Partial Information
Solving Problems by Searching
135