Implement prober4 strategy from PRISON project

axelrod/strategies/_strategies.py

@@ -46,7 +46,7 @@
 from .mindreader import MindReader, ProtectedMindReader, MirrorMindReader
 from .mutual import Desperate, Hopeless, Willing
 from .oncebitten import OnceBitten, FoolMeOnce, ForgetfulFoolMeOnce, FoolMeForever
-from .prober import (Prober, Prober2, Prober3, HardProber,
+from .prober import (Prober, Prober2, Prober3, Prober4, HardProber,
                      NaiveProber, RemorsefulProber)
 from .punisher import Punisher, InversePunisher
 from .qlearner import RiskyQLearner, ArrogantQLearner, HesitantQLearner, CautiousQLearner
@@ -164,6 +164,7 @@
     Prober,
     Prober2,
     Prober3,
+    Prober4,
     ProtectedMindReader,
     Punisher,
     Raider,

axelrod/strategies/prober.py

@@ -102,6 +102,74 @@ def strategy(self, opponent):
                 return D if opponent.history[-1:] == [D] else C
 
 
+class Prober4(Player):
+    """
+    Plays C, C, D, C, D, D, D, C, C, D, C, D, C, C, D, C, D, D, C, D initially.
+    Counts retaliating and provocative defections of the opponent.
+    If the absolute difference between the counts is smaller or equal to 2,
+    defects forever.
+    Otherwise plays C for the next 5 turns and TFT for the rest of the game.
+
+    Names:
+
+    - prober4: [PRISON1998]_
+    """
+
+    name = 'Prober 4'
+    classifier = {
+        'stochastic': False,
+        'memory_depth': 1,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    @init_args
+    def __init__(self):
+        Player.__init__(self)
+        self.init_sequence = [
+            C, C, D, C, D, D, D, C, C, D, C, D, C, C, D, C, D, D, C, D
+        ]
+        self.just_Ds = 0
+        self.unjust_Ds = 0
+        self.cooperation_pool = [C] * 5
+        self.turned_defector = False
+
+    def strategy(self, opponent):
+        if len(opponent.history) == 0:
+            return self.init_sequence[0]
+        if len(self.history) == 0:
+            return self.init_sequence[0]
+        else:
+            turn = len(self.history)
+            if turn < len(self.init_sequence):
+                if opponent.history[-1] == D:
+                    if self.history[-1] == D:
+                        self.just_Ds += 1
+                    if self.history[-1] == C:
+                        self.unjust_Ds += 1
+                return self.init_sequence[turn]
+            if turn == len(self.init_sequence):
+                diff_in_Ds = abs(self.just_Ds - self.unjust_Ds)
+                self.turned_defector = (diff_in_Ds <= 2)
+            if self.turned_defector:
+                return D
+            if not self.turned_defector:
+                if self.cooperation_pool:
+                    return self.cooperation_pool.pop()
+                else:
+                    return D if opponent.history[-1] == D else C
+
+    def reset(self):
+        Player.reset(self)
+        self.just_Ds = 0
+        self.unjust_Ds = 0
+        self.cooperation_pool = [C] * 5
+        self.turned_defector = False
+
+
 class HardProber(Player):
     """
     Plays D, D, C, C initially. Defects forever if opponent cooperated in moves

axelrod/tests/unit/test_prober.py

@@ -99,6 +99,79 @@ def test_strategy(self):
         self.responses_test([D, C, C, D, C], [C, D, C, C], [C])
 
 
+class TestProber4(TestPlayer):
+
+    name = "Prober 4"
+    player = axelrod.Prober4
+    expected_classifier = {
+        'stochastic': False,
+        'memory_depth': 1,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+    initial_sequence = [
+        C, C, D, C, D, D, D, C, C, D, C, D, C, C, D, C, D, D, C, D
+    ]
+    cooperation_pool = [C] * 5
+
+    def test_initial_strategy(self):
+        """Starts by playing CCDCDDDCCDCDCCDCDDCD."""
+        self.responses_test([], [], self.initial_sequence)
+
+    def test_strategy(self):
+        # After playing the initial sequence defects forever
+        # if the absolute difference in the number of retaliating
+        # and provocative defections of the opponent is smaller or equal to 2
+
+        provocative_histories = [
+            [C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [C, D, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [C, D, C, D, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [C, C, D, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [C, C, D, C, D, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D],
+        ]
+
+        history1 = self.initial_sequence
+        responses = [D] * 10
+        for history2 in provocative_histories:
+            self.responses_test(history1, history2, responses)
+
+        # Otherwise cooperates for 5 rounds
+        unprovocative_histories = [
+            [C, C, D, C, D, D, D, C, C, D, C, D, C, C, D, C, D, D, C, D],
+            [D, D, C, D, C, C, C, D, D, C, D, C, D, D, C, D, C, C, D, C],
+            [C, C, D, C, D, D, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [C, C, D, C, D, D, C, C, D, C, C, C, C, C, C, D, D, D, C, C],
+            [C, C, C, C, D, D, C, C, D, C, C, D, D, C, D, C, D, C, C, C],
+        ]
+
+        history1 = self.initial_sequence
+        responses = self.cooperation_pool
+        for history2 in unprovocative_histories:
+            self.responses_test(history1, history2, responses)
+
+        # and plays like TFT afterwards
+            history1 += self.cooperation_pool
+            history2 += self.cooperation_pool
+            self.responses_test(history1, history2, [C])
+
+            history1 += [C]
+            history2 += [D]
+            self.responses_test(history1, history2, [D])
+
+            history1 += [D]
+            history2 += [C]
+            self.responses_test(history1, history2, [C])
+
+            history1 += [C]
+            history2 += [D]
+            self.responses_test(history1, history2, [D])
+
+
 class TestHardProber(TestPlayer):
 
     name = "Hard Prober"

docs/tutorials/advanced/classification_of_strategies.rst

@@ -58,7 +58,7 @@ make a decision::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    24
+    25
 
 Multiple filters can be specified within the filterset dictionary. To specify a
 range of memory_depth values, we can use the 'min_memory_depth' and
@@ -70,7 +70,7 @@ range of memory_depth values, we can use the 'min_memory_depth' and
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    41
+    42
 
 We can also identify strategies that make use of particular properties of the
 tournament. For example, here is the number of strategies that  make use of the