1 Overview

This lecture is concerned with search spaces that model parlor games such as go, chess, checkers, othello, andbackgammon. At an abstractlevel, weareconcerned with two-player, zero-sumgames ofperfectinformationinwhich theplayers’ movesaresequential. Adversarial search algorithmsare designed to return optimal paths, or winning strategies, through game trees, assuming the players are adversaries—rational and self-interested: i.e., they play to win.

2 Definition and Example

A game tree is a 7-tuple Γ = �P,X,S,T,δ,l,v�, where

• P is a set of n players
• X is a finite set of states
• S ⊆ X is a nonempty set of start states
• T ⊆ X is a nonempty set of terminal states
• δ : X → 2^X is a state transition function δ(x)is the set of successor states of x
• l : X → P labels state x with the player who moves at x
• v : T → [−1,1]ⁿ maps terminal states into real-valued vectors vi(x)∈ [−1,1] is the payoff to player i at state x

n

Zero-sumgamesrequirethat =0,forall x ∈ T. In two-player, zero-sum games the two

i=1 ^vi^(x)playersareviewed asadversaries; oneplayeristhemaximizer(Max); the other is the minimizer (Min). By definition, vMAX(x)= −vMIN(x). Thus, it suffices to use one value to represent the value of a state: if v(x)> 0, then Max is the winner; if v(x)< 0, then Min is the winner; if v(x)=0, then the game is a draw.

A

+1 +1

Figure 1: Game tree for 2,2-Nim. Max nodes are squares; Min nodes are circles. The minimax value of this game is −1: there is a winning strategy for Min.

As an example, consider the zero-sum game of perfect information, m,p-NIM. Initially, there are p piles of m matches. To move, a player removes any number of matches from exactly one pile. The losing(orwinning) playeriss/hewhoremovesthe final match. Thegametreerepresentation of 2,2-NIM(fortwoplayers) isdepictedinFigure 1, whereitis modeled asfollows:

• P = {Max,Min}
• X = Y × P: e.g.,((1,1),Max)∈ X Y = {(2,2),(2,1),(2,0),(1,1),(1,0),(0,0)} canonical representation where a ≥ b for allpairs(a,b)

• S = {((2,2),Max),((2,2),Min)}
• T = {((0,0),Max),((0,0),Min)}
• δ((2,2),Max)= {((2,1),Min),((2,0),Min)}, δ((2,1),Min)= {((1,1),Max),((1,0),Max),((2,0),Max)}, ...
• l((2,2),Max)= Max, l((2,1),Min)= Min, l((2,0),Min)= Min, ...
• v((0,0),Max)=(+1,−1), v((0,0),Min) =(−1,+1)

3 Minimax Search

The minimax value of a game tree is the value of the root node x, whenever Min moves first, computed as the minimum value of x’s successors, which are in turn computed as the maximum

1

value of x’ssuccessors’successors,and soon.If theminimaxvalueof agametreeis+1,thenthere exists a winning strategy for max; if the minimax value is −1, then there exists a winning strategy for Min;ifthevalueof theroot nodeis0,thenneitherplayerhasawinning strategy. Thedefinition of the minimax value of agametree suggests abreadth-first-search style computation. Inpractice, the minimax algorithmtraverses nodesindepth-first-search(DFS) orderto ensurethat spaceis managed efficiently. Wepresenttwoimplementationsof minimaxsearch: the firstisrecursive(with backtracking) and the secondis an explicitDFSimplementation(seeAppendixA.1).

4.1 Recursive αβPruning

αβPruning associates an α-value and a β-value with every game:

• The α-value at Max node x is the maximum of two sets of values: (i) the α-values of all (complete) variations rooted at any of x’s ancestors, and(ii) the α-values of all(complete) variations rooted at node x. Hence, an α-value is a lower bound on the minimax value of the game: Max can guarantee that he wins at least this value.
• The β-value at Min node x is the minimum of two sets of values: (i) the β-values of all variations rooted at any of x’s ancestors, and(ii) the β-values of all variations rooted at node

x. Hence, a β-value is an upperbound on the minimax value of thegame: Min canguarantee that he loses no more than this value.

For example, an α-value of 0.4 can be interpreted to mean that Max will get paid at least $0.40; while a β-value of 0.75 can be interpreted to mean that Max willgetpaid at most$0.75(i.e., Min will pay at most $0.75).

It is an invariant of αβPruning that α<β; otherwise, if α = β, the game is solved. The α and β values are computed by updating α-values at Max nodes and β-values at Min nodes, as in MiniMax. Pruning happens as follows:

• If after updating at a Max node x, α strictly exceeds β, then all subtrees rooted at x can be pruned, since there exists a preferable alternative for Min elsewhere in the game. In this case, β (the valueMin can achieve elsewhere) is returned.
• If after updating at a Min node y, β falls strictly below α, then the subtree rooted at y can bepruned, sincethere exists apreferable alternativefor Max elsewhere in the game. In this case, α (the valueMax can achieve elsewhere) is returned.

The recursive version of αβPruning appearsinTable 3. Theinitial call to this algorithminitializes α = −1(lower bound) and β = +1(upperbound). Let x denotethe root nodeof thegametree. If x is a terminal node, the value of x is returned. Otherwise, if x is nonterminal, then αβMiniMax proceeds to recursively call itself on each of x’s children in turn, updating the value of α or β depending on whether x is labeled Max or Min. With each recursive call, α is initialized as the maximum value that can be achieved at any of Max’s choice points along the path to x, and β is initialized as the minimum value that can be achieved at any of Min’s choice points along the path to x. These values are updated as variations rooted at x are completed. If after updating at a Max node, the value of α exceeds the value of β, then min can achieve β rather than α along an alternative path. No further variations in this subtree need be completed, so the algorithm breaks out of the loop and returns β. (Ordinarily, an updatedvalue of α is returned at Max nodes.) The algorithm operates symmetrically on Min nodes.

αβPruning updates α-and β-values as follows during its execution on the 2,2-NIM game tree in Figure 1. This trace differs from the MiniMax trace in Table 2 in that five nodes are pruned. Pruning is evidenced by a Max (Min)node returning a β (α)value rather than an α (β)value.

αβPruning(Γx,α,β)

Inputs	game tree Γx rooted at x
	lower bound α
	upper bound β
Output	value in [α,β]

1. if x ∈ T

(a)

if l(x)= Min, return vMIN(x)

(b)

if l(x)= Max, return vMAX(x)

2. else if l(x)= Min

(a) for all y ∈ δ(x)

i. let β = min{β,αβpruning(Γy,α,β)}

ii. if β ≤ α, return α

(b) return β

3. else if l(x)= Max

(a) for all y ∈ δ(x)

i. let α = max{α,αβpruning(Γy,α,β)}

ii. if α ≥ β, return β

(b) return α

Table 3: Recursive αβPruning.

4.2 Complexity

In thebest case, αβpruningdiscoverstheprincipalvariationonits firsttraversal of thetree,andits

√

effective branching factor ² is b. In this case, its complexity is only O(b^d/2)—substantial savings over the minimax algorithm, which visits O(b^d) nodes. In the worst-case, however, αβpruning prunes no nodes at all.

The order in which nodes are explored greatly impacts the savings that can be achieved via αβpruning. One reasonable ordering heuristic is to first perform iterative deepening search, and then to order successor nodes according to the backed-up values returned by the search at the previous depth.

A.1 Minimax, Revisited

MiniMax-DFS (seeTable 6) traverses thegame treeindepth-firstfashion, visiting all nonterminal nodes twice. The firsttimeit visits anonterminal node,its valueis unknown; toevaluatethenode, its children are pushed onto the stack. The second time it visits a nonterminal node, its value is known; thus,itispopped offthestack, anditsvalueisbacked up toitsparent(SeeTable 7)(unless it is the root node). When MiniMax-DFS visits the root node for the second time, it terminates. Atthispoint,thevalueof theroot nodeistheminimaxvalueof thegame, since all ofits children’s values have been backed up, all of its children’s children’s values have also been backed up, and so on. Otherwise, all of its children would not have been popped off the stack, and it could not have beenvisitedforthesecond time; similarly, all ofitschildren’schildrenwould nothavebeenpopped off the stack, and their children could not have been visited for the second time, and so on.

MiniMax maintains the stack depicted in Table 5 during its execution on the 2,2-NIM game tree in Figure 1. Nodes are subscripted with their values.

A.2 αβPruning, Revisited

Pseudocode that implements αβPruning via explicit depth-first search is shown in Table 8. The depth-first search algorithm maintains both α-and β-values at all nodes. When a node is popped off the stack, a pruning test is immediately performed. (This test is described in the following paragraph.) If the node cannot be pruned, then the algorithm proceeds as in MiniMax-DFS. If it is a terminal node, it is evaluated, and its value is stored at the corresponding α-and β-values.

A−∞ B+∞ A−∞ D−∞ B+∞ A−∞ I+∞ D−∞ B+∞ A−∞ N+1 I+∞ D−∞ B+∞ A−∞ I+1 D−∞ B+∞ A−∞ D+1 B+∞ A−∞ J−1 D+1 B+∞ A−∞ D+1 B+∞ A−∞ B+1 A−∞ E−∞ B+1 A−∞ K−1 E−∞ B+1 CA−∞ E−1 B+1 A−∞ B−1 A−∞ F−∞ B−1 A−∞ L+∞ F−∞ B−1 A−∞ O+1 L+∞ F−∞ B−1 A−∞ L+1 F−∞ B−1 A−∞ F+1 B−1 A−∞ B−1 A−∞ A−1 C+∞ A−1 G−∞ C+∞ A−1 M−1 G−∞ C+∞ A−1 G−1 C+∞ A−1 C−1 A−1 H+1 C−1 A−1 C−1 A−1 A−1

Table 5: MiniMax-DFS on 2,2-NIM.

Otherwise, a test is performed to determine whether the node’s α-and β-values are initialized. If so, this visitis the second; all ofits children’s valueshavebeenbacked up, soits valueis nowbacked up, and it is deleted from the stack. If the node is not yet initialized, its values are initialized to those of its parents, and its children are prepended to the stack.

Thepruning testisperformed at all nodes otherthanthe rootnode. Thetest simply asks whether a node’s α-value is greater than or equal to its β-value, in which case the node can be pruned. As in the pseudocode, let n denote the node in question and m its parent node. Before any of m’s children are evaluated, α(m) <β(m); otherwise the subtree rooted at m would have been pruned already. If m is labeled Min, then as m’s children are evaluated, the value of β potentially decreases. If ever β(m)<α(m), then there exists an alternative formax at least as profitable; or, if β(m)= α(m), then the minimax value ofm is known. On the other hand, if m is labeled Max, then as m’s children are evaluated, the value of α potentially increases. If ever α(m)>β(m), then there exists an alternative for Min at least as desirable; or, if α(m)= β(m), then the minimax value of m is known. In all of these cases, the subtree rooted at m can be pruned.

MiniMax-DFS(Γ,x)

Inputs	game tree Γ, root node x
Output	minimax value of game tree
Initialize	O = {x}, v(n)= ⊥ for n �∈ T

while (O is not empty) do

1. choose first node n ∈ O
1. if n ∈ T
1. if l(n)= Min, let v(n)= vMIN(n)
2. if l(n)= Max, let v(n)= vMAX(n)
2. if v(n)�= ⊥

(a) if n �x=

i. let m = δ⁻¹(n)

ii. BackUp1(Γ,n,m)

(b) delete n from O

4. else if v(n)= ⊥

(a) if l(n)= Min, v(n)=+∞ if l(n)= Max, v(n)= −∞

(b) prependδ(n)to front of O return v(x)

Table 6: MiniMax Depth-First Search.

BackUp1(Γ,n,m) Inputs game tree Γ, node n, parent m Output updated game tree values

1. if l(m)= Min, v(m)= min{v(m),v(n)}if l(m)= Max, v(m)= max{v(m),v(n)}

Table 7: BackUp1 Subroutine: “backs up” values 1-level—from child to parent.

αβPruning-DFS(Γ,x) Inputs game tree Γ, root node x Output minimax value of game tree Initialize O = {x}, α(n)= β(n)= ⊥ for n �∈ T

while (O is not empty) do

1. choose first node n ∈ O
1. if n �= x
1. let m = δ⁻¹(n)
2. if α(m)≥ β(m),delete n from O, continue
1. if n ∈ T
1. if l(n)= Min, let β(n)= α(n)= vMIN(n)
2. if l(n)= Max, let α(n)= β(n)= vMAX(n)
2. if α(n)�⊥ and β(n)= ⊥

= �

(a) if n �x=

i. let m = δ⁻¹(n)

ii. αβBackUp1(Γ,n,m)

(b) delete n from O

5. else if α(n)= β(n)= ⊥

(a)

α(n)= −1 and β(n)=+1

(b)

if n �x

=

i. let m = δ⁻¹(n)

ii. α(n)= max{α(n),α(m)}β(n)= min{β(n),β(m)}

(c) prependδ(n)to front of O

if l(x)= Min, return β(x) if l(x)= Max, return α(x)

αβBackUp1(Γ,n,m) Inputs game tree Γ, node n, parent m Output updated α and β values

1. if l(m)= Min, β(m)= min{β(m),α(n)}if l(m)= Max, α(m)= max{α(m),β(n)}

Table 8: αβPruning Depth-First Search.

13