Overview of past Tournaments

Axelrod’s first tournament

Axelrod’s first tournament is described in his 1980 paper entitled ‘Effective choice in the Prisoner’s Dilemma’ [Axelrod1980]. This tournament included 14 strategies (plus a random “strategy”) and they are listed below, (ranked in the order in which they appeared).

An indication is given as to whether or not this strategy is implemented in the axelrod library. If this strategy is not implemented please do send us a pull request.

Strategies in Axelrod’s first tournament

Name

Author

Axelrod Library Name

Tit For Tat

Anatol Rapoport

TitForTat

Tideman and Chieruzzi

T Nicolaus Tideman and Paula Chieruzz

TidemanAndChieruzzi

Nydegger

Rudy Nydegger

Nydegger

Grofman

Bernard Grofman

Grofman

Shubik

Martin Shubik

Shubik

Stein and Rapoport

Stein and Anatol Rapoport

SteinAndRapoport

Grudger

James W Friedman

Grudger

Davis

Morton Davis

Davis

Graaskamp

Jim Graaskamp

Graaskamp

FirstByDowning

Leslie Downing

RevisedDowning

Feld

Scott Feld

Feld

Joss

Johann Joss

Joss

Tullock

Gordon Tullock

Tullock

(Name withheld)

Unknown

UnnamedStrategy

Random

Unknownd

Random

Axelrod’s second tournament

The code for Axelrod’s second touranment was originally published by the University of Michigan Center for the Study of Complex Systems and is now available from Robert Axelrod’s personal website subject to a disclaimer which states:

“All materials in this archive are copyright (c) 1996, Robert Axelrod, unless otherwise noted. You are free to download these materials and use them without restriction.”

The Axelrod-Python organisation has published a modified version of the original code. In the following table, links to original code point to the Axelrod-Python repository.

Strategies in Axelrod’s second tournament

Original Code

Author

Axelrod Library Name

GRASR

Unknown

Not Implemented

K31R

Gail Grisell

GoByMajority

K32R

Charles Kluepfel

SecondByKluepfel

K33R

Harold Rabbie

Not Implemented

K34R

James W Friedman

Grudger

K35R

Abraham Getzler

Not Implemented

K36R

Roger Hotz

Not Implemented

K37R

George Lefevre

Not Implemented

K38R

Nelson Weiderman

Not Implemented

K39R

Tom Almy

Not Implemented

K40R

Robert Adams

Not Implemented

K41R

Herb Weiner

SecondByWeiner

K42R

Otto Borufsen

SecondByBorufsen

K43R

R D Anderson

Not Implemented

K44R

William Adams

SecondByWmAdams

K45R

Michael F McGurrin

Not Implemented

K46R

Graham J Eatherley

SecondByEatherley

K47R

Richard Hufford

SecondByRichardHufford

K48R

George Hufford

Not Implemented

K49R

Rob Cave

SecondByCave

K50R

Rik Smoody

Not Implemented

K51R

John Willaim Colbert

Not Implemented

K52R

David A Smith

Not Implemented

K53R

Henry Nussbacher

Not Implemented

K54R

William H Robertson

Not Implemented

K55R

Steve Newman

Not Implemented

K56R

Stanley F Quayle

Not Implemented

K57R

Rudy Nydegger

Not Implemented

K58R

Glen Rowsam

SecondByRowsam

K59R

Leslie Downing

RevisedDowning

K60R

Jim Graaskamp and Ken Katzen

SecondByGraaskampKatzen

K61R

Danny C Champion

SecondByChampion

K62R

Howard R Hollander

Not Implemented

K63R

George Duisman

Not Implemented

K64R

Brian Yamachi

SecondByYamachi

K65R

Mark F Batell

Not Implemented

K66R

Ray Mikkelson

Not Implemented

K67R

Craig Feathers

SecondByTranquilizer

K68R

Fransois Leyvraz

SecondByLeyvraz

K69R

Johann Joss

Not Implemented

K70R

Robert Pebly

Not Implemented

K71R

James E Hall

Not Implemented

K72R

Edward C White Jr

SecondByWhite

K73R

George Zimmerman

Not Implemented

K74R

Edward Friedland

Not Implemented

K74RXX

Edward Friedland

Not Implemented

K75R

Paul D Harrington

SecondByHarrington

K76R

David Gladstein

SecondByGladstein

K77R

Scott Feld

Not Implemented

K78R

Fred Mauk

Not Implemented

K79R

Dennis Ambuehl and Kevin Hickey

Not Implemented

K80R

Robyn M Dawes and Mark Batell

Not Implemented

K81R

Martyn Jones

Not Implemented

K82R

Robert A Leyland

Not Implemented

K83R

Paul E Black

SecondByWhite

K84R

T Nicolaus Tideman and Paula Chieruzzi

SecondByTidemanChieruzzi

K85R

Robert B Falk and James M Langsted

Not Implemented

K86R

Bernard Grofman

Not Implemented

K87R

E E H Schurmann

Not Implemented

K88R

Scott Appold

SecondByAppold

K89R

Gene Snodgrass

Not Implemented

K90R

John Maynard Smith

TitFor2Tats

K91R

Jonathan Pinkley

Not Implemented

K92R

Anatol Rapoport

TitForTat

K93R

Unknown

Not Implemented

KPAVLOVC

Unknown

WinStayLoseShift

KRANDOMC

Unknown

Random

KTF2TC

Unknown

TitFor2Tats

KTITFORTATC

Unknown

TitForTat

Stewart and Plotkin’s Tournament (2012)

In 2012, Alexander Stewart and Joshua Plotkin ran a variant of Axelrod’s tournament with 19 strategies to test the effectiveness of the then newly discovered Zero-Determinant strategies.

The paper is identified as doi: 10.1073/pnas.1208087109 and referred to as [Stewart2012] below. Unfortunately the details of the tournament and the implementation of strategies is not clear in the manuscript. We can, however, make reasonable guesses to the implementation of many strategies based on their names and classical definitions.

The following classical strategies are included in the library:

Strategies in Stewart and Plotkin’s tournament

S&P Name

Long Name

Axelrod Library Name

ALLC

Always Cooperate

Cooperator

ALLD

Always Defect

Defector

EXTORT-2

Extort-2

ZDExtort2

HARD_MAJO

Hard majority

HardGoByMajority

HARD_JOSS

Hard Joss

Joss

HARD_TFT

Hard tit for tat

HardTitForTat

HARD_TF2T

Hard tit for 2 tats

HardTitFor2Tats

TFT

Tit-For-Tat

TitForTat

GRIM

Grim

Grudger

GTFT

Generous Tit-For-Tat

GTFT

TF2T

Tit-For-Two-Tats

TitFor2Tats

WSLS

Win-Stay-Lose-Shift

WinStayLoseShift

RANDOM

Random

Random

ZDGTFT-2

ZDGTFT-2

ZDGTFT2

ALLC, ALLD, TFT and RANDOM are defined above. The remaining classical strategies are defined below. The tournament also included two Zero Determinant strategies, both implemented in the library. The full table of strategies and results is available online.

Memory one strategies

In 2012 Press and Dyson [Press2012] showed interesting results with regards to so called memory one strategies. Stewart and Plotkin implemented a number of these. A memory one strategy is simply a probabilistic strategy that is defined by 4 parameters. These four parameters dictate the probability of cooperating given 1 of 4 possible outcomes of the previous round:

  • \(P(C\,|\,CC) = p_1\)

  • \(P(C\,|\,CD) = p_2\)

  • \(P(C\,|\,DC) = p_3\)

  • \(P(C\,|\,DD) = p_4\)

The memory one strategy class is used to define a number of strategies below.

GTFT

Generous-Tit-For-Tat plays Tit-For-Tat with occasional forgiveness, which prevents cycling defections against itself.

GTFT is defined as a memory-one strategy as follows:

  • \(P(C\,|\,CC) = 1\)

  • \(P(C\,|\,CD) = p\)

  • \(P(C\,|\,DC) = 1\)

  • \(P(C\,|\,DD) = p\)

where \(p = \min\left(1 - \frac{T-R}{R-S}, \frac{R-P}{T-P}\right)\).

GTFT came 2nd in average score and 18th in wins in S&P’s tournament.

TF2T

Tit-For-Two-Tats is like Tit-For-Tat but only retaliates after two defections rather than one. This is not a memory-one strategy.

TF2T came 3rd in average score and last (?) in wins in S&P’s tournament.

WSLS

Win-Stay-Lose-Shift is a strategy that shifts if the highest payoff was not earned in the previous round. WSLS is also known as “Win-Stay-Lose-Switch” and “Pavlov”. It can be seen as a memory-one strategy as follows:

  • \(P(C\,|\,CC) = 1\)

  • \(P(C\,|\,CD) = 0\)

  • \(P(C\,|\,DC) = 0\)

  • \(P(C\,|\,DD) = 1\)

WSLS came 7th in average score and 13th in wins in S&P’s tournament.

RANDOM

Random is a strategy that was defined in Axelrod’s first tournament, note that this is also a memory-one strategy:

  • \(P(C\,|\,CC) = 0.5\)

  • \(P(C\,|\,CD) = 0.5\)

  • \(P(C\,|\,DC) = 0.5\)

  • \(P(C\,|\,DD) = 0.5\)

RANDOM came 8th in average score and 8th in wins in S&P’s tournament.

ZDGTFT-2

This memory-one strategy is defined by the following four conditional probabilities based on the last round of play:

  • \(P(C\,|\,CC) = 1\)

  • \(P(C\,|\,CD) = 1/8\)

  • \(P(C\,|\,DC) = 1\)

  • \(P(C\,|\,DD) = 1/4\)

This strategy came 1st in average score and 16th in wins in S&P’s tournament.

EXTORT-2

This memory-one strategy is defined by the following four conditional probabilities based on the last round of play:

  • \(P(C\,|\,CC) = 8/9\)

  • \(P(C\,|\,CD) = 1/2\)

  • \(P(C\,|\,DC) = 1/3\)

  • \(P(C\,|\,DD) = 0\)

This strategy came 18th in average score and 2nd in wins in S&P’s tournament.

GRIM

Grim is not defined in [Stewart2012] but it is defined elsewhere as follows. GRIM (also called “Grim trigger”), cooperates until the opponent defects and then always defects thereafter. In the library this strategy is called Grudger.

GRIM came 10th in average score and 11th in wins in S&P’s tournament.

HARD_JOSS

HARD_JOSS is not defined in [Stewart2012] but is otherwise defined as a strategy that plays like TitForTat but cooperates only with probability \(0.9\). This is a memory-one strategy with the following probabilities:

  • \(P(C\,|\,CC) = 0.9\)

  • \(P(C\,|\,CD) = 0\)

  • \(P(C\,|\,DC) = 1\)

  • \(P(C\,|\,DD) = 0\)

HARD_JOSS came 16th in average score and 4th in wins in S&P’s tournament.

HARD_JOSS as described above is implemented in the library as Joss and is the same as the Joss strategy from Axelrod’s first tournament.

HARD_MAJO

HARD_MAJO is not defined in [Stewart2012] and is presumably the same as “Go by Majority”, defined as follows: the strategy defects on the first move, defects if the number of defections of the opponent is greater than or equal to the number of times it has cooperated, and otherwise cooperates,

HARD_MAJO came 13th in average score and 5th in wins in S&P’s tournament.

HARD_TFT

Hard TFT is not defined in [Stewart2012] but is elsewhere defined as follows. The strategy cooperates on the first move, defects if the opponent has defected on any of the previous three rounds, and otherwise cooperates.

HARD_TFT came 12th in average score and 10th in wins in S&P’s tournament.

HARD_TF2T

Hard TF2T is not defined in [Stewart2012] but is elsewhere defined as follows. The strategy cooperates on the first move, defects if the opponent has defected twice (successively) of the previous three rounds, and otherwise cooperates.

HARD_TF2T came 6th in average score and 17th in wins in S&P’s tournament.

Calculator

This strategy is not unambiguously defined in [Stewart2012] but is defined elsewhere. Calculator plays like Joss for 20 rounds. On the 21 round, Calculator attempts to detect a cycle in the opponents history, and defects unconditionally thereafter if a cycle is found. Otherwise Calculator plays like TFT for the remaining rounds.

Prober

PROBE is not unambiguously defined in [Stewart2012] but is defined elsewhere as Prober. The strategy starts by playing D, C, C on the first three rounds and then defects forever if the opponent cooperates on rounds two and three. Otherwise Prober plays as TitForTat would.

Prober came 15th in average score and 9th in wins in S&P’s tournament.

Prober2

PROBE2 is not unambiguously defined in [Stewart2012] but is defined elsewhere as Prober2. The strategy starts by playing D, C, C on the first three rounds and then cooperates forever if the opponent played D then C on rounds two and three. Otherwise Prober2 plays as TitForTat would.

Prober2 came 9th in average score and 12th in wins in S&P’s tournament.

Prober3

PROBE3 is not unambiguously defined in [Stewart2012] but is defined elsewhere as Prober3. The strategy starts by playing D, C on the first two rounds and then defects forever if the opponent cooperated on round two. Otherwise Prober3 plays as TitForTat would.

Prober3 came 17th in average score and 7th in wins in S&P’s tournament.

HardProber

HARD_PROBE is not unambiguously defined in [Stewart2012] but is defined elsewhere as HardProber. The strategy starts by playing D, D, C, C on the first four rounds and then defects forever if the opponent cooperates on rounds two and three. Otherwise Prober plays as TitForTat would.

HardProber came 5th in average score and 6th in wins in S&P’s tournament.

NaiveProber

NAIVE_PROBER is a modification of Tit For Tat strategy which with a small probability randomly defects. Default value for a probability of defection is 0.1.

Beaufils et al.’s tournament (1997)

In 1997, [Beaufils1997] the authors used a tournament to describe a new strategy of their called “Gradual”. The description given in the paper of “Gradual” is:

This strategy acts as tit-for-tat, except when it is time to forgive and remember the past. It uses cooperation on the first move and then continues to do so as long as the other player cooperates. Then after the first defection of the other player, it defects one time and cooperates two times; after the second defection of the opponent, it defects two times and cooperates two times, … after the nth defection it reacts with n consecutive defections and then calms down its opponent with two cooperations.

This is the only description of the strategy however the paper does include a table of results of the tournament. The scores of “Gradual” against the opponents (including itself) are:

Score of Gradual reported in [Beaufils1997]

Name

Name used in [Beaufils1997]

Score (1000 turns)

Cooperator

coop

3000

Defector

def

915

Random

rand

2815

Tit For Tat

tft

3000

Grudger

spite

3000

Cycler DDC

p_nst

2219

Cycler CCD

p_kn

3472

Go By Majority

sft_mj

3000

Suspicious Tit For Tat

mist

2996

Prober

prob

2999

Gradual

grad

3000

Win Stay Lose Shift

pav

3000

The following code reproduces the above:

>>> import axelrod as axl
>>> players = [axl.Cooperator(),
...            axl.Defector(),
...            axl.Random(),
...            axl.TitForTat(),
...            axl.Grudger(),
...            axl.CyclerDDC(),
...            axl.CyclerCCD(),
...            axl.GoByMajority(),
...            axl.SuspiciousTitForTat(),
...            axl.Prober(),
...            axl.OriginalGradual(),
...            axl.WinStayLoseShift(),
...            ]
>>> turns = 1000
>>> tournament = axl.Tournament(players, turns=turns, repetitions=1, seed=75)
>>> results = tournament.play(progress_bar=False)
>>> for average_score_per_turn in results.payoff_matrix[-2]:
...     print(round(average_score_per_turn * turns, 1))
3000.0
915.0
2763.0
3000.0
3000.0
2219.0
3472.0
3000.0
2996.0
2999.0
3000.0
3000.0

The OriginalGradual strategy implemented has the following description:

A player that punishes defections with a growing number of defections but after punishing for punishment_limit number of times enters a calming state and cooperates no matter what the opponent does for two rounds.

The punishment_limit is incremented whenever the opponent defects and the strategy is not in either calming or punishing state.

Note that a different version of Gradual appears in [CRISTAL-SMAC2018]. This was brought to the attention of the maintainers of the library by one of the authors of [Beaufils1997] and is documented here https://github.com/Axelrod-Python/Axelrod/issues/1294.

The strategy implemented in [CRISTAL-SMAC2018] and defined here as Gradual has the following description:

Similar to OriginalGradual, this is a player that punishes defections with a growing number of defections but after punishing for punishment_limit number of times enters a calming state and cooperates no matter what the opponent does for two rounds.

This version of Gradual is an update of OriginalGradual and the difference is that the punishment_limit is incremented whenever the opponent defects (regardless of the state of the player).

This highlights the importance of best practice and reproducible computational research. Both strategies implemented in this library are fully tested and documented clearly and precisely.