The world's leading poker book publisher

Will Tipton’s Solving Poker With IPython And Fictitious Play

Will Tipton


Anyone who has read Expert Heads Up No Limit Holdem knows that there is tons to learn from solving model games and analyzing the GTO strategies that result. The ability to solve large poker games was directly responsible for many of the insights in EHUNL and set it apart from poker advice available elsewhere. Unfortunately, this sort of work involves large computations, and software to perform these calculations was not publicly accessible – until now.

This video series will walk you through the development of computer code to solve for maximally exploitative and equilibrium strategies of arbitrary HUNL decision trees, to visualize the trees, and to investigate the resulting strategies and the EVs of playing them. You will learn to leverage the powerful but user-friendly iPython (interactive python) programming enviroment and create a tool that allows you to perform many of the calculations described in the books. Moreover, in learning how to build it rather than how to use a pre-existing software package, you will gain the understanding necessary to go beyond published work and to perform game theoretic studies of your own imagination. It’s an exciting time to be a poker player.


Is prior programming experience necessary? Absolutely not. The series was built to teach players without any programming knowledge at all, how to build the computer code to solve valuable situations. All you need is a willingness to learn.
How do I know if this series is for me? If you’re interested in solving poker situations to help you become a much stronger player, this series is for you. If you’re still unsure, we’ve included the first three videos of the series below, free, to show you how simple this is. Watch the first three videos and get a full idea of what the video pack is all about.


iPython setup
Intro to iPython and functions
Hand-vs-hand equity calcuations
Hand-vs-hand equities fast
A bit of homework: ranges
The Ranges class and hand-vs-range equities
Equity distributions
The shove/fold game
Decision points and trees
Visualizing trees with graphviz
Max-EV play
Maximally exploitative strategies and FP
A turn and river spot and discussion
What’s next?

When writing my Range class, __repr_svg__ doesn’t seem to work: trying to display a range gives something like <__main__.Range instance at 0x0638DD00>.

That text is the default representation of a range (the name of the class and its memory address). This happens because it can’t use the image-generating display function we’ve written. There could be two reasons for this: (1) it can’t find the function, or (2) there’s an error when it tries to run it – in this case, it silently falls back on the default representation.

To address (1), make sure you’ve named the function correctly: _repr_svg_. One underscore at the beginning and end and one in the middle. Also make sure that indentation/whitespace is correct as in the video. If it is incorrect, python may not know that that function should be associated with the Range class.

To address (2), run the function manually. In other words, if you have a range called bob, run: bob._repr_svg_(). This way, if an error occurs, it will be displayed, and you can debug.


The full series contains 17 videos in 13:00:43.

  • 01-intro (20:23)
  • 02-windows_ipython_setup (11:03)
  • 03-intro_and_functions (46:31)
  • 04-handvshand-eqs (25:48)
  • 05-equityarray (67:34)
  • 06-range_hw (06:08)
  • 07-range (125:28)
  • 08-eq_distns (16:49)
  • 09-shove_fold (34:24)
  • 10-decPt_and_tree (37:05)
  • 11-graphviz (71:52)
  • 12-strategy_pair (84:23)
  • 13-max-ev (90:57)
  • 14-maxev_and_fp (46:35)
  • 15-details_and_example (63:52)
  • 16-what_next (11:28)
  • 01-intro (20:23)