Combinatorial Game Theory
who wins, and by how much
Generator

Backward induction on a loop with a way out, one round at a time

Backward induction on a loop with a way out, one round at a time
Backward induction on a loop with a way out, one round at a time. Zermelo's argument as it actually runs. Round zero is the positions where the player to move has no move at all, which is the only thing the procedure knows without being told; each later round is what those settle. Anything still unlabelled when nothing more can be deduced has no label and never will — and on a game with a cycle in it, that leftover is exactly the set of drawn positions. The theorem is a statement about this procedure terminating, and it names the winner of nothing.

Zermelo's argument as it actually runs. Round zero is the positions where the player to move has no move at all, which is the only thing the procedure knows without being told; each later round is what those settle. Anything still unlabelled when nothing more can be deduced has no label and never will — and on a game with a cycle in it, that leftover is exactly the set of drawn positions. The theorem is a statement about this procedure terminating, and it names the winner of nothing.

8 essays call zermelo-rounds. The drawing above is what it returns with no arguments at all; every call below passes it something, because a placement that passes nothing draws whichever member of the family the generator happens to default to rather than the one its essay argues about.

Where it is called

Changing this generator changes every one of these figures.

Backward induction on a game that ends, one round at a time. Zermelo's argument as it actually runs. Round zero is the positions where the player to move has no move at all, which is the only thing the procedure knows without being told; each later round is what those settle. Anything still unlabelled when nothing more can be deduced has no label and never will — and on a game with a cycle in it, that leftover is exactly the set of drawn positions. The theorem is a statement about this procedure terminating, and it names the winner of nothing. How it was found

The first theorem, and the winner it declines to name

Zermelo proved in 1913 that a finite game with no chance and no hidden information is decided before anybody sits down — every position is a win for one side or a draw, and which one is settled already. The proof is a labelling procedure, and watching it run shows exactly how little it says.

 How long a win takes, against how long the argument allows. Ordinary impartial games with the size of their position graphs, the number of rounds the backward labelling takes, and the number of moves the longest win actually lasts. The round a position settles in is the length of the play from it, which is computed here a second way so the two must agree. The rounds are a handful and the positions are many, which is the gap Zermelo's 1913 paper is about — his question was how many moves a forced win needs, and the answer he could prove was the size of the whole graph. How it was found

The paper was about how long

Zermelo's 1913 paper is remembered for a theorem it proves in passing. The question it actually asks is how many moves a forced win takes, the answer it can prove is the size of the whole position graph, and the round counter in the procedure is the real answer — a quantity nobody named for another forty years.

 Two solutions to one set of equations. The winning condition written as a single predicate and solved twice: once as the least solution of its own equations and once as the greatest. The least says Left can force a win; the greatest says Left cannot be forced to lose, which admits the positions where Left can keep the game going for ever. On a graph with no cycle in it the two coincide and the equations determine an answer. Where they differ, the difference is exactly the set the backward propagation never reaches — so a draw is not a leftover of the algorithm, it is the equations failing to have one answer. How it was found

The gap between two answers

A draw is usually described as what the backward labelling never reached, which makes it sound like a shortfall of the algorithm. Written as one predicate the winning condition is an equation, the equation is monotone, and it has a least solution and a greatest one — and the set the two disagree about is exactly the drawn set, on every game checked.

 A game every play of which ends, and no round settles. A game whose first move chooses how long the game will be, cut off at several sizes. Every play of it is finite and no position is drawn, so the fourth outcome class has nothing to do with what goes wrong. What goes wrong is the round counter: the opening is a loss, a loss settles only when the last of its options is known, and there is no last option. Cut the game off larger and the round grows, so no number in the column is the answer for the untruncated game — and the induction that labels it has to run past every finite stage. How it was found

Every play ends and no round settles

Take the finiteness hypothesis away carefully — not by adding a cycle, which has already been priced twice, but by adding infinitely many positions to a game every play of which still ends. Nothing is drawn, every line finishes, and the round the opening settles in grows with every cut: two, four, six, eight, twelve, sixteen, and no number in the column is the answer.

 A shuttle and a loop, judged by what the play returns to. A three-node loopy game drawn as a graph, with Left's moves in blue, Right's in red and position a marked. Beside it, each position-and-mover pair under the backward labelling and under the rule that a never-ending play goes to Left when it returns to a infinitely often. Four pairs are drawn by the labelling; the new rule gives two to Left and two to Right and leaves the decided pairs as they were. How it was found

What the play keeps coming back to

A draw is what the backward labelling never reaches, and handing every never-ending play to one player turns the draws into wins wholesale. Judge an infinite play instead by what it keeps returning to, and every draw gets a winner of its own: over the 262,144 three-node games, 15,432 send some of their draws to one player and some to the other, which no wholesale rule can do. Finding those winners takes a fixed point inside a fixed point.

 A hub with two spokes, and the bit of memory it needs. A three-node loopy game in which Left, at a hub, chooses between two spokes and Right must return from either. Left wins a never-ending play that passes through both spokes infinitely often. With one bit of memory recording which spoke is owed, Left wins from the hub; with a strategy that depends only on the position, Left always takes the same spoke and loses. Three position-and-mover pairs change hands. How it was found

One bit of memory

Judge an infinite play by whether one position keeps recurring and every winner can play from a table of one move per position, with nothing remembered. Ask for two positions to keep recurring and that stops being true. At a hub with two spokes a player has to alternate, and a table cannot alternate: over every three-node game, 49,487 position-and-mover pairs are won with one bit of memory and lost without it.

 Which conditions make a winner remember. Every condition on which set of three positions a never-ending play keeps returning to, grouped by two properties of the condition alone, against the arenas swept. 32 of 128 conditions have an arena Left wins and cannot win from a table of one move per position; 19 of those are closed under union. How it was found

The rule decides who has to remember

Whether a winner needs memory is a property of the winning condition and not of the board, and the property everybody reaches for is the wrong one. Of the 128 conditions on which of three positions a play keeps returning to, 32 demand memory and 19 of those are closed under union. What separates them is measured two independent ways and the two agree on all 128: a condition needs no memory exactly when it can be rewritten as a number on each position.

 The tree of {a and b and c}, and the states it costs. The Zielonka tree of one winning condition on which positions a never-ending play recurs at. The root is the whole set of positions; the children of a node are the largest subsets the condition judges the other way. The number of memory states a winner needs is read back up the tree by adding at accepted nodes and taking the largest at rejected ones, and this condition costs 3. How it was found

Two things to hold at once, or three

Whether a condition makes a winner remember has been settled over every condition on three positions; how much it makes them remember has not. A tree built out of the condition alone, with no board in it anywhere, prices all 128: sixty-one cost nothing, fifty-eight cost two states and nine cost three. It also names the property that was nearly right — closure under union of the sets a condition rejects decides it exactly, where being writable as numbers is sufficient and reaches twenty-six.

The whole library · The position index · The figures that play back