implementation-guide

Player 1 with Jack:
  Initial: Check 79%, Bet 21%  (bluff frequency)
  After check-bet: Fold 100%

Player 1 with Queen:
  Initial: Check 100%
  After check-bet: Fold ~67%, Call ~33%

Player 1 with King:
  Initial: Check ~67%, Bet ~33%
  After check-bet: Call 100%

import pyspiel
from open_spiel.python.algorithms import cfr

# Create Kuhn Poker game
game = pyspiel.load_game("kuhn_poker")

# Create CFR solver
cfr_solver = cfr.CFRSolver(game)

# Train
for i in range(10000):
    cfr_solver.evaluate_and_update_policy()

# Get average policy (Nash equilibrium approximation)
average_policy = cfr_solver.average_policy()

# Print strategy for info state "0" (Player 0 with Jack, no history)
print(average_policy.action_probabilities("0"))

from pokergames import *
from pokercfr import *

# Create Kuhn poker
game = kuhn_poker()

# Create CFR solver
cfr = CounterfactualRegretMinimizer(game)

# Train
for i in range(10000):
    cfr.run()

# Get strategy
strategy = cfr.profile

import rlcard
from rlcard.agents import CFRAgent

# Create environment
env = rlcard.make('leduc-holdem')

# Create CFR agent
agent = CFRAgent(env, model_path='./cfr_model')

# Train
for episode in range(10000):
    agent.train()

# Save model
agent.save()

#!/usr/bin/env python3
"""
Complete Kuhn Poker CFR Implementation
Run: python kuhn_cfr_complete.py
"""

import numpy as np
from itertools import permutations
from typing import Dict, List, Tuple

class KuhnPokerCFR:
    """CFR solver for Kuhn Poker."""

    PASS = 0
    BET = 1
    NUM_ACTIONS = 2

    def __init__(self):
        self.regret_sum: Dict[str, np.ndarray] = {}
        self.strategy_sum: Dict[str, np.ndarray] = {}
        self.iterations = 0

    def _get_strategy(self, info_set: str) -> np.ndarray:
        """Get current strategy via regret matching."""
        if info_set not in self.regret_sum:
            self.regret_sum[info_set] = np.zeros(self.NUM_ACTIONS)
            self.strategy_sum[info_set] = np.zeros(self.NUM_ACTIONS)

        regrets = np.maximum(self.regret_sum[info_set], 0)
        total = regrets.sum()

        if total > 0:
            return regrets / total
        return np.ones(self.NUM_ACTIONS) / self.NUM_ACTIONS

    def _get_average_strategy(self, info_set: str) -> np.ndarray:
        """Get Nash equilibrium approximation."""
        if info_set not in self.strategy_sum:
            return np.ones(self.NUM_ACTIONS) / self.NUM_ACTIONS

        total = self.strategy_sum[info_set].sum()
        if total > 0:
            return self.strategy_sum[info_set] / total
        return np.ones(self.NUM_ACTIONS) / self.NUM_ACTIONS

    def _cfr(self, cards: List[int], history: str,
             p0: float, p1: float) -> float:
        """
        CFR recursive traversal.
        Returns expected value for player 0.
        """
        plays = len(history)
        player = plays % 2
        opponent = 1 - player

        # Check for terminal states
        if plays >= 2:
            terminal_pass = history[-1] == 'p'
            double_bet = history[-2:] == 'bb'

            if terminal_pass:
                if history == 'pp':
                    # Both passed - higher card wins
                    return 1 if cards[0] > cards[1] else -1
                else:
                    # One player folded
                    return 1 if history[-2:] == 'bp' else -1

            elif double_bet:
                # Showdown - higher card wins 2
                return 2 if cards[0] > cards[1] else -2

        info_set = str(cards[player]) + history
        strategy = self._get_strategy(info_set)

        # Calculate action utilities
        util = np.zeros(self.NUM_ACTIONS)
        node_util = 0

        for a in range(self.NUM_ACTIONS):
            next_history = history + ('p' if a == 0 else 'b')

            if player == 0:
                util[a] = -self._cfr(cards, next_history,
                                      p0 * strategy[a], p1)
            else:
                util[a] = -self._cfr(cards, next_history,
                                      p0, p1 * strategy[a])

            node_util += strategy[a] * util[a]

        # Update regrets
        for a in range(self.NUM_ACTIONS):
            regret = util[a] - node_util
            if player == 0:
                self.regret_sum[info_set][a] += p1 * regret
            else:
                self.regret_sum[info_set][a] += p0 * regret

        # Update strategy sum
        reach_prob = p0 if player == 0 else p1
        self.strategy_sum[info_set] += reach_prob * strategy

        return node_util

    def train(self, iterations: int) -> float:
        """Train for specified iterations. Returns game value."""
        cards = [0, 1, 2]  # J, Q, K
        util = 0

        for _ in range(iterations):
            for deal in permutations(cards, 2):
                util += self._cfr(list(deal), '', 1, 1)
            self.iterations += 1

        return util / (iterations * 6)  # 6 possible deals

    def get_strategy_profile(self) -> Dict[str, Tuple[float, float]]:
        """Get all Nash equilibrium strategies."""
        profile = {}
        for info_set in sorted(self.strategy_sum.keys()):
            strategy = self._get_average_strategy(info_set)
            profile[info_set] = (strategy[0], strategy[1])
        return profile

    def play_vs_human(self):
        """Interactive game against trained bot."""
        import random

        cards = [0, 1, 2]
        card_names = ['Jack', 'Queen', 'King']

        while True:
            random.shuffle(cards)
            human_card, bot_card = cards[0], cards[1]

            print(f"\nYour card: {card_names[human_card]}")
            print("You go first. Enter 'p' to pass or 'b' to bet:")

            history = ''
            pot = 2  # Both anted 1

            while True:
                player = len(history) % 2

                if player == 0:  # Human
                    action = input("> ").strip().lower()
                    if action not in ['p', 'b']:
                        print("Invalid. Enter 'p' or 'b'")
                        continue
                else:  # Bot
                    info_set = str(bot_card) + history
                    strategy = self._get_average_strategy(info_set)
                    action = 'p' if random.random() < strategy[0] else 'b'
                    print(f"Bot: {action}")

                history += action

                # Check terminal
                if len(history) >= 2:
                    if history[-1] == 'p':
                        if history == 'pp':
                            winner = 'You' if human_card > bot_card else 'Bot'
                            print(f"Showdown! Bot had {card_names[bot_card]}. {winner} wins!")
                        else:
                            winner = 'Bot' if history[-2:] == 'bp' else 'You'
                            print(f"Fold! {winner} wins!")
                        break
                    elif history[-2:] == 'bb':
                        winner = 'You' if human_card > bot_card else 'Bot'
                        print(f"Showdown! Bot had {card_names[bot_card]}. {winner} wins the pot of 4!")
                        break

            if input("\nPlay again? (y/n): ").lower() != 'y':
                break


def main():
    print("=== Kuhn Poker CFR Training ===\n")

    cfr = KuhnPokerCFR()

    # Training with progress
    for i in [1000, 10000, 100000]:
        print(f"Training to {i} iterations...")
        cfr.train(i - cfr.iterations)

    # Display results
    print("\n=== Nash Equilibrium Strategies ===")
    print("Info Set | Pass/Fold | Bet/Call")
    print("-" * 35)

    for info_set, (pass_prob, bet_prob) in cfr.get_strategy_profile().items():
        card = ['J', 'Q', 'K'][int(info_set[0])]
        history = info_set[1:] if len(info_set) > 1 else 'start'
        print(f"{card}:{history:6} |   {pass_prob:.3f}   |   {bet_prob:.3f}")

    # Theoretical game value
    print(f"\nExpected game value: ~-0.0556 (= -1/18)")
    print("Player 2 has slight advantage from position.\n")

    # Offer to play
    if input("Play against the bot? (y/n): ").lower() == 'y':
        cfr.play_vs_human()


if __name__ == "__main__":
    main()

def compute_exploitability(cfr):
    """Compute how exploitable the strategy is."""
    # Best response calculation (simplified)
    # Full implementation requires best response oracle
    pass

def test_terminal_payoffs():
    cfr = KuhnPokerCFR()

    # King vs Jack, both pass -> King wins 1
    assert cfr._cfr([2, 0], 'pp', 1, 1) == 1

    # Jack vs King, bet then fold -> Jack wins 1
    assert cfr._cfr([0, 2], 'bp', 1, 1) == 1

def test_convergence():
    cfr = KuhnPokerCFR()
    cfr.train(100000)

    # Jack should bluff about 1/3 of the time at equilibrium
    strategy = cfr._get_average_strategy('0')  # Jack, no history
    assert 0.15 < strategy[1] < 0.35  # Bet probability