# Source code for axelrod.strategies.axelrod_second

```
"""
Additional strategies from Axelrod's second tournament.
"""
import random
from typing import List
import numpy as np
from axelrod.action import Action
from axelrod.interaction_utils import compute_final_score
from axelrod.player import Player
from axelrod.random_ import random_choice
from axelrod.strategies.finite_state_machines import FSMPlayer
C, D = Action.C, Action.D
[docs]class Champion(Player):
"""
Strategy submitted to Axelrod's second tournament by Danny Champion.
This player cooperates on the first 10 moves and plays Tit for Tat for the
next 15 more moves. After 25 moves, the program cooperates unless all the
following are true: the other player defected on the previous move, the
other player cooperated less than 60% and the random number between 0 and 1
is greater that the other player's cooperation rate.
Names:
- Champion: [Axelrod1980b]_
"""
name = "Champion"
classifier = {
"memory_depth": float("inf"),
"stochastic": True,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
[docs] def strategy(self, opponent: Player) -> Action:
current_round = len(self.history)
# Cooperate for the first 10 turns
if current_round == 0:
return C
if current_round < 10:
return C
# Mirror partner for the next phase
if current_round < 25:
return opponent.history[-1]
# Now cooperate unless all of the necessary conditions are true
defection_prop = opponent.defections / len(opponent.history)
if opponent.history[-1] == D:
r = random.random()
if defection_prop >= max(0.4, r):
return D
return C
[docs]class Eatherley(Player):
"""
Strategy submitted to Axelrod's second tournament by Graham Eatherley.
A player that keeps track of how many times in the game the other player
defected. After the other player defects, it defects with a probability
equal to the ratio of the other's total defections to the total moves to
that point.
Names:
- Eatherley: [Axelrod1980b]_
"""
name = "Eatherley"
classifier = {
"memory_depth": float("inf"),
"stochastic": True,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
[docs] @staticmethod
def strategy(opponent: Player) -> Action:
# Cooperate on the first move
if not len(opponent.history):
return C
# Reciprocate cooperation
if opponent.history[-1] == C:
return C
# Respond to defections with probability equal to opponent's total
# proportion of defections
defection_prop = opponent.defections / len(opponent.history)
return random_choice(1 - defection_prop)
[docs]class Tester(Player):
"""
Submitted to Axelrod's second tournament by David Gladstein.
This strategy is a TFT variant that attempts to exploit certain strategies. It
defects on the first move. If the opponent ever defects, TESTER 'apologies' by
cooperating and then plays TFT for the rest of the game. Otherwise TESTER
alternates cooperation and defection.
This strategy came 46th in Axelrod's second tournament.
Names:
- Tester: [Axelrod1980b]_
"""
name = "Tester"
classifier = {
"memory_depth": float("inf"),
"stochastic": False,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self) -> None:
super().__init__()
self.is_TFT = False
[docs] def strategy(self, opponent: Player) -> Action:
# Defect on the first move
if not opponent.history:
return D
# Am I TFT?
if self.is_TFT:
return D if opponent.history[-1:] == [D] else C
else:
# Did opponent defect?
if opponent.history[-1] == D:
self.is_TFT = True
return C
if len(self.history) in [1, 2]:
return C
# Alternate C and D
return self.history[-1].flip()
[docs]class Gladstein(Player):
"""
Submitted to Axelrod's second tournament by David Gladstein.
This strategy is also known as Tester and is based on the reverse
engineering of the Fortran strategies from Axelrod's second tournament.
This strategy is a TFT variant that defects on the first round in order to
test the opponent's response. If the opponent ever defects, the strategy
'apologizes' by cooperating and then plays TFT for the rest of the game.
Otherwise, it defects as much as possible subject to the constraint that
the ratio of its defections to moves remains under 0.5, not counting the
first defection.
Names:
- Gladstein: [Axelrod1980b]_
- Tester: [Axelrod1980b]_
"""
name = "Gladstein"
classifier = {
"memory_depth": float("inf"),
"stochastic": False,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self) -> None:
super().__init__()
# This strategy assumes the opponent is a patsy
self.patsy = True
[docs] def strategy(self, opponent: Player) -> Action:
# Defect on the first move
if not self.history:
return D
# Is the opponent a patsy?
if self.patsy:
# If the opponent defects, apologize and play TFT.
if opponent.history[-1] == D:
self.patsy = False
return C
# Cooperate as long as the cooperation ratio is below 0.5
cooperation_ratio = self.cooperations / len(self.history)
if cooperation_ratio > 0.5:
return D
return C
else:
# Play TFT
return opponent.history[-1]
[docs]class Tranquilizer(Player):
"""
Submitted to Axelrod's second tournament by Craig Feathers
Description given in Axelrod's "More Effective Choice in the
Prisoner's Dilemma" paper: The rule normally cooperates but
is ready to defect if the other player defects too often.
Thus the rule tends to cooperate for the first dozen or two moves
if the other player is cooperating, but then it throws in a
defection. If the other player continues to cooperate, then defections
become more frequent. But as long as Tranquilizer is maintaining an
average payoff of at least 2.25 points per move, it will never defect
twice in succession and it will not defect more than
one-quarter of the time.
This implementation is based on the reverse engineering of the
Fortran strategy K67R from Axelrod's second tournament.
Reversed engineered by: Owen Campbell, Will Guo and Mansour Hakem.
The strategy starts by cooperating and has 3 states.
At the start of the strategy it updates its states:
- It counts the number of consecutive defections by the opponent.
- If it was in state 2 it moves to state 0 and calculates the
following quantities two_turns_after_good_defection_ratio and
two_turns_after_good_defection_ratio_count.
Formula for:
two_turns_after_good_defection_ratio:
self.two_turns_after_good_defection_ratio = (
((self.two_turns_after_good_defection_ratio
* self.two_turns_after_good_defection_ratio_count)
+ (3 - (3 * self.dict[opponent.history[-1]]))
+ (2 * self.dict[self.history[-1]])
- ((self.dict[opponent.history[-1]]
* self.dict[self.history[-1]])))
/ (self.two_turns_after_good_defection_ratio_count + 1)
)
two_turns_after_good_defection_ratio_count =
two_turns_after_good_defection_ratio + 1
- If it was in state 1 it moves to state 2 and calculates the
following quantities one_turn_after_good_defection_ratio and
one_turn_after_good_defection_ratio_count.
Formula for:
one_turn_after_good_defection_ratio:
self.one_turn_after_good_defection_ratio = (
((self.one_turn_after_good_defection_ratio
* self.one_turn_after_good_defection_ratio_count)
+ (3 - (3 * self.dict[opponent.history[-1]]))
+ (2 * self.dict[self.history[-1]])
- (self.dict[opponent.history[-1]]
* self.dict[self.history[-1]]))
/ (self.one_turn_after_good_defection_ratio_count + 1)
)
one_turn_after_good_defection_ratio_count:
one_turn_after_good_defection_ratio_count =
one_turn_after_good_defection_ratio + 1
If after this it is in state 1 or 2 then it cooperates.
If it is in state 0 it will potentially perform 1 of the 2
following stochastic tests:
1. If average score per turn is greater than 2.25 then it calculates a
value of probability:
probability = (
(.95 - (((self.one_turn_after_good_defection_ratio)
+ (self.two_turns_after_good_defection_ratio) - 5) / 15))
+ (1 / (((len(self.history))+1) ** 2))
- (self.dict[opponent.history[-1]] / 4)
)
and will cooperate if a random sampled number is less than that value of
probability. If it does not cooperate then the strategy moves to state 1
and defects.
2. If average score per turn is greater than 1.75 but less than 2.25
then it calculates a value of probability:
probability = (
(.25 + ((opponent.cooperations + 1) / ((len(self.history)) + 1)))
- (self.opponent_consecutive_defections * .25)
+ ((current_score[0]
- current_score[1]) / 100)
+ (4 / ((len(self.history)) + 1))
)
and will cooperate if a random sampled number is less than that value of
probability. If not, it defects.
If none of the above holds the player simply plays tit for tat.
Tranquilizer came in 27th place in Axelrod's second torunament.
Names:
- Tranquilizer: [Axelrod1980]_
"""
name = "Tranquilizer"
classifier = {
"memory_depth": float("inf"),
"stochastic": True,
"makes_use_of": {"game"},
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self):
super().__init__()
self.num_turns_after_good_defection = 0 # equal to FD variable
self.opponent_consecutive_defections = 0 # equal to S variable
self.one_turn_after_good_defection_ratio = 5 # equal to AD variable
self.two_turns_after_good_defection_ratio = 0 # equal to NO variable
self.one_turn_after_good_defection_ratio_count = 1 # equal to AK variable
self.two_turns_after_good_defection_ratio_count = 1 # equal to NK variable
# All above variables correspond to those in original Fotran Code
self.dict = {C: 0, D: 1}
[docs] def update_state(self, opponent):
"""
Calculates the ratio values for the one_turn_after_good_defection_ratio,
two_turns_after_good_defection_ratio and the probability values,
and sets the value of num_turns_after_good_defection.
"""
if opponent.history[-1] == D:
self.opponent_consecutive_defections += 1
else:
self.opponent_consecutive_defections = 0
if self.num_turns_after_good_defection == 2:
self.num_turns_after_good_defection = 0
self.two_turns_after_good_defection_ratio = (
(
self.two_turns_after_good_defection_ratio
* self.two_turns_after_good_defection_ratio_count
)
+ (3 - (3 * self.dict[opponent.history[-1]]))
+ (2 * self.dict[self.history[-1]])
- ((self.dict[opponent.history[-1]] * self.dict[self.history[-1]]))
) / (self.two_turns_after_good_defection_ratio_count + 1)
self.two_turns_after_good_defection_ratio_count += 1
elif self.num_turns_after_good_defection == 1:
self.num_turns_after_good_defection = 2
self.one_turn_after_good_defection_ratio = (
(
self.one_turn_after_good_defection_ratio
* self.one_turn_after_good_defection_ratio_count
)
+ (3 - (3 * self.dict[opponent.history[-1]]))
+ (2 * self.dict[self.history[-1]])
- (self.dict[opponent.history[-1]] * self.dict[self.history[-1]])
) / (self.one_turn_after_good_defection_ratio_count + 1)
self.one_turn_after_good_defection_ratio_count += 1
[docs] def strategy(self, opponent: Player) -> Action:
if not self.history:
return C
self.update_state(opponent)
if self.num_turns_after_good_defection in [1, 2]:
return C
current_score = compute_final_score(zip(self.history, opponent.history))
if (current_score[0] / ((len(self.history)) + 1)) >= 2.25:
probability = (
(
0.95
- (
(
(self.one_turn_after_good_defection_ratio)
+ (self.two_turns_after_good_defection_ratio)
- 5
)
/ 15
)
)
+ (1 / (((len(self.history)) + 1) ** 2))
- (self.dict[opponent.history[-1]] / 4)
)
if random.random() <= probability:
return C
self.num_turns_after_good_defection = 1
return D
if (current_score[0] / ((len(self.history)) + 1)) >= 1.75:
probability = (
(0.25 + ((opponent.cooperations + 1) / ((len(self.history)) + 1)))
- (self.opponent_consecutive_defections * 0.25)
+ ((current_score[0] - current_score[1]) / 100)
+ (4 / ((len(self.history)) + 1))
)
if random.random() <= probability:
return C
return D
return opponent.history[-1]
[docs]class MoreGrofman(Player):
"""
Submitted to Axelrod's second tournament by Bernard Grofman.
This strategy has 3 phases:
1. First it cooperates on the first two rounds
2. For rounds 3-7 inclusive, it plays the same as the opponent's last move
3. Thereafter, it applies the following logic, looking at its memory of the
last 8\* rounds (ignoring the most recent round).
- If its own previous move was C and the opponent has defected less than
3 times in the last 8\* rounds, cooperate
- If its own previous move was C and the opponent has defected 3 or
more times in the last 8\* rounds, defect
- If its own previous move was D and the opponent has defected only once
or not at all in the last 8\* rounds, cooperate
- If its own previous move was D and the opponent has defected more than
once in the last 8\* rounds, defect
\* The code looks at the first 7 of the last 8 rounds, ignoring the most
recent round.
Names:
- Grofman's strategy: [Axelrod1980b]_
- K86R: [Axelrod1980b]_
"""
name = "MoreGrofman"
classifier = {
"memory_depth": 8,
"stochastic": False,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
[docs] def strategy(self, opponent: Player) -> Action:
# Cooperate on the first two moves
if len(self.history) < 2:
return C
# For rounds 3-7, play the opponent's last move
elif 2 <= len(self.history) <= 6:
return opponent.history[-1]
else:
# Note: the Fortran code behavior ignores the opponent behavior
# in the last round and instead looks at the first 7 of the last
# 8 rounds.
opponent_defections_last_8_rounds = opponent.history[-8:-1].count(D)
if self.history[-1] == C and opponent_defections_last_8_rounds <= 2:
return C
if self.history[-1] == D and opponent_defections_last_8_rounds <= 1:
return C
return D
[docs]class Kluepfel(Player):
"""
Strategy submitted to Axelrod's second tournament by Charles Kluepfel
(K32R).
This player keeps track of the the opponent's responses to own behavior:
- `cd_count` counts: Opponent cooperates as response to player defecting.
- `dd_count` counts: Opponent defects as response to player defecting.
- `cc_count` counts: Opponent cooperates as response to player cooperating.
- `dc_count` counts: Opponent defects as response to player cooperating.
After 26 turns, the player then tries to detect a random player. The
player decides that the opponent is random if
cd_counts >= (cd_counts+dd_counts)/2 - 0.75*sqrt(cd_counts+dd_counts) AND
cc_counts >= (dc_counts+cc_counts)/2 - 0.75*sqrt(dc_counts+cc_counts).
If the player decides that they are playing against a random player, then
they will always defect.
Otherwise respond to recent history using the following set of rules:
- If opponent's last three choices are the same, then respond in kind.
- If opponent's last two choices are the same, then respond in kind with
probability 90%.
- Otherwise if opponent's last action was to cooperate, then cooperate
with probability 70%.
- Otherwise if opponent's last action was to defect, then defect
with probability 60%.
Names:
- Kluepfel: [Axelrod1980b]_
"""
name = "Kluepfel"
classifier = {
"memory_depth": float("inf"),
"stochastic": True,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self):
super().__init__()
self.cd_counts, self.dd_counts, self.dc_counts, self.cc_counts = 0, 0, 0, 0
[docs] def strategy(self, opponent: Player) -> Action:
# First update the response matrix.
if len(self.history) >= 2:
if self.history[-2] == D:
if opponent.history[-1] == C:
self.cd_counts += 1
else:
self.dd_counts += 1
else:
if opponent.history[-1] == C:
self.dc_counts += 1
else:
self.cc_counts += 1
# Check for randomness
if len(self.history) > 26:
if self.cd_counts >= (self.cd_counts + self.dd_counts) / 2 - 0.75 * np.sqrt(
self.cd_counts + self.dd_counts
) and self.cc_counts >= (
self.dc_counts + self.cc_counts
) / 2 - 0.75 * np.sqrt(
self.dc_counts + self.cc_counts
):
return D
# Otherwise respond to recent history
one_move_ago, two_moves_ago, three_moves_ago = C, C, C
if len(opponent.history) >= 1:
one_move_ago = opponent.history[-1]
if len(opponent.history) >= 2:
two_moves_ago = opponent.history[-2]
if len(opponent.history) >= 3:
three_moves_ago = opponent.history[-3]
if one_move_ago == two_moves_ago and two_moves_ago == three_moves_ago:
return one_move_ago
r = random.random() # Everything following is stochastic
if one_move_ago == two_moves_ago:
if r < 0.9:
return one_move_ago
else:
return one_move_ago.flip()
if one_move_ago == C:
if r < 0.7:
return one_move_ago
else:
return one_move_ago.flip()
if one_move_ago == D:
if r < 0.6:
return one_move_ago
else:
return one_move_ago.flip()
[docs]class Borufsen(Player):
"""
Strategy submitted to Axelrod's second tournament by Otto Borufsen
(K32R), and came in third in that tournament.
This player keeps track of the the opponent's responses to own behavior:
- `cd_count` counts: Opponent cooperates as response to player defecting.
- `cc_count` counts: Opponent cooperates as response to player cooperating.
The player has a defect mode and a normal mode. In defect mode, the
player will always defect. In normal mode, the player obeys the following
ranked rules:
1. If in the last three turns, both the player/opponent defected, then
cooperate for a single turn.
2. If in the last three turns, the player/opponent acted differently from
each other and they're alternating, then change next defect to
cooperate. (Doesn't block third rule.)
3. Otherwise, do tit-for-tat.
Start in normal mode, but every 25 turns starting with the 27th turn,
re-evaluate the mode. Enter defect mode if any of the following
conditions hold:
- Detected random: Opponent cooperated 7-18 times since last mode
evaluation (or start) AND less than 70% of opponent cooperation was in
response to player's cooperation, i.e.
cc_count / (cc_count+cd_count) < 0.7
- Detect defective: Opponent cooperated fewer than 3 times since last mode
evaluation.
When switching to defect mode, defect immediately. The first two rules for
normal mode require that last three turns were in normal mode. When starting
normal mode from defect mode, defect on first move.
Names:
- Borufsen: [Axelrod1980b]_
"""
name = "Borufsen"
classifier = {
"memory_depth": float("inf"),
"stochastic": False,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self):
super().__init__()
self.cd_counts, self.cc_counts = 0, 0
self.mutual_defect_streak = 0
self.echo_streak = 0
self.flip_next_defect = False
self.mode = "Normal"
[docs] def try_return(self, to_return):
"""
We put the logic here to check for the `flip_next_defect` bit here,
and proceed like normal otherwise.
"""
if to_return == C:
return C
# Otherwise look for flip bit.
if self.flip_next_defect:
self.flip_next_defect = False
return C
return D
[docs] def strategy(self, opponent: Player) -> Action:
turn = len(self.history) + 1
if turn == 1:
return C
# Update the response history.
if turn >= 3:
if opponent.history[-1] == C:
if self.history[-2] == C:
self.cc_counts += 1
else:
self.cd_counts += 1
# Check if it's time for a mode change.
if turn > 2 and turn % 25 == 2:
coming_from_defect = False
if self.mode == "Defect":
coming_from_defect = True
self.mode = "Normal"
coops = self.cd_counts + self.cc_counts
# Check for a defective strategy
if coops < 3:
self.mode = "Defect"
# Check for a random strategy
if (coops >= 8 and coops <= 17) and self.cc_counts / coops < 0.7:
self.mode = "Defect"
self.cd_counts, self.cc_counts = 0, 0
# If defect mode, clear flags
if self.mode == "Defect":
self.mutual_defect_streak = 0
self.echo_streak = 0
self.flip_next_defect = False
# Check this special case
if self.mode == "Normal" and coming_from_defect:
return D
# Proceed
if self.mode == "Defect":
return D
else:
assert self.mode == "Normal"
# Look for mutual defects
if self.history[-1] == D and opponent.history[-1] == D:
self.mutual_defect_streak += 1
else:
self.mutual_defect_streak = 0
if self.mutual_defect_streak >= 3:
self.mutual_defect_streak = 0
self.echo_streak = 0 # Reset both streaks.
return self.try_return(C)
# Look for echoes
# Fortran code defaults two turns back to C if only second turn
my_two_back, opp_two_back = C, C
if turn >= 3:
my_two_back = self.history[-2]
opp_two_back = opponent.history[-2]
if (
self.history[-1] != opponent.history[-1]
and self.history[-1] == opp_two_back
and opponent.history[-1] == my_two_back
):
self.echo_streak += 1
else:
self.echo_streak = 0
if self.echo_streak >= 3:
self.mutual_defect_streak = 0 # Reset both streaks.
self.echo_streak = 0
self.flip_next_defect = True
# Tit-for-tat
return self.try_return(opponent.history[-1])
[docs]class Cave(Player):
"""
Strategy submitted to Axelrod's second tournament by Rob Cave (K49R), and
came in fourth in that tournament.
First look for overly-defective or apparently random opponents, and defect
if found. That is any opponent meeting one of:
- turn > 39 and percent defects > 0.39
- turn > 29 and percent defects > 0.65
- turn > 19 and percent defects > 0.79
Otherwise, respond to cooperation with cooperation. And respond to defcts
with either a defect (if opponent has defected at least 18 times) or with
a random (50/50) choice. [Cooperate on first.]
Names:
- Cave: [Axelrod1980b]_
"""
name = "Cave"
classifier = {
"memory_depth": float("inf"),
"stochastic": True,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
[docs] def strategy(self, opponent: Player) -> Action:
turn = len(self.history) + 1
if turn == 1:
return C
number_defects = opponent.defections
perc_defects = number_defects / turn
# Defect if the opponent has defected often or appears random.
if turn > 39 and perc_defects > 0.39:
return D
if turn > 29 and perc_defects > 0.65:
return D
if turn > 19 and perc_defects > 0.79:
return D
if opponent.history[-1] == D:
if number_defects > 17:
return D
else:
return random_choice(0.5)
else:
return C
[docs]class WmAdams(Player):
"""
Strategy submitted to Axelrod's second tournament by William Adams (K44R),
and came in fifth in that tournament.
Count the number of opponent defections after their first move, call
`c_defect`. Defect if c_defect equals 4, 7, or 9. If c_defect > 9,
then defect immediately after opponent defects with probability =
(0.5)^(c_defect-1). Otherwise cooperate.
Names:
- WmAdams: [Axelrod1980b]_
"""
name = "WmAdams"
classifier = {
"memory_depth": float("inf"),
"stochastic": True,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
[docs] def strategy(self, opponent: Player) -> Action:
if len(self.history) <= 1:
return C
number_defects = opponent.defections
if opponent.history[0] == D:
number_defects -= 1
if number_defects in [4, 7, 9]:
return D
if number_defects > 9 and opponent.history[-1] == D:
return random_choice((0.5) ** (number_defects - 9))
return C
[docs]class GraaskampKatzen(Player):
"""
Strategy submitted to Axelrod's second tournament by Jim Graaskamp and Ken
Katzen (K60R), and came in sixth in that tournament.
Play Tit-for-Tat at first, and track own score. At select checkpoints,
check for a high score. Switch to Default Mode if:
- On move 11, score < 23
- On move 21, score < 53
- On move 31, score < 83
- On move 41, score < 113
- On move 51, score < 143
- On move 101, score < 293
Once in Defect Mode, defect forever.
Names:
- GraaskampKatzen: [Axelrod1980b]_
"""
name = "GraaskampKatzen"
classifier = {
"memory_depth": float("inf"),
"stochastic": False,
"makes_use_of": set(["game"]),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self):
super().__init__()
self.own_score = 0
self.mode = "Normal"
def update_score(self, opponent: Player):
game = self.match_attributes["game"]
last_round = (self.history[-1], opponent.history[-1])
self.own_score += game.score(last_round)[0]
[docs] def strategy(self, opponent: Player) -> Action:
if self.mode == "Defect":
return D
turn = len(self.history) + 1
if turn == 1:
return C
self.update_score(opponent)
if (
turn == 11
and self.own_score < 23
or turn == 21
and self.own_score < 53
or turn == 31
and self.own_score < 83
or turn == 41
and self.own_score < 113
or turn == 51
and self.own_score < 143
or turn == 101
and self.own_score < 293
):
self.mode = "Defect"
return D
return opponent.history[-1] # Tit-for-Tat
[docs]class Weiner(Player):
"""
Strategy submitted to Axelrod's second tournament by Herb Weiner (K41R),
and came in seventh in that tournament.
Play Tit-for-Tat with a chance for forgiveness and a defective override.
The chance for forgiveness happens only if `forgive_flag` is raised
(flag discussed below). If raised and `turn` is greater than `grudge`,
then override Tit-for-Tat with Cooperation. `grudge` is a variable that
starts at 0 and increments 20 with each forgiven Defect (a Defect that is
overriden through the forgiveness logic). `forgive_flag` is lower whether
logic is overriden or not.
The variable `defect_padding` increments with each opponent Defect, but
resets to zero with each opponent Cooperate (or `forgive_flag` lowering) so
that it roughly counts Defects between Cooperates. Whenever the opponent
Cooperates, if `defect_padding` (before reseting) is odd, then we raise
`forgive_flag` for next turn.
Finally a defective override is assessed after forgiveness. If five or
more of the opponent's last twelve actions are Defects, then Defect. This
will overrule a forgiveness, but doesn't undo the lowering of
`forgiveness_flag`. Note that "last twelve actions" doesn't count the most
recent action. Actually the original code updates history after checking
for defect override.
Names:
- Weiner: [Axelrod1980b]_
"""
name = "Weiner"
classifier = {
"memory_depth": float("inf"),
"stochastic": False,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self):
super().__init__()
self.forgive_flag = False
self.grudge = 0
self.defect_padding = 0
self.last_twelve = [0] * 12
self.lt_index = 0 # Circles around last_twelve
[docs] def try_return(self, to_return):
"""
We put the logic here to check for the defective override.
"""
if np.sum(self.last_twelve) >= 5:
return D
return to_return
[docs] def strategy(self, opponent: Player) -> Action:
if len(opponent.history) == 0:
return C
# Update history, lag 1.
if len(opponent.history) >= 2:
self.last_twelve[self.lt_index] = 0
if opponent.history[-2] == D:
self.last_twelve[self.lt_index] = 1
self.lt_index = (self.lt_index + 1) % 12
if self.forgive_flag:
self.forgive_flag = False
self.defect_padding = 0
if self.grudge < len(self.history) + 1 and opponent.history[-1] == D:
# Then override
self.grudge += 20
return self.try_return(C)
else:
return self.try_return(opponent.history[-1])
else:
# See if forgive_flag should be raised
if opponent.history[-1] == D:
self.defect_padding += 1
else:
if self.defect_padding % 2 == 1:
self.forgive_flag = True
self.defect_padding = 0
return self.try_return(opponent.history[-1])
[docs]class Harrington(Player):
"""
Strategy submitted to Axelrod's second tournament by Paul Harrington (K75R)
and came in eighth in that tournament.
This strategy has three modes: Normal, Fair-weather, and Defect. These
mode names were not present in Harrington's submission.
In Normal and Fair-weather modes, the strategy begins by:
- Update history
- Try to detect random opponent if turn is multiple of 15 and >=30.
- Check if `burned` flag should be raised.
- Check for Fair-weather opponent if turn is 38.
Updating history means to increment the correct cell of the `move_history`.
`move_history` is a matrix where the columns are the opponent's previous
move and the rows are indexed by the combo of this player's and the
opponent's moves two turns ago. [The upper-left cell must be all
Cooperations, but otherwise order doesn't matter.] After we enter Defect
mode, `move_history` won't be used again.
If the turn is a multiple of 15 and >=30, then attempt to detect random.
If random is detected, enter Defect mode and defect immediately. If the
player was previously in Defect mode, then do not re-enter. The random
detection logic is a modified Pearson's Chi Squared test, with some
additional checks. [More details in `detect_random` docstrings.]
Some of this player's moves are marked as "generous." If this player made
a generous move two turns ago and the opponent replied with a Defect, then
raise the `burned` flag. This will stop certain generous moves later.
The player mostly plays Tit-for-Tat for the first 36 moves, then defects on
the 37th move. If the opponent cooperates on the first 36 moves, and
defects on the 37th move also, then enter Fair-weather mode and cooperate
this turn. Entering Fair-weather mode is extremely rare, since this can
only happen if the opponent cooperates for the first 36 then defects
unprovoked on the 37th. (That is, this player's first 36 moves are also
Cooperations, so there's nothing really to trigger an opponent Defection.)
Next in Normal Mode:
1. Check for defect and parity streaks.
2. Check if cooperations are scheduled.
3. Otherwise,
- If turn < 37, Tit-for-Tat.
- If turn = 37, defect, mark this move as generous, and schedule two
more cooperations**.
- If turn > 37, then if `burned` flag is raised, then Tit-for-Tat.
Otherwise, Tit-for-Tat with probability 1 - `prob`. And with
probability `prob`, defect, schedule two cooperations, mark this move
as generous, and increase `prob` by 5%.
** Scheduling two cooperations means to set `more_coop` flag to two. If in
Normal mode and no streaks are detected, then the player will cooperate and
lower this flag, until hitting zero. It's possible that the flag can be
overwritten. Notable on the 37th turn defect, this is set to two, but the
38th turn Fair-weather check will set this.
If the opponent's last twenty moves were defections, then defect this turn.
Then check for a parity streak, by flipping the parity bit (there are two
streaks that get tracked which are something like odd and even turns, but
this flip bit logic doesn't get run every turn), then incrementing the
parity streak that we're pointing to. If the parity streak that we're
pointing to is then greater than `parity_limit` then reset the streak and
cooperate immediately. `parity_limit` is initially set to five, but after
it has been hit eight times, it decreases to three. The parity streak that
we're pointing to also gets incremented if in normal mode and we defect but
not on turn 38, unless we are defecting as the result of a defect streak.
Note that the parity streaks resets but the defect streak doesn't.
If `more_coop` >= 1, then we cooperate and lower that flag here, in Normal
mode after checking streaks. Still lower this flag if cooperating as the
result of a parity streak or in Fair-weather mode.
Then use the logic based on turn from above.
In Fair-Weather mode after running the code from above, check if opponent
defected last turn. If so, exit Fair-Weather mode, and proceed THIS TURN
with Normal mode. Otherwise cooperate.
In Defect mode, update the `exit_defect_meter` (originally zero) by
incrementing if opponent defected last turn and decreasing by three
otherwise. If `exit_defect_meter` is then 11, then set mode to Normal (for
future turns), cooperate and schedule two more cooperations. [Note that
this move is not marked generous.]
Names:
- Harrington: [Axelrod1980b]_
"""
name = "Harrington"
classifier = {
"memory_depth": float("inf"),
"stochastic": True,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self):
super().__init__()
self.mode = "Normal"
self.recorded_defects = 0 # Count opponent defects after turn 1
self.exit_defect_meter = 0 # When >= 11, then exit defect mode.
self.coops_in_first_36 = None # On turn 37, count cooperations in first 36
self.was_defective = False # Previously in Defect mode
self.prob = 0.25 # After turn 37, probability that we'll defect
self.move_history = np.zeros([4, 2])
self.more_coop = 0 # This schedules cooperation for future turns
# Initial last_generous_n_turns_ago to 3 because this counts up and
# triggers a strategy change at 2.
self.last_generous_n_turns_ago = 3 # How many tuns ago was a "generous" move
self.burned = False
self.defect_streak = 0
self.parity_streak = [
0,
0,
] # Counters that get (almost) alternatively incremented.
self.parity_bit = 0 # Which parity_streak to increment
self.parity_limit = 5 # When a parity streak hits this limit, alter strategy.
self.parity_hits = 0 # Counts how many times a parity_limit was hit.
# After hitting parity_hits 8 times, lower parity_limit to 3.
[docs] def try_return(self, to_return, lower_flags=True, inc_parity=False):
"""
This will return to_return, with some end-of-turn logic.
"""
if lower_flags and to_return == C:
# In most cases when Cooperating, we want to reduce the number that
# are scheduled.
self.more_coop -= 1
self.last_generous_n_turns_ago += 1
if inc_parity and to_return == D:
# In some cases we increment the `parity_streak` that we're on when
# we return a Defection. In detect_parity_streak, `parity_streak`
# counts opponent's Defections.
self.parity_streak[self.parity_bit] += 1
return to_return
[docs] def calculate_chi_squared(self, turn):
"""
Pearson's Chi Squared statistic = sum[ (E_i-O_i)^2 / E_i ], where O_i
are the observed matrix values, and E_i is calculated as number (of
defects) in the row times the number in the column over (total number
in the matrix minus 1). Equivalently, we expect we expect (for an
independent distribution) the total number of recorded turns times the
portion in that row times the portion in that column.
In this function, the statistic is non-standard in that it excludes
summands where E_i <= 1.
"""
denom = turn - 2
expected_matrix = (
np.outer(self.move_history.sum(axis=1), self.move_history.sum(axis=0))
/ denom
)
chi_squared = 0.0
for i in range(4):
for j in range(2):
expect = expected_matrix[i, j]
if expect > 1.0:
chi_squared += (expect - self.move_history[i, j]) ** 2 / expect
return chi_squared
[docs] def detect_random(self, turn):
"""
We check if the top-left cell of the matrix (corresponding to all
Cooperations) has over 80% of the turns. In which case, we label
non-random.
Then we check if over 75% or under 25% of the opponent's turns are
Defections. If so, then we label as non-random.
Otherwise we calculates a modified Pearson's Chi Squared statistic on
self.history, and returns True (is random) if and only if the statistic
is less than or equal to 3.
"""
denom = turn - 2
if self.move_history[0, 0] / denom >= 0.8:
return False
if self.recorded_defects / denom < 0.25 or self.recorded_defects / denom > 0.75:
return False
if self.calculate_chi_squared(turn) > 3:
return False
return True
[docs] def detect_streak(self, last_move):
"""
Return true if and only if the opponent's last twenty moves are defects.
"""
if last_move == D:
self.defect_streak += 1
else:
self.defect_streak = 0
if self.defect_streak >= 20:
return True
return False
[docs] def detect_parity_streak(self, last_move):
"""
Switch which `parity_streak` we're pointing to and incerement if the
opponent's last move was a Defection. Otherwise reset the flag. Then
return true if and only if the `parity_streak` is at least
`parity_limit`.
This is similar to detect_streak with alternating streaks, except that
these streaks get incremented elsewhere as well.
"""
self.parity_bit = 1 - self.parity_bit # Flip bit
if last_move == D:
self.parity_streak[self.parity_bit] += 1
else:
self.parity_streak[self.parity_bit] = 0
if self.parity_streak[self.parity_bit] >= self.parity_limit:
return True
[docs] def strategy(self, opponent: Player) -> Action:
turn = len(self.history) + 1
if turn == 1:
return C
if self.mode == "Defect":
# There's a chance to exit Defect mode.
if opponent.history[-1] == D:
self.exit_defect_meter += 1
else:
self.exit_defect_meter -= 3
# If opponent has been mostly defecting.
if self.exit_defect_meter >= 11:
self.mode = "Normal"
self.was_defective = True
self.more_coop = 2
return self.try_return(to_return=C, lower_flags=False)
return self.try_return(D)
# If not Defect mode, proceed to update history and check for random,
# check if burned, and check if opponent's fairweather.
# If we haven't yet entered Defect mode
if not self.was_defective:
if turn > 2:
if opponent.history[-1] == D:
self.recorded_defects += 1
# Column decided by opponent's last turn
history_col = 1 if opponent.history[-1] == D else 0
# Row is decided by opponent's move two turns ago and our move
# two turns ago.
history_row = 1 if opponent.history[-2] == D else 0
if self.history[-2] == D:
history_row += 2
self.move_history[history_row, history_col] += 1
# Try to detect random opponent
if turn % 15 == 0 and turn > 15:
if self.detect_random(turn):
self.mode = "Defect"
return self.try_return(
D, lower_flags=False
) # Lower_flags not used here.
# If generous 2 turns ago and opponent defected last turn
if self.last_generous_n_turns_ago == 2 and opponent.history[-1] == D:
self.burned = True
# Only enter Fair-weather mode if the opponent Cooperated the first 37
# turns then Defected on the 38th.
if turn == 38 and opponent.history[-1] == D and opponent.cooperations == 36:
self.mode = "Fair-weather"
return self.try_return(to_return=C, lower_flags=False)
if self.mode == "Fair-weather":
if opponent.history[-1] == D:
self.mode = "Normal" # Post-Defect is not possible
# Proceed with Normal mode this turn.
else:
# Never defect against a fair-weather opponent
return self.try_return(C)
# Continue with Normal mode
# Check for streaks
if self.detect_streak(opponent.history[-1]):
return self.try_return(D, inc_parity=True)
if self.detect_parity_streak(opponent.history[-1]):
self.parity_streak[
self.parity_bit
] = 0 # Reset `parity_streak` when we hit the limit.
self.parity_hits += 1 # Keep track of how many times we hit the limit.
if self.parity_hits >= 8: # After 8 times, lower the limit.
self.parity_limit = 3
return self.try_return(
C, inc_parity=True
) # Inc parity won't get used here.
# If we have Cooperations scheduled, then Cooperate here.
if self.more_coop >= 1:
return self.try_return(C, lower_flags=True, inc_parity=True)
if turn < 37:
# Tit-for-Tat
return self.try_return(opponent.history[-1], inc_parity=True)
if turn == 37:
# Defect once on turn 37 (if no streaks)
self.more_coop, self.last_generous_n_turns_ago = 2, 1
return self.try_return(D, lower_flags=False)
if self.burned or random.random() > self.prob:
# Tit-for-Tat with probability 1-`prob`
return self.try_return(opponent.history[-1], inc_parity=True)
# Otherwise Defect, Cooperate, Cooperate, and increase `prob`
self.prob += 0.05
self.more_coop, self.last_generous_n_turns_ago = 2, 1
return self.try_return(D, lower_flags=False)
[docs]class MoreTidemanAndChieruzzi(Player):
"""
Strategy submitted to Axelrod's second tournament by T. Nicolaus Tideman
and Paula Chieruzzi (K84R) and came in ninth in that tournament.
This strategy Cooperates if this player's score exceeds the opponent's
score by at least `score_to_beat`. `score_to_beat` starts at zero and
increases by `score_to_beat_inc` every time the opponent's last two moves
are a Cooperation and Defection in that order. `score_to_beat_inc` itself
increase by 5 every time the opponent's last two moves are a Cooperation
and Defection in that order.
Additionally, the strategy executes a "fresh start" if the following hold:
- The strategy would Defect by score (difference less than `score_to_beat`)
- The opponent did not Cooperate and Defect (in order) in the last two
turns.
- It's been at least 10 turns since the last fresh start. Or since the
match started if there hasn't been a fresh start yet.
A "fresh start" entails two Cooperations and resetting scores,
`scores_to_beat` and `scores_to_beat_inc`.
Names:
- MoreTidemanAndChieruzzi: [Axelrod1980b]_
"""
name = "More Tideman and Chieruzzi"
classifier = {
"memory_depth": float("inf"),
"stochastic": False,
"makes_use_of": {"game"},
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self) -> None:
super().__init__()
self.current_score = 0
self.opponent_score = 0
self.last_fresh_start = 0
self.fresh_start = False
self.score_to_beat = 0
self.score_to_beat_inc = 0
def _fresh_start(self):
"""Give the opponent a fresh start by forgetting the past"""
self.current_score = 0
self.opponent_score = 0
self.score_to_beat = 0
self.score_to_beat_inc = 0
def _score_last_round(self, opponent: Player):
"""Updates the scores for each player."""
# Load the default game if not supplied by a tournament.
game = self.match_attributes["game"]
last_round = (self.history[-1], opponent.history[-1])
scores = game.score(last_round)
self.current_score += scores[0]
self.opponent_score += scores[1]
[docs] def strategy(self, opponent: Player) -> Action:
current_round = len(self.history) + 1
if current_round == 1:
return C
# Calculate the scores.
self._score_last_round(opponent)
# Check if we have recently given the strategy a fresh start.
if self.fresh_start:
self._fresh_start()
self.last_fresh_start = current_round
self.fresh_start = False
return C # Second cooperation
opponent_CDd = False
opponent_two_turns_ago = C # Default value for second turn.
if len(opponent.history) >= 2:
opponent_two_turns_ago = opponent.history[-2]
# If opponent's last two turns are C and D in that order.
if opponent_two_turns_ago == C and opponent.history[-1] == D:
opponent_CDd = True
self.score_to_beat += self.score_to_beat_inc
self.score_to_beat_inc += 5
# Cooperate if we're beating opponent by at least `score_to_beat`
if self.current_score - self.opponent_score >= self.score_to_beat:
return C
# Wait at least ten turns for another fresh start.
if (not opponent_CDd) and current_round - self.last_fresh_start >= 10:
# 50-50 split is based off the binomial distribution.
N = opponent.cooperations + opponent.defections
# std_dev = sqrt(N*p*(1-p)) where p is 1 / 2.
std_deviation = (N ** (1 / 2)) / 2
lower = N / 2 - 3 * std_deviation
upper = N / 2 + 3 * std_deviation
if opponent.defections <= lower or opponent.defections >= upper:
# Opponent deserves a fresh start
self.fresh_start = True
return C # First cooperation
return D
[docs]class Getzler(Player):
"""
Strategy submitted to Axelrod's second tournament by Abraham Getzler (K35R)
and came in eleventh in that tournament.
Strategy Defects with probability `flack`, where `flack` is calculated as
the sum over opponent Defections of 0.5 ^ (turns ago Defection happened).
Names:
- Getzler: [Axelrod1980b]_
"""
name = "Getzler"
classifier = {
"memory_depth": float("inf"),
"stochastic": True,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self) -> None:
super().__init__()
self.flack = 0.0 # The relative untrustworthiness of opponent
[docs] def strategy(self, opponent: Player) -> Action:
if not opponent.history:
return C
self.flack += 1 if opponent.history[-1] == D else 0
self.flack *= 0.5 # Defections have half-life of one round
return random_choice(1.0 - self.flack)
[docs]class Leyvraz(Player):
"""
Strategy submitted to Axelrod's second tournament by Fransois Leyvraz
(K68R) and came in twelfth in that tournament.
The strategy uses the opponent's last three moves to decide on an action
based on the following ordered rules.
1. If opponent Defected last two turns, then Defect with prob 75%.
2. If opponent Defected three turns ago, then Cooperate.
3. If opponent Defected two turns ago, then Defect.
4. If opponent Defected last turn, then Defect with prob 50%.
5. Otherwise (all Cooperations), then Cooperate.
Names:
- Leyvraz: [Axelrod1980b]_
"""
name = "Leyvraz"
classifier = {
"memory_depth": 3,
"stochastic": True,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self) -> None:
super().__init__()
self.prob_coop = {
(C, C, C): 1.0,
(C, C, D): 0.5, # Rule 4
(C, D, C): 0.0, # Rule 3
(C, D, D): 0.25, # Rule 1
(D, C, C): 1.0, # Rule 2
(D, C, D): 1.0, # Rule 2
(D, D, C): 1.0, # Rule 2
(D, D, D): 0.25, # Rule 1
}
[docs] def strategy(self, opponent: Player) -> Action:
recent_history = [C, C, C] # Default to C.
for go_back in range(1, 4):
if len(opponent.history) >= go_back:
recent_history[-go_back] = opponent.history[-go_back]
return random_choice(
self.prob_coop[(recent_history[-3], recent_history[-2], recent_history[-1])]
)
[docs]class White(Player):
"""
Strategy submitted to Axelrod's second tournament by Edward C White (K72R)
and came in thirteenth in that tournament.
* If the opponent Cooperated last turn or in the first ten turns, then
Cooperate.
* Otherwise Defect if and only if:
floor(log(turn)) * opponent Defections >= turn
Names:
- White: [Axelrod1980b]_
"""
name = "White"
classifier = {
"memory_depth": float("inf"),
"stochastic": False,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
[docs] def strategy(self, opponent: Player) -> Action:
turn = len(self.history) + 1
if turn <= 10 or opponent.history[-1] == C:
return C
if np.floor(np.log(turn)) * opponent.defections >= turn:
return D
return C
[docs]class Black(Player):
"""
Strategy submitted to Axelrod's second tournament by Paul E Black (K83R)
and came in fifteenth in that tournament.
The strategy Cooperates for the first five turns. Then it calculates the
number of opponent defects in the last five moves and Cooperates with
probability `prob_coop`[`number_defects`], where:
prob_coop[number_defects] = 1 - (number_defects^ 2 - 1) / 25
Names:
- Black: [Axelrod1980b]_
"""
name = "Black"
classifier = {
"memory_depth": 5,
"stochastic": True,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self) -> None:
super().__init__()
# Maps number of opponent defects from last five moves to own
# Cooperation probability
self.prob_coop = {0: 1.0, 1: 1.0, 2: 0.88, 3: 0.68, 4: 0.4, 5: 0.04}
[docs] def strategy(self, opponent: Player) -> Action:
if len(opponent.history) < 5:
return C
recent_history = opponent.history[-5:]
did_d = np.vectorize(lambda action: int(action == D))
number_defects = np.sum(did_d(recent_history))
return random_choice(self.prob_coop[number_defects])
[docs]class RichardHufford(Player):
"""
Strategy submitted to Axelrod's second tournament by Richard Hufford (K47R)
and came in sixteenth in that tournament.
The strategy tracks opponent "agreements", that is whenever the opponent's
previous move is the some as this player's move two turns ago. If the
opponent's first move is a Defection, this is counted as a disagreement,
and otherwise an agreement. From the agreement counts, two measures are
calculated:
- `proportion_agree`: This is the number of agreements (through opponent's
last turn) + 2 divided by the current turn number.
- `last_four_num`: The number of agreements in the last four turns. If
there have been fewer than four previous turns, then this is number of
agreement + (4 - number of past turns).
We then use these measures to decide how to play, using these rules:
1. If `proportion_agree` > 0.9 and `last_four_num` >= 4, then Cooperate.
2. Otherwise if `proportion_agree` >= 0.625 and `last_four_num` >= 2, then
Tit-for-Tat.
3. Otherwise, Defect.
However, if the opponent has Cooperated the last `streak_needed` turns,
then the strategy deviates from the usual strategy, and instead Defects.
(We call such deviation an "aberration".) In the turn immediately after an
aberration, the strategy doesn't override, even if there's a streak of
Cooperations. Two turns after an aberration, the strategy: Restarts the
Cooperation streak (never looking before this turn); Cooperates; and
changes `streak_needed` to:
floor(20.0 * `num_abb_def` / `num_abb_coop`) + 1
Here `num_abb_def` is 2 + the number of times that the opponent Defected in
the turn after an aberration, and `num_abb_coop` is 2 + the number of times
that the opponent Cooperated in response to an aberration.
Names:
- RichardHufford: [Axelrod1980b]_
"""
name = "RichardHufford"
classifier = {
"memory_depth": float("inf"),
"stochastic": False,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self) -> None:
super().__init__()
self.num_agreements = 2
self.last_four_agreements = [1] * 4
self.last_four_index = 0
self.streak_needed = 21
self.current_streak = 2
self.last_aberration = float("inf")
self.coop_after_ab_count = 2
self.def_after_ab_count = 2
[docs] def strategy(self, opponent: Player) -> Action:
turn = len(self.history) + 1
if turn == 1:
return C
# Check if opponent agreed with us.
self.last_four_index = (self.last_four_index + 1) % 4
me_two_moves_ago = C
if turn > 2:
me_two_moves_ago = self.history[-2]
if me_two_moves_ago == opponent.history[-1]:
self.num_agreements += 1
self.last_four_agreements[self.last_four_index] = 1
else:
self.last_four_agreements[self.last_four_index] = 0
# Check if last_aberration is infinite.
# i.e Not an aberration in last two turns.
if turn < self.last_aberration:
if opponent.history[-1] == C:
self.current_streak += 1
else:
self.current_streak = 0
if self.current_streak >= self.streak_needed:
self.last_aberration = turn
if self.current_streak == self.streak_needed:
return D
elif turn == self.last_aberration + 2:
self.last_aberration = float("inf")
if opponent.history[-1] == C:
self.coop_after_ab_count += 1
else:
self.def_after_ab_count += 1
self.streak_needed = (
np.floor(20.0 * self.def_after_ab_count / self.coop_after_ab_count) + 1
)
self.current_streak = 0
return C
proportion_agree = self.num_agreements / turn
last_four_num = np.sum(self.last_four_agreements)
if proportion_agree > 0.9 and last_four_num >= 4:
return C
elif proportion_agree >= 0.625 and last_four_num >= 2:
return opponent.history[-1]
return D
[docs]class Yamachi(Player):
"""
Strategy submitted to Axelrod's second tournament by Brian Yamachi (K64R)
and came in seventeenth in that tournament.
The strategy keeps track of play history through a variable called
`count_them_us_them`, which is a dict indexed by (X, Y, Z), where X is an
opponent's move and Y and Z are the following moves by this player and the
opponent, respectively. Each turn, we look at our opponent's move two
turns ago, call X, and our move last turn, call Y. If (X, Y, C) has
occurred more often (or as often) as (X, Y, D), then Cooperate. Otherwise
Defect. [Note that this reflects likelihood of Cooperations or Defections
in opponent's previous move; we don't update `count_them_us_them` with
previous move until next turn.]
Starting with the 41st turn, there's a possibility to override this
behavior. If `portion_defect` is between 45% and 55% (exclusive), then
Defect, where `portion_defect` equals number of opponent defects plus 0.5
divided by the turn number (indexed by 1). When overriding this way, still
record `count_them_us_them` as though the strategy didn't override.
Names:
- Yamachi: [Axelrod1980b]_
"""
name = "Yamachi"
classifier = {
"memory_depth": float("inf"),
"stochastic": False,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self) -> None:
super().__init__()
self.count_them_us_them = {
(C, C, C): 0,
(C, C, D): 0,
(C, D, C): 0,
(C, D, D): 0,
(D, C, C): 0,
(D, C, D): 0,
(D, D, C): 0,
(D, D, D): 0,
}
self.mod_history = list() # type: List[Action]
[docs] def try_return(self, to_return, opp_def):
"""
Return `to_return`, unless the turn is greater than 40 AND
`portion_defect` is between 45% and 55%.
In this case, still record the history as `to_return` so that the
modified behavior doesn't affect the calculation of `count_us_them_us`.
"""
turn = len(self.history) + 1
self.mod_history.append(to_return)
# In later turns, check if the opponent is close to 50/50
# If so, then override
if turn > 40:
portion_defect = (opp_def + 0.5) / turn
if 0.45 < portion_defect and portion_defect < 0.55:
return D
return to_return
[docs] def strategy(self, opponent: Player) -> Action:
turn = len(self.history) + 1
if turn == 1:
return self.try_return(C, 0)
us_last = self.mod_history[-1]
them_two_ago, us_two_ago, them_three_ago = C, C, C
if turn >= 3:
them_two_ago = opponent.history[-2]
us_two_ago = self.mod_history[-2]
if turn >= 4:
them_three_ago = opponent.history[-3]
# Update history
if turn >= 3:
self.count_them_us_them[(them_three_ago, us_two_ago, them_two_ago)] += 1
if (
self.count_them_us_them[(them_two_ago, us_last, C)]
>= self.count_them_us_them[(them_two_ago, us_last, D)]
):
return self.try_return(C, opponent.defections)
return self.try_return(D, opponent.defections)
[docs]class Colbert(FSMPlayer):
"""
Strategy submitted to Axelrod's second tournament by William Colbert (K51R)
and came in eighteenth in that tournament.
In the first eight turns, this strategy Coopearates on all but the sixth
turn, in which it Defects. After that, the strategy responds to an
opponent Cooperation with a single Cooperation, and responds to a Defection
with a chain of responses: Defect, Defect, Cooperate, Cooperate. During
this chain, the strategy ignores opponent's moves.
Names:
- Colbert: [Axelrod1980b]_
"""
name = "Colbert"
classifier = {
"memory_depth": 4,
"stochastic": False,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self) -> None:
transitions = (
(0, C, 1, C),
(0, D, 1, C), # First 8 turns are special
(1, C, 2, C),
(1, D, 2, C),
(2, C, 3, C),
(2, D, 3, C),
(3, C, 4, C),
(3, D, 4, C),
(4, C, 5, D),
(4, D, 5, D), # Defect on 6th turn.
(5, C, 6, C),
(5, D, 6, C),
(6, C, 7, C),
(6, D, 7, C),
(7, C, 7, C),
(7, D, 8, D),
(8, C, 9, D),
(8, D, 9, D),
(9, C, 10, C),
(9, D, 10, C),
(10, C, 7, C),
(10, D, 7, C),
)
super().__init__(transitions=transitions, initial_state=0, initial_action=C)
[docs]class Mikkelson(FSMPlayer):
"""
Strategy submitted to Axelrod's second tournament by Ray Mikkelson (K66R)
and came in twentieth in that tournament.
The strategy keeps track of a variable called `credit`, which determines if
the strategy will Cooperate, in the sense that if `credit` is positive,
then the strategy Cooperates. `credit` is initialized to 7. After the
first turn, `credit` increments if the opponent Cooperated last turn, and
decreases by two otherwise. `credit` is capped above by 8 and below by -7.
[`credit` is assessed as postive or negative, after increasing based on
opponent's last turn.]
If `credit` is non-positive within the first ten turns, then the strategy
Defects and `credit` is set to 4. If `credit` is non-positive later, then
the strategy Defects if and only if (total # opponent Defections) / (turn#)
is at least 15%. [Turn # starts at 1.]
Names:
- Mikkelson: [Axelrod1980b]_
"""
name = "Mikkelson"
classifier = {
"memory_depth": float("inf"),
"stochastic": False,
"makes_use_of": set(),
"long_run_time": False,
"inspects_source": False,
"manipulates_source": False,
"manipulates_state": False,
}
def __init__(self) -> None:
super().__init__()
self.credit = 7
[docs] def strategy(self, opponent: Player) -> Action:
turn = len(self.history) + 1
if turn == 1:
return C
if opponent.history[-1] == C:
self.credit += 1
if self.credit > 8:
self.credit = 8
else:
self.credit -= 2
if self.credit < -7:
self.credit = -7
if turn == 2:
return C
if self.credit > 0:
return C
if turn <= 10:
self.credit = 4
return D
if opponent.defections / turn >= 0.15:
return D
return C
```