Added a new DynamicTwoTitsForTat strategy which modifies the preexisting TwoTitsForTat stategy by adding a probability of forgiveness based off of the ratio of the opponent's cooperations to total moves (so their rough probability of cooperation).

Signed-off-by: FakeNameSE <grantlycee@gmail.com>

Author: FakeNameSE

axelrod/strategies/_strategies.py

@@ -76,7 +76,7 @@
     TitForTat, TitFor2Tats, TwoTitsForTat, Bully, SneakyTitForTat,
     SuspiciousTitForTat, AntiTitForTat, HardTitForTat, HardTitFor2Tats,
     OmegaTFT, Gradual, ContriteTitForTat, SlowTitForTwoTats, AdaptiveTitForTat,
-    SpitefulTitForTat, SlowTitForTwoTats2, Alexei, EugineNier)
+    SpitefulTitForTat, SlowTitForTwoTats2, Alexei, EugineNier, DynamicTwoTitsForTat)
 from .verybad import VeryBad
 from .worse_and_worse import (WorseAndWorse, KnowledgeableWorseAndWorse,
                               WorseAndWorse2, WorseAndWorse3)
@@ -263,4 +263,5 @@
     ZDGen2,
     ZDSet2,
     e,
+    DynamicTwoTitsForTat,
 ]

axelrod/strategies/titfortat.py

@@ -1,6 +1,8 @@
 from axelrod.actions import Actions, Action
 from axelrod.player import Player
 from axelrod.strategy_transformers import TrackHistoryTransformer, FinalTransformer
+from axelrod.random_ import random_choice
+import random
 
 C, D = Actions.C, Actions.D
 
@@ -92,6 +94,39 @@ class TwoTitsForTat(Player):
     def strategy(opponent: Player) -> Action:
         return D if D in opponent.history[-2:] else C
 
+class DynamicTwoTitsForTat(Player):
+    """A player starts by cooperating and then mimics previous move by 
+    opponent with a dynamic bias based off of the opponents ratio of 
+    cooperations to total moves (so their current probability of 
+    cooperating towards cooporating regardless of the move 
+    (aka: forgiveness)."""
+
+    name = 'Dynamic Two Tits For Tat'
+    classifier = {
+        'memory_depth': 2,  # Long memory, memory-2
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+    
+    @staticmethod
+    def strategy(opponent):
+		# First move
+        if len(opponent.history) == 0:
+            # Make sure we cooporate first turn
+            return C
+        if D in opponent.history[-2:]:
+            # Probability of turning the other cheek based off of 
+            # opponent's probability of defection
+            if random.random() < (opponent.cooperations / len(opponent.history)):
+                return C
+            else:
+                return D
+        else:
+            return C
 
 class Bully(Player):
     """A player that behaves opposite to Tit For Tat, including first move.

axelrod/tests/strategies/test_titfortat.py

@@ -114,6 +114,34 @@ def test_strategy(self):
         self.versus_test(opponent, expected_actions=actions)
 
 
+class TestDynamicTwoTitsForTat(TestPlayer):
+
+    name = 'Dynamic Two Tits For Tat'
+    player = axelrod.DynamicTwoTitsForTat
+    expected_classifier = {
+        'memory_depth': 2,
+        'stochastic': False,
+        'makes_use_of': set(),
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        self.first_play_test(C)
+        self.second_play_test(rCC=C, rCD=D, rDC=C, rDD=D)
+
+        # Will cooperate if opponent cooperates/.
+        actions = [(C, C), (C, C), (C, C), (C, C), (C, C)]
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions)
+        # Will defect twice when last turn of opponent was defection.
+        opponent = axelrod.MockPlayer(actions=[D, C, C, D, C])
+        actions = [(C, D), (D, C), (D, C), (C, D), (D, C)]
+        self.versus_test(opponent, expected_actions=actions)
+        # Test against defector
+        actions = [(C, D), (D, D), (D, D), (D, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions)
+
 class TestBully(TestPlayer):
 
     name = "Bully"

docs/tutorials/advanced/classification_of_strategies.rst

@@ -69,7 +69,7 @@ range of memory_depth values, we can use the 'min_memory_depth' and
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    49
+    50
 
 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