Michaelos strategy

axelrod/strategies/_strategies.py

@@ -76,7 +76,7 @@
     TitForTat, TitFor2Tats, TwoTitsForTat, Bully, SneakyTitForTat,
     SuspiciousTitForTat, AntiTitForTat, HardTitForTat, HardTitFor2Tats,
     OmegaTFT, Gradual, ContriteTitForTat, AdaptiveTitForTat,
-    SpitefulTitForTat, SlowTitForTwoTats2, Alexei, EugineNier, DynamicTwoTitsForTat, NTitsForMTats)
+    SpitefulTitForTat, SlowTitForTwoTats2, Alexei, EugineNier, DynamicTwoTitsForTat, NTitsForMTats, Michaelos)
 from .verybad import VeryBad
 from .worse_and_worse import (WorseAndWorse, KnowledgeableWorseAndWorse,
                               WorseAndWorse2, WorseAndWorse3)
@@ -186,6 +186,7 @@
     MathConstantHunter,
     NaiveProber,
     MEM2,
+    Michaelos,
     MindBender,
     MindController,
     MindReader,

axelrod/strategies/titfortat.py

@@ -649,6 +649,7 @@ def strategy(self, opponent: Player) -> Action:
         # Otherwise play previous move
         return self.history[-1]
 
+
 @FinalTransformer((D,), name_prefix=None)
 class Alexei(Player):
     """
@@ -677,6 +678,7 @@ def strategy(self, opponent: Player) -> Action:
             return D
         return C
 
+
 @FinalTransformer((D,), name_prefix=None)
 class EugineNier(Player):
     """
@@ -761,7 +763,7 @@ def __init__(self, N: int=3, M: int=2) -> None:
         super().__init__()
         self.N = N
         self.M = M
-        self.classifier['memory_depth'] = max([M,N])
+        self.classifier['memory_depth'] = max([M, N])
         self.retaliate_count = 0
 
     def strategy(self, opponent: Player) -> Action:
@@ -772,3 +774,52 @@ def strategy(self, opponent: Player) -> Action:
             self.retaliate_count -= 1
             return D
         return C
+
+
+@FinalTransformer((D,), name_prefix=None)
+class Michaelos(Player):
+    """
+    Plays similar to Tit-for-Tat with two exceptions:
+    1) Defect on last turn.
+    2) After own defection and opponent's cooperation, 50 percent of the time,
+    cooperate. The other 50 percent of the time, always defect for the rest of
+    the game.
+
+    Names:
+
+    - Michaelos: [LessWrong2011]_
+    """
+
+    name = 'Michaelos'
+    classifier = {
+        'memory_depth': 1,
+        'stochastic': True,
+        'makes_use_of': {'length'},
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def __init__(self):
+        super().__init__()
+        self.is_defector = False
+
+    def strategy(self, opponent: Player) -> Action:
+        if not self.history:
+            return C
+        if self.is_defector:
+            return D
+        if self.history[-1] == D and opponent.history[-1] == C:
+            decision = random_choice()
+            if(decision == C):
+                return C
+            else:
+                self.is_defector = True
+                return D
+
+        return opponent.history[-1]
+
+    def reset(self):
+        super().reset()
+        self.is_defector = False

axelrod/tests/strategies/test_titfortat.py

@@ -717,3 +717,50 @@ def test_varying_memory_depth(self):
         self.assertEqual(self.player(1, 1).classifier['memory_depth'], 1)
         self.assertEqual(self.player(0, 3).classifier['memory_depth'], 3)
         self.assertEqual(self.player(5, 3).classifier['memory_depth'], 5)
+
+
+class TestMichaelos(TestPlayer):
+    """
+    Tests for the Michaelos strategy
+    """
+
+    name = "Michaelos: (D,)"
+    player = axelrod.Michaelos
+    expected_classifier = {
+        'memory_depth': 1,
+        'stochastic': True,
+        'makes_use_of': {'length'},
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+
+        actions = [(C, C), (C, C), (C, C), (D, C)]
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions,
+                         attrs={"is_defector": False}, seed=2)
+
+        actions = [(C, C), (C, C), (C, C), (C, C)]
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions,
+                         attrs={"is_defector": False},
+                         match_attributes={"length": -1}, seed=2)
+
+        actions = [(C, D), (D, D), (D, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions,
+                         attrs={"is_defector": False}, seed=2)
+
+        actions = [(C, D), (D, D), (D, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions,
+                         attrs={"is_defector": False},
+                         match_attributes={"length": -1}, seed=2)
+
+        # Chance of becoming a defector is 50% after (D, C) occurs.
+        actions = [(C, C), (C, D), (D, C), (D, D), (D, C), (D, D), (D, C)]
+        self.versus_test(axelrod.Alternator(), expected_actions=actions,
+                         attrs={"is_defector": True}, seed=2)
+
+        actions = [(C, C), (C, D), (D, C), (C, D), (D, C), (D, D), (D, C)]
+        self.versus_test(axelrod.Alternator(), expected_actions=actions,
+                         attrs={"is_defector": True},
+                         match_attributes={"length": -1}, seed=1)

docs/tutorials/advanced/classification_of_strategies.rst

@@ -47,7 +47,7 @@ strategies::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    67
+    68
 
 Or, to find out how many strategies only use 1 turn worth of memory to
 make a decision::
@@ -57,7 +57,7 @@ make a decision::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    28
+    29
 
 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
@@ -69,7 +69,7 @@ range of memory_depth values, we can use the 'min_memory_depth' and
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    51
+    52
 
 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
@@ -80,7 +80,7 @@ length of each match of the tournament::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    28
+    29
 
 Note that in the filterset dictionary, the value for the 'makes_use_of' key
 must be a list. Here is how we might identify the number of strategies that use