# WSOP 2016: Three Way All In For A WSOP Bracelet

The 2016 WSOP provided a variety of great finishes to the world championship events. But few were more exciting than a three-way all in, with Justin Bonomo, Davidi Kitai and Martin Kozlov for a WSOP bracelet in the 6-max $10,000 event. Make no mistake about it, due to the large buy-in and specialized nature of 6-max play, this was an event filled with professionals which created a challenging field. So it’s rather ironic that the event came down to the final three players, all with pocket pairs as their starting hands. All three players pushed their stacks in and we had a three-way all in for a WSOP bracelet to end a very tough event.

What is the probability of all three players being dealt a pocket pair as their starting hand?

Anyone who has played poker knows that pocket pairs as a starting hand do not come along all that often. So any one player being dealt a pair is an uncommon event, 2 players being dealt a pair even less common and so on for any number of players. So when you are talking about 3 pairs being dealt to 3 players (in effect, 100% of the table) it becomes a much smaller number than, say, 3 pairs to 9 seated players.

### Three Way All In For A WSOP Bracelet: A Monte Carlo Simulation

As an exercise in Python programming, we can write a Monte Carlo simulation that can deal millions of starting hands and let us know exactly how uncommon an event this is¹. We start by setting out the following requirements:

- Iterate through 10,000,000 simulations of dealt starting hands to three players; this helps us ensure that we are working with a large enough number to help validate our results.
- All cards must be dealt in a round-robin fashion, just as in a live poker tournament.
- Use Python 2.7 running on OSX.

We can start by developing a small class to both create our deck of cards and also handle the random choice and subsequent card removal. This class is similar to the one shown here.

1 2 3 4 5 6 7 8 9 10 11 | class Deck(object): def __init__( self ): self.deck = [i for i in range (102, 115)] self.deck += [i for i in range(202, 215)] self.deck += [i for i in range(302, 315)] self.deck += [i for i in range(402, 415)] def draw(self): card = random.choice(self.deck) self.deck.remove(card) return card |

Next, we need a class to manage our players. We are going to have multiple instances of this class, to represent the number of players at the table, so we still need to define individual actions for each player

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | class Player(object): def __init__( self ): self._cards = [] # hold a player current cards def clearCards( self ): self._cards = [] def dealCard( self, card ): self._cards.append(card) def hand(self): return self._cards def hasPair(self): #figures out if there is a pair if str(self._cards[0])[-2:]==str(self._cards[1])[-2:]: self._pairValue = int(str(self._cards[0])[-2:]) return True else: return False |

Finally, we can combine all of these items and simulate through the number of iterations that we need. That broad strokes of that class look like the following

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | def runPairSimulation(numberOfPlayers,sims): totalRuns=0 anyPairDealt=0 keyPlayerPairs=0 keyPlayerHasPairOtherPlayerHasPair=0 keyPlayerNoPairOtherPlayerHasPair=0 multiplePairsDealt=0 #prep the array that will track our results myPairs=[[2,0,0,0,0],[3,0,0,0,0],[4,0,0,0,0],[5,0,0,0,0],[6,0,0,0,0],[7,0,0,0,0],[8,0,0,0,0],[9,0,0,0,0],[10,0,0,0,0],[11,0,0,0,0],[12,0,0,0,0],[13,0,0,0,0],[14,0,0,0,0]] #prep the array that will track multiple instances of pairs tablePairs=[[0,0],[1,0],[2,0],[3,0],[4,0],[5,0],[6,0],[7,0],[8,0],[9,0]] #this is where the monte carlo loop starts for i in range(sims): myCards = Deck() myPlayers = [] #holds all the players at the table #fill the array of players for i in range(numberOfPlayers): me = Player() #create a generic player myPlayers.append(me) #Give each player two cards in a round-robin fashion, just like an actual dealer for i in range(2): for i in range(len(myPlayers)): me = myPlayers[i] me.dealCard(myCards.draw()) |

### Three Way All In For A WSOP Bracelet: The Results

So where do we end up with our simulation for a three-way all in for a WSOP bracelet? You can see that I have laid out the number of pairs that are dealt to the players in the table below, reflecting 10,000,000 simulations.

Pairs Dealt | Count | Percentage |
---|---|---|

No Pair | 8,336,746 | 83.3675% |

1 Pair | 1,562,430 | 15.6243% |

2 Pairs | 98,684 | 0.9868% |

3 Pairs | 2,140 | 0.0214% |

An overwhelming percentage of the time, no player is dealt a pair; all three players are dealt a pair 0.0214% of the time – or about 1 in 5000 hands!

These results are even more interesting when we look at the same simulation, except this time we look at it for 9 players.

Pairs Dealt | Count | Percentage |
---|---|---|

No Pair | 5806157 | 58.0616% |

1 Pair | 3240965 | 32.4097% |

2 Pairs | 818057 | 8.1806% |

3 Pairs | 122007 | 1.2201% |

4 Pairs | 11978 | 0.1198% |

5 Pairs | 809 | 0.0081% |

6 Pairs | 27 | 0.0003% |

7 Pairs | 0 | 0% |

8 Pairs | 0 | 0% |

9 Pairs | 0 | 0% |

You can see that as more hands are dealt, the probability of all pair combinations rise. In fact, with 9 players, we can expect three players to get a pair 1.22% of the time. That’s quite a difference from our previous three-player simulation!

### Three Way All In For A WSOP Bracelet: A Rare Treat Indeed

The video that accompanies this post provides us with an event that is pretty rare at 0.0214% probability of it happening. It’s a good video to hold on to, you might never see this same event again in your lifetime.

*¹I fully realize that this problem can also be solved with probability equations. But sometimes its just more fun to write things in Python!*