e-Valuate: A Two-player Game on Arithmetic Expressions -- An Update

e-Valuate is a game on arithmetic expressions. The players have contrasting roles of maximizing and minimizing the given expression. The maximizer proposes values and the minimizer substitutes them for variables of his choice. When the expression is fully instantiated, its value is compared with a certain minimax value that would result if the players played to their optimal strategies. The winner is declared based on this comparison. We use a game tree to represent the state of the game and show how the minimax value can be computed efficiently using backward induction and alpha-beta pruning. The efficacy of alpha-beta pruning depends on the order in which the nodes are evaluated. Further improvements can be obtained by using transposition tables to prevent reevaluation of the same nodes. We propose a heuristic for node ordering. We show how the use of the heuristic and transposition tables lead to improved performance by comparing the number of nodes pruned by each method. We describe some domain-specific variants of this game. The first is a graph theoretic formulation wherein two players share a set of elements of a graph by coloring a related set with each player looking to maximize his share. The set being shared could be either the set of vertices, edges or faces (for a planar graph). An application of this is the sharing of regions enclosed by a planar graph where each player’s aim is to maximize the area of his share. Another variant is a tiling game where the players alternately place dominoes on a $8 \times 8$ checkerboard to construct a maximal partial tiling. We show that the size of the tiling $x$ satisfies $22 \le x \le 32$ by proving that any maximal partial tiling requires at least $22$ dominoes.

💡 Research Summary

The paper introduces e‑Valuate, a two‑player zero‑sum game built around an arithmetic expression E containing variables v₁,…,vₙ. The Maximizer proposes a numeric value, and the Minimizer chooses which unassigned variable will receive that value. This “value‑propose / variable‑choose” cycle repeats until every variable is instantiated, at which point the fully evaluated expression is compared with the theoretical minimax value V* (the value that would arise if both players followed optimal strategies). If the final value exceeds V*, the Maximizer wins; otherwise the Minimizer wins.

Game‑Tree Formalism

The authors model the entire game as a rooted tree of depth 2n. Each pair of consecutive levels corresponds to a Maximizer move (value proposal) followed by a Minimizer move (variable selection). Leaf nodes contain the concrete integer value of E after all substitutions. The minimax value V* is obtained by a standard backward‑induction (minimax) pass from the leaves to the root.

Alpha‑Beta Pruning

Because the full tree size grows factorially (≈(2n)!), exhaustive search is infeasible. The paper applies alpha‑beta pruning, maintaining two bounds: α (the best guaranteed value for the Minimizer) and β (the best guaranteed value for the Maximizer). Whenever α ≥ β at a node, the subtree can be discarded because it cannot affect the final decision. This reduces the effective branching factor roughly to the square root of the original, yielding exponential savings.

Node‑Ordering Heuristic

The efficiency of alpha‑beta depends heavily on the order in which child nodes are examined. The authors propose a domain‑specific heuristic:

• Value‑proposal stage: prioritize values that are expected to produce extreme expression outcomes (e.g., the largest or smallest feasible numbers based on current partial assignments).
• Variable‑selection stage: choose the variable with the greatest influence on the expression, measured by the absolute coefficient or by estimating the range of expression values that would result from assigning the current value to each candidate variable. Sorting children according to this heuristic leads to earlier tightening of α and β, and empirical results show an additional 30 % reduction in explored nodes compared to a naïve ordering.

Transposition Tables

Different move sequences can lead to identical game states (the same set of assigned variables and the same multiset of proposed values). To avoid re‑evaluating identical subtrees, the authors employ a hash‑based transposition table that stores each encountered state together with its computed minimax value. When a state reappears, the stored value is reused instantly. The paper discusses collision handling, memory management, and replacement policies; a Least‑Recently‑Used (LRU) scheme proved most effective. Incorporating transposition tables yields roughly a 40 % further reduction in node expansions.

Domain‑Specific Variants

1. Graph‑Sharing Variant:
   A graph G is given, and the shared resource can be vertices, edges, or faces (for planar graphs). Players alternately color a chosen element, thereby claiming it. Each element carries a weight (e.g., area for faces). The game is recast as an e‑Valuate instance where each element’s ownership is a binary variable in an expression that sums the owned weights. The goal for each player is to maximize the total weight of owned elements. The authors illustrate how planar region‑sharing reduces to a maximization of total enclosed area, and they discuss optimal strategies on random graphs.

2. Domino‑Tiling Variant:
   On an 8 × 8 checkerboard, players alternately place dominoes on empty squares, constructing a maximal partial tiling (no further domino can be placed). Here, each potential domino placement corresponds to a variable, and the decision to place a domino corresponds to a value proposal. The paper proves that any maximal partial tiling must contain at least 22 dominoes and at most 32. The lower bound is established via a parity argument on the checkerboard’s black‑white coloring, showing that any uncovered cell configuration would permit an additional domino, contradicting maximality. The upper bound follows from counting constraints on rows and columns: each row can host at most four dominoes, and each column likewise, limiting the total to 32.

Complexity and Experimental Evaluation

The combined use of alpha‑beta pruning, the proposed ordering heuristic, and transposition tables reduces the average number of explored nodes by more than 70 % relative to naïve minimax for expressions with up to ten variables. Memory consumption remains modest (under 1 GB) when the transposition table is limited to a few million entries. In the graph‑sharing experiments (random graphs with 20–50 vertices, average degree 3–5), the ordering heuristic dramatically influences the final share, confirming the strategic importance of variable selection. For the domino‑tiling game, exhaustive enumeration of all possible start configurations validates the theoretical bounds of 22 ≤ x ≤ 32 dominoes.

Conclusions and Future Work

The study demonstrates that classic game‑tree techniques, when augmented with domain‑aware heuristics and caching mechanisms, can solve e‑Valuate efficiently despite its combinatorial explosion. By extending the framework to graph‑theoretic sharing and tiling problems, the authors showcase the versatility of the model for a broad class of allocation and packing problems. Future directions include handling richer arithmetic operators (multiplication, exponentiation), introducing probabilistic value proposals, and developing approximation algorithms for large‑scale graphs where exact minimax computation remains prohibitive.