UnInformed Search What to do when you don’t know anything

What to know Be able to execute (by hand) an algorithm for a problem Know the general properties Know the advantages/disadvantages Know the pseudo-code Believe you can code it

Assumptions of State-Space Model Fixed number of operators Finite number of operators Known initial state Known behavior of operators Perfect Information Real World  Micro World What we can do.

Concerns State-space: tree vs graph? –Are states repeated? Completeness: finds a solution if one exists Time Complexity Space Complexity: Major problem Optimality: finds best solution Assume Directed Acyclic graphs (DAGS) –no cycles Later: adding knowledge

General Search Algorithm Current State = initial state While (Current State is not the Goal) –Expand State compute all successors/ apply all operators –Store successors in Memory –Select a next State –Set Current state to next If current state is goal: success, else failure

Derived Search Algorithms Algorithm description incomplete What is “store in memory” What is “memory” What is “select” Different choices yield different methods.

Abstract tree for evaluation Let T be a tree where each node has b descendants. B is the branching factor. Suppose that a goal lies at depth d. If goal is root, depth of solution is 0. Unlike in theory, tree usually generated dynamically.

Depth First Storage = Stack Add = push Select = Pop Not complete (if infinite or cycles, otherwise complete) Not optimal Time: O(b^m), space O(bm) where m is max depth.

Ex. DFS for Permutations of 3 Initial State: Next State: add to front, no repeats Stack: { } Next Stack: {,, } Next Stack:,,, } etc Trick: encode states with legal operators –  How much memory? O(n^2)

Breadth First Memory = Queue Store = add to end Select = take from the front Properties: –complete, –optimal: min of steps Time/Space Complexity = –1+b+b^2…+b^d = [b^(d+1) -1 ]/ (b-1) = O(b^d) Problem: Exponential memory Size.

Ex. BFS for Permutations of 3 Init: Queue: { } Next Queue {,, } Next Queue {,,, } So what’s the big deal? Space n!*n for n! search.

Uniform Cost Now assume edges have positive cost Storage = Priority Queue: scored by path cost –or sorted list with lowest values first Select- choose minimum cost add – maintains order Check: careful – only check minimum cost for goal Complete & optimal Time & space like Breadth.

Uniform Cost Example Root – A cost 1 Root – B cost 3 A -- C cost 4 B – C cost 1 C is goal state. Why is Uniform cost optimal? –Expanded does not mean checked node.

Watch the queue R/0 // Path/path-cost R-A/1, R-B/3 R-B/3, R-A-C/5: – Note: you don’t test expanded node –You put it in the queue R-B-C/4, R-A-C/5

Depth Limited Depth First search with limit = l Algorithm change: states not expanded if at depth k. Complete : no Time: O(b^k) Space: O(b*l) Complete if solution <=l, but not optimal.

Iterative Deepening Set l = 0 Repeat –Do depth limited search to depth l –l = l+1 Until solution is found. Complete & Optimal Time: O(b^d) Space: O(bd) when goal at depth d

Comparison Breadth vs ID Branching Factor 10 Depth Breadth ID

Bidirectional Won’t work with most goal predicates Needs identifiable goal states Needs reversible operators. Needs a good hashing functions to determine if states are the same. Then: O(b^d/2) time if bf is b in both directions.

Bidirectional Search Simple Case: Initial State = {Start State+ Goal State} Operators: –forward from start, backwards from goal Standard: Breadth in both directions Check: newly generated states intersect fringe. (can be expensive)

Repeated States Occurs whenever reversible operators Occurs in many problems Improvements –Do not return to k recent states: cheap and non-effective – Do not return to state on path: cycle checking: Cheap and effective –Do not return to any seen state: exponential Memory costs increase for all algorithms

Algorithm Effects Cycles: –DFS incomplete: fix cycle checking –IDS incomplete: fix cycle checking –BFS still complete, but increased cost

Grid World Start (0,0) Goal (8,8) Legal moves: up, down, left, right What happens to algorithms?