Games Hats and Codes Mira Bernstein Wellesley College

Games, Hats, and Codes Mira Bernstein Wellesley College SUMS 2005

A game with hats (N=3)

Some observations • A player gets NO information about his own hat from looking at his teammates’ hats • NO strategy can guarantee victory • Easy strategy: one player guesses, everyone else passes. • Can the players do better than 50%?

A better strategy for N=3 Instructions for all players: If you see two hats of the same color, guess the other color. If you see two different colors, pass.

Possible hat configurations Guesses #1 #2 #3

Possible hat configurations Guesses #1 RED #2 #3

Possible hat configurations Guesses #1 RED BLUE #2 #3

Possible hat configurations Guesses #1 RED BLUE RED #2 #3

Possible hat configurations Guesses #1 RED BLUE #2 #3

Possible hat configurations Guesses #1 #2 RED RED BLUE #3

Possible hat configurations Guesses X √ √ √ X #1 #2 RED #3 RED RED BLUE BLUE

Possible hat configurations X √ √ √ X Probability of winning: 75% • How is this possible? • Can we do better? • What about N >3?

Possible hat configurations Guesses #1 #2 RED #3 RED RED BLUE BLUE

Guesses #1 #2 RED #3 RED 6 correct guesses 6 incorrect guesses RED BLUE # correct = # incorrect BLUE

Why? The same instructions that lead to a correct guess in one situation… BLUE Player #3 … will lead to an incorrect guess in another. BLUE Player #3

In general… If the game is played once with each possible configuration of hats, then # correct guesses = # incorrect guesses True for any number of people N True for any deterministic strategy S

Why does the N=3 strategy work? #1 It takes only one correct guess to win! Strategy: Spread out the good guesses. Concentrate the bad guesses. #2 #3

In general… • When played over all hat combinations with N players, any strategy produces k correct guesses and k incorrect guesses. (The value of k depends on the strategy. ) • Best possible guess arrangement: – 1 correct guess per winning combination – N incorrect guesses per losing combination • A strategy which achieves this is called a perfect strategy.

Do perfect strategies actually exist? #1 N = 3: Yes! Other N? #2 #3

Some terminology H: set of all possible hat configurations (sequences of 0 s and 1 s) Distance in H: number of places in which two elements of H differ. 1 0 0 1 1 0 0 1 Distance: 2

Some terminology Ball of radius r around h H: the set of all configurations whose distance from h is at most r. h: B 1(h): center 1 0 1 1 0 0 0 1 0 0 1 1 0 1 | B 1(h)| = N+1

Some terminology • S: a (deterministic) strategy • L: set of all hat configurations where a team playing according to S loses • W: set of all hat configurations where a team playing according to S wins L W=H

An important fact Suppose h and h’ are elements of H that differ only in the i th entry. If, according to strategy S, Player i guesses correctly in h, then he guesses incorrectly in h’, and vice versa. 4 th player’s guess h: 0 1 0 0 1 h’: 0 1 1 0 0 √ X

Corollaries Theorem 1: Every element h W is within distance 1 of some element of h’ L. Proof: Suppose Player j guesses correctly in h. Let h’ be the hat configuration that differs from h only in the j th entry. Then Player j must guess incorrectly in h’, so h’ is in L.

Corollaries Theorem 2: In a perfect strategy S, every element h W is within distance 1 of exactly one element of L. Proof: Suppose h differs from h 1 L in the i th entry and from h 2 L in the j th entry. Since S is a perfect strategy, all players guess incorrectly in h 1 and h 2. But then Players i and j must both guess correctly in h, which cannot happen in a perfect strategy.

Corollaries In other words…. Theorem 1: Every element h H is contained in a ball of radius 1 around some element of L. Theorem 2: In a perfect strategy S, the balls of radius 1 around elements of L do not overlap.

Codes A perfect code of length N is a subset L in H such that the balls of radius 1 around points of L • include all of H • do not overlap A perfect strategy yields a perfect code!

A perfect code H

A perfect code H = points of L

Perfect code perfect strategy Instructions for Player i: – If the hat configuration might be in L: Guess so that if it’s in L, you’ll be wrong. – If you can tell that the hat configuration is not in L: Pass

Perfect code perfect strategy Results (for hat configuration h): – If h is in L: Every player guesses wrong. – If the hat configuration h is not in L: There is a unique element h’ of L which differs from h in one place -- say the i th place. The i th player can’t tell if the configuration is h or h’, so he guesses away from h’, correctly. All others pass.

Example: N=3 L = {000, 111} 011 001 101 010 000 111 100 110

Example: N=3 L = {000, 111} 011 001 111 101 010 000 110

Example: N=3 L = {000, 111} Instructions for Player i: – If the hat configuration might be in L, guess so that if it’s in L you’ll be wrong. Translation: If you see two 0’s or two 1’s, guess the opposite number.

Example: N=3 L = {000, 111} Instructions for Player i: – If you can tell that the hat configuration is not in L, pass. Translation: If you see two different numbers, pass.

How good are perfect strategies? Theorem: If S is a perfect strategy for N players then the probability of winning is N/ N+1. Proof: In every ball, N out of the N+1 points correspond to winning configurations. Example: If N=3, the probability of winning with a perfect strategy is ¾. There can be no better strategy than the one we found.

Do perfect codes exist for N>3? Theorem: A perfect code of length N can exist only if N=2 m-1 for some integer m. Proof: A perfect code splits H into disjoint balls of radius 1. Each of the balls has N+1 points and H has 2 N points, so 2 N is divisible by N+1. Thus N+1 is a power of 2, so N=2 m-1. Example: We know a perfect code of length 3 = 22 -1. But what about 7, 15, 31, …?

Error-correcting codes I love you! 11010 … I y 11010 …

Error-correcting codes I love you! 11010 … 10010 …

Error-correcting codes I love you!

Error-correcting codes I love you! I y

A different game: Nim A

A different game: Nim f A

A different game: Nim A

A different game: Nim L A

Nim is… • Combinatorial: no element of chance • Impartial: same moves available to each player • Finite: must end after a finite number of moves In any Nim position, exactly one of the players has a winning strategy.

Who wins? P-position: Previous player wins N-position: Next player wins e. g. the empty game is a P-position e. g. two equal piles is a P-position e. g. two unequal piles is an N-position Nim strategy: Figure out which positions are P-positions and move to them!

More on P and N P-position: cannot move to a P-position; move only to an N-position (or not at all) N-position: can move to at least one Pposition If you combine two Nim games into one: • P + P = P: cannot move to another P+P • N + P = N: can move to P+P • N + N = ? (depends on the games)

Position vectors A Nim position with all heaps of size N can be described by a vector of length N. 1 heap of size 5 2 heaps of size 2 3 heaps of size 1 (1, 0, 0, 2, 3)

Position vectors Two equal heaps are a P-position, so we can ignore them (P+P=P, N+P=N). 1 heap of size 5 2 heaps of size 2 3 heaps of size 1 (1, 0, 0, 2, 3)

Position vectors Thus we can replace all the entries in the position vector with 0’s and 1’s. 1 heap of size 5 2 heaps of size 2 3 heaps of size 1 (1, 0, 0, 0, 1) Binary vector

Legal moves Let X, Y be binary position vectors for Nim. One can move from X to Y if • X >Y (as binary numbers) • Distance from X to Y is 1 or 2 Examples: 1 0 1 1

Legal moves Let X, Y be binary position vectors for Nim. One can move from X to Y if • X >Y (as binary numbers) • Distance from X to Y is 1 or 2 Examples: 1 0 0 1

Legal moves Let X, Y be binary position vectors for Nim. One can move from X to Y if and only if • X >Y (as binary numbers) • The distance from X to Y is 1 or 2 Examples: 1 0 0 0

P and N: review P-position: cannot move to a P-position; move only to an N-position (or not at all) N-position: can move to at least one Pposition

P and N revisited Theorem: The distance between two Pposition vectors is ≥ 3. Proof: If the distance were 1 or 2, you could move from the larger vector to the smaller one. However, it is impossible to move from a P-position to a P-position. Corollary: Balls of radius 1 around Ppositions do not overlap.

P and N revisited Theorem: Any vector X with distance ≥ 3 from all smaller P-positions is a P-position. Proof: Since you cannot move from X to any P-position, X itself must be a P-position. Corollary: We can look for P-positions inductively.

How to look for P-positions • Start with (…, 0, 0) • At each step, look for the next smallest sequence that has distance ≥ 3 from every previously-found P-position. • The preceding theorems guarantee that this procedure will give you all and only Ppositions!

Why look for P-positions? • To win at Nim. • The set of all P-positions with heaps of size N will give us non-overlapping balls of radius 1. If N=2 m-1, we may get a perfect code. • To find perfect strategies for the hat game.

P-positions for heaps of size 7 0000000111 0001? ? ? Start with 0 Smallest v with three 1’s Impossible!

P-positions for heaps of size 7 0000000111 0010? ? ? Start with 0 Smallest v with three 1’s Impossible!

P-positions for heaps of size 7 0000000111 0011? ? ? Start with 0 Smallest v with three 1’s

P-positions for heaps of size 7 0000000111 0011001 0011? ? ? Start with 0 Smallest v with three 1’s Next smallest

P-positions for heaps of size 7 0000000111 0011001 0011? ? ? 0 A B

P-positions for heaps of size 7 0000000111 0011001 0011110 0100? ? ? 0 A B A+B Impossible!

P-positions for heaps of size 7 0000000111 0011001 0011110 0101? ? ? 0 A B A+B

P-positions for heaps of size 7 0000000111 0011001 0011110 0101010 01? ? ? 0 A B A+B C

P-positions for heaps of size 7 0000000111 0011001 0011110 0101010 0101101 0110011 0110100 0 A B A+B C C+A C+B C+A+B

P-positions for heaps of size 7 Can we have any other P-positions that begin 01 XXXXX? D Then we would have D+A, D+B, etc: 16 total Can we have 16 P-positions with heaps 6? (16 balls of radius 1) (7 points per ball) > 26 Impossible!

P-positions for heaps of size 7 0000000111 0011001 0011110 0101010 0101101 0110011 0110100 0 A B A+B C C+A C+B C+A+B

P-positions for heaps of size 7 0000000111 0011001 0011110 0101010 0101101 0110011 0110100 0 A B A+B C C+A C+B C+A+B 1000? ? ? No!

P-positions for heaps of size 7 0000000111 0011001 0011110 0101010 0101101 0110011 0110100 0 A B A+B C C+A C+B C+A+B 1001? ? ?

P-positions for heaps of size 7 0000000111 0011001 0011110 0101010 0101101 0110011 0110100 0 A B A+B C C+A C+B C+A+B 1001011 D

P-positions for heaps of size 7 0000000111 0011001 0011110 0101010 0101101 0110011 0110100 0 A B A+B C C+A C+B C+A+B 1001011 1001100 1010010 etc. D D+A D+B

P-positions for heaps of size 7 16 P-positions 8 points per ball 128 = 27 points A perfect code! A vector space over Z 2 with basis 0000111 A 0011001 B 0101010 C 1001011 D

The Hamming Code for N=7 Our code is the kernel of the matrix A = 1111000 1100110 1010101 over Z 2 The columns are the numbers 1 -7 in binary! This code is called the Hamming Code.

The Hamming Code for N=7 A quick way to check if v ker(A): • Record the numbers corresponding to the positions where v has a 1 • Write these numbers in binary, with leading zeros if necessary • Add the numbers as binary vectors: 1+1 = 0, no carry! • v ker(A) iff you get 0

The Hamming Code for N=7 Example: v=(1010001) v has 1’s in positions 7, 5, 1 7=111 5=101 1=001 padding 011 addition with no carry The answer is not 0, so v is not in the code.

Finding the nearest code vector v=(1010001) Which coordinate of v should we change? • When we “added” 7, 5, and 1, we got 0 1 1. • If we change the “ 3” coordinate of v from 0 to 1, we’ll have to “add” another 0 1 1. • 011+011=000! v’ = ( 1 0 1 0 1 ) is in the code.

The Hamming Code for N=2 m-1 Let A be the m N matrix whose columns are the numbers 1 through N, written in binary. For N=15: A = 11110000000 111100001111000 11001100110 101010101 ker(A) is called the Hamming code of length N.

The Hamming Code for N=2 m-1 Every N-vector v is within distance 1 of exactly one code vector v’. A(v), read as a binary number, gives the coordinate in which v and v’ differ! The Hamming code is a perfect code, which makes error-correction especially simple!

Homework • Prove that the Hamming Code really is perfect and that A(v) gives the coordinate of the error. • Using the Hamming code, find a practical strategy for Nim. • Using the Hamming code, find a practical strategy for the hat game for 7 players.

A bit more about codes Not all codes are perfect: – In a general error-correcting code, the balls around the code points are disjoint, but do not necessarily include every point in the space. – In a general covering code, the balls cover the whole space, but may overlap. – A perfect code is both an error-correcting code and a covering code.

A bit more about codes • In a general error-correcting code, the balls around the code points may have radius r>1. • The Hamming codes are (essentially) the only perfect codes with radius 1. • The is only one other perfect code: the Golay code for N=23, with radius 3.

Lexicodes We used the P-positions of a game (Nim) to construct a code (the Hamming code). In general, the P-positions of many impartial games correspond to well-known codes! These can be constructed in increasing lexicographic order, starting at 0 -- hence the name lexicodes!

References • Lexicographic Codes: Error-Correcting Codes from Game Theory, John H. Conway and N. J. A. Sloane, IEEE Trans. Inform. Theory, 1986 http: //www. research. att. com/~njas/doc/lex. pdf • On Hats and Other Covers, H. Lenstra and G. Seroussi, 2002 (preprint) www. hpl. hp. com/infotheory/hats_extsum. pdf