Adversarial Search

Game-Playing

Searching in the presence of an adversary introduces uncertainty
Usually too hard to solve completely
Example: chess branching factor of ~ 35 with ~ 50 moves per player means that a typical search tree has ~ 35¹⁰⁰ nodes
Resource limits force us to approximate

Initial state
Operators
Terminal test
Utility function
Search tree must take into account the different perspectives of the two players (MAX and MIN). You (MAX) are trying to maximize your chances of winning while your opponent (MIN) is trying to minimize your chances of winning.
Utility function returns values from the perspective of MAX

Minimax Algorithm
Recursively call Minimax on each of the initial node's children and choose the move with the largest minimax value If a terminal node has been reached, apply utility function to node and return value If it is MAX's turn to move, recursively call Minimax on node's children and return the maximum of the resulting values If it is MIN's turn to move, recursively call Minimax on node's children and return the minimum of the resulting values

Minimax Algorithm

Recursively call Minimax on each of the initial node's children and choose the move with the largest minimax value
If a terminal node has been reached, apply utility function to node and return value
If it is MAX's turn to move, recursively call Minimax on node's children and return the maximum of the resulting values
If it is MIN's turn to move, recursively call Minimax on node's children and return the minimum of the resulting values

Example: Game of Nim

We use a static evaluation function instead of a utility function to estimate expected utility
Replace terminal test by a cutoff test
Example: material value of pieces in chess

eval(board) = 1 · Δ pawns + 3 · Δ bishops + 9 · Δ queens + ...
In general, eval(s) = w₁ · f₁(s) + w₂ · f₂(s) + ... + w_n · f_n(s) is a weighted linear sum
With 100 seconds and ability to explore 10,000 nodes/sec, we can examine 1,000,000 nodes per move, so b^d = 10⁶. If b = 35, d is slightly less than 4.
4-ply lookahead = human novice
8-ply lookahead = human master, typical PC
14-ply lookahead = Deep Blue, Kasparov
Another problem: cutting off search in non-quiescent states.
Example: White is up by a bishop, but will lose queen on the next move.

If you have an idea that is surely bad, do not take time to analyze just how bad it is.
Effectiveness of alpha-beta pruning depends on the ordering in which successor nodes are examined.
Worst case: O(b^d ) — no gain
Best case: O(b^d/2 ) — big gain, but still exponential
Effective branching factor is sqrt(b) instead of b
Alpha-beta can look twice as far ahead in the game tree as Minimax for the same cost
Example: chess goes from b ~ 35 to b ~ 6.
This can be the difference between playing a game at a novice level versus an expert level.

Typical-case example
- effective branching factor = 2.36
- number of static evaluations = 16
Best-case example
- effective branching factor = 2.11
- number of static evaluations = 11
No alpha-beta pruning (worst-case)
- effective branching factor = 3.0
- number of static evaluations = 27
Algorithm
Example trace of algorithm