Most parallel game-tree search approaches use synchronous methods, where the work is concentrated within a specific part of the tree, or at a given search depth. This article shows that asynchronous game-tree search algorithms can be as efficient as or better than synchronous methods in determining the minimax value. APHID, a new asynchronous parallel game-tree search algorithm, is presented. APHID is implemented as a freely-available portable library, making the algorithm easy to integrate into a sequential game-tree searching program. APHID has been added to four programs written by different authors. APHID yields better speedups than synchronous search methods for an Othello and a checkers program, and comparable speedups on two chess programs.

In games like chess, the node-expansion strategy significantly affects the performance of a gameplaying program. In this article we propose a new game-tree search algorithm that uses the realization probabilities of nodes for deciding upon the range of the search. The realization probability of a node represents the probability that the moves leading to the node will actually be played. Our algorithm expands nodes as long as the realization probability of a node is greater than the threshold.

Abstract ProbCut is a selective-search enhancement to the standard alpha–beta algorithm for two–person games. ProbCut and its improved variant Multi–ProbCut (MPC) have been shown to be effective in Othello and Shogi, but there had not been any report of success in the game of chess previously. This paper discusses our implementation of ProbCut and MPC in the chess engine  ¢¡¤£¦¥¨§�©. Initial test results suggest that the MPC version of  ¢¡¤£¦¥¨§�© is stronger than the original version of  ¢¡¤£¦¥¨§�©: it searches deeper in promising lines and defeated the original ¢¡¤£¦¥¨§� © (59.4%) in a 64–game match. +22���������¨ � Incorporating MPC into  ¢¡¤£¦¥¨§� © £��¤� also increased its tournament � performance against another strong chess program: ’s speed chess tournament score went up from 51 % to 56%.

In this article we review standard null-move pruning and introduce our extended version of it, which we call verified null-move pruning. In verified null-move pruning, whenever the shallow null-move search indicates a fail-high, instead of cutting off the search from the current node, the search is continued with reduced depth. Our experiments with verified null-move pruning show that on average, it constructs a smaller search tree with greater tactical strength in comparison to standard null-move pruning. Moreover, unlike standard null-move pruning, which fails badly in zugzwang positions, verified null-move pruning manages to detect most zugzwangs and in such cases conducts a re-search to obtain the correct result. In addition, verified null-move pruning is very easy to implement, and any standard null-move pruning program can use verified null-move pruning by modifying only a few lines of code.

In this paper we demonstrate how genetic algorithms can be used to reverse engineer an evaluation function’s parameters for computer chess. Our results show that using an appropriate mentor, we can evolve a program that is on par with top tournament-playing chess programs, outperforming a two-time World Computer Chess Champion. This performance gain is achieved by evolving a program with a smaller number of parameters in its evaluation function to mimic the behavior of a superior mentor which uses a more extensive evaluation function. In principle, our mentor-assisted approach could be used in a wide range of problems for which appropriate mentors are available.

Abstract. In this paper we review the conventional versions of nullmove pruning, and present our enhancements which allow for a deeper search with greater accuracy. While the conventional versions of nullmove pruning use reduction values of R ≤ 3, we use an aggressive reduction value of R = 4 within a verified adaptive configuration which maximizes the benefit from the more aggressive pruning, while limiting its tactical liabilities. Our experimental results using our grandmasterlevel chess program, Falcon, show that our null-move reductions (NMR) outperform the conventional methods, with the tactical benefits of the deeper search dominating the deficiencies. Moreover, unlike standard null-move pruning, which fails badly in zugzwang positions, NMR is impervious to zugzwangs. Finally, the implementation of NMR in any program already using null-move pruning requires a modification of only a few lines of code. 1

This paper overviews the Cilk language, illustrating how Cilk supports the programming of parallel game-tree search and other chess mechanisms

Thomsen’s λ search and Nagai’s depth-first proofnumber (DFPN) search are two powerful but very different AND/OR tree search algorithms. Lambda Depth-First Proof Number search (LDFPN) is a novel algorithm that combines ideas from both algorithms. λ search can dramatically reduce a search space by finding different levels of threat sequences. DFPN employs the notion of proof and disproof numbers to expand nodes expected to be easiest to prove or disprove. The method was shown to be effective for many games. Integrating λ order with proof and disproof numbers enables LDFPN to select moves more effectively, while preserving the efficiency of DFPN. LDFPN has been implemented for capturing problems in Go and is shown to be more efficient than DFPN and more robust than an algorithm based on classical λ search.

In this paper we introduce a novel method for automatically tuning the search parameters of a chess program using genetic algorithms. Our results show that a large set of parameter values can be learned automatically, such that the resulting performance is comparable with that of manually tuned parameters of top tournament-playing chess programs. 1.

This paper demonstrates the use of genetic algorithms for evolving a grandmaster-level evaluation function for a chess program. This is achieved by combining supervised and unsupervised learning. In the supervised learning phase the organisms are evolved to mimic the behavior of human grandmasters, and in the unsupervised learning phase these evolved organisms are further improved upon by means of coevolution. While past attempts succeeded in creating a grandmasterlevel program by mimicking the behavior of existing computer chess programs, this paper presents the first successful attempt at evolving a state-of-the-art evaluation function by learning only from databases of games played by humans. Despite the underlying difficulty involved (in comparison to learning from chess programs), our results demonstrate that the evolved program outperforms a two-time World Computer