[Daxonovitch]

So, I'm tossing around the idea of writing a graphical EV analyzer for limit HU play. The idea is that for each hand, you could examine your equity (of your previous results) based on the action and your hole cards.

Basically, for any hand, there are three components: betting pattern, holding, and flop texture.

The first is the betting - there are a finite amount of these:

s: Small Blind
b: Big Blind
c: call/check
r: bet/raise

So, for preflop, the actions are as follows, labelled p ('preflop') A through G:

pA: sc bc (small blind calls, big blind checks)
pB: sc br sc (sb call, bb raise, sb call)
pC: sc br sr bc (sb call, bb raise, sb limp-reraise, bb call)
pD: sc br sr br sc (sb call, bb raise, sb limp-reraise, bb 4bet, sb call)
pE: sr bc (small blind raises, big blind calls)
pF: sr br sc (sb raises, bb 3bets, sb calls)
pG: sr br sr bc (sb raise, bb 3bet, sb 4bet, bb call)

Folds aren't included as your equity for folding is whatever is in the pot, which is negative, unless you find a way to get the dealer to push it to you accidentally. [img]/images/graemlins/blush.gif[/img]

There's a similar list of actions for the flop labelled f ('flop') A through I:

fA: bc sc (bb check, sb check)
fB: bc sr bc (bb check, sb bet, bb call)
fC: bc sr br sc (bb checkraises)
fD: bc sr br sr bc (bb checkraises, sb 3 bets)
fE: bc sr br sr br sc (bb checkraises, sb 3 bets, bb caps)
fF: br sc (bb bets, sb calls)
fG: br sr bc (bb bets, sb raises, bb calls)
fH: br sr br sc (bb bets, sb raises, bb 3bets, sb calls)
fI: br sr br sr bc (4 bets)

So, now, the total number of possible actions is 63 (7x9) although the great majority of them don't really make sense and/or occur rarely (pAfI: limp/check then 4 bets on the flop, pGfA: 4 bets preflop then check/check flop, etc).

Now for the tricky part. The second component to classifying the hand is the holding you have. Here's where it gets fun. The holding can be broken down into two parts: what you have and what you're drawing to. Here are some very high level classifications:

made full house or better
made good flush
made medium flush
made bad flush
made nut straight
made straight (2nd or third nut)
top set
middle/bottom set
two pair
overpair
top pair (good/medium/bad kickers)
middle/bottom pair (good/medium/bad kickers)
ace high
king high
queen high
junk

With the following definitions:

top kicker: A
good kicker: K-T
medium kicker: 9-6
bad kicker: 5-2
good flush: 2nd nut to 4th nut flush
medium flush: 5th to 7th nut flush
bad flush: 8th to 10th nut flush
RR: runner runner

The other half of your holding is the hands you might be drawing to, so here are some drawing hands:

gutshot nut straight draw
gutshot straight draw
gutshot idiot straight draw
nut flush draw
nut good flush draw
nut medium flush draw
nut bad flush draw
straight flush draw
two overcards
one overcard
RR straight draw
RR flush draw

I don't include any two pair type drawing hands, because all hands technically can draw to RR two pair.

These lists of holdings aren't complete (if anyone has suggestions, please feel free to add or discuss).

The third part of a hand is the flop texture:

rainbow
2 flush
3 flush
connected (straights possible)
high cards (2 or more cards higher than ten)
low cards (2 or more cards lower than 6)
high card paired
low card paired

This list isn't complete, either.

So, now we have a complete method by which we can analyze a hand on the flop.. beyond that it gets increasingly complicated, but generally easier to play. Lots of analysis has been done on starting hand requirements so I won't go into that here.

The idea for the program is that you would be able to look at any "node" and determine what kind of equity you have based on hands you've played in that situation previously. The program would be able to accumulate the previous possible nodes and the best "course of action" for your betting pattern (or perhaps list the top choices to you if you want to mix up your play).

For example, say you're in a pF+nutflush+twoovercards ('pF': 3 bets preflop) situation. The program would look to your results for all the possible flop actions (fA through fI) and list your equity for each based on your previous results.

That's the idea, anyway. There's quite a few interesting things about it. Some thoughts:

<li> It's clear that HU is a very complicated game with a lot of situations: 7 preflop betting patterns, 20+ holdings on the flop, 12+ draws, and 8+ flop textures. That's over 13,000 situations with 9 possible flop actions for each, although the great majority of them occur rarely or are simple to play. Being able to play enough hands just to see a handful of these situations enough to figure out some reasonable EV is likely impossible.

<li> Obviously, there's a lot of places someone can play way-less-than optimally. If someone is making a ton of mistakes in a lot of different situations, your equity tree gets many "juicy" nodes - situations that make a lot of money for you. The more those occur, the less variance you'll see (you'll quickly separate a person from his money and the negative variance swings will be offset by the common wins).

<li> Conversely, if someone is playing near optimally, but making a couple mistakes in a few nodes, it'll take you a very long time to capitalize off of those mistakes, hence, your win will be smaller relative to the variance (assuming we play perfectly). Depending on how small the mistakes are and the limit you're playing, you may actually be losing money to the rake.

<li> This would be a start to a complete solution for HU play, one node at a time. First, solve one node. Then, figure out how to solve a node in an automated fashion. Then figure out how to add enough strategy to make the other opponent keep guessing (taking slightly less than optimal solutions if they match up to other nodes - "acting" like you have something else). I think.

<li> At a minimum, it seems possible to take a look at the most commonly occuring situations and analyze them.

<li> A great deal of the holdings could probably be reduced.

<li> It might be fun to name some of the betting patterns for conversational ease ("..so he opened with the Jackhammer, I flopped two pair, Skyscraper, and it held...") or something.

<li> Ultimately, a graphical program would be the goal, where you can view your "strategy" as a tree, clicking on various nodes and drilling into your performance for that node. A really fancy version might be able to train you, knowing where you biggest leaks are (maybe you tend to four-bet lousy flush draws on the turn, and it could tell you how bad your equity in those situations is).

Just some thoughts for now.