AlphaGo vs Lee Sedol: Move 37. A new kind of intuition

The match and the move that named it

On 15 March 2016, in the ballroom of the Four Seasons Hotel in Seoul, a computer program named AlphaGo defeated Lee Sedol, one of the strongest Go players of his generation, by four games to one. The most discussed moment of the series did not arrive at the end. It came five days earlier, on the thirty-seventh move of the second game, when AlphaGo placed a black stone on the fifth line along the right side of the board. This "shoulder hit" sat so far from conventional opening theory that the human commentators first assumed it was a mistake. According to Google DeepMind, AlphaGo's own move-selection network had estimated the probability that a human professional would play there at roughly one in ten thousand. The stone turned out to be structurally central to the game AlphaGo went on to win.

The narrow, documented claim is worth isolating before anything larger is built on it: a system that combined learned pattern recognition with search beat a top-ranked human at Go in a formal five-game match, and produced at least one move that expert players judged genuinely creative rather than merely strong. The broad historical judgment, that this signalled a shift in what machines could do, is a separate matter. It depends on which constraint AlphaGo removed, which tools it inherited, and which later results actually built on it. Keeping those two levels of claim apart is the entire task of placing "Move 37" correctly.

Why Go resisted the methods that beat chess

Nineteen years before Seoul, IBM's Deep Blue beat world chess champion Garry Kasparov largely by searching: it examined a vast number of positions per second and scored each one with a hand-tuned evaluation function. Go breaks that recipe twice over. The board is nineteen lines by nineteen, so there are on the order of 250 plausible moves at each turn and games commonly run about 150 moves. That makes the tree of continuations astronomically larger than in chess. The count of legal board configurations is around 10 to the 170th power, which exceeds the estimated number of atoms in the observable universe. Exhaustive lookahead to the end of the game is simply out of reach.

The harder problem is evaluation. In chess, counting material and applying positional heuristics yields a serviceable estimate of who stands better. In Go, whether a position favours one side can hinge on subtle whole-board relationships that resisted decades of effort to encode by hand. Strong programs plateaued well below professional strength, and top human players still gave the best software large handicaps. The open question for the field was never how to search more positions. It was how to judge a position, and how to guess promising moves, without an explicit rulebook of Go wisdom. AlphaGo's answer was to learn both.

The ingredients AlphaGo inherited

AlphaGo was a synthesis, not a bolt from nowhere, and the honest history names its parts. The idea of learning an evaluation function for a board game by playing has a clear ancestor in Gerald Tesauro's TD-Gammon, which used temporal-difference learning and self-play to reach near-expert backgammon in the early 1990s; the retrospective is documented in Tesauro's account of temporal-difference learning and TD-Gammon. The search half of AlphaGo descended from Monte Carlo tree search, the family of methods that guides random game simulations toward promising lines and had already lifted Go programs above earlier techniques, surveyed thoroughly in Browne and colleagues' survey of Monte Carlo tree search methods.

The perception half came from deep learning, whose maturation across vision and speech in the early 2010s is reviewed in LeCun, Bengio and Hinton's overview of deep learning. DeepMind had also just shown, in its work on human-level control through deep reinforcement learning, that a single network could learn to play many Atari games from pixels and a score signal. And crucially, deep convolutional networks had already been pointed directly at Go: Maddison, Huang, Sutskever and Silver's study of move evaluation in Go using deep convolutional neural networks and, independently, Clark and Storkey's work on teaching deep convolutional networks to play Go both showed that a network could predict expert moves from raw board positions with surprising accuracy. AlphaGo's contribution was to arrange these pieces into a working whole.

How AlphaGo actually worked

The full technical account is Silver and colleagues' Nature paper, "Mastering the game of Go with deep neural networks and tree search". AlphaGo used two kinds of deep convolutional network. A policy network took a board position and output a probability distribution over the next move, in effect a learned sense of "what a strong player would consider here." It was first trained by supervised learning on about 30 million positions drawn from human games on an online server, reaching roughly 57 percent accuracy at predicting the expert's actual move, then improved further by reinforcement learning through self-play. A separate value network took a position and estimated a single number: the probability that the current player would eventually win. That value network is the closest thing in the system to positional judgment, an evaluation learned from millions of games rather than hand-written.

These networks did not play alone. They steered a Monte Carlo tree search. The policy network narrowed the branching factor by focusing the search on plausible moves, while the value network, blended with fast simulated playouts, told the search how good the resulting positions were without playing every line to the end. Learning supplied intuition; search supplied verification, and each covered the other's weakness. The Nature paper also reported the strength this produced against software: AlphaGo won 494 of 495 games against the leading Go programs of the day. In October 2015 it beat the European champion Fan Hui, a professional player, five games to nil in formal conditions, the first time a program had beaten a professional at Go on even terms. The distributed version described in that paper ran across 1,202 CPUs and 176 GPUs; the stronger iteration that faced Lee Sedol ran on Google's first-generation tensor processing units.

What Move 37 actually was, and what "intuition" means here

Move 37 is compelling precisely because it exposes the value network's judgment diverging from human convention and being right. A fifth-line shoulder hit early in the game contradicts a heuristic most players absorb early, that such influence-oriented play on the fifth line concedes too much territory. AlphaGo's policy network agreed that humans rarely play it, hence the one-in-ten-thousand figure DeepMind cited. But its search, guided by the value network, concluded the move increased its winning probability, and dozens of moves later the resulting wall of influence proved decisive. Fan Hui, who had been crushed months earlier and then joined the project, described the stone as beautiful and unlike any human move he had seen.

This is the sense in which the event's title, "a new kind of intuition," is accurate rather than hyperbolic. Intuition here is not consciousness or understanding. It is a learned evaluation function that compresses experience into fast positional judgment, the same faculty a strong human calls "feel," implemented as the output of a network trained on outcomes. The disciplined reading is that AlphaGo demonstrated machine judgment that was not a copy of human judgment, in a domain where correctness could be checked by the game itself. It did not demonstrate general reasoning, and DeepMind's own framing kept the claim to Go.

Lee Sedol's answer: the fragility behind Move 78

The honest counterweight to Move 37 is Move 78, and the same DeepMind account of the match records it. In game four, trailing three to nil, Lee Sedol played a wedge between two AlphaGo stones that Korean commentators later called the "God's touch," a move AlphaGo also rated at roughly one in ten thousand for a human. AlphaGo failed to anticipate it, its evaluation of the position swung, and over the following moves it made a sequence of weak responses and eventually resigned. Lee Sedol won the only human game of the series to a standing ovation.

Move 78 matters historically because it shows the limits of the same machinery that produced Move 37. A learned evaluation function is only as good as the distribution it was trained on, and a rare, precise human idea outside that distribution briefly broke it. The lesson is symmetrical: the system's strength and its brittleness came from the same source, learned intuition guided by search. An account that celebrates the machine's creativity without noting its collapse in game four is not describing the same event.

The competing approaches of the moment

AlphaGo did not arrive into an empty field. The strongest prior Go programs, including Crazy Stone, Zen, Pachi and Fuego, were built on Monte Carlo tree search with lighter, mostly hand-designed knowledge, and they were the very opponents AlphaGo beat 494 times out of 495 in the Nature evaluation. In parallel, other laboratories were pursuing the deep-network route: Facebook's AI Research group was developing its own convolutional-network Go engine, darkforest, over the same period. The live question of 2015 and 2016 was not whether neural networks would help at Go, but whether they could be integrated with search tightly enough, and trained at enough scale, to cross the professional barrier.

Reading the event against these real competitors is more informative than casting it as a lone miracle. AlphaGo's edge was not a single new idea but the depth of the integration: two specialised networks, a supervised phase followed by reinforcement learning, and a search that used both. The distinction between adding a network to an existing program and rebuilding the program around learned evaluation is the substance of the contribution.

What came after: Zero, AlphaZero, and a learned model

The clearest evidence that the method mattered is what it enabled next, and here the later work is explicit about reusing and changing the recipe. In 2017, DeepMind published AlphaGo Zero in "Mastering the game of Go without human knowledge", which dropped the supervised training on human games entirely. Starting from random play and learning only from self-play with a single combined network, AlphaGo Zero surpassed the version that beat Lee Sedol within days of training and defeated it 100 games to nil. Removing the human data both simplified the system and answered a question the original left open: how much of AlphaGo's strength depended on imitating people.

The generalisation followed quickly. AlphaZero, reported in Science as "A general reinforcement learning algorithm that masters chess, shogi, and Go through self-play", and released first as the preprint "Mastering Chess and Shogi by Self-Play with a General Reinforcement Learning Algorithm", applied one algorithm to three different games and, in each, reached or exceeded the best prior programs, including the strong chess engine Stockfish. A further step removed even the requirement to be told the rules: MuZero, "Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model", learned a model of each environment's dynamics and planned within it, extending the learning-plus-search template to games where the rules were not given in advance. This lineage, not the Seoul scoreline alone, is the substantive downstream influence.

The honest limits

Several caveats keep the significance in proportion. AlphaGo was specific to Go, a two-player, perfect-information, deterministic game with a clear win condition, exactly the conditions under which learning-plus-search is easiest to make work. Its victory says nothing directly about open-ended reasoning, common sense, or problems without a crisp objective. The system also consumed very large amounts of computation and specialised hardware, so the achievement was as much an engineering and resources result as a conceptual one. And the value network, for all its skill, was not interpretable: it produced a number, not an explanation, and Move 78 showed that number could be wrong in ways that were hard to foresee.

It is also worth resisting two common overstatements. AlphaGo did not "invent" reinforcement learning, deep networks, or Monte Carlo tree search; each predated it, as the references above make plain. And its results should be read as task-specific game outcomes, a match score and win rates against other programs, never as a fraction of human intelligence. The match was a milestone in a specific domain, demonstrated with unusually public and legible evidence, which is a large part of why it resonated beyond the research community.

How to place Move 37 in AI history

The defensible summary is that AlphaGo's defeat of Lee Sedol was a landmark demonstration that learned evaluation, combined with search, could solve a problem long considered a benchmark for machine intelligence, and that it did so with visible creativity in Move 37 and visible fragility in Move 78. The narrow claim concerns Go. The wider claim, that this reframed what people expected from learning systems, is supported not by the ballroom result on its own but by the trajectory from AlphaGo to AlphaGo Zero, AlphaZero and MuZero, and by how thoroughly the learning-plus-search pattern spread afterward.

A useful way to navigate outward from this event is to hold three questions in view. Which earlier idea supplied a necessary component, whether it was temporal-difference evaluation, Monte Carlo tree search, or convolutional move prediction? Which later project reused the recipe while removing an ingredient, as AlphaGo Zero removed human data and MuZero removed the given rules? And which limitation, such as the brittleness Move 78 exposed, pointed toward the work still to come? Answered together, they place Move 37 where it belongs: not as the moment machines began to think, but as the moment a learned, checkable form of intuition beat the best humans at their own ancient game, and set off a research program that outran the match itself.

References

• Google DeepMind (2016). AlphaGo.
• Silver et al. (2016). Mastering the game of Go with deep neural networks and tree search.
• Silver et al. (2017). Mastering the game of Go without human knowledge.
• Silver et al. (2018). A general reinforcement learning algorithm that masters chess, shogi, and Go through self-play.
• Silver et al. (2017). Mastering Chess and Shogi by Self-Play with a General Reinforcement Learning Algorithm.
• Schrittwieser et al. (2019). Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model.
• Mnih et al. (2015). Human-level control through deep reinforcement learning.
• LeCun, Bengio and Hinton (2015). Deep learning.
• Maddison et al. (2014). Move Evaluation in Go Using Deep Convolutional Neural Networks.
• Clark and Storkey (2014). Teaching Deep Convolutional Neural Networks to Play Go.
• Browne et al. (2012). A Survey of Monte Carlo Tree Search Methods.
• Tesauro (1995). Temporal Difference Learning and TD-Gammon.