- “Interesting alternatives to depth-first searching, such as breadth-first and best-first strategies, have been largely ignored in practice”
- SSS* is best-fist, while A-B is depth-first
- Here they dont use the name AB-SSS*, they call it MT-SSS*?
- “MTD can be used to construct a variety of fixed-depth best-first search algorithms using depth-first search.
- They say that the assumptions for SSS*’s dominance of A-B aren’t met in practice (due to move reordering and use of iterative deepening). Empirical results have A-B actually beating MT-SSS* in checkers at some plies for this reason
- Talk about significant differences between real-world, and synthetic game trees
- MTD(f) is the newest as of the time of writing. It beats a state of the art implementation of Negascout in terms of total nodes, leaves, and clock time. I think this is AB-SSS* or very very similar.
- They say the connection between A-B and SSS* starts with an upper bound on the minimax value, and the max-solution tree, which is the minimal search tree that proves an upper bound
- Most game playing programs use iterative deepening “It is based on the assumption that a shallow search is a good approximation of a deeper search.” “Among the benefits of iterative deepening (ID) in game-playing programs are better move ordering…, and advantages for tournament time control information.”
- “Transposition tables are often used in conjunction with iterative deepening to achieve a partial move ordering. The search value and the branch leading to the highest score (and best move) are saved for each node. When iterative deepening searches on level deeper and revisits nodes, the move suggested by the transposition table (if available) is searched first”
- Transposition tables are also used to recycle computation when it exists in a graph structure
- In emprical results they use very strong programs for comparisons, and modify them as little as possible
- The states from games used are states that acutally came up from tournament play; they mention sometimes states used are contrived
- They are concerned with node/leaf re-expansions, but in pure trees this isn’t an issue
- They say that in practice, memory actually isn’t an issue – and this was written a long time ago
- They keep referring to MT-SSS*, but I don’t see where its described explicitly…
- The MT (Memory-enhanced Test) framework allows depth-first procedures to implement best-first algorithms

Memory-enhanced Test: a Framework

- MT(n,gamma) = A-B(n, gamma-1, gamma) when using transposition tables
- One method is to start with gamma = inf and move down from there
- Talk about “drivers” for MT, which specify:
*n*: the root of the tree*first*: the starting bound for MT*next*: after the completion of a search, how the bounds are updated. This is a function.- MTD would be an algorithm using the MT framework. They list a number of instantiations of algorithms in the framework.
- AB-SSS* = MT-SSS* = MTD(
*n*,*inf*,*bound = g*) - Another searches from -inf, then one tries to do a binary search on the true minimax value, they call this MTD(bi)
- Mention an equivalent algorithm C* that is also guaranteed to dominate A-B
- Can also specify a specific step size to move the bounds by, called MTD(step)
- Say MTD(bi) and step seem inferior
- Transposition tables prevent waste of reexpansion
- MTD(f) is consistently the best algorithm. They say in practice in these agents, it actually uses less memory than A-B
- Says SSS*/MTD(inf) is optimistic (paper seems to be very inconsistent with names, which is even worse across papers
- DUAL*/MTD(-inf) is pessimistic
- and MTD(f) is realistic
- Difference between the algorithms is just a few percent, though (mainly because of the excellent move ordering and other tricks the game programs do aside from the searching itself)
- Number of nodes expanded in experiments depends on whether the number of plies is odd or even, which we didn’t see in our synthetic results
- If you have a guess as to what the minimax value actually will be, initializing the null window to around that area seems to help (for MTD(f))
- “…if MTD(f) is to be effective, the f obtained from the previous iteration must be a good indicator of the next iteration’s value”
- Keep in mind the empirical results are relative to very effective game programs that do excellent move ordering and other tricks
- Argue against reporting results on synthetic trees:
- Real trees have variable branching factor
- Value interdependence from parents to children – usually parent values are good predictors for children (a shallow search is a good approximation of a deeper one). This is probably why UCT can perform so well at Go.
- Existence of graph structure, allows for use of transposition table

Appendix on MT-SSS*

- Every top-level call to MT fails low and builds a max-solution tree. The last call to MT (stops the search) fails high and builds a min-solution tree
- In the first pass, the left-most solution tree with finite g-value (value of the tree rooted at specified node n) is constructed
- During following passes, the following conditions hold:
- Before each pass, the tree exposed is the left-most max solution tree with upper bound = gamma. The children to the left of the min node (child of the root) has already been searched and the lower bound on that subtree is > gamma
- During each pass, every node visited belongs to the max solution tree with upper bound = gamma. For min nodes, children to the left of the child of n (there is only one in the max-solution tree) has a lower bound > gamma and will never be revisited
- Whenever nested calls to MT(n, gamma) fail low, a max-solution tree is created where children of min-nodes have property 1