Pruning and Transposition Tables

PSU CS410/510GAMES Lecture 7
July 13, 2000

• Other Pruning Techniques
  • Quiescence search
    • Horizon Effect is classic problem; don't stop in middle of exchange and guess
    • Determine quiescence by seperate heuristics or by variance in root value
  • Principal Variation Search (PVS) = Korf: ``best-first minimax''
    • Idea: trust eval in interior of tree to prune ``bad'' moves early
    • Trick: always extend (leftmost) path determining root value (variant of AB)
    • Suffers from ``early mistake'' problem: fix by depth cutoff (common), weighting, sampling, etc.
• Transposition Tables
  • Game trees are graphs: e.g. Tic-Tac-Toe has
    • 9! = 362880 possible games
    • 3^9 = 6561 possible positions
  • Dynamic Programming: remember value of game states rather than rediscovering them; remove transpositions
    • Comparing game states expensive: use hash table
    • Any hash table implementation will do: quadratic, open, etc.
    • Tricks are available for fast hashing of game states
  • Problems
    • Must keep track of all the state: player on move, etc.
    • Some games are clocked, e.g. chess ``50-move'' rule
    • Not enough memory: need replacement strategy
  • Replacement strategies
    • FIFO (replace oldest): works for games with local loops
    • LIFO (replace newest): better in general, since leverage is best early
    • Random: models LFU, but harder to implement
    • ``Interesting'' = different from heuristic?
• Narrowing the window: zero-window search
  • Idea: fail to disprove AB window
  • If window wildly wrong, can quickly find subtree that proves it
  • Example: card games
  • MTD(f) (outline by Aske Plaat)
    • The narrower the AlphaBeta window, the more cutoffs you get, the more efficient the search is. Hence MTD(f) uses only search windows of zero size.
    • Zero window AlphaBeta calls return bounds. At the root of the tree the return bounds are stored in upperbound (after AlphaBeta ``failed low'') and lowerbound (after AlphaBeta ``failed high''). The bounds delimit the range of possible values for the minimax value. Each time MTD(f) calls AlphaBeta it gets a value back that narrows the range, and the algorithm is one step closer to hitting the minimax value.
    • Storing nodes in memory gets rid of the overhead inherent in multiple re-searches. A transposition table of sufficient size does the job.
    • It is more efficient to start the search close to its goal. Therefore MTD(f) needs (and can make use of) a good first guess.