This article is an openaccess article distributed under the terms and conditions of the Creative Commons Attribution license (http://creativecommons.org/licenses/by/3.0/).
We numerically solve the classical “Game of Pure Strategy” using linear programming. We notice an intricate evenodd behaviour in the results of our computations that seems to encourage odd or maximal bids.
Simple, twoplayer games are important models for human decision making. They should have sufficiently elementary rules so that they can be studied both theoretically and empirically, yet be sufficiently rich to involve a nontrivial amount of human psychological experience.
We study, and solve numerically, the “Game of Pure Strategy”. The solution is not implementable by a human, but only by a computer. The game is a model of decision making based on bidding, which is an important paradigm in game theory, because it can easily be shown (see below) that
We notice, in the numerical data, that the optimal probabilities of the bids do not follow a unimodal pattern; indeed the parity of the bid is often more important than its actual value. This echoes a known recommendation for online bidding (in which the bidding amounts are less restricted than in room bidding): the website
Goofspiel, also called Game of Pure Strategy (GOPS) is a two person game. Take a standard 52 card deck and discard all of the cards of one suit. The cards of one suit are given to one player, the cards of another suit are given to the other player, and the cards in the remaining suit are shuffled and placed face down in the middle. The cards are valued from low to high as ace = 1, 2, 3, ..., 10, jack = 11, queen = 12, and king = 13.
A
Though the mechanics of the game are simple, the strategy is not. Suppose for example that the king is the upturned card in the first round. Further suppose that you choose to bet one (i.e., the ace). When you turn your card up, you found out that your opponent bet his king winning 13 points. You are happy with this result because you now have 12 more betting points, which should more than make up for the lost 13 points. In fact, it is possible that you could win
To be able to solve GOPS using game theory, we use an equivalent scoring system: the player with the higher card wins from the opponent the value of the upturned card, or wins nothing in the event of a tie. The game is now a twoperson zerosum game that can be represented by a matrix with one row for each possible play of player one and one column for each possible play of player two. The
It is not hard to see that one should
How difficult is it to analyze this game? Suppose the cards are valued from 1 through
To our knowledge, the game had never been previously analyzed beyond
Let
In English, this selfevident rule says the value of the game when player one plays
Blindly applying this rule results in a straightforward recursive program; however, evaluation of
To avoid this issue, we use a bottomup approach storing the values
Linear programming is a standard technique. For the sake of completeness, we are going to explain how to use linear programming to solve a matrix game such as GOPS. Readers already familiar with this technique may wish to skip this section.
If all values
This maximization problem is a
To formulate this as a LP, we introduce the variables
The last two constraint rows are needed to ensure that
Indeed, suppose the remaining cards are
There is a single 0 × 0 game, whose value is 0, and it may be used to start the induction with
If a value is a minimum value in its column and a maximum value in its row, then it is a
We have computed the winning strategies for
Because of its formulation as a maximization of a piecewiselinear function, these probabilities are rational numbers. We shall argue that their denominators are so large as to make exact computations pointless.
We use the publicly available GLPK linear programming solver to solve repeatedly the matrix games. This package implements the simplex algorithm both in floatingpoint and multiprecision rational arithmetic.
In our computer program, we represent the card sets by bitvectors. To conserve space, we use a
The results do not get interesting until
Optimal strategy at the first move,







0.0470  0.1855  0.1182  0.1226  0.1123 

0.8327  0  0.1188  0.07347  0.0241 

0.1203  0.7375  0  0.1915  0 

0  0.0770  0.7630  0.2043  0 

0  0  0  0.4081  0.8636 
The exact values, as pointed before, are prohibitively long to write down. For example, the top entry 0.0470 is really
We have computed the exact values up to
Optimal strategy at the first move,














0  0  .052  .031  0  0  .020  0  0  0  .014  0  .010  
.414  .227  0  .020  .056  .073  0  .034  .047  .036  0  .030  0  
.090  .022  .178  .095  .036  .002  .069  .021  .002  0  .041  0  .037  
.496  .299  .034  .061  .088  .098  0  .054  .065  .067  0  .056  0  
0  .098  .230  .134  .067  0  .124  .039  0  0  .080  0  .065  
0  .355  .092  .107  .124  .185  0  .077  .120  .098  0  .082  0  
0  0  .274  .175  .101  .002  .168  .060  .001  0  .102  .008  .087  
0  0  .139  .154  .165  .218  .021  .103  .142  .138  .016  .099  0  
0  0  0  .221  .148  .045  .202  .092  .029  .015  .123  .028  .126  

0  0  0  0  .215  .266  0  .144  .177  .170  0  .124  .013 

0  0  0  0  0  .110  .397  .151  0  .063  .253  .065  0 

0  0  0  0  0  0  0  .226  .417  .241  .023  0  0 

0  0  0  0  0  0  0  0  0  .170  .348  .508  .661 
Although only the first move of the optimal strategy is given, it already points to some interesting and surprising properties. The probabilities are not at all unimodal; on the contrary, they exhibit an evenodd phenomenon. If the upcard
For small upcards, one should sometimes bet a counterintuitively high amount. If the upcard is a 1, one should never bet a 1 but should bet a 4 nearly 50% of the time! When the upcard is a 2, one should never bet a 1 but should bet a 6 about 35% of the time! When the upcard is a 3, one should sometimes bet as much as an 8! Mysteriously, one’s initial bet should be a 1 only when the upcard is a 3, 4, 7, 11 or 13.
The tables we do not show (available at
The first author made a version of the program that stored the actual probability vectors associated with the optimal strategies. These strategies were then used in a simple program that actually played the 9card game. Despite the counterintuitive nature of these results, the computer player did win the majority of the games.
If one attempts to maximize the
Our computer code was run on a 64bit computer with 160 nodes and 640 GB core memory. It relies on the GLPK linear programming library. It is available at
The computations were made with the help of the RRZN in Hannover, whose support is gratefully appreciated.