Download Games and CSP-Artificial Intelligence-Tutorial Handout and more Exercises Artificial Intelligence in PDF only on Docsity!
Games and CSP search
1. Games:
A) General Minimax search:
function max-value(state, depth)
- if state is an end-state (end of game) or depth is 0 return SV(state)
- v = -infinity
- for s in get-all-next-moves(state) v = max(v, min-value(state, depth-1))
- return v
function min-value(state, depth)
- if state is an end-state (end of game) or depth is 0 return SV(state)
- v = +infinity
- for s in get-all-next-moves(state) v = min(v, max-value(state, depth-1))
- return v
SV (state) returns the static value of the game state. These are the numbers we give you as the leaf nodes in the game search tree. They are generally in the perspective of the current player.
At the very top level your max-value function should return the best move (as well as the best value), so a slight modification is needed here:
function top-level-max-value(state, depth)
- if state is an end-state (end of game) or depth is 0 return SV(state)
- [v, move] = [-infinity, nil]
- for s, move in get-all-next-moves(state) [v, move] = max( [v, move], [min-value(state, depth-1), move] )
- return [v, move]
For example, calling top-level-max-value(start-state, 10) will search the tree up to depth of
- and return the best move and its SV.
B) Minimax Search As One Function:
The functions max-value and min-value in minimax search can be expressed as a single function;
The single function version works for zero-sum games, which assumes that:
SV(A, state) = -SV(B, state)
You can find the static value of a particular game board from A's perspective by negating the static value from B's perspective.
function minimax(state, depth, player)
- if state is an end-state (end of game) or depth <= 0 return SV(player, state)
- v = -infinity
- for s in get-all-next-moves(state) v = max(v, -1 * minimax(state, depth-1, next(player))
- return v
Here player = {0, 1} (A or B) next(player) returns the next player to play; so next(0) = 1 and next(1) = 0.
C) General N-player Minimax:
For a game with N-players taking turns in sequential order A, B, C, D...n : You can use a general version of the one-function minimax to search for the best move.
function n-player-minimax(state, depth, player)
- if state is an end-state (end of game) or depth is 0 then return SV-vector(state)
- v = (-infinity, ..., -infinity) # v is a vector of n static values.
- for s in get-all-next-moves(state) v = vector-max[player](v, nplayer(state, depth-1, next-player(player)))
- return v
The leaves of the n-player game tree now have a vector of static value scores:
SV-vector(state) => (SV(player_1), SV(player_2), SV(player_n))
vector-max[player] is a function that will find the max vector wrt to the player-th element in the vectors.
Example:
vector-max[0]( ( 1 , 2, 3), ( 2 , 3, 1) ) returns (2, 3, 1) since wrt to the 0th element 2 > 1 vector-max[2]( (1, 2, 3 ), (2, 3, 1 ) ) returns (1, 2, 3) since wrt to the 2nd element 3 > 1
Ties are broken with preference for the left most vector (or the one found earlier.)
D) Minimax with Alpha Beta Pruning:
function max-value(state, depth, alpha, beta):
- if state is an end-state (end of game) or depth is 0 then
function tree-rotation-optimizer: From level in [1 ... n] if level is MAX then sort nodes at this level from smallest to largest else if level is MIN then sort nodes at this level from largest to smallest
NOTE: On Quizzes we usually ask you to fill in the static values at inner nodes by running minimax from the leaf up to root.
G: alpha-beta-search + progressive deepening + tree-rotation-optimizer
Here is a rough sketch implementation of how these 3 elements work together as a speed up for game search.
Step 1. Run alpha-beta-search up to depth d. This will yield some static values for (un-pruned) leaf nodes at depth d.
Step 2. Using these computed static values compute the values associated with intermediate nodes by running minimax from leaf up to root.
Step 3. Run the tree-rotation-optimizer on this (possibly-pruned) tree.
Step 4. Record at each node, the ordering of its children.
Step 5. Run alpha beta search at depth d + 1. But when computing the next-moves for any node, lookup the node-ordering from step 4. Evaluate alpha beta with nodes sorted using this ordering. NOTE: Any nodes not in the ordering will automatically receive the lowest priority; such nodes come from having been pruned in alpha beta search.
Note: The results of the tree rotation optimizer only influences alpha beta search evaluation order. It will not actually guarantee maximum pruning at every stage. This is because:
- We are using the rotation algorithm with static values at d to approximate the values of the tree at d+1.
- Pruned nodes from alpha-beta-search will not be used by the rotation algorithm. While the tree-rotation doesn't yield maximum pruning, it does enhance pruning, so we still get a worthwhile speed up.
2. Constraint Satisfaction Problems
Constraint Types โ Unary Constraints - constraint on single variables (often used to reduce the initial domain) โ Binary Constraints - constraints on two variables C(X, Y) โ n-ary Constraints constraints involving n variables. Any n-ary variables n > 2 m Can always be expressed in terms of Binary constraints + Auxiliary variables
Search Algorithm types:
- DFS w/ BT + basic constraint checking (*) m Check current partial solution see if you violated any constraint.
- DFS w/ BT + forward checking (*) m Assume the current partial assignment, apply constraints and reduce domain of other variables.
- DFS w/ BT + forward checking + propagation through singleton domains (*) m If during forward checking, you reduce a domain to size 1 (singleton domain) m Then assume the assignment of singleton domain, repeat forward checking from singleton variable.
- DFS w/ BT with propagation through reduced domains (AC-2)
You can replace DFS with Best-first Search or Beam-search if variable assignments have "scores", or if you are interested in the best assignment.
Variable domain (VD) table - book keeping for what values are allowed for each variable.
Variable Selection Strategies:
- Minimum Remaining Values Heuristic (MRV) m Pick the variable with the smallest domain to start.
- Degree Heuristic - usually the tie breaker after running MRV m When domains sizes are same (for all variables), choose the variable with the most constraints on other variables (greatest number of edges in the constraint graph)
Forward Checking Pseudo Code:
Assume all constraints are Binary on variables X, and Y. constraint.get_X gives the X variable constraint.get_Y gives the Y variable X.domain gives the current domain of variable X.
forward_checking( state )
- run basic constraint checking fail if basic check fails
- Let X be the current variable being assigned,
- Let x be the current value being assigned to X.
- check_and_reduce ( state, X=x )
function check_and_reduce(state, X=x)
- neighbor_constraints = get_constraints(X)
- foreach constraint in neighbor_constraints:
- Y = constraint.get_Y()
- skip if Y is already assigned
- foreach y in Y.get_domain()
- if check_constraint(constraint, X=x, Y=y) fails
- reduce Y's domain by removing y.
- if Y's domain is empty return fail
- return success
forward_checking_with_prop_thru_singletons( state )
- run forward checking
- queue = find all unassigned variables that have domain size = 1
- while queue is not empty
