Implemented strategy Cave (k49r from Axelrod's Second)

Author: gaffney2010

axelrod/strategies/_strategies.py

@@ -9,7 +9,7 @@
     UnnamedStrategy, SteinAndRapoport, TidemanAndChieruzzi)
 from .axelrod_second import (
     Champion, Eatherley, Tester, Gladstein, Tranquilizer, MoreGrofman,
-    Kluepfel, Borufsen)
+    Kluepfel, Borufsen, Cave)
 from .backstabber import BackStabber, DoubleCrosser
 from .better_and_better import BetterAndBetter
 from .bush_mosteller import BushMosteller
@@ -113,6 +113,7 @@
     BushMosteller,
     Calculator,
     CautiousQLearner,
+    Cave,
     Champion,
     CollectiveStrategy,
     ContriteTitForTat,

axelrod/strategies/axelrod_second.py

@@ -718,3 +718,56 @@ def strategy(self, opponent: Player) -> Action:
 
             # Tit-for-tat
             return self.try_return(opponent.history[-1])
+
+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
+    }
+
+    def strategy(self, opponent: Player) -> Action:
+        turn = len(self.history) + 1
+        if turn == 1: return C
+
+        did_d = np.vectorize(lambda action: float(action == D))
+        number_defects = np.sum(did_d(opponent.history))
+        perc_defects = np.average(did_d(opponent.history))
+        
+        # If overly defect 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

axelrod/tests/strategies/test_axelrod_second.py

@@ -490,3 +490,55 @@ def test_strategy(self):
                     [(D, C)] + [(C, C), (C, D), (D, C)] * 8 + \
                     [(D, C)] * 25
         self.versus_test(axelrod.WinShiftLoseStay(D), expected_actions=actions)
+
+class TestCave(TestPlayer):
+    name = "Cave"
+    player = axelrod.Cave
+    expected_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 test_strategy(self):
+        actions = [(C, C)] * 100 
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions)
+
+        # It will take until turn 18 to respond decide to repond D->D
+        random.seed(1)
+        actions = [(C, D)]
+        actions += [(C, D), (D, D), (D, D), (C, D), (C, D), (C, D), (D, D),
+                    (D, D), (C, D), (C, D), (D, D), (C, D), (D, D), (C, D),
+                    (C, D), (D, D), (C, D)] # Randomly choose
+        actions += [(D, D)] * 30 # Defect
+        self.versus_test(axelrod.Defector(), expected_actions=actions)
+
+        # Highly-defective opponent
+        # It will take until turn 20 to respond decide to repond D to C
+        opponent_actions = [D] * 16 + [C, C, C, C, C]
+        almost_defector = axelrod.MockPlayer(actions=opponent_actions)
+
+        random.seed(1)
+        actions = [(C, D)]
+        actions += [(C, D), (D, D), (D, D), (C, D), (C, D), (C, D), (D, D),
+                    (D, D), (C, D), (C, D), (D, D), (C, D), (D, D), (C, D),
+                    (C, D), (D, C), (C, C)] # Randomly choose
+        actions += [(C, C)] # Coop for a minute
+        actions += [(D, C), (D, C)]
+        self.versus_test(almost_defector, expected_actions=actions)
+
+        #Here it will take until turn 40 to detect random and defect
+        random.seed(2)
+        actions = [(C, C)]
+        actions += [(C, D), (D, C), (C, D), (D, C), (C, D), (C, C), (C, D), 
+                    (C, C), (C, D), (D, C), (C, D), (D, C), (C, D), (D, C), 
+                    (C, D), (C, C), (C, D), (D, C), (C, D), (D, C), (C, D), 
+                    (D, C), (C, D), (C, C), (C, D), (C, C), (C, D), (C, C), 
+                    (C, D), (D, C), (C, D), (D, C), (C, D), (D, C), (C, D)] #Randomly choose 
+        actions += [(D, C), (C, D), (D, C)] # 17 D have come, so tit for tat for a while
+        actions += [(D, D), (D, C)] * 100 # Random finally detected
+        self.versus_test(axelrod.Alternator(), expected_actions=actions)

axelrod/tests/strategies/test_meta.py

@@ -331,11 +331,11 @@ class TestMetaMajorityLongMemory(TestMetaPlayer):
     }
 
     def test_strategy(self):
-        actions = [(C, C), (C, D), (C, C), (C, D), (D, C)]
+        actions = [(C, C), (C, D), (D, C), (C, D), (D, C)]
         self.versus_test(opponent=axelrod.Alternator(),
                          expected_actions=actions, seed=0)
 
-        actions = [(C, C), (C, D), (D, C), (C, D), (D, C)]
+        actions = [(C, C), (C, D), (C, C), (C, D), (D, C)]
         self.versus_test(opponent=axelrod.Alternator(),
                          expected_actions=actions, seed=1)
 

docs/tutorials/advanced/classification_of_strategies.rst

@@ -47,7 +47,7 @@ strategies::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    76
+    77
 
 Or, to find out how many strategies only use 1 turn worth of memory to
 make a decision::