AI in game (II) 권태경 Fall, 2006

outline Problem-solving agent Search

Problem-solving agent One kind of goal-based agent Finds a sequence of actions –That leads to desirable states Needs to do –Goal formulation Current situation and performance measure –Problem formulation The process of deciding what actions and states to consider, given a goal Level of detail

Problem-solving agent

Example: Romania On holiday in Romania; currently in Arad Flight leaves tomorrow from Bucharest Formulate goal: –be in Bucharest Formulate problem: –states: various cities –actions: drive between cities Find solution: –sequence of cities, e.g., Arad, Sibiu, Fagaras, Bucharest

Example: Romania Map

problem definition: 4 components A problem is defined by four items: 1.initial state e.g., “ in Arad" 2.actions or successor function S(x) = set of action – state pairs –e.g., S(Arad) = {, … } Or –Initial state and successor function define a state space (e.g. graph) 3.goal test, can be –explicit, e.g., x = “ in Bucharest" –implicit, e.g., Checkmate(x) 4.path cost (additive) –c(x,a,y): step cost of action a to go from state x to state y, assumed to be ≥ 0 –Path cost: sum of the costs of the actions along the path A solution is a sequence of actions leading from the initial state to a goal state

Schematic diagram Actions Initial state Goal test state space successor function

Problem definition in real world Real world is absolutely complex  state space must be abstracted for problem solving (Abstract) state = set of real states (Abstract) action = complex combination of real actions –e.g., "Arad  Zerind" represents a complex set of possible routes, detours, rest stops, etc. For guaranteed realizability, any real state "in Arad ” must get to some real state "in Zerind" (Abstract) solution is valid if it is mapped to –set of real paths that are solutions in the real world Each abstract action should be "easier" than the original problem –usefulness

Vacuum world state space graph states? actions? goal test? path cost? L: go Left R: go Right S: Suck

Vacuum world state space graph states? dirt (2 2 ) and robot location(2), total 8 actions? Left, Right, Suck goal test? no dirt at all locations path cost? 1 per action

Example: The 8-puzzle states? actions? goal test? path cost?

Example: The 8-puzzle states? locations of tiles (9!/2) actions? move blank left, right, up, down goal test? = goal state (given) path cost? 1 per move [Note: optimal solution of n-Puzzle family is NP-hard]

15-Puzzle Sam Loyd offered $1,000 of his own money to the first person who would solve the following problem: ?

But no one ever won the prize !!

outline Problem-solving agent Search

Solving is Searching Solving the problem is done by a search through the state space A solution is a path connecting the initial node to a goal node (any one) I G

Tree search algorithms Basic idea: –exploration of state space by generating successors of already-explored states (a.k.a.~expanding states)

Tree search example Initial state will be the root

Tree search example Whenever a state is generated (or visited or explored), its children nodes will be the next candidate states to explore (but not immediately!) Here “arad” is expanded –Children nodes are placed into the queue

Tree search example “sibiu” is expanded

Implementation: general tree search fringe: the set (here, q) of visited but not expanded nodes Make-node(e): creates a queue with e (element) Insert(e,q): inserts e to q (queue) Remove-front(q) returns first(q) InsertAll(e,q) inserts a set of elements into q

Implementation: general tree search The Expand function creates new nodes, filling in the various fields and using the SuccessorFn of the problem to create the corresponding states.

Implementation: states vs. nodes A state is a (representation of) a physical configuration A node is a data structure constituting part of a search tree includes state, parent node, action, path cost g(x), depth

Search strategies A search strategy is defined by picking the order of node expansion Strategies are evaluated along the following dimensions: –completeness: does it always find a solution if one exists? –time complexity: number of nodes generated –space complexity: maximum number of nodes in memory –optimality: does it always find a least-cost solution? Time and space complexity are measured in terms of –b: maximum branching factor of the search tree –d: depth of the least-cost solution –m: maximum depth of the state space (may be ∞)

Uninformed search strategies Uninformed search strategies use only the information available in the problem definition Also called blind search 5 approaches –Breadth-first search –Uniform-cost search –Depth-first search –Depth-limited search –Iterative deepening search

Breadth-first search Expand shallowest unexpanded node Implementation: –fringe is a FIFO queue, i.e., new successors go at end

Breadth-first search Expand shallowest unexpanded node Implementation: –fringe is a FIFO queue, i.e., new successors go at end

Breadth-first search Expand shallowest unexpanded node Implementation: –fringe is a FIFO queue, i.e., new successors go at end

Breadth-first search Expand shallowest unexpanded node Implementation: –fringe is a FIFO queue, i.e., new successors go at end

Properties of breadth-first search Complete? Yes (if b is finite) Time? 1+b+b 2 +b 3 + … +b d + b(b d -1) = O(b d+1 ) Space? O(b d+1 ) (keeps every node in memory) Optimal? Yes (if cost = 1 per step) Space is the bigger problem (more than time) d+1 level nodes are queued & If the last node is goal

Uniform-cost search Expand least-cost unexpanded node Implementation: –fringe = queue ordered by path cost Equivalent to breadth-first if step costs all equal Complete? Yes, if step cost ≥ ε –Should eliminate any zero-cost action Time? # of nodes with g() ≤ cost of optimal solution, O(b 1+  C*/ ε  ) where C * is the cost of the optimal solution Space? # of nodes with g() ≤ cost of optimal solution, O(b 1+  C*/ ε  ) Optimal? Yes – nodes expanded in increasing order of g() g(x): the path cost of a node x

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front Black nodes: expanded and no children nodes in memory

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

Properties of depth-first search Complete? No: fails in infinite-depth spaces, spaces with loops –Modify to avoid repeated states along path  complete in finite spaces Time? O(b m ): terrible if m is much larger than d – but if solutions are dense, may be much faster than breadth-first Space? O(bm), i.e., linear space! Optimal? No m: the maximum depth of the tree

Depth-limited search = depth-first search with depth limit l, i.e., nodes at depth l have no successors