Methodology for Identifying Optimal Single Bet Sizes and Raise Sizes
I've been working on building simplified baseline strategies from solver outputs and would appreciate some advice on methodology.
My goal is to use solvers (primarily GTO+) to identify:
* Optimal single flop c-bet size for IP and OOP in various formations.
* Optimal flop check-raise sizing.
* Optimal turn check-raise sizing.
* Reasonable simplifications that preserve most of the EV while reducing complexity.
What I'm struggling with is not the mechanics of running a solve, but the experimental process itself.
For example, suppose I start with a richer tree containing multiple flop bet sizes and multiple raise sizes. I can compare EVs and eventually conclude that a single bet size (e.g., 75% pot) and a single raise size (e.g., 2.5x) perform best as simplifications. However, I'm unsure what the next step should be.
Some questions:
1. After identifying a candidate simplified strategy, should I rebuild the tree using only those sizes and let both players re-solve against each other?
2. When testing a simplified strategy, should I lock one player and allow the other to adjust, or should both players be free to adapt?
3. How do you determine whether an EV loss is due to the size itself being inferior or due to the opponent's strategy not having been re-optimized?
4. When searching for an "optimal" single size, what is the standard methodology experienced solver users follow?
5. Are there established guidelines for deciding what actions to lock and what actions to leave unlocked during these experiments?
More broadly, I'm looking for resources that teach solver experimentation as a process rather than solver operation. Most material I've found focuses on how to use the software, but not on how to design good experiments and draw reliable conclusions from the results.
I've been watching Solver School's Solver Masterclass series on YouTube, which has been helpful, but I'm not sure whether it covers this type of methodology in depth.
Are there any threads, articles, courses, Discord communities, or other resources that walk through this process step by step? My ultimate goal is to build a coherent simplified strategy framework, not just analyze individual solves in isolation.
2 Replies
1. Yes
2. You can do either, but usually you just want to look at the Nash. If you believe the nash response vs. your simplified strategy is unrealistic (i.e. that no one is going to play like that), then it can be reasonable to nodelock what you think their response is going to be vs. a specific size and simplify your strategy as a function of that output.
3. When utilizing a solver you are automatically solving for the nash equilibrium given the constraints, so the opponent's "strategy" should always be maximally exploitative given those constraints
4. Simplifying a strategy node such that the sizing used yields a strategy that is intuitive and easily implementable for the user while simultaneously minimizing EV loss either in reality or in the nash response--both things are important
5. I'd recommend mostly nodelocking the initial response rather than subsequent responses as it will get very convoluted very quickly otherwise. That is to say—when you are nodelocking vs. a specific c-bet size then just nodelock the initial response to that bet (call/fold/raise) rather than actions following that.
You can peruse gtowizards library on Youtube and their various articles. GTOwizard also has a subscription for AI solves in which it automatically identifies and solves using optimal 1 sizing strategies if that is what you prefer. This minimizes EV loss vs. nash while utilizing the given number of sizings (in your case -- 1).
Thanks for your reply. I checked out GTO Wizard's AI one-size solves and came up with the following workflow. My goal is not to reproduce equilibrium as accurately as possible, but to create a practical baseline strategy while still understanding the strategic thresholds behind it.
One major constraint is hardware. My laptop doesn't have enough RAM to run the large research trees I'd ideally like to run, especially in SRPs.
My current idea is:
**Flop**
* Use GTO Wizard's AI one-size solution as the baseline.
* Copy the recommended betting and raising sizes into my custom solver tree.
* Essentially treat the flop simplification problem as already solved by GTO Wizard's larger research tree.
**Turn**
* Build a richer turn tree with multiple betting and raising options.
* Use the turn reports to identify strategically distinct turns (heavy polarization, meaningful size splitting, significant raising, etc.).
* For those turns, compare the richer solution against GTO Wizard's AI one-size turn solution and study which hand classes migrate between actions/sizes.
**River**
* Use the AI flop and turn strategies as the baseline.
* Keep multiple river sizes and focus on studying value/bluff thresholds, blocker effects and size-selection logic rather than forcing a one-size river strategy.
The idea is to use GTO Wizard to generate a baseline strategy and then use my own solver work to understand what strategic information is being compressed by those simplifications.
A few concerns I have:
1. Is there a major flaw in treating the flop simplification problem as "solved" by GTO Wizard while using a different turn/river tree?
2. How much should I worry about cumulative simplification error (AI flop -> AI turn -> custom river)?
3. Is this a reasonable way to identify robust thresholds (bet/check, raise/call, thin value/bluffcatching), or am I introducing too much tree dependency?
4. If the goal is a practical baseline strategy rather than a perfect equilibrium approximation, is there anything obvious you'd change?
Curious what people with more solver experience think.
The guiding philosophy is to find the least exploitable sizing at each node.
The most principled way to do this is to leave all nodes unlocked, and make every node complex (multiple sizes), other than the one you're simplifying. Rebuild and re-solve for every candidate size. B33, B65, B100, whatever other sizes you're testing. Then choose the one with the highest EV.
A very common mistake here is to simplify consecutively. For example, BvB, maybe you start by simplifying SB's first node, then BB's response to a check, then SB's response to a bet, and so on, feeding each simplified tree into the next. This process introduces pathological issues (as in, the path you choose changes the results). It starts taking advantage of the limitations of your current tree. So the highest EV size might not actually be optimal, rather it's the best single sizing given that your opponent can't overbet (or whatever the limitation is).
The best tool to do this is obviously GTO Wizard AI, which uses dynamic sizing to do this automatically.
The second best tool is Piotools, a PioSolver wrapper that automates this process. There's a discord server there too which will help you connect with others who have already gone down this path.
Flop Simplifications: In general, it matters way less than people think. Especially on earlier streets.
In this video, I tested flop simplifications accross all textures and found that even very stupid strategies were salvageable, presumably because they solver can adjust on later streets to get the right amount of money into the pot.
River Simplifications: River sizing matters much more than flop, because there are no more future streets to correct sizing errors. But even so, you can see that one-size strategies don't lose that much EV if chosen cleverly.
Thanks a bunch~
