View source for Alpha–beta pruning

{{short description|Search algorithm that seeks to decrease the number of nodes in the minimax algorithm search tree}}
{{other uses|Alphabeta (disambiguation)}}
{{Infobox algorithm
|class=[[Search algorithm]]
|image=
|data=
|time=<math>O(b^d)</math>
|best-time=<math>O\left(\sqrt{b^d}\right)</math>
|average-time=
|space=
|optimal=
|complete=
}}

'''Alpha–beta pruning''' is a [[search algorithm]] that seeks to decrease the number of nodes that are evaluated by the [[Minimax#Minimax algorithm with alternate moves|minimax algorithm]] in its [[game tree|search tree]]. It is an adversarial search algorithm used commonly for machine playing of two-player [[Combinatorial game theory|combinatorial games]] ([[Tic-tac-toe]], [[Chess]], [[Connect 4]], etc.). '''It stops evaluating a move when at least one possibility has been found that proves the move to be worse than a previously examined move.''' Such moves need not be evaluated further. When applied to a standard minimax tree, it returns the same move as minimax would, but prunes away branches that cannot possibly influence the final decision.{{sfn|Russell|Norvig|2021|p=152-161}}

== History ==
John McCarthy during the [[Dartmouth workshop|Dartmouth Workshop]] met Alex Bernstein of [[IBM]], who was writing a chess program. McCarthy invented alpha–beta search and recommended it to him, but Bernstein was "unconvinced".<ref>{{cite web |last=McCarthy |first=John |date=2006-10-30 |title=The Dartmouth Workshop--as planned and as it happened |url=https://www-formal.stanford.edu/jmc/slides/dartmouth/dartmouth/node1.html |access-date=2023-10-29 |website=www-formal.stanford.edu}}</ref>

[[Allen Newell]] and [[Herbert A. Simon]] who used what [[John McCarthy (computer scientist)|John McCarthy]] calls an "approximation"<ref name="JMC">{{cite web
  | author = McCarthy, John
  | title = Human Level AI Is Harder Than It Seemed in 1955
  | date = 27 November 2006
  | url = http://www-formal.stanford.edu/jmc/slides/wrong/wrong-sli/wrong-sli.html
  | access-date = 2006-12-20 |publisher=Stanford University
}}</ref> in 1958 wrote that alpha–beta "appears to have been reinvented a number of times".<ref name="NS">{{cite journal |last1=Newell |first1=Allen |last2=Simon |first2=Herbert A. |title=Computer science as empirical inquiry: symbols and search |journal=Communications of the ACM |date=1 March 1976 |volume=19 |issue=3 |pages=113–126 |doi=10.1145/360018.360022 |doi-access=free }}</ref> [[Arthur Samuel (computer scientist)|Arthur Samuel]] had an early version for a checkers simulation. Richards, Timothy Hart, Michael Levin and/or Daniel Edwards also invented alpha–beta independently in the [[United States]].<ref name="AIM30">{{cite tech report |last1=Edwards |first1=D.J. |last2=Hart |first2=T.P.|date=4 December 1961|title=The Alpha–beta Heuristic |id=AIM-030 |publisher=[[Massachusetts Institute of Technology]] |hdl=1721.1/6098}}</ref> McCarthy proposed similar ideas during the [[Dartmouth workshop]] in 1956 and suggested it to a group of his students including [[Alan Kotok]] at MIT in 1961.<ref name="AIM41">{{cite web | last=Kotok | first=Alan |orig-date=1962 |title=A Chess Playing Program |publisher=RLE and MIT Computation Center |id=Memo 41 |work=Artificial Intelligence Project | date=2004 | url=http://www.kotok.org/AI_Memo_41.html | access-date=2006-07-01}}</ref> [[Alexander Brudno]] independently conceived the alpha–beta algorithm, publishing his results in 1963.<ref name="Marsland">{{cite book |chapter=Computer Chess Methods |title=Encyclopedia of Artificial Intelligence |editor1-first=S. |editor1-last=Shapiro |last=Marsland |first=T.A.|date=May 1987 |publisher=Wiley |pages=159–171 |chapter-url=http://www.cs.ualberta.ca/~tony/OldPapers/encyc.mac.pdf |isbn=978-0-471-62974-0|archive-url=https://web.archive.org/web/20081030023047/http://www.cs.ualberta.ca/~tony/OldPapers/encyc.mac.pdf |archive-date=2008-10-30 }}</ref> [[Donald Knuth]] and Ronald W. Moore refined the algorithm in 1975.<ref name="Knuth-Moore">{{cite journal|last1=Knuth|first1=Donald E.|last2=Moore|first2=Ronald W.|s2cid=7894372|year=1975|title=An analysis of alpha-beta pruning|journal=Artificial Intelligence|volume=6|issue=4|pages=293–326|doi=10.1016/0004-3702(75)90019-3}}</ref><ref name="Abramson">{{cite journal |last1=Abramson |first1=Bruce |title=Control strategies for two-player games |journal=ACM Computing Surveys |date=1 June 1989 |volume=21 |issue=2 |pages=137–161 |doi=10.1145/66443.66444 |s2cid=11526154 }}</ref> [[Judea Pearl]] proved its optimality in terms of the expected running time for trees with randomly assigned leaf values in two papers.<ref name="Pearl1980" /><ref name="Pearl1982" /> The optimality of the randomized version of alpha–beta was shown by Michael Saks and Avi Wigderson in 1986.<ref name="SaksWigderson" />

== Core idea ==
A [[game tree]] can represent many two-player [[zero-sum game]]s, such as chess, checkers, and reversi. Each node in the tree represents a possible situation in the game. Each terminal node (outcome) of a branch is assigned a numeric score that determines the value of the outcome to the player with the next move.<ref name="levy198601">{{cite magazine |last=Levy |first=David |date=January 1986 |title=Alpha-Beta Soup |url=https://archive.org/details/MacUser8601January1986/page/n101/mode/2up |magazine=MacUser |pages=98–102 |access-date=2021-10-19}}</ref>

The algorithm maintains two values, alpha and beta, which respectively represent the minimum score that the maximizing player is assured of and the maximum score that the minimizing player is assured of. Initially, alpha is negative infinity and beta is positive infinity, i.e. both players start with their worst possible score. Whenever the maximum score that the minimizing player (i.e. the "beta" player) is assured of becomes less than the minimum score that the maximizing player (i.e., the "alpha" player) is assured of (i.e. beta &lt; alpha), the maximizing player need not consider further descendants of this node, as they will never be reached in the actual play.

To illustrate this with a real-life example, suppose somebody is playing chess, and it is their turn. Move "A" will improve the player's position.  The player continues to look for moves to make sure a better one hasn't been missed.  Move "B" is also a good move, but the player then realizes that it will allow the opponent to force checkmate in two moves. Thus, other outcomes from playing move B no longer need to be considered since the opponent can force a win. The maximum score that the opponent could force after move "B" is negative infinity: a loss for the player. This is less than the minimum position that was previously found; move "A" does not result in a forced loss in two moves.

== Improvements over naive minimax ==
[[File:AB pruning.svg|thumb|400px|An illustration of alpha–beta pruning. The grayed-out subtrees don't need to be explored (when moves are evaluated from left to right), since it is known that the group of subtrees as a whole yields the value of an equivalent subtree or worse, and as such cannot influence the final result. The max and min levels represent the turn of the player and the adversary, respectively.]]
The benefit of alpha–beta pruning lies in the fact that branches of the search tree can be eliminated.{{r|levy198601}} This way, the search time can be limited to the 'more promising' subtree, and a deeper search can be performed in the same time. Like its predecessor, it belongs to the [[branch and bound]] class of algorithms. The optimization reduces the effective depth to slightly more than half that of simple minimax if the nodes are evaluated in an optimal or near optimal order (best choice for side on move ordered first at each node).

With an (average or constant) [[branching factor]] of ''b'', and a search depth of ''d'' [[Ply (game theory)|plies]], the maximum number of leaf node positions evaluated (when the move ordering is [[wiktionary:pessimal|pessimal]]) is [[Big O notation|''O'']](''b''<sup>''d''</sup>) – the same as a simple minimax search. If the move ordering for the search is optimal (meaning the best moves are always searched first), the number of leaf node positions evaluated is about ''O''(''b''×1×''b''×1×...×''b'') for odd depth and ''O''(''b''×1×''b''×1×...×1) for even depth, or <math>O(b^{d/2}) = O(\sqrt{b^d})</math>. In the latter case, where the ply of a search is even, the effective branching factor is reduced to its [[square root]], or, equivalently, the search can go twice as deep with the same amount of computation.{{sfn|Russell|Norvig|2021|p=155}} The explanation of ''b''×1×''b''×1×... is that all the first player's moves must be studied to find the best one, but for each, only the second player's best move is needed to refute all but the first (and best) first player move—alpha–beta ensures no other second player moves need be considered. When nodes are considered in a random order (i.e., the algorithm randomizes), asymptotically,
the expected number of nodes evaluated in uniform trees with binary leaf-values is <math>\Theta( ((b-1+\sqrt{b^2+14b+1})/4 )^d )</math>
.<ref name="SaksWigderson">{{cite book |last1=Saks |first1=M. |first2=A. |last2=Wigderson |chapter=Probabilistic Boolean Decision Trees and the Complexity of Evaluating Game Trees |title=27th Annual Symposium on Foundations of Computer Science |pages=29–38 |year=1986 |doi=10.1109/SFCS.1986.44 |isbn=0-8186-0740-8 |s2cid=6130392 }}</ref>
For the same trees, when the values are assigned to the leaf values independently of each other and say zero and one are both equally probable, the expected number of nodes evaluated is <math>\Theta( (b/2)^{d} )</math>, which is much smaller than the work done by the randomized algorithm, mentioned above, and is again optimal for such random trees.<ref name="Pearl1980">{{cite journal |last=Pearl |first=Judea |title=Asymptotic Properties of Minimax Trees and Game-Searching Procedures |journal=[[Artificial Intelligence (journal)|Artificial Intelligence]] |volume=14 |issue=2 |year=1980 |pages=113–138 |doi=10.1016/0004-3702(80)90037-5 }}</ref> When the leaf values are chosen independently of each other but from the <math>[0,1]</math> interval uniformly at random, the expected number of nodes evaluated increases to <math>\Theta( b^{d/log(d)} )</math> in the <math>d\to\infty</math> limit,<ref name="Pearl1982">{{cite journal |last=Pearl |first=Judea |title=The Solution for the Branching Factor of the Alpha-Beta Pruning Algorithm and Its Optimality |journal=Communications of the ACM |volume=25 |issue=8 |year=1982 |pages=559–64 |doi=10.1145/358589.358616 |s2cid=8296219 |doi-access=free }}</ref> which is again optimal for this kind of random tree. Note that the actual work for "small" values of <math>d</math> is better approximated using <math>0.925 d^{0.747}</math>.<ref name="Pearl1982" /><ref name="Pearl1980" />

A chess program that searches four plies with an average of 36 branches per node evaluates more than one million terminal nodes. An optimal alpha-beta prune would eliminate all but about 2,000 terminal nodes, a reduction of 99.8%.{{r|levy198601}}

[[File:Minmaxab.gif|thumb|400px|An animated pedagogical example that attempts to be human-friendly by substituting initial infinite (or arbitrarily large) values for emptiness and by avoiding using the [[negamax]] coding simplifications.]]
Normally during alpha–beta, the [[subtrees]] are temporarily dominated by either a first player advantage (when many first player moves are good, and at each search depth the first move checked by the first player is adequate, but all second player responses are required to try to find a refutation), or vice versa. This advantage can switch sides many times during the search if the move ordering is incorrect, each time leading to inefficiency. As the number of positions searched decreases exponentially each move nearer the current position, it is worth spending considerable effort on sorting early moves. An improved sort at any depth will exponentially reduce the total number of positions searched, but sorting all positions at depths near the root node is relatively cheap as there are so few of them.  In practice, the move ordering is often determined by the results of earlier, smaller searches, such as through [[Iterative deepening depth-first search|iterative deepening]].

Additionally, this algorithm can be trivially modified to return an entire [[principal variation]] in addition to the score. Some more aggressive algorithms such as [[MTD(f)]] do not easily permit such a modification.

== Pseudocode ==
The pseudo-code for depth limited minimax with alpha–beta pruning is as follows:{{sfn|Russell|Norvig|2021|p=154}}

 '''function''' alphabeta(node, depth, α, β, maximizingPlayer) '''is'''
     '''if''' depth == 0 '''or''' node is terminal '''then'''
         '''return''' the heuristic value of node
     '''if''' maximizingPlayer '''then'''
         value := &minus;∞
         '''for each''' child of node '''do'''
             value := max(value, alphabeta(child, depth &minus; 1, α, β, FALSE))
             '''if''' value ≥ β '''then'''
                 '''break''' ''(* β cutoff *)''
             α := max(α, value)
         '''return''' value
     '''else'''
         value := +∞
         '''for each''' child of node '''do'''
             value := min(value, alphabeta(child, depth &minus; 1, α, β, TRUE))
             '''if''' value ≤ α '''then'''
                 '''break''' ''(* α cutoff *)''
             β := min(β, value)
         '''return''' value

 ''(* Initial call *)''
 alphabeta(origin, depth, &minus;[[Infinity|∞]], +[[Infinity|∞]], TRUE)

Implementations of alpha–beta pruning can often be delineated by whether they are "fail-soft," or "fail-hard". The pseudo-code illustrates the fail-soft variation. With fail-soft alpha–beta, the alphabeta function may return values (v) that exceed (v < α or v > β) the α and β bounds set by its function call arguments. In comparison, fail-hard alpha–beta limits its function return value into the inclusive range of α and β.

== Heuristic improvements ==
Further improvement can be achieved without sacrificing accuracy by using ordering [[heuristic]]s to search earlier parts of the tree that are likely to force alpha–beta cutoffs. For example, in chess, moves that capture pieces may be examined before moves that do not, and moves that have scored highly in [[Iterative deepening depth-first search|earlier passes]] through the game-tree analysis may be evaluated before others. Another common, and very cheap, heuristic is the [[killer heuristic]], where the last move that caused a beta-cutoff at the same tree level in the tree search is always examined first. This idea can also be generalized into a set of [[refutation table]]s.

Alpha–beta search can be made even faster by considering only a narrow search window (generally determined by guesswork based on experience). This is known as an ''[[aspiration window]]''. In the extreme case, the search is performed with alpha and beta equal; a technique known as ''[[MTD(f)#Zero-window searches|zero-window search]]'', ''null-window search'', or ''scout search''. This is particularly useful for win/loss searches near the end of a game where the extra depth gained from the narrow window and a simple win/loss evaluation function may lead to a conclusive result. If an aspiration search fails, it is straightforward to detect whether it failed ''high'' (high edge of window was too low) or ''low'' (lower edge of window was too high). This gives information about what window values might be useful in a re-search of the position.

Over time, other improvements have been suggested, and indeed the Falphabeta (fail-soft alpha–beta) idea of John Fishburn is nearly universal and is already incorporated above in a slightly modified form. Fishburn also suggested a combination of the killer heuristic and zero-window search under the name Lalphabeta ("last move with minimal window alpha–beta search").

== Other algorithms ==
Since the [[minimax]] algorithm and its variants are inherently [[depth-first search|depth-first]], a strategy such as [[Iterative deepening depth-first search|iterative deepening]] is usually used in conjunction with alpha–beta so that a reasonably good move can be returned even if the algorithm is interrupted before it has finished execution. Another advantage of using iterative deepening is that searches at shallower depths give move-ordering hints, as well as shallow alpha and beta estimates, that both can help produce cutoffs for higher depth searches much earlier than would otherwise be possible.

Algorithms like [[SSS*]], on the other hand, use the [[best first search|best-first]] strategy.  This can potentially make them more time-efficient, but typically at a heavy cost in space-efficiency.<ref>{{citation|doi=10.1146/annurev.cs.02.060187.002315|title=Search techniques|journal=Annual Review of Computer Science|volume=2|pages=451–467|year=1987|first1=Judea|last1=Pearl|author1-link=Judea Pearl|first2=Richard|last2=Korf|author2-link=Richard E. Korf|quote=Like its A* counterpart for single-player games, SSS* is optimal in terms of the average number of nodes examined; but its superior pruning power is more than offset by the substantial storage space and bookkeeping required.}}</ref>

== See also ==
{{Div col|colwidth=20em}}
* [[Minimax]]
* [[Expectiminimax]]
* [[Negamax]]
* [[Pruning (algorithm)]]
* [[Branch and bound]]
* [[Combinatorial optimization]]
* [[Principal variation search]]
* [[Transposition table]]
* [[Late move reductions]]
{{Div col end}}

== References ==
{{Reflist}}

== Bibliography ==
* {{cite book
| first1 = Stuart J. | last1 = Russell | author1-link = Stuart J. Russell
| first2 = Peter.    | last2 = Norvig  | author2-link = Peter Norvig
| title=[[Artificial Intelligence: A Modern Approach]]
| year = 2021
| edition = 4th 
| isbn = 9780134610993 
| lccn = 20190474
| publisher = Pearson | location = Hoboken
}}
* {{cite book |first1=George T. |last1=Heineman |first2=Gary |last2=Pollice |first3=Stanley |last3=Selkow | title= Algorithms in a Nutshell | publisher=[[Oreilly Media]] | year=2008 | chapter=7. Path Finding in AI | pages = 217–223 | isbn=978-0-596-51624-6 }}
* {{cite book |author1-link=Judea Pearl |first=Judea |last=Pearl |title=Heuristics: Intelligent Search Strategies for Computer Problem Solving |publisher=Addison-Wesley |location= |date=1984 |isbn=978-0-201-05594-8 |oclc=1035596197 |url=https://archive.org/details/heuristicsintell00pear}}
* {{cite book | first=John P. |last=Fishburn | title= Analysis of Speedup in Distributed Algorithms (revision of 1981 PhD thesis) | publisher=UMI Research Press | year=1984 | chapter=Appendix A: Some Optimizations of α-β Search | pages = 107–111 | isbn=0-8357-1527-2 }}

{{Graph traversal algorithms}}
{{Game theory}}

{{DEFAULTSORT:Alpha-Beta Pruning}}
[[Category:Game artificial intelligence]]
[[Category:Graph algorithms]]
[[Category:Optimization algorithms and methods]]
[[Category:Search algorithms]]
[[Category:Articles with example pseudocode]]
[[Category:Combinatorial game theory]]