Project 1: Background

1. Project 1: Background • Informed search : 8- puzzle world • BFS, DFS and A* algorithms • Heuristics : Manhattan distance , Number of misplaced tiles • Lisp programming • Defstruct, defparameter, setf, list, zerop • mapcar, append, cond, loop..do, aref • Funcall, return-from, format and ….

2. A* search • Combines • Uniform cost search • g(n): Exact path cost from start state to node n • Initial node: 0, later nodes: (parent g-value)+1 • Greedy search • h(n): Heuristic path cost from node n to a goal state • Initial node:0, later nodes: Manhattan distance/ Misplaced Number of tiles • Heuristic function for A* f(n) = g(n) + h(n) • choose h(n) so that it never overestimates (admissible) • A*: Next node to expand is node with lowest f(n)

3. Some lisp • Funcall(a b c d..) calls function “a” with arguments b,c,d.. • Sort(list #’< :key x) sorts the “list” in “<“ order based on the x field of each item in “list” – destructive • Append(list1 list2), cond • (mapcar #’(lambda (x) (op)) ‘(list)) computes op on each item of list and returns new list (**Children fn**) • ‘ quote (common mistake) protects from evaluation • (Make-array ‘(2 3) :initial-element 0) 2 by 3 array • (Aref array x y) returns x,y the element of array • Equalp (cannot be used with arrays)

4. A* Search Code A list of nodes (state, action, parent, g-val, h-val, f-val) (defun A* (nodesgoalpchildren-fnfvalue-fn) ( cond ((null nodes) nil) ;; Return the first node if it is a goal node. ((funcall goalp (first nodes)) (first nodes)) ;; Append the children to the set of old nodes (t (A* (sort (append (funcall children-fn (first nodes)) (rest nodes)) #'< :key fvalue-fn ) goalp children-fn fvalue-fn)))) (t (let ((temp (sort (append (funcall children-fn (first nodes) (rest nodes)) #'< :key fvalue-fn ))) (A* temp ‘goalp ‘children-fn ‘fvalue-fn))))) Functions : goalp: Compare current state to goal-state: returns true or nil children-fn: takes parent-node and returns a list of children nodes fvalue-fn: takes a node and returns its f-value ( a one line code) A*: Good place to find the maximum length of queue

5. Node structure & global parameters • Node • State : Could be just an array (3*3) • Parent : again a node • Action :left, right, up, down from parent (string) • G-val : parent g-val + 1 • H-val : call manhattan distance or misplaced tiles • F-val: G-val + H-val • Start node(start state, NIL, NIL, 0,0,0) • Global parameters • (defparameter) • Number of nodes generated • Number of nodes expanded • Maximum size of queue • Goal state

6. goalp • Goalp (state) • Compare state with goal (global) • Do NOT use equalp • Loop for each element in state to compare with corresponding element in goal state • generalize and write “equal-state” to compare any two states • return true / NIL (return-from)

7. Children Fn & puzzle children • You have left-child, similarly right, up, down child • puzzle children will call each of them on a given state • (append left right down up) • Good place to keep track of number of nodes generated and expanded

8. Heuristics • Manhattan • for each element a at (x,y) in “state” • Find position (another function) of a in goal state Say (x1,y1) • Find (abs(x-x1)+abs(y-y1)) • Number of misplaced tiles • modification of goalp • whenever 2 corresponding elements are not equal , increment a counter initially set to 0

9. Possible Order in writing functions • Goalp • Right, up, down children • Children-fn • Heuristics • A* • Then statistics