How the solved charts are made

Most poker tools ask you to trust the output. This one shows the machine instead. Every chart in the app comes from a solver built here rather than a dataset licensed from somewhere else, which means the assumptions in it are ours to state — and the only honest way to state them is completely. So this page is written the way an appendix is written: enough detail to reproduce the claims, and no claim wider than the evidence.

The one-paragraph version

Every starting hand class — AKs, 77, 72o, 169 of them — is given a showdown equity against every other class by sampling real boards from a real deck, and that table is checked against a complete enumeration of all 1,712,304 boards. A game tree is built containing every sequence of preflop actions the table can take under a fixed bet-sizing schedule. CFR+ plays that tree against itself a few thousand times, keeping a running tally of regret at every decision for every hand; the average of the strategies it played converges to an equilibrium. The output is, per node per hand, a probability for each legal action and what that action is worth. The single place an assumption enters is at endings where the betting stopped with chips still behind — there is no flop in this tree — and those are priced by a four-constant model of postflop play that was fitted against 508 real flop-to-river solves. Each chart ships with two measurements: how much any seat could still gain by deviating, and what share of hands ran through that model.

What “solved” actually means

The instinct is that somewhere there is a true answer and a solver measures it, the way you would measure π. That is not the shape of the problem. A preflop strategy is only right relative to what everyone else is doing. If everybody folds, stealing is right; if everybody three-bets, folding is right. No strategy is best in isolation.

What a solver finds is a fixed point: one strategy per seat, such that no seat can improve by unilaterally changing theirs. That is a Nash equilibrium. It is not the strategy that beats a bad field hardest — against bad players something more exploitative always wins more — it is the strategy that cannot be beaten, which is a narrower and far more useful guarantee for a study tool.

Two consequences follow, and they are the two things that surprise people:

• Equilibria are computed, not observed. You cannot obtain one by watching a million hands, because the players in those hands were not at equilibrium. Every published chart is somebody’s computation — including the ones you would use to check this one.
• More than two players weakens the guarantee. Two-player zero-sum games have a unique equilibrium value and a clean certificate. Three or more players can have many equilibria, and which one an algorithm lands on depends on where it started. This is a known limit of the mathematics, not a quirk of this implementation, and it applies to every multiway solver on the market.

Why a hand comes out at 63% raise

Because a pure strategy leaks information. If you always raise A5s and always fold A4s, an opponent can act on that, and the moment they do, one of those two decisions becomes wrong. The equilibrium fix is to leave them nothing to act on.

The mechanical version is what actually happens in the code: at equilibrium, every action a hand takes with positive frequency has exactly the same expected value as every other action that hand takes. If raising were worth more than folding, the solver would raise more; if less, it would raise less. It settles where the two are equal.

That gives you a free consistency check, and it is worth carrying: a mixed hand is an indifferent hand. If a chart shows a hand at 40% raise and the EV column says raising is worth half a big blind more than folding, one of those two numbers is wrong. Most hands are not mixed — in a typical node the great majority of the 169 classes come out pure — and the interesting dozen sitting on the threshold are the entire difference between a solved chart and a percentile ladder, which structurally cannot say “sometimes”.

The pipeline, end to end

1. 169 hand classes

A deck deals 1326 distinct two-card hands. Before the flop suits are interchangeable, so those collapse to 169 classes: 13 pairs at 6 combinations each, 78 suited at 4, 78 offsuit at 12. Those weights matter everywhere — a range containing AKo is three times as likely to be dealt as the same range containing AKs — so every frequency on this site is weighted by combinations, never by grid cells.

2. The equity table

For each of the 14,365 unordered class pairs, 60,000 random (hero combination, villain combination, board) triples are drawn from a seeded generator and the wins, ties and losses counted. Both the hands and the board are sampled, so AKs against QJs is averaged over the suit configurations that share a suit and the ones that do not, in their true proportions. The generator is seeded, so the table is a pure function of the code: run it again and you get the same file.

Sampling error is at most 0.20 percentage points per cell. That figure is checked rather than asserted: a separate routine enumerates all C(48,5) = 1,712,304 boards for a matchup with no sampling anywhere, and fifteen class pairs are run through both. The gap:

Wins and ties are stored separately rather than collapsed into the usual win + tie/2. That shorthand is exactly right in chips and wrong under ICM, where a chopped pot is worth strictly more than the average of winning and losing one. Collapsing it would bias every bubble range toward under-calling.

3. The tree

Every sequence of preflop actions the table can take, under a fixed sizing schedule, becomes a node. A node’s identity is the string of actions that reaches it: "" is the first decision of the hand, FFFR is fold-fold-fold-raise. Endings are classified into three kinds, and that classification is the whole basis of the trust ladder below: everybody folded, everybody is all-in, or the betting stopped with chips still behind.

4. CFR+

At every decision point, for every hand, keep a running tally of how much better you would have done had you always taken action A instead of the mix you actually played. That is the regret for A. Next iteration, play each action in proportion to its accumulated positive regret. Repeat. The theorem is that the average of the strategies played converges to an equilibrium.

Two details matter enough to name. Regret is floored at zero — the “+” in CFR+ — so an action that was bad for two thousand iterations does not have to climb out of a two-thousand-iteration hole when the equilibrium later makes it good. And the average is weighted by iteration number, because later iterations are the ones near equilibrium. Together those are worth roughly an order of magnitude in iterations.

What ships is the average, never the last iteration. The current strategy at any given iteration is a best-ish response to the recent past: it overshoots, undershoots and cycles. The average does not.

5. Read-out and encoding

One top-down pass under the average strategy computes, per decision node: the strategy for all 169 hands, the expected value of each action in big blinds, how often this seat arrives here holding each hand, and how often the table reaches the node at all. Each 169-number array is then written as 169 printable characters, which quantises a frequency to about 1.1 percentage points — finer than the line width of the cell it gets painted into, and small enough that a whole chart set for one format, table size and depth compresses to roughly the size of a photograph. That is why opening a spot in the app costs one request and every click afterwards costs none.

The game tree, and what it leaves out

Five deliberate simplifications. Each is a claim you could argue with, so each gets its cost stated.

One raise size per node

The entire sizing claim of the package is a lookup table, not a solve:

Plus all-in, always. A priced raise that would leave less than 10% of the stack behind is dealt as all-in instead, so the tree never grows a “raise to 47 with 3 behind” node that nobody distinguishes from shoving.

What it costs: a true equilibrium picks its own sizes and would pick slightly different ones. Preflop that is the cheapest of the five compromises and the one solvers most agree about. What it buys is a chart a person can read: three overlapping raise sizes per node is unreadable and triples the tree. The honest caveat is that these sizes were read off equilibrium solutions rather than derived, which makes them the easiest thing here to get wrong without a test noticing.

At most three players enter the pot

After three seats have voluntarily put chips in, the only legal action for anyone else is fold. This is the abstraction with teeth, and it is a cliff rather than a slope. Nine-handed at 200bb:

What it costs: four-way limped pots and squeeze-over-squeeze sequences do not exist. Two entrants would be worse — it makes “UTG raises, button calls” a spot where the big blind is forbidden to defend — and unlimited is not a bigger dataset, it is no dataset. Three buys every spot with a name: opens, defends, three-bets, four-bets, squeezes, cold calls. Where the cap is the only reason a seat cannot continue, the app says so rather than drawing it as a fold, because a node that reads “fold 100%” because the model ran out of room looks exactly like one that folds because folding is right.

Only the small blind may limp

Every other seat’s limp is dominated in published solutions, and offering it costs a branch at every seat at every depth. The big blind’s free option is to check, which is a different action and is always available.

Equal stacks, and no rake

Every seat starts with the same stack. A chart has to assume something, and the moment stacks differ the answer depends on whose stack is short — a question the app has no way to ask. It is also what makes the effective stack at every ending well-defined, and what means there are no side pots to get wrong.

No rake is modelled anywhere. That is correct for tournaments and it is a real difference from a cash solve, which is worth knowing before comparing anything — see reading these against another solver.

Classes, not combinations

The solver’s unit is the 169-class hand, so a seat’s belief about another seat’s holding does not update on its own cards. Showdown equity does account for card removal between the two hands at showdown — the sampler never deals a card twice — but ranges do not block each other. If you hold AA, the fact that two aces are gone from everyone else’s range is not reflected.

What it costs: about a tenth of a percentage point on frequencies at the margin. Undoing it means solving over 1326 combinations, roughly 60× the work per iteration, for less than the postflop model’s error bar. Every preflop chart tool makes this trade.

The trust ladder: which numbers can be wrong

This is the section to remember. Every number in the product traces back to an ending, and endings are not equally trustworthy.

Tier 3 deserves a sentence of detail. A true three-way equity needs a 169³ table; what is used instead is the average of the seat’s pairwise equities, rescaled so the three shares sum to one. It is exactly right heads-up and approximate from three seats up, where it over-rewards a hand that crushes one opponent while losing to the other — being 90% against one player and 10% against another is not the same as being 50% against both, and this treats them the same. The error is small, it has one sign, and it only touches nodes where three players get all-in before the flop.

The postflop model, and how it was fitted

When a hand ends with chips still behind, there is a flop coming that this tree does not contain. Two formulas price it. The first says how much of the money behind ends up in the middle:

commitment(spr) = 1 / (1 + spr^1.375)

The second says who is favoured after the flop. A hand that is 55% to win at showdown does not win 55% of the pots it plays: acting last you fold when you miss and charge when you hit, and you capture more than your share. That gap is the largest thing this tree does not contain, so one number stands in for it:

edge(spr) = min(0.07, max(0, −0.02 + 0.0175 · log₂(1 + spr)))

The edges are added, not multiplied, and they sum to exactly zero: the player in position takes that much more of the pot and the player out of position takes that much less, whatever the equities are. That detail is load-bearing rather than stylistic. The natural way to write it is realised = R × equity, with R above one in position — and that version was written first. Multiply each seat’s equity by a different factor and the shares stop summing to one, so chips are no longer conserved; the obvious fix is to normalise by the average equity of everyone’s range, and that is the fatal step, because it makes an ending’s payoff depend on the opponents’ ranges rather than on their hands. A payoff that moves when the opponent’s strategy moves is not a game payoff, and CFR has no fixed point to converge to. The symptom was measurable: exploitability plateauing at 0.053 big blinds and refusing to fall no matter how long it ran, on a tree that reached zero to five decimal places when the flop endings were removed.

The fitting run

Until August 2026 every constant in those two lines was chosen by hand. That is normal — every preflop solver replaces postflop play with something cheaper — but there is a spectrum, and it is worth being precise about where this sat:

The gap between the second row and the third was never the shape of the approach. Both replace postflop with a prediction. The difference was that one of them had been fitted to reality. So in August 2026 the constants were fitted: 508 flop-to-river solves across 18 spots, 49 hours of solver time, using TexasSolver as the instrument.

Three things about the method are worth stating, because they are what make the result a measurement rather than a curve fit:

• The spots are not invented. The generator re-solves real preflop spots, walks the equilibrium down to every flop-going ending, and measures the most frequently reached ones first — so the model is checked where the charts actually consult it.
• Each constant is measured from a quantity only it controls. Written out, the model is linear in equity: the slope is the pot the hand turned out to be played for, which is the commitment term and nothing else; the difference between the two seats’ mean values, net of what their ranges are worth in equity, is twice the positional edge and nothing else. A joint fit over all four at once was also run and is reported alongside — but it is not how the numbers were chosen, because fitting both together lets a wrong commitment hide inside a compensating edge.
• Every node was also solved with the stacks taken away. With nothing behind, nobody can bet, the hand is checked down, and each hand is worth exactly its equity share of the pot — which measures that board sample’s own equities exactly. This matters more than it sounds: on the validation range, sixteen boards returned a played pot of 8.39 where arithmetic says 10.00, a sixteen percent miss that would otherwise have read as the model over-predicting the pot by sixteen percent. The control run removes an error the size of the effect.

What it found

Both constants were wrong, in opposite directions:

Error per hand more than halves. The staged fit and the joint fit land on the same commitment exponent — 1.375 against 1.382 — which is the evidence that the model’s shape is adequate and only its numbers were wrong. Had those two disagreed, no choice of constants would have helped.

The old model over-predicted how much of the stacks ends up in the middle everywhere, and got steadily worse the deeper the stacks — which is exactly where the 100bb and 200bb charts live:

The visible effect on the charts is that deep opening ranges widened into the band published charts occupy. A six-handed under-the-gun open at 200bb moved from 13.2% — tighter than any published chart — to 20.5%.

The two biases that remain, named

Fitting the constants does not fix the model’s form, and two known biases survive it. Both are stated in the source, and both point the same way, so they compound rather than cancel.

• Money goes in symmetrically here; in real poker it goes in selectively. The model adds the extra chips to the pot for both seats and then lets raw equity decide who wins them. Real players get more in when they are ahead. So the model over-rewards hands that are simply ahead before the flop and under-rewards hands that play well after it.
• The positional edge does not know what you are holding. Equity realisation depends on the hand, not just the seat. Suited connectors and small pairs over-realise because they make hands that get paid; offsuit broadway under-realises because it makes second-best top pair. This model applies one number to everyone, so it is slightly too kind to offsuit high cards and slightly too harsh on suited speculative hands, in every flop-going pot, at every depth.

The fitting run turned up a third finding that has been recorded and deliberately not shipped. Split the eighteen spots by which side raised last before the flop, and the measured edge falls into two flat bands — 7.6–8.6% when the preflop aggressor is in position, and −0.2–2.5% when it is out of position — with almost no dependence on stack depth, the only axis the shipped formula uses. Keying the edge on the aggressor would be legal, since the aggressor is fixed by the action string rather than by anybody’s strategy. It was fitted both ways: correcting the constants removes 55% of the error, and the extra term removes another 4%. It is not in the product because a 4% improvement is not worth a new term whose most likely explanation is that it is measuring something else — probably the model’s single-shared-pot form running out where a very wide range faces a very narrow one.

Convergence, and the charts that are not shipped

Every solve reports its exploitability: the most any one seat could gain by unilaterally playing their best response while everyone else keeps playing the converged strategy, in big blinds per hand. It is computed directly, not estimated.

The generator does not fix an iteration count. It solves, measures, and re-solves with more iterations — 400, then 1,200, then 3,000 — until the measurement clears the bar, which makes the measurement the stopping rule instead of a guess about it. The bar is 0.010bb heads-up and loosens with the square root of the table size, to 0.017bb six-handed and 0.021bb nine-handed. That is not a concession to the clock: the number being measured is a maximum over every seat, and a maximum over nine samples is larger than a maximum over two for the same underlying quality, so holding nine-handed to the heads-up figure would be holding it to a stricter standard while appearing to hold it to the same one.

For scale: the difference between the best and second-best action on a genuinely close hand is usually a few hundredths of a big blind, so a chart sitting at its bar can be wrong about which of two marginal actions is marginally better, and cannot be wrong about anything a player would notice.

A spot that never clears its bar is not written at all. An unconverged chart is not a worse chart, it is a wrong one, and it renders in exactly the same colours as a good one. Of 512 attempted — 4 formats × 8 table sizes × 16 stack depths — 507 shipped and 5 did not. All five were ICM bubble spots, which are the hardest to converge because the payoff curve is steep. Across the 507 that did ship, exploitability runs from 0.00004 to 0.01995 big blinds per hand, with a median of 0.007.

How much of a given chart is modelled

Every chart also ships a second number: the share of deals, weighted by combinations, that end at a flop-going ending — the ones priced by the model rather than solved. Near zero, the chart is a solve. Near one, it is a model of a solve.

For the cash format, as shipped today:

Two things to read off it. It rises with depth, as it should — more chips behind means more hands that see a flop. And it falls sharply with table size, which surprises people until you count: at a full table most hands are folds by seats that never entered the pot, and a fold is tier-1 arithmetic. A heads-up chart is mostly model; a nine-handed chart is mostly arithmetic with a modelled core.

Reading these against another solver

Checking a chart against a commercial tool is the right instinct and it is the fastest way to find a real defect. It is also easy to do in a way that produces a disagreement which means nothing. Four things must match before a difference is evidence of anything:

• Rake. This solver models none. A cash solve with rake in it plays tighter, and the difference is largest exactly where pots are small and multiway — limped pots, blind defence, small three-bet pots. If you are comparing against a raked cash solution, expect ours to look looser, and expect the gap to be wider at a full table than heads-up.
• Raise sizes. Ours are fixed by the schedule above. A chart solved with 2.5bb opens is a different chart from one solved with 2.2bb opens, and the frequency difference is not an error in either. Match the size or do not compare the frequency.
• Ante and structure. The cash format here posts no ante and no straddle. The tournament formats post a big-blind ante of exactly one big blind. The two ICM formats use named, representative payout structures — ten left and nine paid on a flat curve; nine left, all paid, first paying eleven times ninth — not any specific tournament’s. A chart solved against a different payout ladder is a different chart.
• Stack depth and table size. Table size here is really a “players behind you” control: everyone in front has folded and posted nothing, so a nine-handed cutoff and a six-handed cutoff face the same problem.

Where the two should agree

• Short stacks. At 10bb most endings are folds and all-ins, and there is very little postflop left to model. Restricted to shove-or-fold, this solver reproduces an independent implementation — a different algorithm sharing no code below the equity table — to within a tenth of a percentage point at 6bb, 10bb and 15bb, with exploitability at zero to five decimal places. That check runs in the test suite, and it is the strongest single piece of evidence in the project.
• All-in-heavy spots at any depth. Four-bet-jam and call decisions, short-stack squeezes, anything where the money goes in before the flop.
• The shape of every range. Which hands are at the top, which are folds, and roughly where the boundary sits. The model errors here are worth points of frequency, not reclassifications.

Where the two will drift, and by how much

For orientation, here is what this solver actually opens with, six-handed, 100bb, cash — raise-first-in, as a share of hands dealt:

Those sit inside the band published six-max charts occupy, and the ladder between seats is the right shape. The disagreements are elsewhere, and they are predictable from the model rather than mysterious:

• Big blind defence will look tight. Facing that 2.2bb button open, this solver folds 56.6%, calls 28.2% and three-bets 15.1%. A real postflop solve defends wider, and the reason is the second named bias above: the hands the big blind should be calling with are suited, connected and speculative, and this model under-rewards exactly those. If you check one thing against another solver, check this one — it is the largest systematic disagreement in the set, and it is the place a fix would show up first.
• Heads-up is the weakest format. A heads-up chart runs 61% of its deals through the model at 100bb, against 38% six-handed — there are no folds by uninvolved seats to dilute it. It shows: at 100bb this solver has the small blind limping 58.8% and raising 38.2%, where real heads-up solutions raise most of their range. That limp is the model saying it cannot price a raised pot accurately enough to prefer one, and it is the clearest single artifact in the dataset. Treat heads-up charts above about 25bb as illustrative.
• Marginal flatting decisions generally. Whether to call a raise with a hand that will go on to play a flop is precisely the decision the postflop model exists to price, so it is precisely where its error lands.
• Hand-type composition at the margin. Expect our calling ranges to skew slightly too heavy on offsuit broadway and slightly too light on suited connectors and small pairs. Same bias, seen from the other side.
• Deep stacks. Everything above gets worse with depth, because depth is what puts hands into the model.
• Anything four-handed after the flop, uneven stacks, or raked. Not modelled at all — not a disagreement, an absence.

The structural difference between this and a tool like GTO Wizard is one sentence: they solve postflop for real and use those solutions to value preflop endings; this uses a fitted formula instead. Everything else in the two pipelines is broadly the same idea — hand classes or combinations, showdown equity, a discretised betting tree, and a regret-minimising solver. Neither is computing unabstracted poker; that remains out of reach for everyone. The difference is that their approximation of the future is learned from an enormous set of solved postflop situations and reacts to both players’ exact ranges, and ours is two formulas fitted to 508 of them. That is a large difference, and it is concentrated entirely in the places listed above.

What this solver has that a licensed dataset does not: every number is reproducible from its own source, every assumption is named where it can be argued with, and the quality of each chart is measured and published rather than assumed. That is what this page is for.

The free percentile chart is a different thing

The app has two kinds of chart and they should not be confused. The percentile chart — the one with the slider — is not a solve at all. It is the 169 hands in a fixed strength order, coloured in until you have the share you asked for. It answers “what does the top 25% of hands look like”, which is a useful thing to see and is not a strategy.

One detail there is worth stating because almost every chart gets it wrong. The 13×13 grid has 169 cells but a deck deals 1326 combinations, and the cells are not equally likely: a pair is 6, a suited hand 4, an offsuit hand 12. The hands that fall out of a range first are overwhelmingly offsuit, which are the heaviest cells. So the top 40% of the grid is about 32% of your actual deals. Every percentage in this app is a share of deals.

The solved charts are everything else on this page: real frequencies, real expected values, per node, from the solver. Free accounts get the complete cash 100bb chart set at every table size — every node and every mixed frequency, with the expected-value columns held back.

What would close the gap

In descending order of value per unit of effort, and honestly assessed:

1. Make the positional edge depend on the hand. A 169-entry table instead of one constant removes the largest named bias in both directions at once, and it is the one visible in big blind defence. It needs a source to fit against, which the calibration harness now provides.
2. Extend the fitting run. Eighteen spots were fitted; the rest were not. Multiway flops were not measured at all, because every public postflop solver is two-player. Both are more of an existing machine rather than a new one.
3. Add a second raise size where it matters. The aces raise/jam mix is the schedule visibly failing to express what the equilibrium wants. One extra priced size at three-bet nodes would remove the artifact where it is worst; it costs tree size, so it has to be measured nine-handed before committing.
4. Solve over 1326 combinations instead of 169 classes. Adds real card removal between ranges. Roughly 60× the cost per iteration, worth about a tenth of a percentage point. Last, because it is the most expensive item on the list and the smallest correction.
5. Real postflop solves at the flop endings. The actual gap-closer, and an order of magnitude more work than everything above put together. It is the difference between a solved preflop chart and a preflop chart with a modelled tail.

---