1. Search as a problem solving technique. Consider an AI program that is capable of formulating a desired goal based on the analysis of the current world state. To reach its goal, the program must be able to formulate a search problem by: –providing a description of the current world state, –providing a description of its own actions that can transform one world state into another one, –providing a description of the goal state where the desired goal holds. Problem solution consists of finding a path from the current state to the goal state. To define how “good” the solution is, a path cost function can be assigned to the path. Different solutions to the same problem can be compared by means of the corresponding path cost functions.

2. Example: the missionaries and cannibals problem. n Description of the current state: a sequence of six numbers, representing the number of missionaries, cannibals and boats on each bank of the river. Assuming 3 missionaries, 3 cannibals and one boat, the initial state is (setf start '(3 3 1 0 0 0)) n Description of possible actions (or operators): take either one missionary, one cannibal, two missionaries, two cannibals, or one of each across the river in the boat, i.e. (setf list-of-actions '((1 0 1) (0 1 1) (2 0 1) (0 2 1) (1 1 1))) n Description of the goal state, i.e. (setf finish '(0 0 0 3 3 1)) Note that some world states are illegal (the number of cannibals must always be less or equal to the number of missionaries on each side of the river. Therefore, we must impose certain constraints on the search to avoid illegal states. We also must guarantee that search will not fall in a loop (some actions may “undo” the result of a previous action).

3. Problem space is a complete description of the domain, and is only procedurally defined. 3,3,1,0,0,0 2,2,0,1,1,1 2,3,1,1,0,0 2,0,0,1,3,1 3,3,0,0,0,1 3,3,1,0,0,0 3,2,1,0,1,0 3,2,0,0,1,1 3,1,1,0,2,0 3,1,0,0,2,1 2,3,0,1,0,1 1,1,1,2,2,0 1,2,0,2,1,1 1,2,1,2,1,0 1,3,1,2,0,0 3,0,0,0,3,1 3,0,1,0,3,0 2,1,0,1,2,1 2,0,1,1,3,0 1,0,1,2,3,0 1,1,0,2,2,1 0,3,1,3,0,0 1,3,0,2,0,1 0,3,0,3,0,1 2,2,1,1,1,0 2,1,1,1,2,0 0,1,0,3,2,1 0,1,1,3,2,0 0,2,0,3,1,1 0,2,1,3,1,0

4. Search (or solution) space is a part of the problem space which is actually examined 3,3,1,0,0,0 3,1,0,0,2,1 3,2,0,0,1,1 2,2,0,1,1,1 [1,1,1] [0,1,1] [0,2,1] Dead end 3,2,1,0,1,0 [1,0,1] [0,1,1] 3,0,0,0,3,1 2,2,0,1,1,1 3,1,0,0,2,1 3,0,0,0,3,1 [0,2,1] [0,1,1] [1,0,1] [0,2,1] Dead end...

5. Depth-first search: always expand the path to one of the nodes at the deepest level of the search tree Each path is a list of states on that path, where each state is a list of six elements (m1 c1 b1 m2 c2 b2). Initially, the only path contains only the start state, i.e. ((3 3 1 0 0 0)). (defun depth-first (start finish &optional (queue (list (list start)))) (cond ((endp queue) nil) ((equal finish (first (first queue))) (reverse (first queue))) (t (depth-first start finish (append (extend (first queue)) (rest queue)))))) (defun extend (path) (print (reverse path)) (setf extensions (get-extensions path)) (mapcar #'(lambda (new-node) (cons new-node path)) (filter-extensions extensions path)))

6. Breadth-first search: always expand all nodes at a given level, before expanding any node at the next level (defun breadth-first (start finish &optional (queue (list (list start)))) (cond ((endp queue) nil) ((equal finish (first (first queue))) (reverse (first queue))) (t (breadth-first start finish (append (rest queue) (extend (first queue))))))) (defun extend (path) (print (reverse path)) (setf extensions (get-extensions path)) (mapcar #'(lambda (new-node) (cons new-node path)) (filter-extensions extensions path)))

7. Depth-first vs breadth-first search Depth-first search 1. Space complexity: O(bd), where b is the branching factor, and d is the depth of the search. 2. Time complexity: O(b^d). 3. Not guaranteed to find the shortest path (not optimal). 4. Not guaranted to find a solution (not complete) 5. Polinomial space complexity makes it applicable for non-toy problems. Breadth-first search 1. Space complexity: O(b^d) 2. Time complexity: O(b^d). 3. Guaranted to find the shortest path (optimal). 4. Guaranted to find a solution (complete). 5. Exponential space complexity makes it impractical even for toy problems.

8. Informed search strategies: best-first “greedy” search Best-first search always expends the node that is believed to be the closest to the goal state. This is defined by means of the selected evaluation function. Example: consider the following graph whose nodes are represented by means of their property lists: (setf (get 's 'neighbors) '(a d) (get 'a 'neighbors) '(s b d) (get 'b 'neighbors) '(a c e) (get 'c 'neighbors) '(b) (get 'd 'neighbors) '(s a e) (get 'e 'neighbors) '(b d f) (get 'f 'neighbors) '(e)) (setf (get 's 'coordinates) '(0 3) (get 'a 'coordinates) '(4 6) (get 'b 'coordinates) '(7 6) (get 'c 'coordinates) '(11 6) (get 'd 'coordinates) '(3 0) (get 'e 'coordinates) '(6 0) (get 'f 'coordinates) '(11 3))

9. To see the description of a node, we can say: * (describe 'a)........ Property: COORDINATES, Value: (4 6) Property: NEIGHBORS, Value: (S B D) To find how close a given node is to the goal, we can use the formula computing the straight line distance between the two nodes: defun distance (node-1 node-2) (let ((coordinates-1 (get node-1 'coordinates)) (coordinates-2 (get node-2 'coordinates))) (sqrt (+ (expt (- (first coordinates-1) (first coordinates-2)) 2) (expt (- (second coordinates-1) (second coordinates-2)) 2)))))

10. Given two partial paths, whose final node is closest to the goal, can be defined by means of the following closerp predicate: (defun closerp (path-1 path-2 finish) (< (distance (first path-1) finish) (distance (first path-2) finish))) The best-first search now means “expand the path believed to be the closest to the goal”, i.e. (defun best-first (start finish &optional (queue (list (list start)))) (cond ((endp queue) nil) ((equal finish (first (first queue))) (reverse (first queue))) (t (best-first start finish (sort (append (extend (first queue)) (rest queue)) #'(lambda (p1 p2) (closerp p1 p2 finish))))))) (defun extend (path) (print (reverse path)) (mapcar #'(lambda (new-node) (cons new-node path)) (remove-if #'(lambda (neighbor) (member neighbor path)) (get (first path) 'neighbors))))

11. Iterative improvement methods: hill-climbing search If the current state contains all the information needed to solve the problem, then we try the best modification possible to transform the current state into the goal state. (defun hill-climb (start finish &optional (queue (list (list start)))) (cond ((endp queue) nil) ((equal finish (first (first queue))) (reverse (first queue))) (t (hill-climb start finish (append (sort (extend (first queue)) #'(lambda (p1 p2) (closerp p1 p2 finish))) (rest queue))))))

12. Iterative improvement methods: beam search Beam search is similar to breadth-first, but it only extends a specified number of “best” paths, where “best” means closest to the goal. That is, beam search looks at a small number of ways to continue. (defun beam (start finish width &optional (queue (list (list start)))) (setf queue (butlast queue (max (- (length queue) width) 0))) ; trim the queue to the required width (cond ((endp queue) nil) ((equal finish (first (first queue))) (reverse (first queue))) (t (beam start finish width (sort (apply #'append (mapcar #'extend queue)) #'(lambda (p1 p2) (closerp p1 p2 finish)))))))

13. Iterative breadth-first example from the book Although the most natural implementation of the breadth-first search is the recursive one, sometimes because of the efficiency considerations it can be implemented iteratively. (defun bsolve (initial) (do ((queue (list (list initial initial)) ; first parameter (append (cdr queue) new-paths)) (new-paths nil nil)) ; second parameter ((null queue)) ; termination test (when (goal-recognizer (caar queue)) (return (values (caar queue) (cdar queue)))) (setq new-paths (expand-path (car queue))))) (defun goal-recognizer (state) (if (eql state goal) t nil))