Revisions to Prisoner's Dilemma v.2 - Battle Royale

replaced http://codegolf.stackexchange.com/ with https://codegolf.stackexchange.com/

Source Link

edited Apr 13, 2017 at 12:39

1

In this question this question, a game was devised in which players would face each other off pair by pair in the Prisoner's Dilemma, to determine which iterative strategy scored the highest against others.

replaced http://math.stackexchange.com/ with https://math.stackexchange.com/

Source Link

edited Apr 13, 2017 at 12:19

Community Bot

1

In this question this question, I devised a way for multiple people to play the Prisoners' Dilemma against each other all at the same time. In this variation, the payoff matrix is unnecessary, with each outcome between each pair of two players being the sum of two functionally independent decisions.

Rollback to Revision 12

Source Link

edited Apr 11, 2015 at 22:02

Martin Ender

197.2k
67
447
975

In each round of this multiplayer, multi-round Prisoner's Dilemma, a player $A$A can decide to "take 1" from some other player $B$B. In this circumstance, $A$'sA's score increases by 1, while $B$'sB's score decreases by 2. This decision is allowed to happen between each ordered pair of players.

This is the only decision made for each player – either to "take 1" or not to "take 1" from each other player, which are homologous to defection and cooperation respectively. The effective payoff matrix between two players $P_1$P1 and $P_2$P2 looks as follows:

The game will consist of $P \times 25$P * 25 rounds, where $P$P is the number of participating players. All players start with a score of $0$0. Each round will consist of the following procedure:

One line containing 3 numbers, $P$P, $D$D, and $N$N.
$P$P is the total number of players in the game. Each player is randomly assigned an ID number from $1$1 to $P$P at the beginning of the game.
$D$D is the ID of the current player.
$N$N is the number of rounds that have been played.
$N$N lines, each line representing the outcomes of a round. On line $k$k of $N$N, there will be some number $n_k$n_k of ordered pairs $(a, b)$(a, b), separated by spaces, which represent that the player with ID $a$a "took 1" from the player with ID $b$b in that round.
A uniformly random number $R$R from $0$0 to $18446744073709551615 (2^{64}2⁶⁴ -1 1)$, to act as a pseudorandom seed. These numbers will be read from a pre-generated file, which will be released at the end of the tournament so that people can verify the results for themselves.
One extra line that represents some form of state to be read into your program, if your program produced such an output in the previous round. At the beginning of the game, this line will always be empty. This line will not be modified by either the scoring code or other programs.

A list of $K$K numbers, which are the IDs of the programs it will "take 1" from this round. An empty output means it will do nothing.
Optionally, one extra line representing some form of state to pass on to later rounds. This exact line will be fed back to the program in the next round.

Below is an example input for the beginning of the game for a player of ID $3$3 in a 4-player game:

Below is an example output in which player $3$3 takes 1 from everybody else:

In each round of this multiplayer, multi-round Prisoner's Dilemma, a player $A$ can decide to "take 1" from some other player $B$. In this circumstance, $A$'s score increases by 1, while $B$'s score decreases by 2. This decision is allowed to happen between each ordered pair of players.

This is the only decision made for each player – either to "take 1" or not to "take 1" from each other player, which are homologous to defection and cooperation respectively. The effective payoff matrix between two players $P_1$ and $P_2$ looks as follows:

The game will consist of $P \times 25$ rounds, where $P$ is the number of participating players. All players start with a score of $0$. Each round will consist of the following procedure:

One line containing 3 numbers, $P$, $D$, and $N$.
$P$ is the total number of players in the game. Each player is randomly assigned an ID number from $1$ to $P$ at the beginning of the game.
$D$ is the ID of the current player.
$N$ is the number of rounds that have been played.
$N$ lines, each line representing the outcomes of a round. On line $k$ of $N$, there will be some number $n_k$ of ordered pairs $(a, b)$, separated by spaces, which represent that the player with ID $a$ "took 1" from the player with ID $b$ in that round.
A uniformly random number $R$ from $0$ to $(2^{64}-1)$, to act as a pseudorandom seed. These numbers will be read from a pre-generated file, which will be released at the end of the tournament so that people can verify the results for themselves.
One extra line that represents some form of state to be read into your program, if your program produced such an output in the previous round. At the beginning of the game, this line will always be empty. This line will not be modified by either the scoring code or other programs.

A list of $K$ numbers, which are the IDs of the programs it will "take 1" from this round. An empty output means it will do nothing.
Optionally, one extra line representing some form of state to pass on to later rounds. This exact line will be fed back to the program in the next round.

Below is an example input for the beginning of the game for a player of ID $3$ in a 4-player game:

Below is an example output in which player $3$ takes 1 from everybody else:

In each round of this multiplayer, multi-round Prisoner's Dilemma, a player A can decide to "take 1" from some other player B. In this circumstance, A's score increases by 1, while B's score decreases by 2. This decision is allowed to happen between each ordered pair of players.

This is the only decision made for each player – either to "take 1" or not to "take 1" from each other player, which are homologous to defection and cooperation respectively. The effective payoff matrix between two players P1 and P2 looks as follows:

The game will consist of P * 25 rounds, where P is the number of participating players. All players start with a score of 0. Each round will consist of the following procedure:

One line containing 3 numbers, P, D, and N.
P is the total number of players in the game. Each player is randomly assigned an ID number from 1 to P at the beginning of the game.
D is the ID of the current player.
N is the number of rounds that have been played.
N lines, each line representing the outcomes of a round. On line k of N, there will be some number n_k of ordered pairs (a, b), separated by spaces, which represent that the player with ID a "took 1" from the player with ID b in that round.
A uniformly random number R from 0 to 18446744073709551615 (2⁶⁴ - 1), to act as a pseudorandom seed. These numbers will be read from a pre-generated file, which will be released at the end of the tournament so that people can verify the results for themselves.
One extra line that represents some form of state to be read into your program, if your program produced such an output in the previous round. At the beginning of the game, this line will always be empty. This line will not be modified by either the scoring code or other programs.

A list of K numbers, which are the IDs of the programs it will "take 1" from this round. An empty output means it will do nothing.
Optionally, one extra line representing some form of state to pass on to later rounds. This exact line will be fed back to the program in the next round.

Below is an example input for the beginning of the game for a player of ID 3 in a 4-player game:

Below is an example output in which player 3 takes 1 from everybody else: