This project delves into the analysis of iterated binary choice games, exploring various strategic interactions where players make repeated decisions with strategies. The focus includes analyzing players with predetermined strategies and extends to systematically exploring every possible combination of choices (represented as 1s and 2s) and their interactions. Emphasis is placed on understanding the impact of diverse strategies on payoffs and comprehensively mapping out the choices and resulting outcomes. By employing game theory principles, this research aims to uncover patterns, optimal strategies, and the dynamics of cooperation versus competition in diverse game settings.
Introduction
Introduction
The Prisoner’s Dilemma
The Prisoner’s Dilemma
Arguably the most renowned problem in Game Theory, The Prisoner’s Dilemma is a type of binary choice game that explores the scenario where two parties must decide independently whether to cooperate or act selfishly, without knowing the other’s choice. Their resulting fates depend on the combination of the two parties’ decisions. In this classic example, two suspects are interrogated separately about a crime. Each suspect has two options: to remain silent or confess. If both suspects remain silent, they each receive a two-year sentence. If one confesses while the other remains silent, the confessor gets an eight-year sentence, and the silent suspect gets only one year. However, if both suspects confess, they each receive a five-year sentence.
Below, a Payoff Grid for the Prisoner’s Dilemma is represented. The blue words and colors represent Player A’s choices and outputs, while the orange words and colors represent Player B’s choices and outputs.
Below, a Payoff Grid for the Prisoner’s Dilemma is represented. The blue words and colors represent Player A’s choices and outputs, while the orange words and colors represent Player B’s choices and outputs.
In[]:=
prisonersdilemmapayoffMatrix = {{Style["", Blue],Style["Cooperate", Orange],Style["Defect", Orange]},{Style["Cooperate", Blue],{Style[-2, Blue], Style[-2, Orange]},{Style[-8, Blue], Style[-1, Orange]}},{Style["Defect", Blue], {Style[-1, Blue], Style[-8, Orange]},{Style[-5, Blue],Style[-5, Orange]}}};Grid[prisonersdilemmapayoffMatrix, Frame -> All, FrameStyle -> Black]
Out[]=
Cooperate | Defect | |
Cooperate | {-2,-2} | {-8,-1} |
Defect | {-1,-8} | {-5,-5} |
This presents a unique dilemma, where each suspect must make a choice without knowing the choices of the other. The paradox of the Prisoner’s Dilemma is that although both robbers can achieve the least total jail time by cooperating and staying silent (resulting in two years total), the individual incentives they face push them to betray each other, as the possibility of a one-year sentence far outweighs. This mutual defection leads to the maximum combined jail time of five years. Thus, in a single game, the safest strategy is to always defect to avoid being taken advantage of.
But what if the game was played more than just once?
But what if the game was played more than just once?
Repeated Play and Strategic Adaptation in the Prisoner’s Dilemma
Repeated Play and Strategic Adaptation in the Prisoner’s Dilemma
Playing the Prisoner’s Dilemma game multiple times introduces strategic elements where players can develop and adapt their approaches based on previous rounds. In repeated plays, players can create strategies to maximize their payoffs over the long term by observing and reacting to their opponent’s past choices. This adaptation involves analyzing the outcomes of past games or rounds to predict and influence future decisions, aiming to achieve higher payoffs than in a single, isolated play of the game. Thus, repeated play allows for the creation of complex strategies that consider both immediate gains and long-term consequences, a critical aspect of decision-making in game theory.
In this project, “1” denotes cooperation, where a player chooses to cooperate with their opponent and “2” indicates defection, where a player chooses not to cooperate.
In this project, “1” denotes cooperation, where a player chooses to cooperate with their opponent and “2” indicates defection, where a player chooses not to cooperate.
Why the Prisoner’s Dilemma?
Why the Prisoner’s Dilemma?
The prisoner’s dilemma offers a framework for understanding the intersections and outcomes between cooperation and competition, crucial in fields from business and economics to politics and social science. It can illustrate how the pursuit of self-interest can lead to suboptimal outcomes when both parties act selfishly, despite a scenario where cooperation would benefit both players.
In practical terms, this dilemma is evident in business competition, such as between Coca-Cola and PepsiCo, where decisions like pricing strategies can resemble the choices faced in the prisoner’s dilemma. Each company must decide whether to cooperate by maintaining higher prices for mutual profitability or defect by lowering prices to gain market share, triggering a price war that harms both parties’ profitability. This dynamic applies similarly in political negotiations, where cooperation in managing issues like national debt can lead to mutual benefits, while defection can lead to instability and political losses for all parties involved. Exploring these concepts on a smaller scale is the objective of this project.
In practical terms, this dilemma is evident in business competition, such as between Coca-Cola and PepsiCo, where decisions like pricing strategies can resemble the choices faced in the prisoner’s dilemma. Each company must decide whether to cooperate by maintaining higher prices for mutual profitability or defect by lowering prices to gain market share, triggering a price war that harms both parties’ profitability. This dynamic applies similarly in political negotiations, where cooperation in managing issues like national debt can lead to mutual benefits, while defection can lead to instability and political losses for all parties involved. Exploring these concepts on a smaller scale is the objective of this project.
Initializing Variables
Initializing Variables
Payoff Matrices for Types of Games
Payoff Matrices for Types of Games
Manipulating Payoffs to Simulate Different Games
Manipulating Payoffs to Simulate Different Games
The Prisoner’s Dilemma is just one example of a binary choice game. Many other games also involve two players making binary decisions and receiving payoffs based on their combined choices. These games differ primarily in their payoff structures. For instance, in Coin Game, each player gets 2 coins if they win, but also have the opportunity to win more if they cheat the other. Thus, each game is unique due to its specific payoff structure.
In[]:=
coingamepayoffMatrix={{Style["",Blue],Style["Cooperate",Orange],Style["Cheat",Orange]},{Style["Cooperate",Blue],{Style[2,Blue],Style[2,Orange]},{Style[3,Blue],Style[-1,Orange]}},{Style["Cheat",Blue],{Style[-1,Blue],Style[3,Orange]},{Style[0,Blue],Style[0,Orange]}}};Grid[coingamepayoffMatrix,Frame->All,FrameStyle->Blend[{Yellow,Orange}]]
Out[]=
Cooperate | Cheat | |
Cooperate | {2,2} | {3,-1} |
Cheat | {-1,3} | {0,0} |
In Stag Hunt, players are rewarded if they both cooperate to catch a stag, earning 3 points each. However, if one tries to cheat, the cheater has less winnings than if they cooperated.
In[]:=
stagshuntpayoffMatrix={{Style["",Blue],Style[" Stag ",Blue],Style[" Hare ",Blue]},{Style[" Stag ",Blue],{Style[3,Blue],Style[3,Orange]},{Style[0,Blue],Style[1,Orange]}},{Style[" Hare ",Blue],{Style[1,Blue],Style[0,Orange]},{Style[1,Blue],Style[1,Orange]}}};Grid[stagshuntpayoffMatrix,Frame->All,FrameStyle->Darker[Green]]
Out[]=
Stag | Hare | |
Stag | {3,3} | {0,1} |
Hare | {1,0} | {1,1} |
Asymmetric Payoff Matrices
Asymmetric Payoff Matrices
We can also model payoff matrices where the payoffs are asymmetric. In the Prisoner’s Dilemma, asymmetric payoff matrices occur when the rewards and penalties assigned to each player’s choices differ, reflecting an imbalance in payoffs. Asymmetric matrices add a layer of complexity in the strategic decision-making process, as each player must consider not only their own potential outcomes but also the differing consequences faced by the other player.
This matrix can even model real-world scenarios where the stakes are not equal, such as in negotiations between parties with differing resources. For instance, one player’s payoff for mutual cooperation might be higher due to their greater capacity to benefit from collaboration, while their penalty for mutual defection could be lower, representing a smaller loss relative to the other player.
This matrix can even model real-world scenarios where the stakes are not equal, such as in negotiations between parties with differing resources. For instance, one player’s payoff for mutual cooperation might be higher due to their greater capacity to benefit from collaboration, while their penalty for mutual defection could be lower, representing a smaller loss relative to the other player.
In[]:=
asymmetricpayoffMatrix={{Style["",Blue],Style["Cooperate",Orange],Style["Defect",Orange]},{Style["Cooperate",Blue],{Style[10,Blue],Style[20,Orange]},{Style[0,Blue],Style[-10,Orange]}},{Style["Defect",Blue],{Style[30,Blue],Style[0,Orange]},{Style[20,Blue],Style[10,Orange]}}};Grid[asymmetricpayoffMatrix,Frame->All,FrameStyle->Darker[Red]]
Out[]=
Cooperate | Defect | |
Cooperate | {10,20} | {0,-10} |
Defect | {30,0} | {20,10} |
Functional Payoff Matrices
Functional Payoff Matrices
Below, the four games are represented without the specialized formatting above. “cg” represents the coin game, “pd” represents the Prisoner’s Dilemma, “sh” represents Stag’s Hunt, and “as” represents the asymmetrical game. These payoff matrices will be used from now on to supplement code readability and functionality.
cgpayoffMatrix={{{2,2},{-1,3}},{{3,-1},{0,0}}};pdpayoffMatrix = {{{-2,-2},{-8,-1}},{{-1,-8},{-5,-5}}};shpayoffMatrix = {{{3,3},{0,1}},{{1,0},{1,1}}};aspayoffMatrix = {{{10,20},{0,-10}},{{30,0},{20,10}}};
Defining Foundational Functions
Defining Foundational Functions
Foundational functions are crucial to this project for establishing the basic algorithms and methods for simulating and recording the iterated binary choice games.
Calculating Payoffs Based Off of User Inputs
Calculating Payoffs Based Off of User Inputs
This function accepts two lists: the first list contains Player One’s moves over several games, and the second list contains Player Two’s moves. Using the specified payoff matrix, the function returns the total score for both Player One and Player Two over that specified number of rounds.
However, the function has a few drawbacks when used as is. Firstly, it requires users to manually input lists of equal length, detailing each move for every round. Additionally, it only calculates the total payoffs, not the payoffs for each individual round.
However, the function has a few drawbacks when used as is. Firstly, it requires users to manually input lists of equal length, detailing each move for every round. Additionally, it only calculates the total payoffs, not the payoffs for each individual round.
In[]:=
calculatePayoffs[moves1_List,moves2_List,payoffMatrix_List]:=Module[{payoffs,totalPayoff1=0,totalPayoff2=0},payoffs=payoffMatrix[[#1,#2]]&@@@Transpose[{moves1,moves2}];{totalPayoff1,totalPayoff2}=Map[Total,Transpose[payoffs]];{totalPayoff1,totalPayoff2}]
Making Player Bots with Set Strategies
Making Player Bots with Set Strategies
Player Bots are just functions with hard-coded strategies based on predefined rules or algorithms.
Primitive Bots
Primitive Bots
When playing the game multiple times, the simplest strategies are to always play one choice or the other. For example, if playing multiple rounds, one player could play 1 (cooperate) for every round. Though it may not do well, it is still a “strategy.”
Coding these types of primitive bots are the most basic step. As such, the functions alwaysCooperate and alwaysDefect represent bots that always play 1 or always play 2, respectively.
In[]:=
alwaysCooperate[opponentHistory_,pos_]:=1
In[]:=
alwaysDefect[opponentHistory_,pos_]:=2
There is also the concept of a bot that randomly picks a choice for each round, thus named Random Choice Bot:
In[]:=
randomBot[history_,pos_]:= RandomInteger[{1,2}]
Complex Bots
Complex Bots
The copyCat strategy entails the idea of a bot that does the same move as its opponents last move. For instance, if the opponents last move was cooperate, copyCat will cooperate in the current round.
In[]:=
copyCat[history_List,pos_]:=Module[{Move},If[Length[history[[oppositeChoice[pos]]]]==0,1,Move=history[[oppositeChoice[pos]]][[-1]];Move]]
The adamBot bases its decision on the sum of move histories from both players, including its own. If the sum is odd, it chooses to play 1. if even, it chooses 2. (Credit to Mentor Adam for idea).
In[]:=
adamBot[history_List,pos_]:=Module[{sumMoves},If[Length[history[[2]]]==0,1,sumMoves=Total[Flatten[history]];If[OddQ[sumMoves],1,2]]]
For some bots, needed a simple function to take the opposite of a move. For instance, if the move is 1, then oppositeChoice returns 2.
In[]:=
oppositeChoice[x_Integer]:= If[x==1,2,1]
The opposite of copyCat, diffBot selects the opposite move as the opponent’s last move.
In[]:=
diffBot[history_List,pos_]:=Module[{Move},If[Length[history[[pos]]]==0,1,Which[history[[oppositeChoice[pos]]][[-1]]==1,Move=2,history[[oppositeChoice[pos]]][[-1]]==2,Move =1];Move]]
Simple Bot starts by cooperating. If the opponent cooperates in return, Simple Bot repeats its last move. If the opponent defects in response, Simple Bot switches to the opposite move compared to its own last move.
In[]:=
simpleBot[history_List,pos_]:= Module[ {Move},If[Length[history[[pos]]]==0,1,Which[history[[oppositeChoice[pos]]][[-1]]==1,Move=history[[pos]][[-1]],history[[oppositeChoice[pos]]][[-1]]==2,Move =oppositeChoice[history[[pos]][[-1]]]]]]
Simulating the Games
Simulating the Games
Recording Move History
Recording Move History
To simulate a game between two bots, we first need a function that records the move history for each bot. This way, the bots are able to see each other’s prior moves to base its strategy off of. The following function accomplishes this task by taking 5 arguments. The first two are the player bots (again, functions) that face off. The next parameter is a list of 2 sublists that represents the bots’ histories. The next two parameters are to ensure that the bots are in the correct positions and are looking at the correct move histories.
Simulating Matches between Bots
Simulating Matches between Bots
The simulateGame function simulates a specified number of rounds of a given binary choice game (using the parameter PayoffMatrix) between two bots. This function combines the calculate payoffs and record game history functions. It initializes with an empty game history and payoffs, then iteratively updates these by recording the moves of both bots and calculating the resulting payoffs for each round. The Nest function is used to perform these updates for the specified number of rounds.
After the simulation, it creates a grid that displays the round number, each player’s moves, and their respective payoffs, with styled headers for clarity. Additionally, it generates a line plot that visualizes the accumulated payoffs of both players over the rounds, and returns these visualizations in an association. This example generates 20 rounds of the coin game between randomBot and copyCat.
After the simulation, it creates a grid that displays the round number, each player’s moves, and their respective payoffs, with styled headers for clarity. Additionally, it generates a line plot that visualizes the accumulated payoffs of both players over the rounds, and returns these visualizations in an association. This example generates 20 rounds of the coin game between randomBot and copyCat.
Asymmetric Matches Between Bots
Asymmetric Matches Between Bots
An interesting case occurs when bots engage in an asymmetric binary choice game. In this scenario, the bots operate under different payoff matrices, meaning the rewards and penalties they face for their decisions are not identical. This setup can reveal how varying incentives influence strategic behavior. For example, a bot with a higher reward for cooperation might be more inclined to cooperate, even if its opponent’s rewards for defection are higher.
Furthermore, The position of bots in an asymmetric game significantly also affects their strategies and interactions. A bot in a stronger position with higher rewards for cooperation or lower penalties for defection might adopt a more aggressive strategy, while a weaker bot may be more cautious and cooperative. For example, consider the asymmetric payoff matrix defined earlier. One bot receives a reward of 10 for mutual cooperation (Player 1) while the other receives 20 (Player 2), and the penalties for mutual defection are 20 (Player A) and 10 (Player B), respectively. In such a setup, even if the same two bots are playing the game, the varying rewards and penalties based on their positions result in different outcomes and winners.
Furthermore, The position of bots in an asymmetric game significantly also affects their strategies and interactions. A bot in a stronger position with higher rewards for cooperation or lower penalties for defection might adopt a more aggressive strategy, while a weaker bot may be more cautious and cooperative. For example, consider the asymmetric payoff matrix defined earlier. One bot receives a reward of 10 for mutual cooperation (Player 1) while the other receives 20 (Player 2), and the penalties for mutual defection are 20 (Player A) and 10 (Player B), respectively. In such a setup, even if the same two bots are playing the game, the varying rewards and penalties based on their positions result in different outcomes and winners.
To Illustrate, in these games, copyCat and simpleBot are playing 20 rounds of the asymmetrical game. In the first 10 games, copyCat occupies the first position while simpleBot occupies the second. However, In the latter 10 games, their positions are switched. Even though their moves are the same in both sets of games, because of the asymmetrical payoffs, the player in the first position always comes out on top.
Creating a Round-Robin Tournament between Bots
Creating a Round-Robin Tournament between Bots
Making a Tournament Table
Making a Tournament Table
To create a tournament, I needed to modify the simulateGame function to return just the winner between each matchup. To do this, I replaced the listline plot and the grid with a which statement that returned the bot that won the match, which was still determined by the magnitude of the payoffs.
Now, I was able to create a Tournament Grid using this simplified simulateGamebasic function.
The simulateGameGridTable function constructs a grid to display the results of a round-robin tournament among bots, each playing against every other bot for a specified number of rounds and using a given payoff matrix. It initializes a matrix where each cell contains the results of a game between two bots, and headers are filled with bot names. The matrix is filled using a nested Table and Which statement, calling simulateGameBasic for each bot pair. The first row and column list the bot names, while the other cells display the simulation results. Self Match represents a bot playing against itself, while Tie represents a match between two bots resulting in a draw.
The simulateGameGridTable function constructs a grid to display the results of a round-robin tournament among bots, each playing against every other bot for a specified number of rounds and using a given payoff matrix. It initializes a matrix where each cell contains the results of a game between two bots, and headers are filled with bot names. The matrix is filled using a nested Table and Which statement, calling simulateGameBasic for each bot pair. The first row and column list the bot names, while the other cells display the simulation results. Self Match represents a bot playing against itself, while Tie represents a match between two bots resulting in a draw.
This example shows a tournament of all 7 bots playing the coin game 25 times:
Creating a Leaderboard for the Bots
Creating a Leaderboard for the Bots
A leaderboard of all the bots first required another modification to the simulateGame function. This time, I modified it so that it returned only a two element list of the total payoffs for each bot, the first representing bot A’s payoffs and the second for bot B’s. For the sake of the point accumulation in the tournament, I also included a conditional that set the payoffs to {0,0} if the bots played themselves.
Using this, I was able to create a new tournament grid that displayed not the winning bots, but the payoffs.
This example shows the payoffs for all 7 bots after 15 rounds of the coin game:
Using this grid, I could calculate the total payoffs for each bot in the tournament by just simply totaling the first indices of the payoffs in each row, then updating them to each respective bot.
This calculateLeaderboard function simulates a round-robin tournament where each bot plays against every other bot a specified number of times, using a given payoff matrix to determine the payoffs. It calculates the total payoffs for each bot across all games by iterating over each pair of bots, using the simulateGamePayoffs function, and accumulating the payoffs. The function then pairs each bot with its corresponding total payoff, sorts these pairs in descending order based on the payoffs, and creates a grid displaying the results. The grid shows the bot names in the first column and their respective total payoffs in the second column, with the highest scoring bots listed at the top.
This Leaderboard shows the total payoffs for each bot after 15 rounds of the coin game:
“Dominant” Strategies
“Dominant” Strategies
In game theory surrounding these types of binary choice games, the strategy of always defecting consistently yields a higher personal payoff compared to cooperating, regardless of the opponent’s choice. This strategy illustrates the idea of a “dominant strategy”. In game theory, a “dominant strategy” refers to a player’s optimal choice that guarantees the highest payoff regardless of the choices made by others. In the Prisoner’s Dilemma, “Always Defect” is widely recognized as a dominant strategy because it consistently offers a higher payoff compared to cooperating, disregarding of the opponent’s decision.
This concept correlates directly to why the bot Always Defect tops the leaderboard each time. Since no bots actually punish the dominant strategy of always defecting (for instance, cooperating only until someone defects), the incentive of always defect proves to be the best strategy.
This concept correlates directly to why the bot Always Defect tops the leaderboard each time. Since no bots actually punish the dominant strategy of always defecting (for instance, cooperating only until someone defects), the incentive of always defect proves to be the best strategy.
Exhaustively Testing Strategies Based on All Possible Combinations of Moves
Exhaustively Testing Strategies Based on All Possible Combinations of Moves
The Nature of Choices
The Nature of Choices
In a binary choice game, a single player has two options: to cooperate (1) or to defect (2). In this project, I represent these options as the integers 1 and 2. Ignoring strategies and bots analyzing each other’s histories, we find a finite number of distinct move lists based on all possible combinations of 1s and 2s.
Ultimately, a strategy is a sequence of plays—either 1s (cooperate) or 2s (defect)—that a player follows throughout the game. Each distinct sequence of 1s and 2s corresponds to a different strategy. For instance, a strategy might be “cooperate in the first two rounds, then defect in the next two rounds,” represented as the sequence {1, 1, 2, 2}. By enumerating all possible sequences, we can explore the full range of strategies and potential outcomes in the game.
Thus, for a given number of rounds, there are a finite number of combinations of 1s and 2s that make up a MoveList, or an overall strategy. The total number of possible MoveLists for a given number of rounds is determined by 2^n, where n is the number of rounds. For example, with 4 rounds, each player has 2^4, or 16, possible MoveLists, representing all possible sequences of cooperation and defection over those 4 rounds. This can be generated using the built-in function Tuples:
Ultimately, a strategy is a sequence of plays—either 1s (cooperate) or 2s (defect)—that a player follows throughout the game. Each distinct sequence of 1s and 2s corresponds to a different strategy. For instance, a strategy might be “cooperate in the first two rounds, then defect in the next two rounds,” represented as the sequence {1, 1, 2, 2}. By enumerating all possible sequences, we can explore the full range of strategies and potential outcomes in the game.
Thus, for a given number of rounds, there are a finite number of combinations of 1s and 2s that make up a MoveList, or an overall strategy. The total number of possible MoveLists for a given number of rounds is determined by 2^n, where n is the number of rounds. For example, with 4 rounds, each player has 2^4, or 16, possible MoveLists, representing all possible sequences of cooperation and defection over those 4 rounds. This can be generated using the built-in function Tuples:
Pitting the Possible Strategies Against Each Other using Tuples
Pitting the Possible Strategies Against Each Other using Tuples
Not only can we enumerate all possible strategies, but we can also play them against each other and display the winning strategies in a grid. To determine the winner of each strategy matchup, I modified the calculatePayoffs function. This new version, called payoffsGrid, uses a Which conditional to return the moves list that wins in each matchup. If it is a tie, it simply returns {0, 0}.
The function matchUps[l_List] generates all combinations of elements in list l, arranged in a grid where each element pairs with every other element exactly once.
The function resultpayoffMatrix[l_List, payoffMatrix_List] computes the payoff for each pair of strategies from list l using the specified payoffMatrix. It applies the function payoffsGrid to each pair of strategies generated by matchUps[l], which contains all possible pairwise combinations of strategies from l. The result is a grid where each cell represents the payoff obtained by applying payoffMatrix to the respective pair of strategies from l.
The best strategy for playing n rounds of a binary choice game is the one that wins the most matchups. Therefore, the move list that appears the most frequently as a winner is considered the best strategy. The function bestStrategy determines the most common outcomes across all pairs of strategies in list x, based on the provided payoff matrix. It does this by flattening the results from resultpayoffMatrix into a single list, filtering out {0, 0}, which represents a tie, and then identifying the most common result using Commonest.
The function tournamentGrid takes in a list and a payoff matrix, generating a grid displaying the payoff outcomes between strategies using resultpayoffMatrix. It also determines the best strategy based on the most common outcomes using the bestStrategy function. The result is returned as an association containing keys “Grid” for the grid display and “Best Strategy” for the identified best strategy. The first row and column list all the possible move lists of the players for a n number of rounds (represented by the last argument of Tuples), and the inner cells display the winning strategies (move lists) of each matchup.
This tournament grid shows all the possible combinations of 1s and 2s of a length 3, then plays them against one another using the prisoner’s dilemma payoff matrix.
Using Matrix Plot to visualize the Tournament Grid
Using Matrix Plot to visualize the Tournament Grid
To visually represent winning strategies, we can input a grid into MatrixPlot. However, because MatrixPlot only accepts single-digit numbers and not lists, I had to convert each Move List to a unique single number. By labeling each strategy with a unique number, I ensured that each strategy is distinct and compatible with MatrixPlot. The first step is to convert the results of the tournament grid from a list of winning strategies into single numbers that can be input into MatrixPlot. For example, the resultpayoffMatrix currently looks like this:
Using replacement rules and binary, this expression changes {0,0} to -1 and converts any other tuple of integers to a binary number, where the tuple is first adjusted by subtracting 1 from each element and then interpreted as a binary number. Thus, I was able to convert this matrix of winning strategies into single digit numbers:
Then, I parametrized the expression into a function using MatrixPlot, taking two arguments: the list of tuples to be inputted and the payoff Matrix for the game being played.
All Finite Functions Between Four Elements with Three Outcomes
All Finite Functions Between Four Elements with Three Outcomes
The Concept of Mapping Between Two Sets
The Concept of Mapping Between Two Sets
Furthermore, we can enumerate the outcomes from four possible choices associated with binary choice games. There are a finite number of mappings between a set of 4 elements, representing different combinations of choices, and a set of 3 elements, representing outcomes (A wins, B wins, or Tie). Specifically, for each of the 4 elements in the domain, we can choose one of 3 elements from the codomain. This results in 3^4 or 81 possible mappings or outcomes.
Each mapping represents a unique instance of a binary choice game, where outcomes—whether player A wins, player B wins, or the game ends in a tie—are determined by the strategies chosen over a series of rounds. Visualizing these mappings allows us to analyze and compare the outcomes of different strategies in these games. This can reveal how varying player decisions lead to distinct game results.
Notice that the strategies focus solely on winning each round. I have simplified the analysis to explore only three possible outcomes: A wins, B wins, or a Tie.
Each mapping represents a unique instance of a binary choice game, where outcomes—whether player A wins, player B wins, or the game ends in a tie—are determined by the strategies chosen over a series of rounds. Visualizing these mappings allows us to analyze and compare the outcomes of different strategies in these games. This can reveal how varying player decisions lead to distinct game results.
Notice that the strategies focus solely on winning each round. I have simplified the analysis to explore only three possible outcomes: A wins, B wins, or a Tie.
Creating a Directed Graph as an Arrow Diagram
Creating a Directed Graph as an Arrow Diagram
The createBlobAndArrowDiagram1 function helps illustrate these mappings by creating a directed graph where each element in the domain is connected to its corresponding element in the codomain. This function generates a graph where each element in the domain is connected to an element in the codomain according to the specified mapping. The positions of the vertices are specified to organize the graph visually, making it easier to understand the relationships between the elements.
For example, considering the following domain, codomain, and mapping:
Using the createBlobAndArrowDiagram1 function, we can create a visual representation of these mappings:
Using Tuples, we can generate all 81 possible configurations of a game involving 4 choices and 3 outcomes. Here, the domain represents all combinations of choices where each player can choose between options 1 or 2. The codomain specifies the possible outcomes of the game as “A” (Player A wins), “T” (Tie), and “B” (Player B wins). By taking the Tuples of the codomain with a length equal to the number of elements in the domain, we generate all possible matrices that represent the outcomes of these games. This process results in payoffMatrices containing 81 matrices, each representing a unique configuration of outcomes for a binary choice game where Player A and Player B make choices 1 or 2, leading to outcomes “A”, “T”, or “B”.
Then, I can apply the createBlobAndArrowDiagram1 function over these new payoff matrices to generate a diagram for each game configuration:
Using Manipulate, I can visually explore the 81 configurations of a binary choice game with createBlobAndArrowDiagram1, illustrating how Player A and Player B’s choices (1 or 2) lead to outcomes “A”, “T”, or “B”.
Creating Matrix Plots to Represent Outcomes
Creating Matrix Plots to Represent Outcomes
Furthermore, I can also represent the game outcomes in a Matrix Plot. To do this, I can convert the list of game outcomes above into 2x2 payoff matrices using conditional assignments. Each outcome in the list corresponds to a specific position in the matrix, reflecting the possible results of a binary choice game.
This matrixCreator function processes a list representing payoff matrices, transforming each element into an actual payoff matrix using conditional Which statements. When Player A wins, it returns {1, 0}. When Player B wins, it returns {0, 1}. For a tie, it returns {0, 0}.
Then, this code generates a list of 2x2 payoff matrices by applying the matrixCreator function to each configuration in payoffMatrices using Table.
Now, I can use matrixPlotPayoffs to create matrix plots for each of the generated payoff matrices. This code uses Table to apply matrixCreator to each element in payoffMatrices, converting each game configuration into a 2x2 payoff matrix. Then, matrixPlotPayoffs maps over these matrices to visualize the strategic outcomes represented in each binary choice game configuration.
Similarly as above, I can use Manipulate to visualize strategic outcomes for all 81 possible binary choice game configurations using matrixPlotPayoffs. Each scenario is represented by a 2x2 payoff matrix created with matrixCreator from payoffMatrices.
Combining the Diagrams with the Matrix Plots into a single Visualization
Combining the Diagrams with the Matrix Plots into a single Visualization
Using Partition and Riffle, I can pair each binary choice game’s blob and arrow diagram with its corresponding matrix plot. This combines visual representations of strategic choices and outcomes into a list of sublists, with each sublist representing the arrow diagrams with their respective output matrix plots.
Finally, ListAnimate cycles through both the blob and arrow diagrams and the corresponding matrix plots. This function uses the above list of strategic choices and outcomes visualized in both types of representations for all 81 possible configurations of the binary choice game.
Interesting Visual Representations
Interesting Visual Representations
Some iterations of the possible binary choice games generated interesting and beautiful matrix plots. Here is my favorite one, number 57, a binary choice game with move lists iterated 2^10 times, and its corresponding directed arrow diagram.
Conclusion and Applications
Conclusion and Applications
The objective of this project was to explore the various incentives, strategies, and resultant outcomes when player choices are predetermined and outcomes can be anticipated. Even focusing on straightforward binary choices and clear outcomes, the scope for this exploration was vast. One can even consider the broader implications on a global scale, where there are countless decisions and factors. In the larger world, every decision, whether made by individuals, organizations, or nations, adds to the vast amount of interactions and consequences. From economic policies shaping markets to diplomatic incentives influencing international relations, the complexity magnifies exponentially. Each decision reflects not only immediate gains or losses but also longterm effects that occur in global societies.
Implications for Future Research
Implications for Future Research
This project offers several paths for extension. It could explore games with multiple player choices, like rock-paper-scissors, to introduce more strategic complexity. Additionally, investigating mixed strategies would enhance the analysis by allowing players to make decisions based on probability. Furthermore, a more detailed examination of cumulative payoffs beyond simply win, lose, or tie outcomes could provide deeper insights into long-term strategic implications.
Acknowledgements
Acknowledgements
Thank you to my mentor Adam Millar and TA Logan Gilbert. Both of their support is truly immeasurable.
Citations
Citations
◼
Picardo, E. (2024, January 26). The prisoner’s dilemma in business and the economy. Investopedia. https://www.investopedia.com/articles/investing/110513/utilizing-prisoners-dilemma-business-and-economy.asp
◼
The evolution of trust. (n.d.). https://ncase.me/trust/
CITE THIS NOTEBOOK
CITE THIS NOTEBOOK
Analyzing all possible iterated binary choice games
by Aziz Sahibnazarov
Wolfram Community, STAFF PICKS, July 12, 2024
https://community.wolfram.com/groups/-/m/t/3215898
by Aziz Sahibnazarov
Wolfram Community, STAFF PICKS, July 12, 2024
https://community.wolfram.com/groups/-/m/t/3215898