implementing search

Lecture 2-2 CS250: Intro to AI/Lisp

Implementing Search

Lecture 2-2

January 14th/19th, 1999

CS250


8-Puzzle

5 46 1 87 3 2

1 2 38 47 6 5

• States?

• Operators?

• Goal test?

• Path cost?


8-Queens

• Place 8 queens on a chess board, with no one attacking any other

• Goal test?

• Path cost?

• States

• Operators?


Cryptarithmetic

• Puzzles with numbers replaced by letters

FORTY+ TEN+ TEN=====SIXTY


Missionaries & Cannibals

• Three missionaries and three cannibals wish to cross a river in a boat that won’t hold all three

• States?

• Operators?

• Goal test?

• Path cost?


Real-World Problems

• Route finding

• TSP

• VLSI

• Robot navigation

• Paint booth scheduling


Search Trees

S ta te S pa ce

S ta te 1 ,1 ,1 S ta te 1 ,1 ,2

S ta te 1 ,1 S ta te 1 ,2

S ta te 1

S ta te 2 ,2

S ta te 2 S ta te 3

S ta te 0 ,0

(In it ia l s ta te )


What’s in a Node?

• State - what state are we in?

• Parent - Which node generated the current node?

• Operator - Action which generated node from parent

• Node depth - Number of nodes from root

• Cost - Path cost from initial node


Lieutenant Node & General Search

function GENERAL-SEARCH(problem, QUEUEING-FN) returns solution or failure

nodes MAKE-QUEUE(MAKE-NODE(INITIAL-STATE[problem]))

loop do

if nodes is empty then return failure

node REMOVE-FRONT(nodes)

if GOAL-TEST[problem] applied to STATE(node) succeeds then return node

nodes QUEUING-FN(nodes, EXPAND(node, OPERATORS[problem]))

end


Coding Goals

• Create the initial node list– Need the right ordering

• Write a loop

• If test

• Functions for:– QUEUEING-FN, REMOVE-FRONT, GOAL-TEST,

EXPAND, MAKE-NODE


In Lisp...

(defun general-search (problem queuing-fn)"Expand nodes according to the specification of PROBLEM until we find a solution or run out of nodes to expand.The QUEUING-FN decides which nodes to look at first. [p 73]”

(let ((nodes (make-initial-queue problem queuing-fn))node)

(loop (if (empty-queue? nodes) (RETURN nil))(setq node (remove-front nodes))(if (goal-test problem (node-state node)) (RETURN node))(funcall queuing-fn nodes (expand node problem)))))


A Few Lisp Ends

(setq var1 form1 var2 form2 ...)

return terminates a loop and returns the value of the specified expression as the value of the loop

special form: A list (but not a macro), which is a form with special syntax or special evaluation rulesor both, possibly manipulating the evaluation environment or control flow or both.

The first element of a special form is a special operator.


Dumb & Smart Searching

• Does the search algorithm use information beyond GOAL-TEST?– Uninformed/blind searching does not– Informed/heuristic search does


Factors in Search Strategy

• Completeness - Are we guaranteed to find a solution, if one exists?

• Time complexity - How long does it take?

• Space complexity - How much memory?

• Optimality - Find the best of several solutions?


Different Strokes for Different Searches

• Why is GENERAL-SEARCH general?


Breadth-First Search

• Go sideways before you go down– How do we do this in GENERAL-

SEARCH?

• How good is it?– Completeness?– How long does it take?– How much memory?– Optimality?


Uniform Cost

• BFS: No shorter path is a solution, but what about cost?

• Uniform cost expands the lowest cost node

• When is BFS also uniform?

g(node) = DEPTH(node)


Depth-first Search

• Go down before you go sideways

• Saves memory over BFS - why?

• How good is it?– Completeness?– How long does it take?– Optimality?

• Depth-limited search


Iterative Deepening Search

• Repeated depth-limited search– Depth 0, depth 1, depth 2, …

• Same states expanded multiple times– Higher branching factors make repeated

expansion less important

• How good is it?

• Good choice when:– Big search space– Unknown solution depth


Bidirectional Search

• Start from the beginning and the end, meet in the middle

• Divide and conquer– Cut the depth of each search in half– From O(bd) to O(2bd/2)– For b = 10, d = 6:

• BFS searches 1,111,111• Bidirectional searches 2,222


Sounds Great, Where do I Sign Up?

• Searching backwards?

• Calculating predecessors can be tricky

• Many goal states are a problem

• Generate a node and ask, “Is it in the other half of the tree?”

• Different halves can have different searches


Search Comparison

Criterion BFS UniformCost

DFS Depth-Limited

IterativeDeepening

Bidirectional

Time bd bd bm bl bd bd/2

Space bd bd bm bl bd bd/2

Optimal? Yes Yes No No Yes YesComplete Yes Yes No Yes, if

l<=dYes Yes

d = depth of the goal

m = max tree depth

l = depth limit


And the Winner is...

• Depth-first iterative deepening– Asymptotically optimal in time– Asymptotically optimal in space

among blind searches that find optimal solutions


Constraint Satisfaction Search

• Constraint Satisfaction Problem (CPS): additional structural properties– States are values of a set of variables– Goal test specifies constraints on variable

values• Unary - cryptarithmetic• Binary - 8-Queens• 3rd and higher-order• Absolute or just nice to have


Why Bother?

• Less general than the notion of ‘problem’

• More efficient algorithms– Constraints are fine-grained


Domains

• Variables Vi have domains, Di

• Discrete or continuous?


AIMA Code (for homework)

• Code from AIMA

/courses/current/CS250/Code/AIMA/doc/overview.html

http://www.classes.cs.uchicago.edu/courses/current/CS250/Code/AIMA/doc/overview.html

http://www.classes.cs.uchicago.edu/courses/current/CS250/Code/AIMA/doc/overview.html

implementing search

Documents

generalsearch general

nodes return nilsetq

node problema

current node

initial node listneed

rootcost path cost

search strategycompleteness

othergoal test