def do_gnuth_experiments():
# player_valuations = range(50, 53)
# opponent_valuations = range(50, 52)
player_valuations = range(50, 56)
opponent_valuations = range(50, 54)
#
# player_valuations = range(50, 59)
# opponent_valuations = range(50, 56)
#
# player_valuations = range(50, 62)
# opponent_valuations = range(50, 58)
# player_valuations = range(50, 65)
# opponent_valuations = range(50, 60)
# player_valuations = range(50, 200 + 1)
# opponent_valuations = range(50, 150 + 1)
game_name = str(len(player_valuations)) + "_strong_" + str(
len(opponent_valuations)) + "_weak_auction"
start_time = time.time()
player_specification = GnuthPlayerSpecification(
player_valuations=player_valuations)
opponent_specification = GnuthPlayerSpecification(
player_valuations=opponent_valuations)
sample_auction = FirstPriceAuction(
game_name=game_name,
player_specification=player_specification,
opponent_specification=opponent_specification)
sample_auction.calculate_equilibria()
logging.info("--- %s seconds ---" % (time.time() - start_time))
def run_first_price(no_jumps,
no_ties,
all_pay,
player_valuations=[],
only_pure=True,
num_players=2,
specification_class=AuctionPlayerSpecification,
player_specifications=None,
valuations=0):
if player_specifications is None:
valuations = len(specification_class.player_valuations)
game_name = "num_players_" + str(num_players) + "_allpay_" + str(
all_pay) + "_noties_" + str(no_ties) + "_nojumps_" + str(
no_jumps) + "_" + str(valuations) + "_valuations_auction"
if player_specifications is None:
player_specifications = [
AuctionPlayerSpecification(player_actions=player_valuations,
player_types=player_valuations,
no_jumps=no_jumps)
for _ in range(num_players)
]
another_sample_auction = FirstPriceAuction(
game_name=game_name,
player_specifications=player_specifications,
all_pay=all_pay,
no_ties=no_ties)
logging.info("Running: " + game_name)
another_sample_auction.calculate_equilibria(only_pure)
def main():
player_valuations = [0, 1, 2]
player_specification = AuctionPlayerSpecification(
player_actions=player_valuations,
player_types=player_valuations,
no_jumps=False)
opponent_specification = AuctionPlayerSpecification.from_specification(
player_specification)
third_player_specification = AuctionPlayerSpecification.from_specification(
player_specification)
auction_with_ties = FirstPriceAuction(game_name="3-bidders-with-ties",
player_specifications=[
player_specification,
opponent_specification,
third_player_specification
],
all_pay=False,
no_ties=False)
auction_with_ties.calculate_equilibria(only_pure=True)
class GnuthAuctionTest(unittest.TestCase):
def __init__(self, *args, **kwargs):
super(GnuthAuctionTest, self).__init__(*args, **kwargs)
self.player_specification = GnuthPlayerSpecification(
player_valuations=[50, 51, 52])
self.opponent_specification = GnuthPlayerSpecification(
player_valuations=[50, 51])
self.sample_auction = FirstPriceAuction(game_name="gnuth_auction",
player_specifications=[
self.player_specification,
self.opponent_specification
])
def test_no_jumpy_strategies(self):
another_player_specification = GnuthPlayerSpecification(
player_valuations=[50, 51, 52, 53])
another_opponent_specification = GnuthPlayerSpecification(
player_valuations=[50, 51, 52])
expected_player_strategies = [(50, 50, 50, 50), (50, 50, 50, 51),
(50, 50, 51, 51), (50, 50, 51, 52),
(50, 51, 51, 51), (50, 51, 51, 52),
(50, 51, 52, 52), (50, 51, 52, 53)]
actual_player_strategies = another_player_specification.get_pure_strategies(
)
self.assertEqual(sorted(actual_player_strategies),
sorted(expected_player_strategies))
expected_oponent_strategies = [(50, 50, 50), (50, 50, 51),
(50, 51, 51), (50, 51, 52)]
actual_opponent_strategies = another_opponent_specification.get_pure_strategies(
)
self.assertEqual(sorted(actual_opponent_strategies),
sorted(expected_oponent_strategies))
def test_pure_strategies(self):
expected_strategies = [(50, 50, 50), (50, 50, 51), (50, 51, 51),
(50, 51, 52)]
actual_strategies = list(
self.player_specification.get_pure_strategies())
self.assertEqual(actual_strategies, expected_strategies)
expected_strategies = [(50, 50), (50, 51)]
actual_strategies = list(
self.opponent_specification.get_pure_strategies())
self.assertEqual(actual_strategies, expected_strategies)
def test_auction_utilities(self):
expected_strong_utility = Fraction(1, 2)
expected_weak_utility = Fraction(1, 4)
strong_bidder_strategy = (50, 50, 50)
weak_bidder_strategy = (50, 50)
actual_strong_utility, actual_weak_utility = self.sample_auction.get_expected_utilities(
(strong_bidder_strategy, weak_bidder_strategy))
self.assertAlmostEqual(actual_strong_utility, expected_strong_utility)
self.assertAlmostEqual(actual_weak_utility, expected_weak_utility)
expected_strong_utility = Fraction(1 / 12)
expected_weak_utility = 0
strong_bidder_strategy = (50, 50, 52)
weak_bidder_strategy = (50, 51)
actual_strong_utility, actual_weak_utility = self.sample_auction.get_expected_utilities(
(strong_bidder_strategy, weak_bidder_strategy))
self.assertAlmostEqual(actual_strong_utility, expected_strong_utility)
self.assertAlmostEqual(actual_weak_utility, expected_weak_utility)
def test_calculate_equilibria(self):
actual_equilibria = self.sample_auction.calculate_equilibria(
only_pure=True)
self.assertEqual(len(actual_equilibria), 2)
for equilibrium in actual_equilibria:
weak_bidder_strategy = self.opponent_specification.get_strategy_index(
(50, 50))
weak_bidder_index = 1
self.assertEqual(
equilibrium[(weak_bidder_index, weak_bidder_strategy)], "1")
strong_bidder_index = 0
strong_bidder_strategy = self.player_specification.get_strategy_index(
(50, 50, 50))
other_strong_bidder_strategy = self.player_specification.get_strategy_index(
(50, 50, 51))
strong_equilibrium = equilibrium[(
strong_bidder_index,
strong_bidder_strategy)] == "1" or equilibrium[(
strong_bidder_index, other_strong_bidder_strategy)] == "1"
self.assertTrue(strong_equilibrium)