AlphaBeta is not as good as you think: a simple class of synthetic games for a better analysis of deterministic game-solving algorithms

Deterministic game-solving algorithms are conventionally analyzed in the light of their average-case complexity against a distribution of random game-trees, where leaf values are independently sampled from a fixed distribution. This simplified model enables uncluttered mathematical analysis, revealing two key properties: root value distributions asymptotically collapse to a single fixed value for finite-valued trees, and all reasonable algorithms achieve global optimality. However, these findings are artifacts of the model’s design: its long criticized independence assumption strips games of structural complexity, producing trivial instances where no algorithm faces meaningful challenges. To address this limitation, we introduce a class of synthetic games generated by a probabilistic model that incrementally constructs game-trees using a fixed level-wise conditional distribution. By enforcing ancestor dependencies, a critical structural feature of real-world games, our framework generates problems with adjustable difficulty while retaining some form of analytical tractability. For several algorithms, including AlphaBeta and Scout, we derive recursive formulas characterizing their average-case complexities under this model. These allow us to rigorously compare algorithms on deep game-trees, where Monte-Carlo simulations are no longer feasible. While asymptotically, all algorithms seem to converge to identical branching factor (a result analogous to that of independence-based models), deep finite trees reveal stark differences: AlphaBeta incurs a significantly larger constant multiplicative factor compared to algorithms like Scout, leading to a substantial practical slowdown. Our framework sheds new light on classical game-solving algorithms, offering rigorous evidence and analytical tools to advance the understanding of these methods under a richer, more challenging, and yet tractable model.

💡 Research Summary

The paper revisits the average‑case analysis of deterministic two‑player zero‑sum game‑solving algorithms, exposing a fundamental flaw in the widely used “standard model”. In that model leaf values are drawn independently from a fixed distribution, which makes the mathematics tractable but eliminates any correlation among sibling nodes. As shown by Pearl, when the leaf domain is finite the root value collapses to a single constant as the tree height grows, causing all reasonable algorithms to achieve the same √b branching factor and rendering algorithmic comparisons meaningless.

To overcome this limitation the authors introduce the “forward model”. Starting from a root value x, each internal node generates b children: one “special child” is chosen uniformly and forced to inherit the negated parent value (‑x), guaranteeing the minimax constraint; the remaining b‑1 children are sampled from a level‑wise conditional distribution µ that is truncated according to the parent value. This construction injects ancestor‑dependent correlations that mimic the strategic continuity observed in real games such as chess or Go.

The paper provides a rigorous average‑case analysis for several classic algorithms under this model. First, for binary‑valued trees (win/loss) the SOLVE algorithm’s branching factor is derived as a closed‑form function t(q,b) where q is the Bernoulli parameter of µ. The analysis shows a smooth spectrum: q=1 yields the trivial √b case, q=0 reproduces the worst‑case O(b) branching factor, and intermediate q values give any desired difficulty level, something impossible in the standard model.

Next, the authors consider richer value sets {‑n,…,n} and study TEST, AlphaBeta, and Scout. They define the expected cost Iₓ,ₛ(h,c) for a node with value x, remaining children c, and threshold s, together with an auxiliary cost Jₓ,ₛ(h,c) conditioned on the “special child” already being identified. By carefully conditioning on whether the next examined child is special or normal, they derive recursive equations (7) and (8) that exactly capture the algorithmic dynamics under the forward model. These recursions enable the computation of average costs for trees up to depth h≈5000 without Monte‑Carlo simulation.

The main theoretical findings are twofold. Asymptotically (h→∞) all algorithms share the same branching factor r(b), which depends only on the chosen µ, mirroring the result of the independence‑based analysis. However, for finite depths the constant factors differ dramatically. AlphaBeta, because it must explore all siblings until the special child is found, incurs a multiplicative overhead of roughly 1.5–2× compared to Scout or a bisection‑based use of TEST. This explains why AlphaBeta can be slower in practice despite its optimal asymptotic √b bound.

Beyond analysis, the forward model offers a tunable difficulty knob: by adjusting µ’s truncation or categorical probabilities, researchers can generate benchmark trees of any desired hardness, something the standard model cannot provide. The authors release an open‑source codebase that implements the recursive formulas and allows exact average‑case evaluation for a wide range of parameters.

In conclusion, the work demonstrates that the independence assumption underlying traditional average‑case studies is an artifact that masks real algorithmic differences. The forward model restores structural dependencies while retaining analytical tractability, and it reveals that AlphaBeta is not universally optimal: in realistic, finite‑depth settings other algorithms can be substantially more efficient. This contribution supplies both a new theoretical framework and practical tools for the community to reassess and benchmark game‑solving algorithms under more realistic conditions.