Address comments from @marcharper (RevisedDowning)

Author: drvinceknight

axelrod/strategies/_strategies.py

@@ -26,6 +26,7 @@
     SecondByCave,
     SecondByChampion,
     SecondByColbert,
+    SecondByDowning,
     SecondByEatherley,
     SecondByGetzler,
     SecondByGladstein,
@@ -366,6 +367,7 @@
     MindReader,
     MindWarper,
     MirrorMindReader,
+    SecondByDowning,
     SecondByGrofman,
     SecondByTidemanAndChieruzzi,
     Negation,

axelrod/strategies/axelrod_first.py

@@ -189,10 +189,23 @@ class FirstByDowning(Player):
     is assumed to be the behaviour. Interestingly, in future tournaments this
     strategy was revised to not defect on the opening two rounds.
 
-    Note that response to the first round allows us to estimate
+    It is assumed that these first two rounds are used to create initial
+    estimates of
     beta = P(C_o | D_s) and we will use the opening play of the player to
-    estimate alpha = P(C_o | C_s). This is an assumption with no clear
-    indication from the literature.
+    estimate alpha = P(C_o | C_s).
+    Thus we assume that the opponents first play is a response to a cooperation
+    "before the match starts".
+
+    So for example, if the plays are:
+
+    [(D, C), (D, C)]
+
+    Then the opponent's first cooperation counts as a cooperation in response to
+    the non existent cooperation of round 0. The total number of cooperations in
+    response to a cooperation is 1. We need to take in to account that extra
+    phantom cooperation to estimate the probability alpha=P(C|C) as 1 / 1 = 1.
+
+    This is an assumption with no clear indication from the literature.
 
     --
     This strategy came 10th in Axelrod's original tournament.
@@ -236,7 +249,10 @@ def strategy(self, opponent: Player) -> Action:
             self.number_opponent_cooperations_in_response_to_D += 1
 
         alpha = (self.number_opponent_cooperations_in_response_to_C /
-                 (self.cooperations + 1))  # Adding 1 to count for opening move
+                 (self.cooperations + 1))  # Adding 1 to count for assumption
+                                           # that first opponent move being a
+                                           # response to a cooperation. See
+                                           # docstring for more information.
         beta = (self.number_opponent_cooperations_in_response_to_D /
                  (self.defections))
 

axelrod/strategies/axelrod_second.py

@@ -61,6 +61,71 @@ def strategy(self, opponent: Player) -> Action:
                 return D
         return C
 
+class SecondByDowning(Player):
+    """
+    Strategy submitted to Axelrod's second tournament by Leslie Downing.
+    (K59R).
+
+    Revised Downing attempts to determine if players are cooperative or not.
+    If so, it cooperates with them.
+
+    This strategy is a revision of the strategy submitted by Downing to
+    Axelrod's first tournament.
+
+
+    Names:
+    - Revised Downing: [Axelrod1980]_
+    """
+
+    name = "Second by Downing"
+
+    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.good = 1.0
+        self.bad = 0.0
+        self.nice1 = 0
+        self.nice2 = 0
+        self.total_C = 0  # note the same as self.cooperations
+        self.total_D = 0  # note the same as self.defections
+
+    def strategy(self, opponent: Player) -> Action:
+        round_number = len(self.history) + 1
+
+        if round_number == 1:
+            return C
+
+        # Update various counts
+        if round_number > 2:
+            if self.history[-1] == D:
+                if opponent.history[-1] == C:
+                    self.nice2 += 1
+                self.total_D += 1
+                self.bad = self.nice2 / self.total_D
+            else:
+                if opponent.history[-1] == C:
+                    self.nice1 += 1
+                self.total_C += 1
+                self.good = self.nice1 / self.total_C
+        # Make a decision based on the accrued counts
+        c = 6.0 * self.good - 8.0 * self.bad - 2
+        alt = 4.0 * self.good - 5.0 * self.bad - 1
+        if c >= 0 and c >= alt:
+            move = C
+        elif (c >= 0 and c < alt) or (alt >= 0):
+            move = self.history[-1].flip()
+        else:
+            move = D
+        return move
 
 class SecondByEatherley(Player):
     """

axelrod/tests/strategies/test_axelrod_second.py

@@ -2030,3 +2030,41 @@ def test_strategy(self):
                    (C, C),
                    (D, C)]
         self.versus_test(axelrod.Random(0.5), expected_actions=actions, seed=7)
+
+
+class TestSeconodByDowning(TestPlayer):
+
+    name = "Revised Downing"
+    player = axelrod.SecondByDowning
+    expected_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 test_strategy(self):
+        actions = [(C, C), (C, C), (C, C)]
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions)
+
+        actions = [(C, D), (C, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions)
+
+        opponent = axelrod.MockPlayer(actions=[D, C, C])
+        actions = [(C, D), (C, C), (C, C), (C, D)]
+        self.versus_test(opponent, expected_actions=actions)
+
+        opponent = axelrod.MockPlayer(actions=[D, D, C])
+        actions = [(C, D), (C, D), (D, C), (D, D)]
+        self.versus_test(opponent, expected_actions=actions)
+
+        opponent = axelrod.MockPlayer(actions=[C, C, D, D, C, C])
+        actions = [(C, C), (C, C), (C, D), (C, D), (D, C), (D, C), (D, C)]
+        self.versus_test(opponent, expected_actions=actions)
+
+        opponent = axelrod.MockPlayer(actions=[C, C, C, C, D, D])
+        actions = [(C, C), (C, C), (C, C), (C, C), (C, D), (C, D), (C, C)]
+        self.versus_test(opponent, expected_actions=actions)