Merge pull request #1099 from Axelrod-Python/mem2_zd

Adds a memory two generalization of a zero determinant strategy

Author: meatballs

axelrod/strategies/_strategies.py

@@ -27,7 +27,7 @@
 from .geller import Geller, GellerCooperator, GellerDefector
 from .gambler import (
     Gambler, PSOGambler1_1_1, PSOGambler2_2_2, PSOGambler2_2_2_Noise05,
-    PSOGamblerMem1)
+    PSOGamblerMem1, ZDMem2)
 from .gobymajority import (GoByMajority,
     GoByMajority10, GoByMajority20, GoByMajority40,
     GoByMajority5,
@@ -87,6 +87,7 @@
 
 # Note: Meta* strategies are handled in .__init__.py
 
+
 all_strategies = [
     Adaptive,
     AdaptiveTitForTat,
@@ -270,6 +271,7 @@
     ZDExtort4,
     ZDGTFT2,
     ZDGen2,
+    ZDMem2,
     ZDMischief,
     ZDSet2,
     e,

axelrod/strategies/gambler.py

@@ -117,3 +117,36 @@ def __init__(self) -> None:
         parameters = Plays(self_plays=2, op_plays=2, op_openings=2)
 
         super().__init__(parameters=parameters, pattern=pattern)
+
+
+class ZDMem2(Gambler):
+    """
+    A memory two generalization of a zero determinant player.
+
+    Names:
+
+    - ZDMem2: Original name by Marc Harper
+    - Unnamed [LiS2014]_
+
+    """
+
+    name = "ZD-Mem2"
+
+    classifier = {
+        'memory_depth': 2,
+        'stochastic': True,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def __init__(self) -> None:
+        pattern = [11 / 12, 4 / 11, 7 / 9, 1 / 10,
+                   5 / 6, 3 / 11, 7 / 9, 1 / 10,
+                   2 / 3, 1 / 11, 7 / 9, 1 / 10,
+                   3 / 4, 2 / 11, 7 / 9, 1 / 10]
+        parameters = Plays(self_plays=2, op_plays=2, op_openings=0)
+
+        super().__init__(parameters=parameters, pattern=pattern)

axelrod/strategies/lookerup.py

@@ -176,8 +176,7 @@ def make_keys_into_plays(lookup_table: dict) -> dict:
     return new_table
 
 
-def create_lookup_table_keys(player_depth: int,
-                             op_depth: int,
+def create_lookup_table_keys(player_depth: int, op_depth: int,
                              op_openings_depth: int) -> list:
     """Returns a list of Plays that has all possible permutations of C's and
     D's for each specified depth. the list is in order,

axelrod/tests/strategies/test_gambler.py

@@ -375,3 +375,67 @@ def test_vs_DCDDC(self):
         self.versus_test(axelrod.MockPlayer(opponent_actions),
                          expected_actions=new_expected,
                          seed=new_seed)
+
+
+class TestZDMem2(TestPlayer):
+    name = "ZD-Mem2"
+    player = axelrod.ZDMem2
+
+    expected_classifier = {
+        'memory_depth': 2,
+        'stochastic': True,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_new_data(self):
+        original_data = {
+            ('', 'CC', 'CC'): 11 /12,
+            ('', 'CC', 'CD'): 4 / 11,
+            ('', 'CC', 'DC'): 7 / 9,
+            ('', 'CC', 'DD'): 1 / 10,
+            ('', 'CD', 'CC'): 5 / 6,
+            ('', 'CD', 'CD'): 3 / 11,
+            ('', 'CD', 'DC'): 7 / 9,
+            ('', 'CD', 'DD'): 1 / 10,
+            ('', 'DC', 'CC'): 2 / 3,
+            ('', 'DC', 'CD'): 1 / 11,
+            ('', 'DC', 'DC'): 7 / 9,
+            ('', 'DC', 'DD'): 1 / 10 ,
+            ('', 'DD', 'CC'): 3 / 4,
+            ('', 'DD', 'CD'): 2 / 11,
+            ('', 'DD', 'DC'): 7 / 9,
+            ('', 'DD', 'DD'): 1 / 10,
+        }
+        converted_original = convert_original_to_current(original_data)
+        self.assertEqual(self.player().lookup_dict, converted_original)
+
+    def test_vs_defector(self):
+        seed = 5
+        expected = [(C, D), (C, D), (D, D), (D, D), (D, D), (D, D), (D, D),
+                    (D, D), (C, D), (D, D)]
+
+        self.versus_test(axelrod.Defector(), expected_actions=expected,
+                         seed=seed)
+
+    def test_vs_cooperator(self):
+        seed = 5
+        expected = [(C, C), (C, C), (C, C), (C, C), (C, C), (D, C), (C, C),
+                    (D, C), (C, C), (C, C)]
+
+        self.versus_test(axelrod.Cooperator(), expected_actions=expected,
+                         seed=seed)
+
+    def test_vs_alternator(self):
+        seed = 2
+        expected = [(C, C), (C, D), (D, C), (D, D), (C, C), (C, D), (D, C)]
+        self.versus_test(axelrod.Alternator(), expected_actions=expected,
+                         seed=seed)
+
+        new_seed = 1
+        expected = [(C, C), (C, D), (C, C), (D, D), (D, C), (C, D), (D, C)]
+        self.versus_test(axelrod.Alternator(), expected_actions=expected,
+                         seed=new_seed)

docs/reference/bibliography.rst

@@ -35,6 +35,7 @@ documentation.
 .. [Li2009] Li, J. & Kendall, G. (2009). A Strategy with Novel Evolutionary Features for the Iterated Prisoner’s Dilemma. Evolutionary Computation 17(2): 257–274.
 .. [Li2011] Li, J., Hingston, P., Member, S., & Kendall, G. (2011). Engineering Design of Strategies for Winning Iterated Prisoner ’ s Dilemma Competitions, 3(4), 348–360.
 .. [Li2014] Li, J. and Kendall, G. (2014). The Effect of Memory Size on the Evolutionary Stability of Strategies in Iterated Prisoner's Dilemma. IEEE Transactions on Evolutionary Computation, 18(6) 819-826
+.. [LiS2014] Li, Siwei. (2014). Strategies in the Stochastic Iterated Prisoner's Dilemma. Available at: http://math.uchicago.edu/~may/REU2014/REUPapers/Li,Siwei.pdf
 .. [Mathieu2015] Mathieu, P. and Delahaye, J. (2015). New Winning Strategies
   for the Iterated Prisoner's Dilemma. Proceedings of the 2015
   International Conference on Autonomous Agents and Multiagent Systems.

docs/tutorials/advanced/classification_of_strategies.rst

@@ -47,7 +47,7 @@ strategies::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    70
+    71
 
 Or, to find out how many strategies only use 1 turn worth of memory to
 make a decision::
@@ -69,7 +69,7 @@ range of memory_depth values, we can use the 'min_memory_depth' and
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    54
+    55
 
 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