Iterated Prisoner's Dilemma Unofficial "Competition"

Programming
1

The Iterated Prisoner’s Dilemma is a classic problem in game theory, and I decided to make a “competition” for it. (the winner gets nothing) Posting early because blystii guessed a number…

Rules

  1. One submission per user. I won’t include second submissions.
  2. Strategies must only use built-in Python features, plus the random module, and must not have any side effects.
  3. Strategies may be at most 256 LLOC (Logical Lines of Code).
  4. Strategies must terminate. You may use a while True or any other way to loop indefinitely, so long as it is guaranteed to terminate.
  5. Strategy names must be unique. If they are not unique, the name of the submitter will be prepended.
  6. The deadline for submissions is December 31st, 23:59 UTC. Results should be announced by January 2nd, who knows if I’ll remember.

Making a submission

Format for submitting

Name: your name here

# your code here

Example submission

Name: tit_for_tat

def tit_for_tat(ours, theirs):
    return theirs[-1] if theirs else True

Another example

Name: random_choice

def random_choice(ours, theirs):
    return random.choice([True, False])

How to code a strategy

A strategy is really just a Python function taking a list of its own moves, and its opponent’s moves. Returning True means the strategy wishes to cooperate, returning False means it wishes to defect. Note that the lists of moves are not updated until both moves are made.

How winners will be decided

Temptation (T) is 5.
Reward (R) is 3.
Punishment (P) is 1.
Sucker (S) is 0.

This satisfies the two rules for the iterated prisoner’s dilemma:

  1. T > R > P > S
  2. 2R > T + S

Visually, this means:

Payoff Matrix You Cooperate You Defect
They Cooperate You get 3, they get 3 You get 5, they get 0
They Defect They get 5, you get 0 You get 1, they get 1

The winner is whoever gets the most points across all matchups.

Strategies will be faced off against each other, round-robin style.

Notes

  • “Counter strategies”, those which exist soley to perform well against certain strategies, are strongly discouraged.
2

Name: no_surrender

def no_surrender(ours, theirs):
    return all(theirs)
3

I’ll just go ahead and make my own(I wont count myself in the extremely unlikely scenario that this wins)
Name: tft_with_random_opposites

def tft_with_random_opposites(ours, theirs):
    original = theirs[-1] if theirs else True
    return random.choice([original, original, not original])
4

image
image249×202 36.6 KB

5

This top one is my actual submission, I just wanted to make some others for fun.

Name: majority_rule

def majority_rule(ours, theirs):
    if ours:return theirs.count(True) > theirs.count(False)
    return True

I remember seeing a game like this and I recall the optimal strategy (of the ones they tried), but this seems more fun and interesting.

Now for the ones I’m NOT submitting
Feel free to include these for the fun of it or not at all, I don’t care if I won’t win with them, I just think it’d be fun to see them compete.

Name: confused_mathematician

def confused_mathematician(ours, theirs):
    n = len(ours)
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:return False
    return True

Name: flip_flop

def flip_flop(ours, theirs):
    return theirs.count(False) % 2 == 0

Name: bad_first_impression

def bad_first_impression(ours, theirs):
    return bool(ours)

Name: minority_rule

def minority_rule(ours, theirs):
    if ours:return theirs.count(True) <= theirs.count(False)
    return True
2 Likes
6

Realized that points per matches played and points overall would have the same winners, fixed now.

7

Name: random_theirs

def random_theirs(ours, theirs):
    return random.choice(theirs + [True])
1 Like