Fixed spelling, added reference, feedback edits

Author: zewaywong

docs/how-to/heterogeneous_matches.rst

@@ -1,7 +1,7 @@
 .. _heterogeneous-matches:
 
-Heterogeneous Matches
-=====================
+Use custom matches
+===================
 
 Axelrod Matches are homogeneous by nature but can be extended to utilize additional attributes of heterogeneous players. 
 This tutorial indicates how the Axelrod :code:`Match` class can be manipulated in order to play heterogeneous tournaments and Moran processes using country mass as a score modifier.
@@ -17,20 +17,20 @@ The following lines of code creates a list of players from the available demo st
 Using the :code:`setattr()` method, additional attributes can be passed to players to enable access during matches and tournaments without manual modification of individual strategies::
 
     >>> def set_player_mass(players, masses):
-    >>> """Add mass attribute to player strategy classes to be accessable via self.mass"""
-    >>>     for player, mass in zip(players, masses):
-    >>>         setattr(player, "mass", mass)
-    >>>
+    ...     """Add mass attribute to player strategy classes to be accessable via self.mass"""
+    ...     for player, mass in zip(players, masses):
+    ...         setattr(player, "mass", mass)
+    ...
     >>> set_player_mass(players, masses)
 
 The :code:`Match` class can be partially altered to enable different behaviour. Here we extend :code:`axl.Match` and overwrite its :code:`final_score_per_turn()`
-function to utilize the player mass attribute als a multiplier for the final score::
+function to utilize the player mass attribute as a multiplier for the final score::
 
     >>> class MassBaseMatch(axl.Match):
-    >>> """Axelrod Match object with a modified final score function to enable mass to influence the final score as a multiplier"""
-    >>> def final_score_per_turn(self):
-    >>>     base_scores = axl.Match.final_score_per_turn(self)
-    >>>     return [player.mass * score for player, score in zip(self.players, base_scores)] 
+    ...     """Axelrod Match object with a modified final score function to enable mass to influence the final score as a multiplier"""
+    ...     def final_score_per_turn(self):
+    ...         base_scores = axl.Match.final_score_per_turn(self)
+    ...         return [player.mass * score for player, score in zip(self.players, base_scores)] 
 
 We can now create a tournament like we normally would and pass our custom :code:`MassBaseMatch` to the tournament with the :code:`match_class` keyword argument::
 
@@ -39,22 +39,17 @@ We can now create a tournament like we normally would and pass our custom :code:
     >>> print(results.ranked_names)
     ['Defector', 'Grudger', 'Tit For Tat', 'Cooperator', 'Random: 0.5']
 
-Additionally, Moran Processes can also be altered to incorporate heterogeneous matches. In order to 
-use our previously defined :code:`MassBaseMatch`, we require one additional change to the :code:`MoranProcess` class::
+Similarly to [Krapohl2020] we are going to assign a mass to each individual for a Moran process.
+This requires us to build a specific match class:
 
     >>> class MassBasedMoranProcess(axl.MoranProcess):
-    >>> """Axelrod MoranProcess class """
-    >>> def __next__(self):
-    >>>     set_player_mass(self.players, masses)
-    >>>     super().__next__()
-    >>>     return self
+    ...     """Axelrod MoranProcess class """
+    ...     def __next__(self):
+    ...         set_player_mass(self.players, masses)
+    ...         super().__next__()
+    ...         return self
 
-With this code snippet we can override the :code:`__next__()` call within the MoranProcess to include :code:`set_player_mass()` 
-every round. This ensures that every player has mass attributes after the Moran process is triggered. 
-Subsequently, with :code:`super().__next__()` the base MoranProcess :code:`__next__()` call is triggered. This method enables quick 
-modifications to tournaments and moran processes with minimal repetitive code.
-
-We can now create a Moran process as we normally would, with the inclusion of the match class as a keyword argument::
+In [Krapohl2020] a non standard Moran process is used where the mass of individuals is not reproduced so we will use inheritance to create a new Moran process that keeps the mass of the individuals constant.
 
     >>> mp = MassBasedMoranProcess(players, match_class=MassBaseMatch)
     >>> mp.play()

docs/reference/bibliography.rst

@@ -35,6 +35,7 @@ documentation.
 .. [Hilbe2017] Hilbe, C., Martinez-Vaquero, L. A., Chatterjee K., Nowak M. A. (2017). Memory-n strategies of direct reciprocity, Proceedings of the National Academy of Sciences May 2017, 114 (18) 4715-4720; doi: 10.1073/pnas.1621239114.
 .. [Kuhn2017] Kuhn, Steven, "Prisoner's Dilemma", The Stanford Encyclopedia of Philosophy (Spring 2017 Edition), Edward N. Zalta (ed.), https://plato.stanford.edu/archives/spr2017/entries/prisoner-dilemma/
 .. [Kraines1989] Kraines, David, and Vivian Kraines. "Pavlov and the prisoner's dilemma." Theory and decision 26.1 (1989): 47-79. doi:10.1007/BF00134056
+.. [Krapohl2020] Krapohl, S., Ocelík, V. & Walentek, D.M. The instability of globalization: applying evolutionary game theory to global trade cooperation. Public Choice 188, 31–51 (2021). https://doi.org/10.1007/s11127-020-00799-1
 .. [LessWrong2011] Zoo of Strategies (2011) LessWrong. Available at: http://lesswrong.com/lw/7f2/prisoners_dilemma_tournament_results/
 .. [Li2007] Li, J, How to Design a Strategy to Win an IPD Tournament, in Kendall G., Yao X. and Chong S. (eds.) The iterated prisoner’s dilemma: 20 years on. World Scientific, chapter 4, pp. 29-40, 2007.
 .. [Li2009] Li, J. & Kendall, G. (2009). A Strategy with Novel Evolutionary Features for the Iterated Prisoner’s Dilemma. Evolutionary Computation 17(2): 257–274.