= 27d567bc2d48d9f40e9ccc20ea370b15)
I've written a pretty good program to complete variant 3 but I'm such a lurker on this site i lack the nessesary karma to submit it as a article. So here it is as a comment instead:
Inspired by prase's contest, (results here) and Eliezer_Yudkowsky's comment, I've written a program that plays iterated games of prisoners dilemma, with the cravat that each player can simulate his opponent. I'm now running my own contest. You can enter your onwn strategy by sending it to me in a message. Deadline to enter is Sunday September 25. The contest itself will run shortly there after.
Each strategy plays 100 iterations against each other strategy, with cumulative points. Each specific iteration is called a turn, each set of 100 iterations is called a match. (thanks prase for the terminology). Scoring is CC: (4,4) DC: (7,0) CD: (0,7) DD: (2,2).
Every turn, each strategy receives a record of all the moves it and its opponent made this match, a lump of time to work and its opponents code. Strategies can't review enemy code directly but they can run it through any simulations they want before deciding their move, within the limits of the amount of time they have to work.
Note that strategies can not pass information to themselves between iterations or otherwise store it, other than the record of decisions. They start each turn anew. This way any strategy can be simulated with any arbitrary record of moves without running into issue.
Strategies in simulations need a enemy strategy passed into them. To avoid infinite recursion of simulations, they are forbidden from passing themselves. They can have as many secondary strategies as need however. This creates a string of simulations where strategy(1) simulates enemy(1), passing in strategy(2) which enemy(1) simulates and passes in enemy(2) which strategy(2) simulates and passes in strategy(3). The final sub-strategy passed in by such a chain must be a strategy which performs NO simulations.
for example, the first sub-strategy could be an exact duplicate of main strategy other than that it passed the titfortat program instead. so mainstrategy => substrategy1 => titfortat.
You can of course use as many different sub_strategies as you need, the programs are limited by processing time, not memory. Strategies can run their simulated opponent on any history they devise, playing which ever side they choose.
Strategies can't read the name of their opponent, see the number of strategies in the game, watch any other matches or see any scores outside their current match.
Strategies are not cut off if they run out of time, but both will receive 0 points for the turn. The decisions of the turn will be recorded as if normal.
I never figured out a good way to keep strategies from realizing they were being simulated simply by looking at how much time they were given. Not knowing how much time they have would make it prohibitively difficult to avoid timing out. My hack solution is to not give a definitive amount of time for the main contest but instead a range: from 0.01 seconds to 0.1 seconds per turn, with the true time to be know only by me. This is far from ideal, and if anyone has a better suggestion I'm all ears.
To give reference: a strategy that runs 2 single turn simulations of titfortat against titfortat takes, on average 3.510^-4 seconds. Running only 1 single turn simulations took only 1.510^-4 seconds. titfortat by itself takes about 2.5*10^-5 seconds to run a single turn. Unfortunately, do to factor outside of my control, matlab, the software I'm running will for unknown reasons take 3 to 5 times as long as normal about 1 out of a 100 times. Leave yourself some buffer.
Strategies are NOT allowed a random number generator. This is different from prase's contest but I would like to see strategies for dealing with enemy intelligence trying to figure them out without resorting to unpredictability.
I've come up with a couple of simple example strategies that will be performing in the contest.
Careful_cheater:
simulates its opponent against titfortat to see its next move. If enemy defects, Carefulcheater defects. If enemy cooperates, Carefulcheater simulates its next move after that with a record showing Carefulcheater defecting this turn, passing titfortat. If the opponent would have defected on the next turn, Carefulcheater cooperates, but if the opponent would have cooperated despite Careful_cheaters defection, it goes ahead and defects.
simulations show it doing evenly against titfortat and its usual variations, but Carefulcheater eats forgiving programs like titfor2tats alive.
Everyman:
simulates 10 turn matchs with its opponent against several possible basic strategies, including titfortat, titfortat_optimist (cooperates first two turns), and several others, then compares the scores of each match and plays as the highest scoring
Copy_cat:
Switches player numbers and simulates its opponent playing Copycats record while passing its opponent and then performs that action. That is to say, it sees what its opponent would do if it were in Copycats position and up against itself.
this is basically DuncanS strategy from the comments. DuncanS, your free to enter another one sense I stole yours as an example
and of course titfortat and strategy "I" from prase's contest will be competing as well.
one strategy per person, all you need for a strategy is a complete written description, though I may message back for clarification. I reserve the right to veto any strategy I deem prohibitively difficult to implement.
= b715d02e85f7b3b4ae65ca3d3e450868)
Subscribe to RSS Feed
= f037147d6e6c911a85753b9abdedda8d){kind=logo}
I can't believe that this one hasn't been done before:
Unless you are Eliezer Yudkowsky, there are 3 things that are certain in life: death, taxes and the second law of thermodynamics.