What does Four-Player Imperfect Information conclude, in numbers, about “Solving the Game, and the Money”?
Answer: Chapter 6 verifies counterfactual regret minimisation on a two-player zero-sum game (exploitability from 0.667 to 0.0013, value −0.055554 against −1/18) and honestly reports two negative results on a three-player game: exploitability still falls to 4 × 10⁻⁶, and four simple deviations failed to push the player below the equilibrium value. The Kelly growth curve is nearly symmetric (half-Kelly keeps 75.3 %, 1.5× Kelly 75.7 %), so the reason to stake less is estimation error, not the curve's shape.
Scope of the numbers: Marked boxes separate published evidence, runnable Python calculations (16 programs), classical sources and the author's models and hypotheses; apart from cited literature data, all data in the book are synthetic.
Data table
The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 0.0013, 0.667, 10, 18
Two-player zero-sum one-card betting game: 6 deals, 12 information sets.
Exploitability = best-response value for p0 plus that for p1; it is zero
exactly at equilibrium and positive otherwise.
iterations exploitability value to player 0
1 0.666667 -0.020833
10 0.182288 -0.035974
100 0.046601 -0.054715
1000 0.013010 -0.055178
10000 0.002972 -0.055531
100000 0.001265 -0.055554
(the game's known value to player 0 is -1/18 = -0.055556)
exploitability falls from 0.667 to 0.0013
Average strategy (P(pass), P(bet)):
card J, history '- ' -> pass 0.780, bet 0.220
card Q, history '- ' -> pass 1.000, bet 0.000
card K, history '- ' -> pass 0.337, bet 0.663
card J, history 'b ' -> pass 1.000, bet 0.000
card Q, history 'b ' -> pass 0.664, bet 0.336
card K, history 'b ' -> pass 0.000, bet 1.000
card J, history 'p ' -> pass 0.668, bet 0.332
card Q, history 'p ' -> pass 1.000, bet 0.000
card K, history 'p ' -> pass 0.000, bet 1.000
card J, history 'pb ' -> pass 1.000, bet 0.000
card Q, history 'pb ' -> pass 0.445, bet 0.555
card K, history 'pb ' -> pass 0.000, bet 1.000
The known equilibria of this game have the first player betting the worst
card (J) at a rate alpha in [0, 1/3] and betting K at 3 x alpha. Here the
average strategy bets J at 0.220 and K at 0.663, a ratio of 3.01,Show the full program
# Chapter 6. Counterfactual regret minimisation where it is guaranteed to
# work: a two-player zero-sum game. The toy game is the standard one-card
# betting game (Kuhn's game), an abstraction of "commit or fold with private
# information" small enough to solve exactly and large enough to have a
# non-trivial mixed equilibrium. Zinkevich and colleagues' result is that
# regret matching on counterfactual regrets converges, in the AVERAGE
# strategy, to a Nash equilibrium of a two-player zero-sum game. The program
# demonstrates that by computing exact exploitability, which falls toward
# zero. Programme p08 then removes the two-player condition. Standard library
# only; exact tree traversal, no sampling.
import math
from itertools import permutations
CARDS = [0, 1, 2]
ACTIONS = "pb"
NAMES = {0: "J", 1: "Q", 2: "K"}
class Node:
def __init__(self):
self.regret = [0.0, 0.0]
self.strategy_sum = [0.0, 0.0]
def strategy(self):
r = [max(0.0, x) for x in self.regret]
s = math.fsum(r)
return [0.5, 0.5] if s <= 0 else [x / s for x in r]
def average(self):
s = math.fsum(self.strategy_sum)
return [0.5, 0.5] if s <= 0 else [x / s for x in self.strategy_sum]
nodes = {}
def is_terminal(history):
if len(history) < 2:
return False
return history[-1] == "p" or history[-2:] == "bb"
def terminal_util(history, cards):
"""Utility for the player who would act next at this terminal history,
i.e. the
standard Kuhn convention: the value is for `player = len(history) % 2`."""
player = len(history) % 2
opp = 1 - player
higher = cards[player] > cards[opp]
if history[-1] == "p":
if history == "pp":
return 1 if higher else -1
return 1 # the opponent folded to a bet
return 2 if higher else -2 # double bet
def cfr(cards, history, p0, p1):
"""Returns the utility of `history` for the player about to act."""
if is_terminal(history):
return terminal_util(history, cards)
player = len(history) % 2
key = (cards[player], history)
node = nodes.setdefault(key, Node())
strat = node.strategy()
util = [0.0, 0.0]
node_util = 0.0
for i, a in enumerate(ACTIONS):
if player == 0:
util[i] = -cfr(cards, history + a, p0 * strat[i], p1)
else:
util[i] = -cfr(cards, history + a, p0, p1 * strat[i])
node_util += strat[i] * util[i]
reach_opp = p1 if player == 0 else p0
reach_self = p0 if player == 0 else p1
for i in range(2):
node.regret[i] += reach_opp * (util[i] - node_util)
node.strategy_sum[i] += reach_self * strat[i]
return node_util
# A best response must be measurable with respect to the responder's OWN
# information, so it cannot depend on the opponent's card. The tree is small
# enough to enumerate every deterministic strategy of the responder: each
# player has 6 information sets (3 cards x 2 histories at which they act),
# hence 2^6 = 64 pure strategies.
INFOSETS = {0: [(c, h) for h in ("", "pb") for c in CARDS],
1: [(c, h) for h in ("b", "p") for c in CARDS]}
def value_for_p0(cards, history, strat0, strat1):
"""Expected value to player 0, both players following given strategy
maps."""
if is_terminal(history):
u = terminal_util(history, cards)
return u if len(history) % 2 == 0 else -u
player = len(history) % 2
probs = (strat0 if player == 0 else strat1)[(cards[player], history)]
return math.fsum(
probs[i] * value_for_p0(cards, history + a, strat0, strat1)
for i, a in enumerate(ACTIONS)
)
def pure_strategies(player):
sets = INFOSETS[player]
for mask in range(1 << len(sets)):
yield {k: ([1.0, 0.0] if (mask >> i) & 1 == 0 else [0.0, 1.0])
for i, k in enumerate(sets)}
def full(avg, player):
"""avg restricted to one player's information sets, defaulting to
uniform."""
return {k: avg.get(k, [0.5, 0.5]) for k in INFOSETS[player]}
def exploitability(avg):
"""Best-response value for each player against the other's average
strategy.
At equilibrium the two sum to zero (the game's value cancels)."""
deals = list(permutations(CARDS, 2))
s0, s1 = full(avg, 0), full(avg, 1)
best0 = max(
math.fsum(value_for_p0(c, "", p, s1) for c in deals) / len(deals)
for p in pure_strategies(0)
)
best1 = max(
math.fsum(-value_for_p0(c, "", s0, p) for c in deals) / len(deals)
for p in pure_strategies(1)
)
return best0 + best1
def game_value(avg):
deals = list(permutations(CARDS, 2))
s0, s1 = full(avg, 0), full(avg, 1)
return math.fsum(value_for_p0(c, "", s0, s1) for c in deals) / len(deals)
if __name__ == "__main__":
deals = list(permutations(CARDS, 2))
print(
"Two-player zero-sum one-card betting game: 6 deals, 12 information"
" sets."
)
print(
"Exploitability = best-response value for p0 plus that for p1; it is"
" zero"
)
print("exactly at equilibrium and positive otherwise.\n")
print(" iterations exploitability value to player 0")
marks = {1, 10, 100, 1000, 10000, 100000}
ex = []
for it in range(1, 100001):
for cards in deals:
cfr(cards, "", 1.0, 1.0)
if it in marks:
avg = {k: v.average() for k, v in nodes.items()}
ex.append(exploitability(avg))
print(" {:10d} {:16.6f} {:19.6f}"
.format(it, ex[-1], game_value(avg)))
print(" (the game's known value to player 0 is -1/18 = {:.6f})"
.format(-1.0 / 18.0))
print(" exploitability falls from {:.3f} to {:.4f}"
.format(ex[0], ex[-1]))
avg = {k: v.average() for k, v in nodes.items()}
print("\nAverage strategy (P(pass), P(bet)):")
for key in sorted(avg, key=lambda k: (len(k[1]), k[1], k[0])):
card, hist = key
print(" card {}, history '{:3s}' -> pass {:.3f}, bet {:.3f}"
.format(NAMES[card], hist or "-", avg[key][0], avg[key][1]))
jb = avg[(0, "")][1]
print(
"\nThe known equilibria of this game have the first player betting"
" the worst"
)
print(
"card (J) at a rate alpha in [0, 1/3] and betting K at 3 x alpha."
" Here the"
)
print(
"average strategy bets J at {:.3f} and K at {:.3f}, a ratio of"
" {:.2f},".format(
jb, avg[(2, "")][1], avg[(2, "")][1] / jb if jb else float("nan")
)
)
print(
"against the predicted 3.00, and exploitability falls toward zero."
" That is"
)
print("Zinkevich and colleagues' guarantee in action.")
print(
"\nWhat the guarantee rests on: TWO players and ZERO sum."
" Programme p08"
)
print("removes the first condition and shows what survives.")Single source and citation
Fan, Y. (2026). Imperfect-Information Stochastic Games, Bayesian Hand-Reading and Counterfactual Regret Minimisation in Four-Player Tile Dynamics (Version 1.0.0), Chapter 6: Solving the Game, and the Money. 5D Library. https://doi.org/10.5281/zenodo.24020464
DOI: 10.5281/zenodo.24020464 · Read the monograph · 5DL-B-055 · v1.0.0 · CC-BY-NC-ND-4.0
BibTeX
@book{fan2026055,
author = {Fan, Yafu},
title = {Imperfect-Information Stochastic Games, Bayesian Hand-Reading and Counterfactual Regret Minimisation in Four-Player Tile Dynamics},
year = {2026},
publisher = {5D Library},
edition = {1.0.0},
doi = {10.5281/zenodo.24020464},
url = {https://doi.org/10.5281/zenodo.24020464}
}Other chapter answers in this book
- Chapter 1 · Scale: Why the Information Sets Cannot Be Listed
- Chapter 2 · The Tile Pool: Hypergeometric Inference and a Result That Runs Backwards
- Chapter 3 · Hand Reading: Suji Is a Deduction, Not a Regularity
- Chapter 4 · Shanten, Acceptance and the Race: Ignoring Three Players Overstates the Win
- Chapter 5 · Folding: Optimal Stopping, and a Conclusion Stated Backwards
- Chapter 7 · Classics Read Side by Side: The Substantial and the Empty, the Orthodox and the Unorthodox, and the Fog of War
- Chapter 8 · Practice and a Pre-Registered Test