strategic_evaluation.py

# Start of adjusting this so that it works with strategy be two separate matrix , one for each position, exactly like
# Strategy.strategy_base

import copy
import numpy as np
from betting_games import BettingGame


# strategy is a np array of size number_of_hands*number_of_public_state

# This function is going to compute reach probabilities, utilities, and anything else that it can
# and return them as np array

def world_node_strategic_evaluation(strategy, game):
    number_of_hands = np.shape(strategy)[0]
    number_of_public_nodes = game.public_tree.number_of_nodes

    # word_state_values[op_hand, ip_hand, public_node] induced by given strategy are going to be stored in this matrix
    # values at terminal states are computed already
    world_state_values = game.terminal_values_all_node.copy()

    # world_state_value[ , , t.parent] += world_state_value[ , , t]**strategy[ , t]
    nonzero_nodes = game.node[1:]
    reverse_node_list = nonzero_nodes[::-1]

    for current_node in reverse_node_list:
        current_player = game.public_state[current_node].to_move
        parent_node = game.public_state[current_node].parent
        parent_node_player = 1 - current_player

        # if parent_node player is op we multiply rows of value matrix
        if parent_node_player == 0:
            world_state_values[:, :, parent_node] += (
                    world_state_values[:, :, current_node] * (strategy[:, current_node].reshape(number_of_hands, 1)))

        # else if parent_node player is ip we multiply cols of value matrix
        elif parent_node_player == 1:
            world_state_values[:, :, parent_node] += (
                    world_state_values[:, :, current_node] * strategy[:, current_node])

    return world_state_values


# -------------------------------- INITIALIZING EXAMPLE OF STRATEGIC BETTING GAMES ----------------------------------- #


#KUHN_BETTING_GAME = BettingGame(bet_size=0.5, max_number_of_bets=2,
#
#                                deck={0: 1, 1: 1, 2: 1}, deal_from_deck_with_substitution=False)
#K = KUHN_BETTING_GAME
#KU = K.uniform_strategy()
#KV = world_node_strategic_evaluation(K.uniform_strategy(), K)
#K_p_states = K.public_state
#
#G = BettingGame(4, deck={i: 1 for i in range(8)})
#GV = world_node_strategic_evaluation(G.uniform_strategy(), G)
#G_p_state = G.public_state

test_start = np.ones((2, 3, 9))
test_start[0, :, :] = np.array([[1, 0.5, 0.5, 1, 1, 1, 1, 0.5, 0.5], [1, 0.9, 0.1, 1, 1, 1, 1, 0.7, 0.3],
                                [1, 0.05, 0.95, 1, 1, 1, 1, 0.1, 0.9]])
test_start[1, :, :] = np.array([[1, 1, 1, 0.6, 0.4, 0.2, 0.8, 1, 1], [1, 1, 1, 0.3, 0.7, 0.35, 0.65, 1, 1],
                                [1, 1, 1, 0.1, 0.9, 0.05, 0.95, 1, 1]])
test_start_one = test_start[0, :, :]*test_start[1, :, :]
KK = BettingGame(bet_size=0.5, max_number_of_bets=2,

                                deck={0: 1, 1: 1, 2: 1}, deal_from_deck_with_substitution=False)

KTS = world_node_strategic_evaluation(test_start_one, KK)