Search

1
Search

• Search plays a key role in many parts of AI.
  These algorithms provide the conceptual backbone
  of almost every approach to the systematic
  exploration of alternatives.
• There are four classes of search algorithms,
  which differ along two dimensions
• First, is the difference between uninformed (also
  known as blind) search and then informed (also
  known as heuristic) searches.
• Informed searches have access to task-specific
  information that can be used to make the search
  process more efficient.
• The other difference is between any solution
  searches and optimal searches.
• Optimal searches are looking for the best
  possible solution while any-path searches will
  just settle for finding some solution.

2
Graphs

• Graphs are everywhere E.g., think about road
  networks or airline routes or computer networks.
• In all of these cases we might be interested in
  finding a path through the graph that satisfies
  some property.
• It may be that any path will do or we may be
  interested in a path having the fewest "hops" or
  a least cost path assuming the hops are not all
  equivalent.

3
Romania graph
4
Formulating the problem

• On holiday in Romania currently in Arad.
• Flight leaves tomorrow from Bucharest.
• Formulate goal
• be in Bucharest
• Formulate problem
• states various cities
• actions drive between cities
• Find solution
• sequence of cities, e.g., Arad, Sibiu, Fagaras,
  Bucharest

5
Another graph example

• However, graphs can also be much more abstract.

• A path through such a graph (from a start node to
  a goal node) is a "plan of action" to achieve
  some desired goal state from some known starting
  state.
• It is this type of graph that is of more general
  interest in AI.

6
Problem solving

• One general approach to problem solving in AI is
  to reduce the problem to be solved to one of
  searching a graph.
• To use this approach, we must specify what are
  the states, the actions and the goal test.
• A state is supposed to be complete, that is, to
  represent all the relevant aspects of the problem
  to be solved.
• We are assuming that the actions are
  deterministic, that is, we know exactly the state
  after the action is performed.

7
Goal test

• In general, we need a test for the goal, not just
  one specific goal state.
• So, for example, we might be interested in any
  city in Germany rather than specifically
  Frankfurt.
• Or, when proving a theorem, all we care is about
  knowing one fact in our current data base of
  facts.
• Any final set of facts that contains the desired
  fact is a proof.

8
Vacuum cleaner?
9
Vacuum cleaner
10
Vacuum cleaner
11
Formally

• A problem is defined by four items
• initial state e.g., "at Arad"
• actions and successor function S set of
  action-state tuples
• e.g., S(Arad) (goZerind, Zerind),
  (goTimisoara, Timisoara), (goSilbiu,
  Silbiu)
• goal test, can be
• explicit, e.g., x "at Bucharest"
• implicit, e.g., Checkmate(x)
• path cost (additive)
• e.g., sum of distances, or number of actions
  executed, etc.
• c(x,a,y) is the step cost, assumed to be 0
• A solution is a sequence of actions leading from
  the initial state to a goal state

12
Example The 8-puzzle

• states?
• actions?
• goal test?
• path cost?

13
Example The 8-puzzle

• states? locations of tiles
• actions? move blank left, right, up, down
• goal test? goal state (given)
• path cost? 1 per move

14
Romania graph
15
Tree search example
16
Tree search example
17
Tree search example
18
Tree search algorithms

• Basic idea
• Exploration of state space by generating
  successors of already-explored states (i.e.
  expanding states)

19
Implementation states vs. nodes

• A state is a (representation of) a physical
  configuration
• A node is a bookeeping data structure
  constituting of state, parent node, action, path
  cost g(x), depth
• The Expand function creates new nodes, filling in
  the various fields and using the SuccessorFn of
  the problem to create the corresponding states.

20
The fringe

• The collection of nodes that have been generated
  but not yet expanded is called fringe. (outlined
  in bold)
• We will implement collection of nodes as queues.
  The operations on a queue are as follows
• Empty?(queue) check to see whether the queue is
  empty
• First(queue) returns the first element
• Remove-First(queue) returns the first element and
  then removes it
• Insert(element, queue) inserts an element into
  the queue and returns the resulting queue
• InsertAll(elements, queue) inserts a set of
  elements into the queue and returns the resulting
  queue

21
Implementation

• public class Problem
• Object initialState
• SuccessorFunction successorFunction
• GoalTest goalTest
• StepCostFunction stepCostFunction
• HeuristicFunction heuristicFunction

22
Some pseudocode interpretations

• Successor-Fnproblem(Statenode)
• is in fact
• problem. Successor-Fn(node.State)
• or
• problem.getSuccessorFunction().getSuccessors(
  node.getState() )

23
Implementation general tree search
The queue policy of the fringe embodies the
strategy.
24
Search strategies

• A search strategy is defined by picking the order
  of node expansion
• Strategies are evaluated along the following
  dimensions
• completeness does it always find a solution if
  one exists?
• time complexity number of nodes generated
• space complexity maximum number of nodes in
  memory
• optimality does it always find a least-cost
  solution?
• Time and space complexity are measured in terms
  of
• b maximum branching factor of the search tree
• d depth of the least-cost solution
• m maximum depth of the state space

25
Uninformed search strategies

• Uninformed do not use information relevant to the
  specific problem.
• Breadth-first search
• Uniform-cost search
• Depth-first search
• Depth-limited search
• Iterative deepening search

26
Breadth-first search

• TreeSearch(problem, FIFO-QUEUE()) results in a
  breadth-first search.
• The FIFO queue puts all newly generated
  successors at the end of the queue, which means
  that shallow nodes are expanded before deeper
  nodes.
• I.e. Pick from the fringe to expand the
  shallowest unexpanded node

27
Breadth-first search

• Expand shallowest unexpanded node
• Implementation
• fringe is a FIFO queue, i.e., new successors go
  at end

28
Breadth-first search

• Expand shallowest unexpanded node
• Implementation
• fringe is a FIFO queue, i.e., new successors go
  at end

29
Breadth-first search

• Expand shallowest unexpanded node
• Implementation
• fringe is a FIFO queue, i.e., new successors go
  at end

30
Properties of breadth-first search

• Complete?
• Yes (if b is finite)
• Time?
• 1bb2b3 bd b(bd-1) O(bd1)
• Space?
• O(bd1) (keeps every node in memory)
• Optimal?
• Yes (if cost is a non-decreasing function of
  depth, e.g. when we have 1 cost per step)

31
Suppose b10, 10,000 nodes/sec, 1000 bytes/node
Depth Nodes Time Memory
2 1100 .11 sec 1 Megabyte
4 111,100 11 sec 106 Megabyte
6 107 19 min 10 Gigabyte
8 109 31 hours 1 Terabyte
10 1011 129 days 101 Terabyte
12 1013 35 years 10 Petabyte
14 1015 3,523 1 Exabyte
32
Uniform-cost search

• Expand least-cost unexpanded node.
• The algorithm expands nodes in order of
  increasing path cost.
• Therefore, the first goal node selected for
  expansion is the optimal solution.
• Implementation
• fringe queue ordered by path cost (priority
  queue)
• Equivalent to breadth-first if step costs all
  equal
• Complete? Yes, if step cost e (I.e. not zero)
• Time? number of nodes with g cost of optimal
  solution, O(bC/ e) where C is the cost of the
  optimal solution
• Space? Number of nodes with g cost of optimal
  solution, O(bC/ e)
• Optimal? Yes nodes expanded in increasing order
  of g(n)

33
Try it here
34
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

35
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

36
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at front

37
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at
  front
  

38
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at
  front
  

39
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at
  front
  

40
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at
  front
  

41
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at
  front
  

42
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at
  front
  

43
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at
  front
  

44
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at
  front
  

45
Depth-first search

• Expand deepest unexpanded node
• Implementation
• fringe LIFO queue, i.e., put successors at
  front
  

46
Properties of depth-first search

• Complete? No fails in infinite-depth spaces,
  spaces with loops
• Modify to avoid repeated states along path
• ? complete in finite spaces
• Time? O(bm) terrible if m is much larger than d
• but if solutions are dense, may be much faster
  than breadth-first
• Space? O(bm), i.e., linear space!
• Optimal? No

47
Depth-limited search

• DepthLimitedSearch (int limit)
• stackADT fringe
• insert root into the fringe
• do
• if (Empty(fringe)) return NULL / Failure /
• nodePT Pop(fringe)
• if (GoalTest(nodePT-gtstate))
• return nodePT
• / Expand node and insert all the successors /
• if (nodePT-gtdepth lt limit)
• insert into the fringe Expand(nodePT)
• while (1)

48
Iterative deepening search

• IterativeDeepeningSearch ()
• for (int depth0 depth)
• nodeDepthLimitedtSearch(depth)
• if ( node ! NULL )
• return node

49
Iterative deepening search l 0
50
Iterative deepening search l 1
51
Iterative deepening search l 2
52
Iterative deepening search l 3
53
Iterative deepening search

• Number of nodes generated in a depth-limited
  search to depth d with branching factor b
• NDLS b0 b1 b2 bd-2 bd-1 bd
• Number of nodes generated in an iterative
  deepening search to depth d with branching factor
  b
• NIDS (d1)b0 d b1 (d-1)b2 3bd-2
  2bd-1 1bd
• For b 10, d 5,
• NDLS 1 10 100 1,000 10,000 100,000
  111,111
  
• NIDS 6 50 400 3,000 20,000 100,000
  123,456
  
• Overhead (123,456 - 111,111)/111,111 11

54
Properties of iterative deepening search

• Complete? Yes
• Time? (d1)b0 d b1 (d-1)b2 bd O(bd)
• Space? O(bd)
• Optimal? Yes, if step cost 1

55
Summary of algorithms
56
Repeated states

• Failure to detect repeated states can turn a
  linear problem into an exponential one!

57
Graph search
58
Class problem

• You have three jugs, measuring 12 gallons, 8
  gallons, and 3 gallons, and a water faucet.
• You can fill the jugs up, or empty them out from
  one another or onto the ground.
• You need to measure out exactly one gallon.