# Texas Hold 'em Series (4): Hand Evaluation

### 2019-04-09

In the previous post, we considered the probabilities of making one specific hand with the turn/river card. This can be rather useful in specific situations, but still cannot apply thoughout a game. Poker is essentially an incomplete information game. Different from Go, where you can see all stones placed on the chessboard and thereby “solve” an optimal move, you never know you opponents’ pocket cards until showdown (yet even then, people mucks). Also, you have little clue on the unshown community cards. Therefore, in order to evaluate a hand during a poker game, we’d better opt for a online evaluation algorithm instead of considering this as a DP-like problem.

# Hand Values

For the sake of convenience, the table of hand values is shown again below.

Name | Description | Example |
---|---|---|

High Card | Simple value of the card. Lowest: deuce; highest: ace. | `As` `4s` `7h` `Td` `2c` |

Pair | Two cards with the same value. | `As` `4s` `7h` `Td` `Ac` |

Two Pairs | Two pairs where each pair of cards have the same value. | `As` `4s` `4h` `Td` `Ac` |

Three of a Kind | Three cards with the same value. | `As` `4s` `4h` `4d` `2c` |

Straight | Five cards in consecutive values (ace can precede deuce or follow up king). | `9s` `Ts` `Jh` `Qd` `Kc` |

Flush | Five cards of the same suit. | `Ah` `4h` `7h` `Th` `2h` |

Full House | Three of a kind with the rest two making a pair. | `As` `4s` `4h` `4d` `Ac` |

Four of a Kind | Four cards of the same value. | `As` `4s` `4h` `4d` `4c` |

Straight Flush | Straight of the same suit. | `9h` `Th` `Jh` `Qh` `Kh` |

Royal Flush | Straight flush from ten to ace. | `Th` `Jh` `Qh` `Kh` `Ah` |

# Evaluation

Our ultimate goal is to be able to evaluate the probability of a win (and tie), i.e. the relative strength of our hand. However, let’s just try to get one step back and consider evaluating the absolute strengths. Here we denote it as the **hand value**. Ideally, there are \(\binom{52}{5}=2,598,960\) possible hands but much less valid values. An intuitive idea to match all these hands to their values, which is also what I did, is to first generate a sparse mapping from hands to values, and then condense it. First we need a function that identifies hand types. Then, for hands within the same type, we encode them like a carry system (e.g. decimal); for hands across different types, we manually add offsets so that higher hand types always yield higher values. The final results are stored in the dictionary `hv`

and serialized locally. The highest value is 6144 and here is a glance of `hv`

:

```
{
'2s3s4s5s7h' : 0,
'2s3s4s5s7c' : 0,
'2s3s4s5s7d' : 0,
'2s3s4s5h7s' : 0,
'2s3s4s5h7h' : 0,
...
'9dTdJdQdKd' : 6143,
'TsJsQsKsAs' : 6144,
'ThJhQhKhAh' : 6144,
'TcJcQcKcAc' : 6144,
'TdJdQdKdAd' : 6144,
}
```

# Simulation

Now that we have the full mapping from hands to values, there are two things we can do to calculate the probabilities:

- Enumerate all opponent hands exhaustively, and compare hand values
- Simulate certain number of opponent hands, and then compare

Things are gonna be much easier when we only consider the two-player case (a.k.a. heads-up games). In that case, we can literally count and evaluate all scenarios — when there’re 2 pocket cards for me and 3 community cards shown, we only need to enumerate \(\binom{52-5}{2}=1,081\) opponent hands, which is lightning fast to finish with modern programming languages like Python or C++. However, when we have more players, like 5, the first method gets nasty. The hands of each opponent are not independent, so we have to go through \(\binom{52-5}{2\times 4} > 3\times 10^8\) situations and that, different to the heads-up scenario, would be unacceptably slow no matter which language we use. Therefore, we opt for the second method at some cost of precision. The code (partial) is shared below.

```
def handEval(my_pocket, community, n_players, hv,
n_tot=1024, ranges=None, verbose=False):
'''
PARAMETERS:
my_pocket: list of 2 strings
community: list of 3-5 strings
n_players: integer
hv: hand_value dictionary
n_tot: integer
ranges: list of (n_players - 1) floats (default: None)
verbose: boolean
RETURN: (float, float)
'''
assert len(set(my_pocket + community)) == len(my_pocket + community) and \
all(card in deck for card in my_pocket + community), 'invalid cards'
assert n_players < 10, 'too many players'
n_unshown = 5 - len(community)
np.random.seed(123)
if ranges is None: ranges = [1] * (n_players - 1)
simulation = []
for j in range(n_tot):
available = [c for c in deck if (c not in my_pocket + community)]
sim = np.random.choice(available, n_unshown, replace=False).tolist()
available = [c for c in available if c not in sim]
for i in range(n_players - 1):
pf_range = [pf for k, pf in enumerate(pf_full) if
pf[0] in available and pf[1] in available and
k < len(pf_full) * ranges[i]]
idx = np.random.choice(range(len(pf_range)))
cards = pf_range[idx]
sim += cards
available = [c for c in available if c not in cards]
simulation.append(sim)
if verbose:
print('{}/{} ({:.2%})'.format(j + 1, n_tot, (j + 1) / n_tot), end='\r')
n_win = n_tie = 0
if not n_tot: n_tot = len(simulation)
for i, cards in enumerate(simulation):
cards = list(cards)
new_community = cards[:n_unshown]
my_full_hand = my_pocket + community + new_community
op_full_hands = []
for j in range(n_players - 1):
op_pocket = cards[n_unshown + j * 2:n_unshown + j * 2 + 2]
op_full_hands.append(op_pocket + community + new_community)
my_value = value(my_full_hand, hv)[0]
op_values = [value(op_full_hand, hv)[0] for op_full_hand in op_full_hands]
op_value = max(op_values)
# print(value(my_full_hand, hv)[1])
# for op_full_hand in op_full_hands:
# print(value(op_full_hand, hv)[1])
# print()
n_win += (my_value > op_value)
n_tie += (my_value == op_value)
if verbose: print(' ' * 50, end='\r')
return n_win / n_tot, n_tie / n_tot
if __name__ == '__main__':
with open('hv.json', 'r') as f: hv = json.load(f)
my_pocket = input('Pocket: ').split()
community = input('Community: ').split()
n_players = int(input('Players: '))
ranges = input('Opponent Ranges: ').split()
ranges = [float(i) for i in ranges] if ranges else None
p_win, p_tie = handEval(my_pocket, community, n_players, hv, ranges=ranges, verbose=True)
print('P(win) = {:.4%}\nP(tie) = {:.4%}'.format(p_win, p_tie))
```

# Example

Below are two example tests.

```
Pocket: Tc Jd
Community: 4h 5h 6d 2h Kh
Players: 2
Opponent Ranges:
```

```
P(win) = 5.4688%
P(tie) = 0.4883%
```

```
Pocket: Tc Jd
Community: 4h 5h 6d 2h Kh
Players: 2
Opponent Ranges: 0.1
```

```
P(win) = 1.9531%
P(tie) = 0.7812%
```

Note here I also implement an interesting parameter called `ranges`

which represents the opponents prior ranges at pre-flop. When passing an empty value, all combinations of two cards are considered. When we specify a list of ranges (numbers from 0 to 1, say \(x\%\)), then the opponents are assumed to only play when their pocket cards are at least in the top \(x\%\) pairs of all pairs. See this table for more reasoning.