Semi-Strongly solved: a New Definition Leading Computer to Perfect Gameplay

Strong solving of perfect-information games certifies optimal play from every reachable position, but the required state-space coverage is often prohibitive. Weak solving is far cheaper, yet it certifies correctness only at the initial position and provides no formal guarantee for optimal responses after arbitrary deviations. We define semi-strong solving, an intermediate notion that certifies correctness on a certified region R: positions reachable from the initial position under the explicit assumption that at least one player follows an optimal policy while the opponent may play arbitrarily. A fixed tie-breaking rule among optimal moves makes the target deterministic. We propose reopening alpha-beta, a node-kind-aware Principal Variation Search/Negascout scheme that enforces full-window search only where semi-strong certification requires exact values and a canonical optimal action, while using null-window refutations and standard cut/all reasoning elsewhere. The framework exports a deployable solution artifact and, when desired, a proof certificate for third-party verification. Under standard idealizations, we bound node expansions by O(d b^(d/2)). On 6x6 Othello (score-valued utility), we compute a semi-strong solution artifact supporting exact value queries on R and canonical move selection. An attempted strong enumeration exhausts storage after exceeding 4x10^12 distinct rule-reachable positions. On 7x6 Connect Four (win/draw/loss utility), an oracle-value experiment shows that semi-strong certification is 9,074x smaller than a published strong baseline under matched counting conventions. Semi-strong solving provides an assumption-scoped, verifiable optimality guarantee that bridges weak and strong solving and enables explicit resource-guarantee trade-offs.

💡 Research Summary

The paper introduces “semi‑strong solving,” a new intermediate notion for perfect‑information, zero‑sum games that lies between the classic strong and weak solving concepts. Strong solving requires exact game‑theoretic values and optimal moves for every position reachable from the start, which quickly becomes infeasible for large state spaces. Weak solving, by contrast, only guarantees the value (and a strategy) for the initial position and a single optimal line, offering no formal guarantee when a human or another agent deviates from that line.

Semi‑strong solving defines a certified region R: the set of positions that can arise from the initial state under the explicit assumption that one designated player (the “optimal agent”) always follows a canonical optimal move (selected by a deterministic tie‑breaking rule), while the opponent (the “free agent”) may choose any legal move. Positions that require both players to deviate from optimal play are excluded from R. The region is defined separately for the case where the optimal agent moves first (R_first) and where it moves second (R_second); the final certified region is the union R = R_first ∪ R_second.

To compute a semi‑strong solution efficiently, the authors propose reopening alpha‑beta, a node‑kind‑aware variant of Principal Variation Search/Negascout. Each search node is labeled with a kind (P, A′, P′, C, A) that encodes a specific certification obligation:

• P‑nodes (principal‑variation capable) must be solved with a full window and must identify the canonical optimal move; all legal moves must be examined because the free agent could select any of them.
• A′‑nodes (optimal‑agent turn) also require a full‑window search and exact value, but only the canonical optimal move needs to be identified.
• P′‑nodes (free‑agent turn) must cover all legal moves without pruning, ensuring correctness under arbitrary opponent choices.
• C and A nodes correspond to ordinary cut/all reasoning where only sound bounds are needed.

The algorithm performs full‑window searches only for nodes whose obligations demand exact values (P and A′). Everywhere else it uses null‑window searches to quickly refute moves. When a previously explored child becomes the principal variation (PV) due to α‑raising, the algorithm “reopens” that child with a full‑window search, guaranteeing that the final PV is exact. This selective reopening yields a theoretical node‑expansion bound of O(d·b^{d/2}) under the same perfect‑ordering assumptions that give classic α‑β its Θ(b^{d/2}) behavior; the extra factor d reflects the additional work needed to certify the region R.

Empirical evaluation is performed on two benchmarks:

1. 6×6 Othello (score‑difference utility). A full strong enumeration exhausts memory after exceeding 4 × 10^{12} rule‑reachable positions, while the semi‑strong solver stores only on the order of 10^{9} positions, yet provides exact values and canonical optimal moves for every position in R.
2. 7×6 Connect Four (win/draw/loss utility). Using an oracle for exact WDL values, the authors show that the number of positions required for semi‑strong certification is 9,074 times smaller than a published strong solution when counted under identical conventions.

The framework outputs two artifacts:

• A solution artifact – essentially a dumped transposition table – that supports exact value queries and canonical move extraction for any position in R.
• An optional proof certificate – additional logs or a full transposition‑table dump – enabling third‑party verification of the artifact’s correctness.

The authors argue that semi‑strong solving offers a practical, verifiable guarantee for AI agents that play optimally while humans (or other agents) may deviate arbitrarily. By making the certification scope explicit, developers can trade off memory and compute resources against the size of the guaranteed region, bridging the gap between weak and strong solving. The reopening‑alpha‑beta scheme demonstrates that this intermediate guarantee can be achieved with only modest overhead compared to standard α‑β search, making the approach suitable for real‑world game engines and for research that demands provable optimality within a controllable resource budget.