def test_if_only_root_is_chance():
logical_expression = lambda node: not node.is_chance()
root = KuhnRootChanceGameState(CARDS_DEALINGS)
assert root.is_chance()
for k in root.children:
child = root.children[k]
__recursive_tree_assert(child, logical_expression)
def test_termination():
root = KuhnRootChanceGameState(CARDS_DEALINGS)
assert not root.is_terminal()
assert not root.play(KQ).play(BET).is_terminal()
assert not root.play(JQ).play(CHECK).play(BET).is_terminal()
assert not root.play(QJ).play(CHECK).is_terminal()
assert root.play(KQ).play(BET).play(FOLD).is_terminal()
assert root.play(JQ).play(CHECK).play(CHECK).is_terminal()
assert root.play(JK).play(BET).play(CALL).is_terminal()
assert root.play(QJ).play(CHECK).play(BET).play(FOLD).is_terminal()
assert root.play(QJ).play(CHECK).play(BET).play(CALL).is_terminal()
def test_termination():
root = KuhnRootChanceGameState(2, CARDS_DEALINGS)
assert not root.is_terminal()
assert not root.play(K0Q0).play(BET).is_terminal()
assert not root.play(J0Q0).play(CHECK).play(BET).is_terminal()
assert not root.play(Q0J0).play(CHECK).is_terminal()
assert root.play(K0Q0).play(BET).play(FOLD).is_terminal()
assert root.play(J0Q0).play(CHECK).play(CHECK).is_terminal()
assert root.play(J0K0).play(BET).play(CALL).is_terminal()
assert root.play(Q0J0).play(CHECK).play(BET).play(FOLD).is_terminal()
assert root.play(Q0J0).play(CHECK).play(BET).play(CALL).is_terminal()
def test_if_possible_to_play_unavailable_action():
root = KuhnRootChanceGameState(CARDS_DEALINGS)
with pytest.raises(KeyError):
root.play(CALL)
with pytest.raises(KeyError):
root.play(BET).play(BET)
with pytest.raises(KeyError):
root.play(CHECK).play(CALL)
def test_kuhn_player_to_act_changes_correctly_for_children():
logical_expression = lambda node: all([
node.player_to_act == -node.children[k].player_to_act
for k in node.children
])
root = KuhnRootChanceGameState(CARDS_DEALINGS)
for k in root.children:
child = root.children[k]
__recursive_tree_assert(child, logical_expression)
def test_kuhn_to_move_changes_correctly_for_children():
logical_expression = lambda node: all([
node.current_player == node.children[k].current_player.get_next_player(
) for k in node.children
])
root = KuhnRootChanceGameState(2, CARDS_DEALINGS)
for k in root.children:
child = root.children[k]
__recursive_tree_assert(child, logical_expression)
def test_evaluation():
root = KuhnRootChanceGameState(2, CARDS_DEALINGS)
KQ_node = root.children[K0Q0]
assert KQ_node.play(BET).play(FOLD).evaluation() == 1
assert KQ_node.play(BET).play(CALL).evaluation() == 2
assert KQ_node.play(CHECK).play(BET).play(FOLD).evaluation() == -1
assert KQ_node.play(CHECK).play(CHECK).evaluation() == 1
QJ_node = root.children[Q0J0]
assert QJ_node.play(BET).play(FOLD).evaluation() == 1
assert QJ_node.play(BET).play(CALL).evaluation() == 2
assert QJ_node.play(CHECK).play(BET).play(FOLD).evaluation() == -1
assert QJ_node.play(CHECK).play(CHECK).evaluation() == 1
KJ_node = root.children[K0J0]
assert KJ_node.play(BET).play(FOLD).evaluation() == 1
assert KJ_node.play(BET).play(CALL).evaluation() == 2
assert KJ_node.play(CHECK).play(BET).play(FOLD).evaluation() == -1
assert KJ_node.play(CHECK).play(CHECK).evaluation() == 1
QK_node = root.children[Q0K0]
assert QK_node.play(BET).play(FOLD).evaluation() == 1
assert QK_node.play(BET).play(CALL).evaluation() == -2
assert QK_node.play(CHECK).play(BET).play(FOLD).evaluation() == -1
assert QK_node.play(CHECK).play(CHECK).evaluation() == -1
JQ_node = root.children[J0Q0]
assert JQ_node.play(BET).play(FOLD).evaluation() == 1
assert JQ_node.play(BET).play(CALL).evaluation() == -2
assert JQ_node.play(CHECK).play(BET).play(FOLD).evaluation() == -1
assert JQ_node.play(CHECK).play(CHECK).evaluation() == -1
JK_node = root.children[J0K0]
assert JK_node.play(BET).play(FOLD).evaluation() == 1
assert JK_node.play(BET).play(CALL).evaluation() == -2
assert JK_node.play(CHECK).play(BET).play(FOLD).evaluation() == -1
assert JK_node.play(CHECK).play(CHECK).evaluation() == -1
def test_kuhn_tree_actions_number_equal_to_children():
root = KuhnRootChanceGameState(CARDS_DEALINGS)
__recursive_tree_assert(root, lambda node: len(node.children) == len(node.actions))
def test_inf_sets():
root = KuhnRootChanceGameState(CARDS_DEALINGS)
assert root.inf_set() == "."
assert root.play(KQ).inf_set() == ".K."
assert root.play(KQ).play(BET).inf_set() == ".Q.BET"
assert root.play(KQ).play(BET).play(FOLD).inf_set() == ".K.BET.FOLD"
assert root.inf_set() == "."
assert root.play(QJ).inf_set() == ".Q."
assert root.play(QJ).play(BET).inf_set() == ".J.BET"
assert root.play(QJ).play(BET).play(FOLD).inf_set() == ".Q.BET.FOLD"
assert root.play(QJ).play(BET).play(CALL).inf_set() == ".Q.BET.CALL"
assert root.inf_set() == "."
assert root.play(JK).inf_set() == ".J."
assert root.play(JK).play(CHECK).inf_set() == ".K.CHECK"
assert root.play(JK).play(CHECK).play(CHECK).inf_set() == ".J.CHECK.CHECK"
assert root.play(JK).play(CHECK).play(BET).inf_set() == ".J.CHECK.BET"
assert root.play(JK).play(CHECK).play(BET).play(CALL).inf_set() == ".K.CHECK.BET.CALL"
assert root.play(JK).play(CHECK).play(BET).play(FOLD).inf_set() == ".K.CHECK.BET.FOLD"
def test_player_a_acts_first():
root = KuhnRootChanceGameState(CARDS_DEALINGS)
for k in root.children:
child = root.children[k]
assert child.to_move == A
def test_kuhn_to_move_chance_at_root():
root = KuhnRootChanceGameState(CARDS_DEALINGS)
assert root.to_move == CHANCE
from common.constants import CARDS_DEALINGS, NUM_PLAYERS
from games.algorithms import ChanceSamplingCFR, VanillaCFR
from games.kuhn import KuhnRootChanceGameState
root = KuhnRootChanceGameState(NUM_PLAYERS, CARDS_DEALINGS)
print("\nChance Sampling CFR without tied-rewards")
chance_sampling_cfr = ChanceSamplingCFR(root)
chance_sampling_cfr.run(iterations=1000, tied_rewards=False)
chance_sampling_cfr.compute_nash_equilibrium()
# read Nash-Equilibrum via chance_sampling_cfr.nash_equilibrium member
# try chance_sampling_cfr.value_of_the_game() function to get value of the game (-1/18)
results = chance_sampling_cfr.value_of_the_game()
print("results:: Game value: {}".format(results[0]))
print("Player rewards:: ",
"".join(["{}: {} ".format(k, v) for k, v in results[1].items()]))
print("Team 1 reward: {} Team 2 reward: {}".format(
(results[1][0] + results[1][2]) / 2, (results[1][1] + results[1][3]) / 2))
print("Avg Team reward: {}".format(sum(results[1].values()) / 4))
root = KuhnRootChanceGameState(NUM_PLAYERS, CARDS_DEALINGS)
print("\nChance Sampling CFR with tied-rewards")
chance_sampling_cfr = ChanceSamplingCFR(root)
chance_sampling_cfr.run(iterations=1000, tied_rewards=True)
chance_sampling_cfr.compute_nash_equilibrium()
# read Nash-Equilibrum via chance_sampling_cfr.nash_equilibrium member
# try chance_sampling_cfr.value_of_the_game() function to get value of the game (-1/18)
results = chance_sampling_cfr.value_of_the_game()
print("results:: Game value: {}".format(results[0]))
print("Player rewards:: ",
"".join(["{}: {} ".format(k, v) for k, v in results[1].items()]))
print("Team 1 reward: {} Team 2 reward: {}".format(
def test_kuhn_player_to_act_chance_at_root():
root = KuhnRootChanceGameState(CARDS_DEALINGS)
assert root.player_to_act == CHANCE
from common.constants import CARDS_DEALINGS
from games.kuhn import KuhnRootChanceGameState
from games.algorithms import ChanceSamplingCFR, VanillaCFR
import matplotlib.pyplot as plt
import numpy as np
root = KuhnRootChanceGameState(CARDS_DEALINGS)
print('Chance_sampling')
chance_sampling_cfr = ChanceSamplingCFR(root)
X1 = []
Y1 = []
X2 = []
Y2 = []
for i in range(80):
X1.append(i * 10)
chance_sampling_cfr.run(iterations=10)
chance_sampling_cfr.compute_nash_equilibrium()
value1 = chance_sampling_cfr.value_of_the_game()
Y1.append(value1)
print('Vanilla')
vanilla_cfr = VanillaCFR(root)
for j in range(80):
X2.append(j * 10)
vanilla_cfr.run(iterations=5)
vanilla_cfr.compute_nash_equilibrium()
value2 = vanilla_cfr.value_of_the_game()
Y2.append(value2)
plt.figure()
def test_inf_sets():
root = KuhnRootChanceGameState(2, CARDS_DEALINGS)
assert root.inf_set() == "."
assert root.play(K0Q0).inf_set() == ".K0."
assert root.play(K0Q0).play(BET).inf_set() == ".Q0.BET"
assert root.play(K0Q0).play(BET).play(FOLD).inf_set() == ".K0.BET.FOLD"
assert root.inf_set() == "."
assert root.play(Q0J0).inf_set() == ".Q0."
assert root.play(Q0J0).play(BET).inf_set() == ".J0.BET"
assert root.play(Q0J0).play(BET).play(FOLD).inf_set() == ".Q0.BET.FOLD"
assert root.play(Q0J0).play(BET).play(CALL).inf_set() == ".Q0.BET.CALL"
assert root.inf_set() == "."
assert root.play(J0K0).inf_set() == ".J0."
assert root.play(J0K0).play(CHECK).inf_set() == ".K0.CHECK"
assert root.play(J0K0).play(CHECK).play(
CHECK).inf_set() == ".J0.CHECK.CHECK"
assert root.play(J0K0).play(CHECK).play(BET).inf_set() == ".J0.CHECK.BET"
assert root.play(J0K0).play(CHECK).play(BET).play(
CALL).inf_set() == ".K0.CHECK.BET.CALL"
assert root.play(J0K0).play(CHECK).play(BET).play(
FOLD).inf_set() == ".K0.CHECK.BET.FOLD"
def test_player_a_acts_first():
root = KuhnRootChanceGameState(2, CARDS_DEALINGS)
for k in root.children:
child = root.children[k]
# assert child.to_move == A
assert child.current_player.index == 0
