Abstract Proof Search
Studied by Tristan Cazenave
Surveyed by Akihiro Kishimoto
Outline
• Background
• Abstract moves
• Combination of Abstract Proof Search with
Alpha-Beta Search
• Experimental Results
• Conclusions
Motivations
• Current Go programs
– Selective search based on heuristics
• Drastically reduce branching factor
• Sometimes returns an incorrect answer
Is it possible to select moves safely while
improving the reliability of the search
results?
Contributions
• Abstract proof search
– Search complete and minimal sets of moves
– Always return correct results
– Much better results than basic alpha-beta search
in Atari Go (capture game)
Target Problem: Atari Go
• Capture marked stones
5-ply
9-ply
15-ply
Search Algorithm (1 / 2)
•
Alpha-Beta Search with 3 values +
enhancements
1. INFINITY: win for the player to move
•
•
String has more than 5 liberties and black to play
String is captured and white to play
2. -INFINITY: loss for the player to move
•
3. 0:
Opposite to the above
unknown
Search Algorithm (2 / 2)
• Enhancements:
–
–
–
–
–
Iterative deepening
Transposition table
Quiescence search
Null window search (not at the root)
History heuristic
Overview of Abstract Proof
Search
1. Generate “abstract moves” that can
modify the outcome of the search
–
c.f. lambda-search [Thomsen CG2000]
2. Do abstract analysis using 1
3. If it succeeds in 2, stop searching pass a
score back to the parent
4. Try all the moves if it fails in 2
Generating abstract moves
• What is an abstract move?
– A forced move that leads to a win/ prevents
from a loss
• Definition of game states:
– g: white wins what ever move black makes
– gi: white wins if white to play
– ip: gi if black passes (black has to prevent gi)
Example of Game States
How to generate abstract moves?
• Use the liberties of the string and dependencies
between game states
• E.g.
– abstract moves that can change ip1
liberty of the string or liberties of the adjacent strings
in atari
– g1 for white
ip1 game for black and still gi1 after each of the forced
black moves made
Dependency between Game
States
Combining with Alpha-Beta
Search (1 / 4)
• Do an abstract search before doing a
standard search
– OR node (white’s turn)
• Check if gi1, if not check if gi2, if not check if gi3
• One of gi works
white wins
• Otherwise try the moves associated to the position
Combining with Alpha-Beta
Search (2 / 4)
int Capturegi2() {
if (number of liberties == 2)
for each liberty l
if (LegalMove(l, white)) {
MakeMove(l, white);
if (Captureg1()) return 1;
UndoMove();
}
return 0;
}
Combining with Alpha-Beta
Search (3 / 4)
• At AND node (black’s turn)
– Check if ip1, ip2, or ip3
– None of them is verified
black wins
(I.e. enough liberties)
– Try moves associated to ip1, ip2, or ip3
• If it cannot prevent a capture, white wins
Combining with Alpha-Beta
Search (4 / 4)
int Captureip2(S) {
res = 0;
if (Capturegi2()) {
res = 1;
CompleteSetOfMovesToPreventgi2(S1);
for each move m of S1
if (LegalMove(m,black)) {
MakeMove(m,black);
if (!Capturegi1() and !Capturegi2()) add m to S;
UndoMove();
}
}
Note: S == empty && res == 2
return res;
}
 black loses
Experimental Results (1 / 2)
• Test suites:
– Graded Go problems for Beginners Volume 1-3
• Environment:
– K6-2 450MHz
Experimental Results (2 / 2)
• Performance on Volume 2 & 3
Conclusions
• Abstract proof search achieves excellent
results
– 6 times slower in terms of # of nodes per
second
– Much less node expansion that can pay the
price