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 Opposite to the above 3.0: 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(); } return res; } Note: S == empty && res == 2  black loses

Experimental Results (1 / 2) Test suites: –Graded Go problems for Beginners Volume 1-3 Environment: –K MHz

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