COMPUTATIONAL GAME STUDY · 2026-10-22
Honey Islands Battle is Solved
A two-player game in which the players narrow down the 1,304,983 solutions of a logic puzzle. The first player wins, both under the standard rule and under the redundant-hint rule.
Abstract
Honey Islands is a hexagonal logic puzzle on 61 cells. Its puzzle space has exactly 1,304,983 solutions. In Honey Islands Battle two players alternately place black stones on undetermined cells; each stone discards the solutions in which that cell is white, and the player whose stone leaves exactly one solution wins. We solve the initial position under two rules. Under the standard rule the first player wins; 42 of the 61 first moves win. Under the redundant-hint rule, where stones may also go on cells already determined black, the first player wins with every first move.
The key observation is that a position is determined by its set of determined-black cells, which gives an exact, symmetry-reducible transposition key. We solved all 3,122 symmetry-distinct positions after three moves with a bitset negamax solver and backed the values up to the root (58.8 billion search nodes, 121.7 CPU-hours for the standard rule; 2.65 billion, 7.0 CPU-hours for the redundant-hint rule). An independently written checker confirms the result under the redundant-hint rule from the root down. Beyond the book, the solver recomputed a winning move in at most about 20 minutes in sampled games, and we argue that the game is weakly solved in the sense of Allis. Solved under identical settings, a depth-3 position needs about a quarter of the search nodes under the redundant-hint rule (geometric mean 0.27 over a stratified sample of 102 positions). Along perfect play sampled from the game tree, winning moves are 3.3 times as dense for the first player from move 5 on.
First player wins (standard rule: 42 of 61 first moves; redundant-hint rule: all 61)
1. Introduction
Every logic puzzle with a fixed board has a set of solutions. Hints narrow that set down; a well-posed puzzle ends with exactly one. Honey Islands Battle turns that process into a game: the players supply the hints. It is a game of pure information with no hidden state and no chance, so it has a definite value. Determining that value is what it means to solve a game [1]; a recent example is Othello [2].
The puzzle and its complete solution set come from the author's Honey Islands real-time solver (ハニーアイランドリアルタイムソルバ), which enumerates all solutions. This study takes that set as given (Section 6 lists the checks we ran on it) and contributes:
- the values of the initial position and of every first move under two rules;
- a proof that the determined-black mask is an exact position key, which makes the game tractable;
- an independent re-solve of the proof under the redundant-hint rule;
- an estimate of the number of positions (about 1011);
- a comparison of the two rules: exact values near the root, the density of winning moves along sampled perfect play, and the cost of solving the same positions;
- a WebAssembly game and analysis tool that uses the opening book.
2. Rules
2.1 The puzzle space
The board is a hexagon of radius 4: 61 cells. A solution colors 25 cells black so that the white cells form six islands of six cells each. There are 1,304,983 solutions, and the set is closed under the 12 symmetries of the hexagon.
2.2 Standard rule
Let S be the set of solutions still possible; initially all of them. A cell is determined black if it is black in every solution of S, determined white if it is white in every one, and undetermined otherwise. On their turn a player places a black stone on an undetermined cell c, and S becomes {s ∈ S : c is black in s}. Each stone is one move (one ply), and moves are numbered from 1. The player whose stone makes |S| = 1 wins; equivalently, the player to move in a position with one solution has lost. A legal move never empties S, and the game ends after at most 61 moves.
2.3 Redundant-hint rule
Stones may also be placed on determined-black cells that carry no stone yet. Such a stone is a redundant hint: it leaves S unchanged and in effect only passes the turn. The number of redundant hints available is p = |D(S)| − (stones placed), where D(S) is the set of determined-black cells and every stone on the board counts, redundant hints included. A regular move that determines k cells besides its own raises p by k; a redundant hint lowers it by one. Stones on determined-white cells remain illegal, since they would leave no solution.
Standard rule
Redundant-hint rule
stone (move number) determined black determined white undetermined
3. Positions
Proposition. Let D = D(S) be the determined-black mask of a reachable set S. Then S = {s : D ⊆ s}, where s ranges over all solutions and is identified with its set of black cells.
Proof. A reachable S is {s : T ⊆ s} for the set T of stones placed. Every s ∈ S contains D by definition of D. Conversely, T ⊆ D because every stone is black in every remaining solution, so any s ⊇ D contains T and lies in S. ∎
Both players have the same moves, so the value of a position for the player to move depends only on S (and p), not on which player is to move. Consequently D is an exact transposition key for the standard rule, and (D, p) for the redundant-hint rule. Different stone sets that determine the same cells merge.
Lemma. For each symmetry g of the hexagon, the positions D and g(D) (with the same p) have the same value.
Proof. The solution set is closed under g, so g maps {s : D ⊆ s} bijectively onto {s : g(D) ⊆ s}. It maps undetermined cells to undetermined cells and determined-black cells to determined-black cells, hence legal moves to legal moves, and it preserves |S| and p. The claim follows by induction on (|S|, p) in lexicographic order: a regular move decreases |S|, and a redundant hint keeps |S| and decreases p. ∎
Positions related by a symmetry therefore merge as well: we use the smallest of the 12 images of D, computed with byte lookup tables, as the canonical key. After three moves there are 3,122 canonical positions under both rules. Under the redundant-hint rule exactly one of them has a redundant hint available.
4. Method
4.1 Solver
The solver is an exact win/loss negamax in Rust. At the start of a job it re-indexes the job's own solutions and stores, for each cell, a bitset of the solutions in which that cell is black. A sub-position is a sparse list of bitset words, kept in one scratch region per search depth, and a child is obtained with a bitwise AND. Cell counts are popcounts. Two simple rules prune the search. A child with one solution is an immediate win. A child with two solutions is never played, because the opponent then wins at once. The remaining moves are tried smallest child first. Values are cached in a lock-free transposition table shared by all threads of a process, keyed by the canonical mask.
4.2 Opening-book decomposition
We enumerated every position up to depth 3 together with the edges between them, and solved each of the 3,122 depth-3 positions as an independent job. Values were backed up by negamax: a position wins if and only if some child loses. While solving, the values of large positions (at least 3,000 solutions) were exported. These files were merged every 30 minutes and distributed to all workers, so machines did not re-solve each other's sub-positions. Once the root was decided, positions it no longer needed were postponed, and the rest were ordered by proof numbers. All 3,122 positions were still solved to complete the book.
4.3 Computation
The standard rule ran on 2026-10-22 on two home PCs and two cloud virtual machines that had spare capacity. It took 121.7 CPU-hours and 58.8 billion search nodes, and 3,523,789 large positions were shared between machines. The redundant-hint rule ran afterwards on one home PC: 7.0 CPU-hours and 2.65 billion nodes, with 203,010 shared positions.
Standard rule: depth-3 positions by machine (machine names withheld). Wall-clock time was about 3.3 hours from the first progress record to completion.
| Machine | Positions solved | CPU-hours | Nodes (billions) |
|---|---|---|---|
| Home PC A | 1,670 | 30.2 | 25.59 |
| Home PC B | 255 | 16.6 | 5.98 |
| Cloud VM A | 610 | 34.0 | 14.36 |
| Cloud VM B | 587 | 40.8 | 12.84 |
| total | 3,122 | 121.7 | 58.77 |
| Redundant-hint rule (Home PC A) | 3,122 | 7.0 | 2.65 |
5. Results
Values by depth (canonical positions; “win” = the player to move wins)
| Depth | Positions | Standard: win / loss | Redundant-hint rule: win / loss |
|---|---|---|---|
| 0 (initial) | 1 | 1 / 0 | 1 / 0 |
| 1 | 9 | 3 / 6 | 0 / 9 |
| 2 | 180 | 175 / 5 | 180 / 0 |
| 3 | 3,122 | 2,650 / 472 | 137 / 2,985 |
Under the standard rule, 6 of the 9 canonical first moves win for the first player. Over the 61 cells these are 42 winning and 19 losing first moves. Under the redundant-hint rule, every first move wins. After any reply, the first player can again move to a lost position: 95.6% of all depth-3 positions are lost for the player to move.
results/<rule>/m4/ (move 4).5.1 A perfect-play line
Because the value of every position on the way is known, perfect play can be read off directly: the winning side always plays a move that keeps the win, and for the losing side every move loses. Many such lines exist, so we pick one with a tie-break that makes it short and easy to follow. While more than 3,000 solutions remain, the winner plays the winning move that leaves the fewest solutions and the loser the move that keeps the most. From 3,000 solutions down, an exact game-length search decides: the winner finishes as fast as possible and the loser resists as long as possible. (This search agrees with plain minimax on 160 small positions.)
Under the standard rule the first player wins in 19 plies. The game-length search takes over at move 6, with 968 solutions; from there each move removes only a few solutions. Under the redundant-hint rule the first player wins in 23 plies. Move 7 cuts 220 solutions to 4 and determines 14 black cells besides its own. The next 14 moves are all redundant hints, played alternately, and then two regular moves finish the game (animated in Section 2; data: standard, redundant-hint rule, hib pv2). The four solutions remain throughout the redundant hints. After them the second player is to move with four solutions and no redundant hint left, a lost position. Such long runs of redundant hints are a product of this tie-break; they are rare in sampled perfect play (Section 7.2).
5.2 Game size
Number of positions. By the Proposition of Section 3, a position under the standard rule is a cell set D that is the intersection of a nonempty family of solutions, and every such set is reachable by placing its cells as stones. We estimated the number of these sets with Knuth’s estimator [12] on the Close-by-One enumeration tree [13], using importance sampling (a child is chosen with probability proportional to its number of solutions times 20.15m, where m is the number of cells the Close-by-One order still allows it to add) and 14,000 random root-to-leaf walks. Positions are counted without symmetry reduction.
Number of positions under the standard rule by solutions left (tools/analysis/count_positions.py; data)
| Solutions left | Positions | Standard error |
|---|---|---|
| 100,000 or more | 62,031 (exact) | – |
| 10,000–99,999 | 4.4 × 107 | 0.2 × 107 |
| 1,000–9,999 | 2.9 × 109 | 0.2 × 109 |
| 100–999 | 2.5 × 1010 | 0.2 × 1010 |
| 10–99 | 5.7 × 1010 | 1.2 × 1010 |
| 2–9 | 1.7 × 1010 | 1.1 × 1010 |
| 2 or more | 1.0 × 1011 | 0.2 × 1011 |
| 1 (game over) | 1,304,983 (exact) | – |
We checked the estimator in two ways. On three random subsets of 300–400 solutions, exact enumeration and the estimate agree (z = +0.43, −0.40, +0.22). On the full solution set, an exact count of the positions with at least 100,000 solutions gives 62,031, against an estimate of 62,611 ± 2,000. The relative standard error is 19% for the total and largest for positions with few solutions. Under the redundant-hint rule a position also carries p, so its number of positions is at least as large; we did not estimate it.
Game length. To measure the size of the game we played 20,000 random games under each rule, choosing every legal move with equal probability (a redundant hint counts as one move). Under the standard rule a game lasts on average 11.23 plies (median 11; 90% of games take 8–14 plies; range 6–19). Under the redundant-hint rule it lasts 12.61 plies (median 12; 9–18; range 5–25), with 1.40 redundant hints per game. The number of legal moves stays near 61 for the first six plies, then falls quickly as the solutions run out; redundant hints keep it higher late in the game. The number of distinct positions after 1, 2 and 3 moves is 9, 180 and 3,122 up to symmetry (the table above).
Mean number of legal moves by ply in random games (hib gamesize; data)
| Ply | 0 | 4 | 6 | 8 | 10 | 12 | 14 | 16 | 18 |
|---|---|---|---|---|---|---|---|---|---|
| Standard | 61.0 | 57.0 | 53.9 | 42.6 | 26.0 | 15.3 | 10.3 | 8.6 | 6.0 |
| Redundant-hint rule | 61.0 | 57.0 | 53.9 | 44.3 | 30.1 | 20.3 | 15.2 | 12.0 | 9.6 |
Plies to the end of the game
| Standard | Redundant-hint rule | |
|---|---|---|
| random games (mean of 20,000) | 11.23 | 12.61 |
| perfect play sampled from the game tree (mean of 200, Section 7.2) | 10.51 [10.25, 10.77] | 10.87 [10.58, 11.17] |
| the perfect-play line of Section 5.1 | 19 | 23 |
In sampled perfect play the game lasts 7–17 plies under the standard rule and 7–19 under the redundant-hint rule, always an odd number since the first player wins. The means of the two rules differ by 0.36 plies, and their 95% intervals overlap. Sampled perfect games are about one ply shorter than random games under the standard rule and 1.7 plies shorter under the redundant-hint rule, where random players use 1.40 redundant hints per game against 0.10 in sampled perfect play.
5.3 Solution class
Allis [1] distinguishes three levels. A game is ultra-weakly solved if the value of the initial position is known, weakly solved if a strategy that achieves this value from the initial position is known for both players under reasonable resources, and strongly solved if such a strategy is known from every legal position.
The computation of Section 4 gives more than the value. For every reply of the second player, the book names a first-player move to a depth-3 position that the solver proved lost for the player to move, and each such proof is a complete search of that position’s subtree. A winning strategy for the first player is therefore fixed by the proof; beyond depth 3 it is not stored but recomputed by the solver when needed. For the second player, whose value is a loss, every strategy attains that value.
We measured the cost of this recomputation in the 715 sampled games of Section 7.2. At each winning position the solver valued every move, which is more work than finding one winning move. The shared table of Section 4 was loaded, and the transposition table was kept across the ten games of a run; the times are for one thread of a desktop CPU (AMD Ryzen 9 9950X).
Time to value every move of a winning position in sampled games (data)
| Positions | Standard: median / max | Redundant-hint rule: median / max |
|---|---|---|
| first winning position outside the book (move 5; move 4 after an error at move 3) | 12.6 s / 20.4 min | 5.7 s / 6.2 min |
| all later winning positions | 0.001 s / 78 s | 0.001 s / 31 s |
In this operational sense the game is weakly solved: the first player’s winning strategy is not tabulated, but in our samples it was executed in at most about 20 minutes per move. These are sample maxima, not a worst-case bound. We did not attempt a strong solution.
6. Verification
Independent checker. verify/ is a second solver written from the rules alone. It does not depend on or copy the main engine and uses only the Rust standard library. It uses no symmetry and no shared tables, and keys its table by the raw mask D (or D, p). Its own tests compare it with a plain recursive reference on 200 random small positions per rule.
Redundant-hint rule: confirmed. From the book values we chose a proof set: for each depth-1 position, one losing child where one suffices, all children where all are needed, down to depth 3. This gave 164 depth-3 positions. The checker re-solved all 164: every value agrees, and from them alone it follows that the initial position and all nine depth-1 positions have the book's values (570 million nodes, 4.4 minutes on one thread).
Standard rule: partial. The corresponding proof set has 201 positions. The checker agreed on all 71 it finished before we stopped it. Without shared tables and symmetry it was about 47 times slower than the book solve, so the full check would have taken several days on the capacity available. The standard-rule result therefore rests on the main solver. Within the main computation, 601 depth-3 positions were solved twice in separate runs after jobs were reassigned, and every pair agrees. We cross-checked the main solver against a JavaScript reference solver on small positions, and the main solver's mode for the redundant-hint rule against a plain reference implementation on 13 small positions.
Data. The solution file was converted from the real-time solver's output. Its count, the 25/6×6 structure and its closure under the 12 symmetries were checked (tools/convert.py, tools/symcheck.py).
7. Comparing the two rules
7.1 Exact values near the root
Through depth 3 the two rules have the same moves and the same positions; a redundant hint first becomes available at depth 3, in one of the 3,122 positions. The values nevertheless differ, because redundant hints become available later in the game. At depth 3 the value differs in 2,537 positions (81%).
Depth-3 positions by value under each rule (“win” = the player to move, here the second player, wins; tools/analysis/exact_shallow.py)
| Redundant-hint rule: win | Redundant-hint rule: loss | |
|---|---|---|
| Standard: win | 125 | 2,525 |
| Standard: loss | 12 | 460 |
The share of winning moves differs as well. At move 1, 42 of 61 moves win under the standard rule and all 61 under the redundant-hint rule. At move 2 the second player has winning moves only under the standard rule: 23 of the 180 moves in the three winning depth-1 positions. At move 3, over all winning depth-2 positions, 15.1% of the moves win under the standard rule (1,555 of 10,325) and 95.4% under the redundant-hint rule (10,131 of 10,620).
7.2 Perfect play sampled from the game tree
Beyond depth 3 we sampled games from the perfect-play tree. At a winning position the player to move chooses uniformly among the moves that keep the win; at a losing position, uniformly among all moves. Moves that lead to the same position (the same D, and under the redundant-hint rule the same p) count as one move. Every move of every winning position on the path is valued exactly by the solver (hib ppgames). In these games the first player is always the winning side. To observe the second player as the winning side, we also sampled games in which the first player makes one error at move 3, chosen uniformly among its losing moves, and both players play perfectly afterwards. We sampled 200 games of each kind under each rule. Under the redundant-hint rule, 85 of the 200 error games were discarded because move 3 had no losing move; the remaining 115 are conditioned on such a move existing, so the second-player rows of the two rules are not directly comparable. Intervals are 95% bootstrap intervals over games.
Share of winning moves at winning positions, by move number (tools/analysis/pp_stats.py; perfect play, error at move 3). Move 1 is exact.
| Move | Winning side | Standard | Redundant-hint rule |
|---|---|---|---|
| 1 | first | 0.689 | 1.000 |
| 3 | first | 0.170 [0.156, 0.185] | 0.954 [0.945, 0.963] |
| 5 | first | 0.078 [0.071, 0.085] | 0.509 [0.477, 0.540] |
| 7 | first | 0.069 [0.064, 0.074] | 0.189 [0.173, 0.205] |
| 9 | first | 0.081 [0.074, 0.090] | 0.123 [0.111, 0.138] |
| 11 | first | 0.121 [0.105, 0.140] | 0.156 [0.135, 0.182] |
| 13 | first | 0.236 [0.172, 0.335] | 0.277 [0.212, 0.373] |
| 5 and later | first | 0.084 [0.080, 0.087] | 0.275 [0.262, 0.289] |
| 4 | second | 0.043 [0.039, 0.047] | 0.020 [0.018, 0.021] |
| 6 | second | 0.063 [0.058, 0.068] | 0.093 [0.080, 0.107] |
| 8 | second | 0.066 [0.060, 0.072] | 0.108 [0.093, 0.124] |
| 10 | second | 0.103 [0.088, 0.120] | 0.129 [0.106, 0.157] |
| 12 | second | 0.164 [0.125, 0.208] | 0.186 [0.116, 0.319] |
| 6 and later | second | 0.077 [0.073, 0.081] | 0.105 [0.095, 0.114] |
Under the standard rule, 4–8% of the moves keep the win at moves 4–9; the share rises toward the end of the game, when few moves remain. Under the redundant-hint rule nearly all moves win at moves 1 and 3, and the share falls to 12–19% by moves 7–9. From move 5 on, winning moves are 3.3 times as dense for the first player as under the standard rule, and from move 6 on 1.4 times as dense for the second player. The exception is move 4, the second player’s first winning position, where the share is 2.0% under the redundant-hint rule against 4.3% under the standard rule.
Redundant hints in perfect play. In the 200 sampled perfect-play games under the redundant-hint rule, 20 redundant hints were played, in 13 games (6.5% [3.5%, 10.0%]): 13 by the winner and 7 by the loser. In 216 winning positions a redundant hint was available; it was a winning move in 33 of them and the only winning move in 9.
7.3 Cost of solving the same positions
The main computation used 2.65 billion nodes for the redundant-hint rule against 58.8 billion for the standard rule. This ratio does not compare like with like: the two runs used different shared tables, job orders and machines. We therefore solved a sample of depth-3 positions under both rules with identical settings: a fresh transposition table of 224 entries for each solve, symmetry reduction, no shared table and one thread (hib isocost, AMD Ryzen 9 9950X). The 3,121 depth-3 positions without a redundant hint were stratified by their pair of values, and up to 30 were drawn at random from each stratum.
Paired solving cost at depth 3 (“win” = the player to move wins; tools/analysis/iso_stats.py; data). The node ratio is the geometric mean of redundant-hint-rule nodes over standard-rule nodes. The win/win stratum has 124 positions here because the one depth-3 position with a redundant hint is excluded.
| Standard / redundant-hint rule | Positions | Sampled | Node ratio [95%] | Fewer nodes under the redundant-hint rule | Median seconds (standard / redundant-hint) |
|---|---|---|---|---|---|
| win / win | 124 | 30 | 0.36 [0.21, 0.61] | 23 / 30 | 2.5 / 1.7 |
| win / loss | 2,525 | 30 | 0.38 [0.24, 0.63] | 24 / 30 | 10.6 / 10.9 |
| loss / win | 12 | 12 | 0.014 (all 12) | 12 / 12 | 160 / 3.4 |
| loss / loss | 460 | 30 | 0.036 [0.031, 0.043] | 30 / 30 | 368 / 21 |
The redundant-hint rule needed fewer nodes in 89 of the 102 positions. At positions won for the player to move under the standard rule, it needed 2.6–2.8 times fewer nodes. At positions lost under the standard rule, where every move must be refuted, it needed 28–71 times fewer. Weighted by stratum size, the geometric-mean ratio is 0.27. Time follows nodes except in the win/loss stratum, where the medians are equal because the redundant-hint rule spends more time per node. The slowest solve took 33 minutes under the standard rule and 90 seconds under the redundant-hint rule.
These measurements do not identify a cause. They are consistent with the denser winning moves of Section 7.2: a search at a winning position stops at the first winning move found, and refuting a lost position consists of such searches below each of its moves.
8. AI and opening book
Search. Random playouts do not predict the exact value. From each of the 3,122 depth-3 positions we ran 200 random playouts, choosing every legal move with equal probability as in Section 5.2, and used the share won by the player to move as a predictor of the exact value. The AUC was 0.51 [0.49, 0.54] under the standard rule and 0.45 [0.40, 0.50] under the redundant-hint rule, where 0.5 is chance (hib playauc, tools/analysis/playout_auc.py; data). Playing strength therefore comes from exact solving rather than from Monte Carlo tree search. The AI spends most of its time proving moves smallest child first, and uses an MCTS-Solver [3] for the rest. The Rust/WebAssembly engine solves about 3.6 times faster than our earlier JavaScript engine. Against the earlier AI it scored 25/48 at 1 second per move and 15/20 at 3 seconds.
Book. The AI first checks a book of 222,865 positions for the standard rule (2.2 MB) and 71,721 for the redundant-hint rule (0.7 MB). The book holds every position up to depth 3, the winning depth-4 replies, and the shared positions with at most five determined-black cells. If some move leads to a recorded loss for the opponent, the AI plays it at once, choosing at random among such moves. When the opponent moves after a lost depth-3 position, the book holds a winning reply in 87% of cases under the standard rule and 57% under the redundant-hint rule; allowing six cells barely changes this. With the book, the AI as first player won 5 of 5 games against the same AI without the book under both rules (1 second per move). As second player it won 3 of 5. These are small samples.
Reproducibility
export CARGO_TARGET_DIR="$PWD/rust/target"
cargo test --release --offline --manifest-path rust/Cargo.toml
cargo build --release --offline --manifest-path rust/Cargo.toml
cargo test --release --offline --manifest-path verify/Cargo.toml
tools/build-wasm.sh && npm test
# independent check of the redundant-hint-rule proof set (about 5 minutes)
verify/target/release/hibverify solve pass results/pass/verify-proofset-jobs.txt /tmp/res.txt 1
python3 tools/analysis/verify_compare.py results/pass /tmp/res.txt
# Sections 5.2, 5.3 and 7 (arguments are described at the top of each script)
python3 tools/analysis/count_positions.py estimate
python3 tools/analysis/exact_shallow.py
rust/target/release/hib ppgames <known> analyze/data/book-normal.bin 10 <seed>
rust/target/release/hib isocost results/pp/iso-jobs.txt
python3 tools/analysis/pp_stats.py results/pp/normal.txt results/pp/pass.txt
python3 tools/analysis/iso_stats.py results/pp/iso-jobs.txt results/pp/isocost.txthib ppgames takes RULE=pass for the redundant-hint rule (with book-pass.bin) and ERR_PLY=2 for an error at move 3. <known> is the table of large positions shared during the main computation (58 MB, not included); with an empty file the games and values are the same and only the times change.
Results: results/<rule>/positions.txt (positions up to depth 3), edges.txt, depth3-results.txt (key, value, winning move, solutions, ms, nodes, stones), winkeys.txt, and the verifier outputs.
References
- L. V. Allis. Searching for Solutions in Games and Artificial Intelligence. PhD thesis, University of Limburg, 1994.
- H. Takizawa. Othello is Solved. arXiv:2310.19387, 2023.
- M. H. M. Winands, Y. Björnsson, J.-T. Saito. Monte-Carlo Tree Search Solver. Computers and Games, 2008.
- R. Gasser. Solving Nine Men’s Morris. In Games of No Chance, MSRI Publications 29, 1996.
- J. W. Romein, H. E. Bal. Solving the Game of Awari using Parallel Retrograde Analysis. IEEE Computer 36(10), 2003.
- J. Schaeffer et al. Checkers Is Solved. Science 317, 2007.
- DOSELLO is Solved. wand125.github.io/solving-dosello, 2026.
- G. McGuire, B. Tugemann, G. Civario. There is no 16-Clue Sudoku: Solving the Sudoku Minimum Number of Clues Problem via Hitting Set Enumeration. Experimental Mathematics 23(2), 2014. arXiv:1201.0749.
- S. McCoy, N. Sieben. Impartial Achievement Games on Convex Geometries. arXiv:2010.11319.
- D. Grier. Deciding the Winner of an Arbitrary Finite Poset Game is PSPACE-Complete. arXiv:1209.1750.
- T. J. Schaefer. On the Complexity of Some Two-Person Perfect-Information Games. Journal of Computer and System Sciences 16, 1978.
- D. E. Knuth. Estimating the Efficiency of Backtrack Programs. Mathematics of Computation 29, 1975.
- S. O. Kuznetsov. A Fast Algorithm for Computing All Intersections of Objects from an Arbitrary Semilattice. Nauchno-Tekhnicheskaya Informatsiya, Ser. 2 27(5), 1993.