ICM

ICM · updated 2026-03-08

What is ICM

• Independent Chip Model - mathematical model for evaluating the value of tournament chips
• Based on the probability of finishing in a certain place in the tournament
• Considers stack sizes of all players and payout structure
• Chips have diminishing returns

Key Concepts

• Tournament chips ≠ monetary value
• Chip value depends on:
• Own stack size
• Opponents' stack sizes
• Payout structure
• Number of remaining players

Mathematical Model

Basic ICM Formula

The monetary value of a player's stack is calculated as the sum of all possible prizes multiplied by the probability of finishing in that place:

ICM_value = Σ (Prize_i × Probability_i)

where: - Prize_i - prize for place i - Probability_i - probability of finishing in place i

Probability Calculation

The probability of finishing in a specific place is calculated recursively:

1. Probability of busting first:

P(first_out) = (Total_chips - Player_chips) / Total_chips

2. Probability of surviving the round:

P(survive) = Player_chips / Total_chips

````

3. **Recursive calculation for each position**

## Practical Application

### When to Use ICM
- **Bubble play** - before the money
- **Final table**
- **Deals** - prize pool negotiations
- **Strategic decisions** in tournaments

### ICM Pressure
Concept describing the impact of ICM on strategy:
- Big stacks can pressure medium stacks
- Short stacks are forced to play tight
- Medium stacks are the most vulnerable

## Parameters for Calculation

### Input Data
1. **Player stacks** (chip counts)  
   - Current stacks of all active players  
   - Updated in real time  

2. **Payout structure**  
   - Prize sizes for each place  
   - Percentage distribution of prize pool  
   - Number of paid places  

3. **Number of players**  
   - Current number of active players  
   - Tournament positions  

### Example Input
```javascript
// Player stacks
const chipStacks = [15000, 12000, 8000, 5000, 3000];

// Payout structure (in dollars or percentages)
const payoutStructure = [1000, 600, 400, 250, 150];

// Or as percentages of prize pool
const payoutPercentages = [0.4, 0.24, 0.16, 0.10, 0.10];
````

## Calculation Algorithm

### Step-by-Step Process

1. **Initialization**

    - Get all players' stacks

    - Get payout structure

    - Determine number of prize places

2. **Recursive calculation**

    - For each player calculate bust probability

    - Recursively compute ICM for remaining players

    - Sum weighted probabilities

3. **Optimization**

    - Use memoization for repeated calculations

    - Cache intermediate results


## Practical Examples

### Example 1: Simple Calculation

**Situation:**

- 3 players: 6000, 3000, 1000 chips

- Prizes: $100, $60, $40


**ICM values:**

- Player 1 (6000): ~$75

- Player 2 (3000): ~$68

- Player 3 (1000): ~$57


### Example 2: Bubble Situation

**Situation:**

- 4 players, only 3 are paid

- Stacks: 5000, 4000, 3000, 1000

- Prizes: $300, $200, $100


**Strategic conclusions:**

- Short stack (1000) under maximum pressure

- Medium stacks avoid confrontation

- Big stack can bluff more often


## Application in Bot

### Bot Integration

A bot can use ICM for:

- **Automatic calculations** of stack value

- **Strategic recommendations** in tournaments

- **Deal analysis** between players

- **EV evaluation** of different decisions


### API Interface

```javascript
// Main function for bot
function calculateICMForBot(gameState) {
    const { stacks, payouts, playerCount } = gameState;
    return {
        icmValues: calculateICM(stacks, payouts),
        recommendations: generateRecommendations(stacks, payouts),
        bubbleFactor: calculateBubblePressure(stacks, payouts)
    };
}

Note created for bot usage in ICM calculations in poker tournaments.