Der-Johng Sun

Job-level proof-number search for connect6

This paper proposes a new approach for proof number (PN) search, named job-level PN (JL-PN) search, where each search tree node is evaluated or expanded by a heavy-weight job, which takes normally over tens of seconds. Such JL-PN search is well suited for parallel processing, since these jobs are allowed to be performed by remote processors independently. This paper applies JL-PN search to solving automatically several Connect6 positions including openings on desktop grids. For some of these openings, so far no human expert had been able to find a winning strategy. Our experiments also show that the speedups for solving the test positions are roughly linear, fluctuating from sublinear to superlinear. Hence, JL-PN search appears to be a quite promising approach to solving games.

Job-Level Proof Number Search

This paper introduces an approach, called generic job-level search, to leverage the game-playing programs which are already written and encapsulated as jobs. Such an approach is well suited to a distributed computing environment, since these jobs are allowed to be run by remote processors independently. In this paper, we present and focus on a job-level proof number search (JL-PNS), a kind of generic job-level search for solving computer game search problems, and apply JL-PNS to solving automatically several Connect6 positions, including some difficult openings. This paper also proposes a method of postponed sibling generation to generate nodes smoothly, and some policies, such as virtual win, virtual loss, virtual equivalence, flagging, or hybrids of the above, to expand the nodes. Our experiment compared these policies, and the results showed that the virtual-equivalence policy, together with flagging, performed the best against other policies. In addition, the results also showed that the speedups for solving these positions are 8.58 on average on 16 cores.

A Volunteer-Computing-Based Grid Environment for Connect6 Applications

This paper presents a volunteer-computing-based grid environment or called a desktop grid environment for Connect6 applications. The Connect6 application described in this paper is to let professional Connect6 players to develop or solve openings, based on two programs, NCTU6 and Verifier. NCTU6 is to make Connect6 moves, written by the team led by Wu [19][21]. NCTU6 Verifier (abbr. Verifier), modified from NCTU6, is to verify whether one player wins in a given game position, or to generate the defensive moves if not winning in the position. Since both NCTU6 and Verifier consume huge amount of computation resources and requires on-demand responses, we design a desktop grid environment that provides players with on-demand computing through dynamic resource provisioning. The underlying desktop grid achieves high throughput computing by harvesting the idle CPU times on desktop computers connected to the Internet.

Solving the Slitherlink Problem

Slither link is one of challenging puzzle games to human and computer players. In this paper, we propose an efficient method to solve Slither link puzzles. After using this method, we can solve each of 10,000 25x30 puzzles given in [9] within 0.05 seconds. Without using the method, it takes at least 10 minutes to solve some of these puzzles.

Efficient online algorithm for identifying useless states in distributed systems

In a distributed system, detecting whether a given logical predicate is true on the global states is fundamental for testing and debugging the program. Detecting predicates by examining all global states is intractable due to the combinatorial nature of the problem. This work designs an efficient online algorithm that identifies the consistent and useless states each time a new state is reported. This paper formulates the optimality of detecting algorithms in terms of pseudo states, which are employed to represent unknown states to the monitor process. Based on this technique, memory space of the debugger can be minimized by removing the useless states without affecting the debugging results. While minimizing memory space, the proposed algorithm requires only O(p2M) time in total, where p is the number of processes, and M is the number of reported states.

HAPPYNURI wins the Nurikabe Tournament

0Table 1: The participants and final standings. The game Nurikabe is a kind of pencil puzzle introduced by Nikoli Inc. (1991), a Japanese puzzle magazine publisher. The game Nurikabe is played on a typically rectangular grid of cells that consists of one black and several white islands, each of which is a group of connected cells. In a Nurikabe puzzle, some cells initially contain numbers as shown in Figure 1(a), each of which indicates the size of the white island that contains the cell only and does not contain any other cells with numbers. These white islands are separated by one black island of which the cells cannot form a 2 x 2 square. Figure 1(a) shows one example of Nurikabe puzzle and Figure 1(b) shows its solution. Nurikabe has been shown to be NP-complete by McPhail (2003) and Holzer et al. (2004).

An Efficient Approach to Solving Nonograms

A nonogram puzzle is played on a rectangular grid of pixels with clues given in the form of row and column constraints. The aim of solving a nonogram puzzle, an NP-complete problem, is to paint all the pixels of the grid in black and white while satisfying these constraints. This paper proposes an efficient approach to solving nonogram puzzles. We propose a fast dynamic programming (DP) method for line solving, whose time complexity in the worst case is O(kl) only, where the grid size is l×l and k is the average number of integers in one constraint, always smaller than l. In contrast, the time complexity for the best line-solving method in the past is O(kl2). We also propose some fully probing (FP) methods to solve more pixels before running backtracking. Our FP methods can solve more pixels than the method proposed by Batenburg and Kosters (before backtracking), while having a time complexity that is smaller than theirs by a factor of O(l). Most importantly, these FP methods provide useful guidance in choosing the next promising pixel to guess during backtracking. The proposed methods are incorporated into a fast nonogram solver, named LalaFrogKK. The program outperformed all the programs collected in webpbn.com, and also won both nonogram tournaments that were held at the 2011 Conference on Technologies and Applications of Artificial Intelligence (TAAI 2011, Taiwan). We expect that the proposed FP methods can also be applied to solving other puzzles efficiently.