By:-

Akshay Rajvanshi
 How many players?
• One
• Two
 Element of chance?
• Deterministic
• Nondeterministic
 Outcome
• Zero sum (what one player wins, the other loses)
• Non-zero sum
 Deterministic Nondeterministic

Tower of Hanoi Solitaire

One
Player

Chess Backgammon
Tic-Tac-Toe Poker
Two Go
Player
 Players: We call them Max and Min.
 Initial State: Includes board position and whose turn it is.
 Operators: These correspond to legal moves.
 Terminal Test: A test applied to a board position, which
determines whether the game is over or not. In chess, for
example, this would be a checkmate.
 Utility Function: A function which assigns a numeric value
to a terminal state. For example, in chess the outcome is
win (+1), lose (-1) or draw (0). Note that by convention, we
always measure utility relative to Max.
 Normal search problem: Max searches for a for
moves to winning position and then makes the
first move in the sequence.

 Game search problem: Clearly, this is not

feasible in a game situation where Min's moves
must be taken into consideration. Max must
devise a strategy which leads to a winning
position no matter what moves Min makes.
 A way to play such a game is to:

Consider all the legal moves you can make.

Each move leads to a new board configuration
(position).
Evaluate each resulting position and determine which is
best
Make that move.
Wait for your opponent to move and repeat?
 Problem spaces for typical games represented as trees.
 Root node represents the “board” configuration at which a
decision must be made as to what is the best single move to
make next. (not necessarily the initial configuration)
 Evaluator function rates a board position.(a real number).
 Arcs represent the possible legal moves for a player (no costs
associated to arcs)
 Terminal nodes represent end-game configurations (the
result must be one of “win”, “lose”, and “draw”, possibly
with numerical payoff)
If it is my turn to move, then the root is labeled a "MAX"
node; otherwise it is labeled a "MIN" node indicating my
opponent's turn.
Each level of the tree has nodes that are all MAX or all
MIN; nodes at level i are of the opposite kind from those at
level i+1
Complete game tree: includes all configurations that can be
generated from the root by legal moves (all leaves are
terminal nodes)
Incomplete game tree: includes all configurations that can be
generated from the root by legal moves to a given depth
(looking ahead to a given steps)
 Evaluationfunction or static evaluator is used to evaluate the
"goodness" of a game position.
 Evaluation function is a heuristic function.
 The evaluation function is a estimate of the cost from the
start node to a goal.
 The zero-sum assumption allows us to use a single evaluation
function to describe the goodness of a board with respect to
both players.
 f(n) > 0: position n good for me and bad for you.
 f(n) < 0: position n bad for me and good for you
 f(n) near 0: position n is a neutral position.
 f(n) >> 0: win for me.
 f(n) << 0: win for you..
 f(n) = +1 if the position is a win
for X.
 f(n) = -1 if the position is a
win for O.
 f(n) = 0 if the position is a draw.
 Create start node as a MAX node with current board
configuration
 Expand nodes down to some depth (i.e., play) of
lookahead in the game.
 Apply the evaluation function at each of the leaf nodes
 Obtain the “back up" values for each of the non-leaf
nodes from its children by Minimax rule until a value is
computed for the root node.
 Pick the operator associated with the child node whose
backed up value determined the value at the root as the
move for MAX
 2

2 1 2 1

2 7 1 8 2 7 1 8 2 7 1 8

This is the move 2

Static evaluator selected by minimax
value
2 1
MAX

MIN
2 7 1 8
Representing the “board”.
Generating all legal next boards.
Evaluating a position.
Remembering the position.
Taking decision for the next step.
Remembering the chance.
Look ahead.
1. Generate the whole game tree.
2. Apply the utility function to leaf nodes to get their values.
3. Use the utility of nodes at level n to derive the utility of
nodes at level n-1.
4. Continue backing up values towards the root (one layer at a
time).
5. Eventually the backed up values reach the top of the tree, at
which point Max chooses the move that yields the highest
value. This is called the minimax decision because it
maximises the utility for Max on the assumption that Min
will play perfectly to minimise it.