Poker-AI.org

Poker AI and Botting Discussion Forum
It is currently Sun Jan 19, 2020 7:17 pm

All times are UTC




Post new topic Reply to topic  [ 5 posts ] 
Author Message
 Post subject: Nash Equilibrium and ICM
PostPosted: Wed Jan 08, 2020 7:24 pm 
Offline
Veteran Member

Joined: Wed Mar 20, 2013 1:43 am
Posts: 253
I see that Pio Solver for example has an option to enter a tournament payout structure for the Nash equilibrium computation.
Does anyone have an idea how to integrate ICM into the calculation? Are there any online ressources on this?


Top
 Profile  
 
PostPosted: Fri Jan 10, 2020 10:31 am 
Offline
Site Admin
User avatar

Joined: Sun Feb 24, 2013 9:39 pm
Posts: 605
I've never played in a tournament, never used ICM, and given this question all of 2 minutes thought. So in complete expectation of being shot down in flames or ignored here is my idea.

As I understand it ICM tells you the dollar value of the chips in different circumstances. So I'd compute the dollar value of every terminal outcome of the game tree and use that in the calculation of ev instead of the number of chips.


Top
 Profile  
 
PostPosted: Fri Jan 10, 2020 1:26 pm 
Offline
Junior Member

Joined: Wed Mar 18, 2015 10:02 am
Posts: 15
Human poker players calculate pot odds and equity. So with high ICM you need much more equity to call than in ring games, meaning you simply increase threshold for equity to defend a hand. How much equity more you need, it is all approximation, there is no math proof.
Obviously with high ICM you need more with less ICM less equity. E.g if you are shortstack and opponent has more chips than you, and bets river, if you are right before the bubble your ICM is very high, so you only want to call strong hands.
You can use ICMIZER 3, https://www.icmpoker.com/icmizer/
to get a feeling how they use ICM in different spots.


Top
 Profile  
 
PostPosted: Sat Jan 18, 2020 3:22 pm 
Offline
Veteran Member

Joined: Wed Mar 20, 2013 1:43 am
Posts: 253
spears wrote:
I've never played in a tournament, never used ICM, and given this question all of 2 minutes thought. So in complete expectation of being shot down in flames or ignored here is my idea.

As I understand it ICM tells you the dollar value of the chips in different circumstances. So I'd compute the dollar value of every terminal outcome of the game tree and use that in the calculation of ev instead of the number of chips.


Yes that was my first idea as well. I will try it and report the results.


Top
 Profile  
 
PostPosted: Sun Jan 19, 2020 5:01 am 
Offline
Veteran Member

Joined: Wed Mar 20, 2013 1:43 am
Posts: 253
Ok, so the first step will be calculating the ICM equities, I have found the following code in the archive:

Code:
#include <iostream>
using namespace std;

double getEquity(int player, int depth, int payouts, int stacks, double total, double* p_payouts, double* p_stacks)
{
   /*
      func doing the recursive ICM calculation
   */
   double eq = p_stacks[player]/total*p_payouts[depth];

   if(payouts > depth+1)
   {
      for(int j=0;j < stacks; j++)
      {
         if(j != player && p_stacks[j] > 0)
         {
            double c = p_stacks[j];

            p_stacks[j] = 0;
            eq += getEquity(player, depth+1, payouts, stacks, total-c, p_payouts, p_stacks)*c/total;
            p_stacks[j] = c;
         }
      }
   }

   return eq;
}

double getEquity(int player, int payouts, int stacks, double* p_payouts, double* p_stacks)
{
   /*
      player - player index
      payouts - amount of
      stacks - amount of
      p_payouts - pointer containing adress of the payout structure
      p_stacks - pointer containing adress of the stack size structure
   */
   double total = 0;

   for(int j=0;j<stacks;j++) total += p_stacks[j];

   return getEquity(player, 0, payouts, stacks, total, p_payouts, p_stacks);
}

int main()
{
   //-----------------------------------------------------------------------------------------------------
   // Test Examples
   //-----------------------------------------------------------------------------------------------------
   int payouts = 3, stacks = 6;
   double p_stacks[6] = {5500, 3500, 3000, 1500, 1000, 500};
   double p_payoutsSNG[3] = {0.5,0.3,0.2};
   double p_payoutsDON[3] = {0.33,0.33,0.33};
   double p_payouts1st[3] = {1,0,0};

   //SNG structure
   cout << "SNG Equities" << endl;

   for(int j=0;j<stacks;j++)
   {
      cout << "Equity stack " << j << ": " << getEquity(j, payouts, stacks, p_payoutsSNG, p_stacks) << endl;
   }

   //DON structure
   cout << "DON Equities" << endl;

   for(int j=0;j<stacks;j++)
   {
      cout << "Equity stack " << j << ": " << getEquity(j, payouts, stacks, p_payoutsDON, p_stacks) << endl;
   }

   //Winner gets all structure
   cout << "Winner gets all Equities" << endl;

   for(int j=0;j<stacks;j++)
   {
      cout << "Equity stack " << j << ": " << getEquity(j, payouts, stacks, p_payouts1st, p_stacks) << endl;
   }

   system("PAUSE");

   return 0;
}


It gives me the same results as Pio, so it's most likely correct.

My plan is to first compute how stacks change at each terminal node and then to compute the new ICM values for those terminal nodes. The difference in ICM values between the starting stacks and the stacks at the terminal node will then be the value of that terminal node for each player.

I have also read that there are ways to approximate the ICM values, does anyone know anything about that? I will first test it with this code, but an approximation might come in handy if the code isn't fast enough.


Top
 Profile  
 
Display posts from previous:  Sort by  
Post new topic Reply to topic  [ 5 posts ] 

All times are UTC


Who is online

Users browsing this forum: No registered users and 2 guests


You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Search for:
Powered by phpBB® Forum Software © phpBB Group