Implemented a naive prober strategy (like tit for tat, but randomly defects).

axelrod/strategies/_strategies.py

@@ -44,6 +44,7 @@
 from .mindreader import MindReader, ProtectedMindReader, MirrorMindReader
 from .oncebitten import OnceBitten, FoolMeOnce, ForgetfulFoolMeOnce, FoolMeForever
 from .prober import Prober, Prober2, Prober3, HardProber
+from .naiveprober import NaiveProber
 from .punisher import Punisher, InversePunisher
 from .qlearner import RiskyQLearner, ArrogantQLearner, HesitantQLearner, CautiousQLearner
 from .rand import Random

axelrod/strategies/naiveprober.py

@@ -0,0 +1,46 @@
+from axelrod import Actions, Player, init_args, random_choice
+
+C, D = Actions.C, Actions.D
+
+
+class NaiveProber(Player):
+    """
+    Like tit-for-tat, but it occasionally defects with a small probability.
+    """
+
+    name = 'Naive Prober'
+    classifier = {
+        'memory_depth': 1,  # Four-Vector = (1.,0.,1.,0.)
+        'stochastic': True,
+        'makes_use_of': set(),
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    @init_args
+    def __init__(self, p=0.1):
+        """
+        Parameters
+        ----------
+        p, float
+            The probability to defect randomly
+        """
+        Player.__init__(self)
+        self.p = p
+        if (self.p == 0) or (self.p == 1):
+            self.classifier['stochastic'] = False
+
+    def strategy(self, opponent):
+        # First move
+        if len(self.history) == 0:
+            return C
+        # React to the opponent's last move
+        if opponent.history[-1] == D:
+            return D
+        # Otherwise cooperate, defect with a small probability
+        choice = random_choice(1 - self.p)
+        return choice
+
+    def __repr__(self):
+        return "%s: %s" % (self.name, round(self.p, 2))

axelrod/tests/unit/test_naiveprober.py

@@ -0,0 +1,40 @@
+"""Test for the Naive Prober strategy."""
+
+import axelrod
+from .test_player import TestPlayer, test_responses
+
+C, D = axelrod.Actions.C, axelrod.Actions.D
+
+
+class TestNaiveProber(TestPlayer):
+
+    name = "Naive Prober: 0.1"
+    player = axelrod.NaiveProber
+    expected_classifier = {
+        'memory_depth': 1,
+        'stochastic': True,
+        'makes_use_of': set(),
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        "Randomly defects and always retaliates like tit for tat."
+        self.first_play_test(C)
+        # Always retaliate a defection
+        self.responses_test([C] * 2, [C, D], [D])
+
+    def test_random_defection(self):
+        # Random defection
+        player = self.player(0.4)
+        opponent = axelrod.Random()
+        test_responses(self, player, opponent, [C], [C], [D], random_seed=1)
+
+    def test_reduction_to_TFT(self):
+        player = self.player(0)
+        opponent = axelrod.Random()
+        test_responses(self, player, opponent, [C], [C], [C], random_seed=1)
+        test_responses(self, player, opponent, [C], [D], [D])
+        test_responses(self, player, opponent, [C, D], [D, C], [C])
+        test_responses(self, player, opponent, [C, D], [D, D], [D])

docs/reference/overview_of_strategies.rst

@@ -1000,3 +1000,23 @@ HardProber is implemented in the library::
     ['D', 'D', 'C', 'C', 'D']
     >>> p2.history
     ['C', 'C', 'C', 'C', 'C']
+
+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.
+
+Here is how NaiveProber is implemented in the library::
+
+    >>> import axelrod
+    >>> p1 = axelrod.NaiveProber()  # Create a Prober3 player
+    >>> p2 = axelrod.Defector()  # Create a player that always defects
+    >>> for round in range(5):
+    ...     p1.play(p2)
+
+    >>> p1.history
+    ['C', 'D', 'D', 'D', 'D']
+    >>> p2.history
+    ['D', 'D', 'D', 'D', 'D']