![Page 1: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/1.jpg)
Introduction to Artificial Intelligence
Blind Search
Ruth Bergman
Fall 2004
![Page 2: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/2.jpg)
Search Strategy
• Partial search tree for route finding from Arad to Bucharest.
Arad(a) The initial state (search node)
(b) After expanding Arad
(c) After expanding Sibiu
Arad
Sibiu Timisoara Zerind
Arad
Sibiu Timisoara Zerind
Arad Fagaras OradeaRimnicu Vilcea
goal test
choosing one option
• Which node to expand?• Which nodes to store in memory?
![Page 3: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/3.jpg)
Search Trees
• Search node – book-keeping data structure used to represent the search tree– State is a configuration of the world
(defstruct node state ;;; state (domain dependent) ancestor ;;; the ancestor node in the search graph f ;;; the cost of the node action ;;; the specific action that led to this node from its ) ;;; ancestor
![Page 4: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/4.jpg)
Depth-first Search
Searching Strategies
• Expand deepest node first.• DFS (state path)
if goalp(state) return pathelse for c in succ(state)
return DFS(c, path | state)
![Page 5: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/5.jpg)
DFS implementation in Lisp
(defun dfs (node) (cond
((goalp (node-state node)) node)(t (let ((children (successor-fn node))) (dfs2 children)))))
(defun dfs2 (states) ;; input list of nodes (cond
((null states) nil)((dfs (car states)))((dfs2 (cdr states)))))
![Page 6: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/6.jpg)
• Criteria– Completeness: if there is a solution will
the algorithm find it?– Time complexity: how much time does the
algorithm take to arrive at a solution, if one exists?
– Space complexity: how much space does the algorithm require?
– Optimality: is the solution optimal?
Search Strategy Properties
![Page 7: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/7.jpg)
In-Completeness of DFS
• DFS is not complete– fails in infinite-depth spaces, spaces with
loops
• Variants– limit depth of search– avoid re-visiting nodes.– avoid repeated states along path
=> complete in finite spaces
![Page 8: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/8.jpg)
DFS with depth limit
(defun dfs (node depth) (cond
((goalp (node-state node)) node)((zerop depth) nil)((let ((children (successor-fn node))) (dfs2 children (- depth 1)))))
(defun dfs2 (states depth) (cond
((null states) nil)((dfs (car states) depth))((dfs2 (cdr states) depth))))
![Page 9: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/9.jpg)
• Properties – Complete: No
• Guaranteed to stop• Complete only if exists solution at level l<d (where d is the
maximum depth)
– Time complexity: O(b^d) • Best case l• Worst case (b^(d+1)-1)/(b-1)
Where b is the branching factor
• improved performance when there are many solutions
– Space complexity: O(bd) • i.e., linear space
– Optimal: No
DFS with depth limit Performance
Searching Strategies
![Page 10: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/10.jpg)
DFS with no revisits
• avoid nodes that have already been expanded.=> exponential space complexity.
– Not practical.
![Page 11: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/11.jpg)
DFS with no repeated states
(defun dfs (node path) (cond
((goalp (node-state node)) path)((let ((children (successor-fn node))) (dfs2 children (cons (node-state node) path)))))
(defun dfs2 (states path) (cond
((null states) nil)((member (car states) path) nil)((dfs (car states) path))((dfs2 (cdr states) path))))
=> Complete in finite spaces
1
87
6
54
3
2
![Page 12: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/12.jpg)
Backtracking Search
Searching Strategies
• When states are expanded by applying operators• The algorithm expands one child at a time (by applying one operator)• If search fails, backtrack and expand other children• Backtracking search results in even lower memory requirements than DFS
1
9
13
1187
6
54
3
2
10
151412
1
3
11
1298
5
76
4
2
10
151413
DFS node discovery
Backtracking searchnode discovery
![Page 13: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/13.jpg)
• Advantages – Low space complexity – Good chance of success when there are many solutions.– Complete if there is a solution shorter than the depth limit.
• Disadvantages– Without the depth limit search may continue down an infinite
branch.– Solutions longer than the depth limit will not be found.– The solution found may not be the shortest solution.
DFS Summary
Searching Strategies
![Page 14: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/14.jpg)
Breadth-first Search
Searching Strategies
• Expand node with minimal depth.• avoid revisiting nodes. Since every node is in memory, the
additional cost is negligible.
![Page 15: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/15.jpg)
BFS implementation in Lisp
(defun bfs (queue) (let* ((node (car queue))
(state (node-state node))) (cond
((null queue) nil)((goalp state) node)((let ((children (successor-fn node))) (bfs (append (cdr queue) children)))))))
1
3
7
121110
5
98
4
2
6
151413
![Page 16: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/16.jpg)
BFS Performance
Searching Strategies
• Properties– Complete: Yes (if b is finite)– Time complexity: 1+b+b^2+…+b^l = O(b^l)– Space complexity: O(b^l) (keeps every node in
memory) – Optimal: Yes (if cost=1 per step); not optimal in
general• where b is branching factor and • l is the depth of the shortest solution
![Page 17: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/17.jpg)
Uniform cost Search
A
GS
C
551 10
15 5
B
S SS S
AA A
BB B
CC C
G G G
0
1 5 1511
155
11 10
15
• Expand least-cost unexpanded node– the breadth-first search is just uniform cost search
with f(n)=DEPTH(n)
– Node discovery
– Stop at first expanded goal node
Searching Strategies
![Page 18: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/18.jpg)
Uniform cost Search
• Properties of Uniform-Cost Search– Complete: Yes, if step cost >= e (epsilon)– Time complexity: # of nodes with f <= C*
• C* = cost of optimal solution• Worst case O(b^(C*/e))• O(b^l) if step costs are equal
– Space complexity: # of nodes with f <= C*, O(b^l)
– Optimal: Yes, if step cost >= e (epsilon)
Searching Strategies
![Page 19: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/19.jpg)
• Combine the best of both worlds– Depth first search has linear memory requirements– Breadth first search gives an optimal solution.
• Iterative Deepening Search executes depth first search with depth limit 1, then 2, 3, etc. until a solution is found.
• The algorithm has no memory between searches.
Iterative Deepening Search
Searching Strategies
![Page 20: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/20.jpg)
• Limit=0
• Limit=1
• Limit=2
• Limit=3
Iterative Deepening Search
…
Searching Strategies
![Page 21: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/21.jpg)
• Properties– Complete: Yes– Time complexity: (l+1)*b^0+l*b+(l-
1)*b^2+…+1*b^l = O(b^l) – Space complexity: O(bl)– Optimal: Yes, if step cost = 1
• Can be modified to explore uniform-cost tree
Iterative Deepening Search
Searching Strategies
![Page 22: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/22.jpg)
• Numerical demonstration:Let b=10, l=5.– BFS resource use (memory and # nodes
expanded)1+10+100+1000+10000+100000 = 111,111
– Iterative Deepening resource use• Memory requirement: 10*5 = 50• # expanded nodes6+50+400+3000+20000+100000 = 123,456
=> re-searching cost is small compared with the cost of expanding the leaves
Iterative Deepening Search - Discussion
Searching Strategies
![Page 23: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/23.jpg)
• Simultaneously search both forward from the initial state and backward from the goal, and stop when the two searches meet in the middle.
Bidirectional Search
Start Goal
Searching Strategies
![Page 24: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/24.jpg)
• Properties– Complete: Yes (using a complete search
procedure for each half)– Time complexity: O(b^(l/2))– Space complexity: O(b^(l/2))– Optimal: Yes, if step cost = 1
• Can be modified to explore uniform-cost tree
Bidirectional Search Performance
Searching Strategies
![Page 25: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/25.jpg)
Bidirectional Search Discussion
• Numerical Example (b=10, l = 6)– Bi-directional search finds solution at d=3 for both
forward and backward search. Assuming BFS in each half 22,200 nodes are generated.
– Compare with 11,111,100 for a standard BFS.
• Implementation issues:– Operators are reversible.– There may be many possible goal states.– Check if a node appears in the “other” search tree.– What’s the best search strategy in each half.
![Page 26: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/26.jpg)
– b is the branching factor;– l is the depth of solution;– m is the maximum depth of the search tree;– d is the depth limit.
Comparison Search Strategies
CriterionBreadth-
FirstUniform-
CostDepth-First
Depth-Limited
Iterative Deepening
Bi-directional
(if applicable)
Time b^l b^l b^m b^d b^l b^(l/2)
Space b^l b^l bm bd bl b^(l/2)
Optimal? Yes Yes No No Yes Yes
Complete?
Yes Yes NoYes, if d>=l
Yes Yes
Searching Strategies
![Page 27: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/27.jpg)
Herbert
A reactive-based robot that collects soda cans, sometimes.
![Page 28: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/28.jpg)
Alternate implementations of Search Algorithms
• Iteration
• Unnamed functions (lambda expressions)
• Mapping functions
![Page 29: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/29.jpg)
DFS implementation in Lisp
(defun dfs (state) (cond
((goalp state) (list state))(t (do* ((children (new-states state) (cdr children))) (solution (dfs (car children)) (dfs (car children))) ((or solution (null children))
(if solution (cons state solution) nil))))))
![Page 30: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/30.jpg)
DFS with depth limit
(defun dfs-d (state depth) (cond
((goalp state) (list state)) ((zerop depth) nil)
(t (do* ((children (new-states state) (cdr children))) (solution (dfs (car children) (1- depth)) (dfs (car children) (1- depth))) ((or solution (null children))
(if solution (cons state solution) nil))))))
![Page 31: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/31.jpg)
DFS with no repeated states
(defun dfs-d-g (state depth path) (cond
((goalp state) (list state)) ((zerop depth) nil)
(t (do* ((children (new-states state) (cdr children))) (solution (if (member (car children) path)
nil (dfs (car children) (1- depth) (cons state path))
…)) ((or solution (null children))
(if solution (cons state solution) nil))))))
1
87
6
54
3
2
=> Complete in finite spaces
![Page 32: Introduction to Artificial Intelligence Blind Search](https://reader036.vdocuments.us/reader036/viewer/2022062315/568151cd550346895dc00899/html5/thumbnails/32.jpg)
BFS implementation in Lisp
(defun bfs (state) (let ((queue (list (list state nil)))) (do* ((state (caar queue) …)
(children (new-states state) …))((or (null queue) (goalp state)) (if (null queue) nil (car state))(setq queue (append
(cdr queue) (mapcar
#'(lambda (state) (cons state (car queue))) children)))))))
1
3
7
121110
5
98
4
2
6
151413