I don't think this game is a prisoner's dilemma, since the tournament implies that all pure deterministic strategies yield the same outcome (an all-players tie) if applied by everyone, while the interesting thing about PD is that mutual cooperation is preferable to mutual defection.

Also, it is not a "program equilibrium" game, since running simulations gives much less information than analyzing the source code. For instance, clique strategies, which are often occur in the Nash equilibria of program equilibrium games, are impossible in your game.

Is there a particular reason you've decided on using exactly 100 rounds per bout? Having a fixed end-point can cause some unusual behaviour to crop up at the end turn, and depending on how many levels of recursion are applied, multiple turns before that.

(One alternative I've seen is that after any given round, there's a 99.30925% chance there will be another, which gives close to 50% odds that the game will last 100 turns or less.)

Found something slightly amusing:

-- Simulate my opponent playing a round against me, and to the opposite of
-- whatever my opponent does. Limit my opponent to 10ms, defect if they go
-- over.
trollBot :: Bot
trollBot = Bot run where
    run op hist = do
        simulation <- time 10000 . runBot op mirrorBot $ invert hist
        return (case simulation of
                Nothing   -> Cooperate
                Just Cooperate -> Defect
                Just Defect -> Cooperate)

When I enter trollBot into the simulation tournament, it actually ends up doing better than any of the default bots during the first round, pretty consistently. It also results in a win for defectBot.

I'm puzzled as to why trollBot does as well as it does. Is it just a function of the particular players it's up against, or is that actually a viable strategy?

Last year, AlexMennen ran an iterated prisoner's dilemma tournament

Correction: my tournament was one-shot prisoner's dilemma.

Anyway, I'm glad to see this is being tried again.

I am so excited. When will you post results?

In the examples you show how to run the opponent, but how do you access the source code? For example, how do you distinguish a cooperate bot from a (if choice < 0.0000001 then Defect else Cooperate) bot without a million simulations?

Thanks for running this!

One thought however is that Haskell is a lot less well known then python, so if you want a large stable of bots, you may wind up needing to give some coding help to aspiring entrants

How is the tournament going to work in terms of what plays what? Is every bot going to play against every other bot? Is there a big pool, where successful bots get more copies and then we run for a while? Can a person submit multiple bots?

The best strategy depends heavily on the expected opponents. For example, a bot that tries to detect itself in order to cooperate only makes sense if it might play itself.

Thanks for running this, and for translating my psuedocode bot into Haskell!

I assume we are only allowed to enter one bot, correct?

What is the deadline?

This post says September 1st, while the linked github repo says September 15, 2014 13:59 UTC.

I'm having trouble comprehending what running one of these bots would consist of. Suppose MyBot is put against OpponentBot. So MyBot is going to run a simulation of OpponentBot, and that instance of OpponentBot is going to run a simulation of MyBot, and that instance is going to run a simulation of OpponentBot ... how does this process terminate? My head hurts.