Quote:
Originally Posted by Rambler1
To Doug/Sam/TimTam/punter/other super smart math/programmer/HU elites posting ITT:
I apologize if what I'm about to ask has been at least strongly implied by various posters smarter than me. I have read a majority of this thread, and I have not seen the following question asked, although I think Sam/punter/TimTam might have just assumed everyone is aware of what I'm about to ask and that the answer is yes.
Cliffs: Is it correct to say that due to bucketing/abstraction, the bot must treat a min bet as something greater than a min bet; therefore, the bot will always "overreact" to min bets? If correct, does the same logic apply to most all-ins for the same reason (i.e., the bot will always "underreact" to all-ins)?
Assumptions:
Due to the abstractions/estimations in the bot's algorithm which are necessary because the bot does not have an infinitely (or at least sufficiently) powerful computer to calculate the Nash Equilibrium play with all specific hands (e.g. K2o vs. K3o treated identically), and most importantly for the conclusions I am about to make, bet sizes, the bot "buckets" (a/k/a groups and treats identically) certain hands and bet sizes at any particular point in its game tree.
For instance, in a game with 200 big blinds, after a flop comes down where there were no pre-flop raises, maybe donk bets of 1, 2, and 3 big blinds are treated identically by the bot, because the bot does not have sufficient computational power to calculate distinct strategies to deal with 1 bb flop bets, 2 bb flop bets, and 3 bb flop bets, so to conserve resources it calculates one strategy that it will implement regardless of whether the flop bet of the opponent is 1, 2, or 3 bb.
Conclusions:
Due to this "bucketing" of the bet sizes of the bot's opponent, the bot will necessarily always over-value/overreact to min bets, because there is nothing below the min bet amount that the bot can "bucket." In other words, if the minimum bet is 1, the bot is at a disadvantage (so long as its opponent is aware of the bucketing and knows how to exploit it) because the bot's strategy to deal with a bet of 1 must always be sufficient to deal with a bet of 1 + X, and probably [1 + (X + 1)], [1 + (X + 2)], etc.
Due to the fact that the bot's opponent knows that there is no number less than the min bet for the bot to bucket, the min bet is necessarily at the very bottom of the bot's "bucket range" (I know that's not correct terminology, but I hope that makes sense). So where the human min donk bets a flop, the human knows that the bot has bucketed its min bet of 1 and is treating it as a bet of 1 + *some number*. Regardless of what *some number* is, the human knows the bot is going to treat the min donk bet as something greater than a min donk bet; therefore, the bot is necessarily not going to treat the min donk bet optimally (at least according to the bot's algorithm's version of GTO).
Similarly, the bot will under-react to/underestimate most all-in bets, because the bot will probably have bucketed the all-in bet amount with certain lesser bet amounts.
Unless I'm missing something, which is definitely possible, unless the bot's programmers specifically accounted for the possibility that the bot's opponent could have the above knowledge about the abstraction/bucketing it employs (or maybe they accounted for it for some other reason), the bot's opponent could always use the above information to exploit: 1) the bot's overreaction to min bets, and 2) the bot's underreaction to all-ins in most spots.
To Doug/cheet/dong/bjorn specifically - is this how you and the other players discovered the "min donk bet exploit," or was it just by chance?
There are two different kinds of "abstraction," card abstraction and betting abstraction. The "card abstraction" is like the bucketing of the K2o and K3o. For the "betting abstraction" we selected several bet sizes for each situation. E.g., 0.25 pot, 0.5 pot, 0.75 pot, pot, 2 pot, all-in. When the opponent chose a size in between two sizes that we had in the abstraction, we needed to interpret their size as one of the two. Here is a paper describing our main approach for doing this and a comparison to other approaches,
http://www.cs.cmu.edu/~sganzfri/Translation_IJCAI13.pdf.
Basically, it assumes that opponent will call a bet of size x with probability 1/(1+x), which comes from pot odds. The main mapping we use is
f(x) = [(B-x)(1+A)]/[(B-A)(1+x)],
where A, B are sizes in the abstraction, and x is the size taken by the opponent.
For the flop minbet example, he bets 100 into pot of 500. So x = 0.2. The closest actions we have are A = 0 (for check) and B = 0.25. Plugging these in to the formula give f(x) = 1/6 = 0.167. This is the probability we map his bet down to 0 and interpret it as a check. So we pick a random number in [0,1], and if it's above 1/6 we interpret the bet as 0.25 pot, and otherwise as a check.
In some of the sessions we used some different approaches for various reasons maybe I will discuss later.