Announcing the 2014 program equilibrium iterated PD tournament

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.)

I am glad to see this trend continuing!

You seem to have neglected to include the Bitcoin address to contribute to the prize pool.

I pledge to contribute 10 mBTC to the prize pool and 1 mBTC tip to the organizer once the relevant addresses are publicly posted. This is conditional on a vaguely sane prize distribution policy, and a pledge to return the contribution if there are insufficient submissions to be interesting. (I'm hoping that 11 mBTC is a small enough amount that no one feels a need to quibble over the fact that my pledge is pretty vague. If you'd like me to make it less vague, please say so.)

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?

Submitted! I'm excited to see how this pans out.

Really cool project, thanks a lot! I actually like your choice of haskell - the example bots are beautiful. I thought about implementing something like this myself some time ago, but I wouldn't have been able to do it as well as you did.

Just one small concern about the tournament rules:

One round could take up to 10 second if both players make full use of their time, so one match of a 100 rounds could take up to 1000 seconds, right? And let's say there are at a very rough estimate 100 matches per tournament. And you want to run 1000 tournaments. Maybe I just made a stupid mistake, I am quite tired right now, but this could theoretically require years of computation time, couldn't it?

Oh, and I could probably translate bots into haskell, if you need help.

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.

OK; I'm reasonably sure I've come up with a strategy that is a simulation equilibrium (a la "program equilibrium") and cooperates with itself.

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.

This looks fun! I will participate.

Sounds like fun!

Throwing this idea out there. If instead of returning Nothing on a timeout, it would be nice if a "current Choice" state were returned. Bots could update this state until time ran out.