Repository: djcunningham0/multielo (language: python)

Issue:
add win probability simulation to MultiElo



Discussion / hints:

Fix patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..863f2af
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,34 @@
+# Change Log
+
+## [0.3.0] -- 2021-11-09
+
+### Added
+
+* Can now handle ties in the MultiElo and Tracker objects.
+
+### Changed
+
+* Refactored how default parameters are set and removed multielo/config.py. Could possibly
+  break old code if you are directly accessing the default values, but impact should be small.
+
+## [0.2.0] -- 2021-04-21
+
+### Added
+
+* Estimate result probabilities with simulate_win_probabilities method in MultiElo class
+* Improved logging, tests, documentation, and other small coding style improvements
+
+### Changed
+
+### Fixed
+
+## [0.1.0] -- 2020-08-02
+
+### Added
+
+* Initial commit
+
+### Changed
+
+### Fixed
+
diff --git a/README.md b/README.md
index 13a1214..67a3652 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,14 @@
 # multielo
 
-This package implements a multiplayer extension of the popular Elo rating
-system.
+This package implements a multiplayer extension of the popular Elo rating system.
 
  * [Installation](#installation)
  * [Example Usage](#example-usage)
  * [Methodology](#methodology)
    * [Traditional Elo ratings](#traditional-elo-ratings)
    * [Extension to multiplayer](#extension-to-multiplayer)
+ 
+For additional information, see the [blog post](https://towardsdatascience.com/developing-a-generalized-elo-rating-system-for-multiplayer-games-b9b495e87802) on Towards Data Science (or try [this link](https://towardsdatascience.com/developing-a-generalized-elo-rating-system-for-multiplayer-games-b9b495e87802?sk=89615c121aa78c7b502e9dce35ece5e1) if you hit a paywall).
 
 ## Installation
 
@@ -17,8 +18,8 @@ The package can be installed from GitHub with using ``pip``.
 pip install git+git://github.com/djcunningham0/multielo.git
 ```
 
-You can install a specific released version of the package using tag names. For
-example, to install release v0.1.0 you can use:
+You can install a specific released version of the package using tag names.
+For example, to install release v0.1.0 you can use:
 
 ```bash
 pip install git+git://github.com/djcunningham0/multielo.git@v0.1.0
@@ -26,189 +27,158 @@ pip install git+git://github.com/djcunningham0/multielo.git@v0.1.0
 
 ## Example Usage
 
-The following example shows how to calculate updated Elo ratings after a 
-matchup using the default settings in the package.
+The following example shows how to calculate updated Elo ratings after a matchup using the default settings in the package.
 
 ```python
->>> from multielo import MultiElo
->>> import numpy as np
->>>
->>> elo = MultiElo()
->>>
->>> # player with 1200 rating beats a player with 1000 rating
->>> elo.get_new_ratings(np.array([1200, 1000]))
-array([1207.68809835,  992.31190165])
->>>
->>> # player with 900 rating beats player with 1000 rating
->>> elo.get_new_ratings(np.array([900, 1000]))
-array([920.48207999, 979.51792001])
->>>
->>> # 3-way matchup
->>> elo.get_new_ratings(np.array([1200, 900, 1000]))
-array([1208.34629612,  910.43382278,  981.21988111])
+from multielo import MultiElo
+import numpy as np
+
+elo = MultiElo()
+
+# player with 1200 rating beats a player with 1000 rating
+elo.get_new_ratings(np.array([1200, 1000]))
+#  array([1207.68809835,  992.31190165])
+
+# player with 900 rating beats player with 1000 rating
+elo.get_new_ratings(np.array([900, 1000]))
+#  array([920.48207999, 979.51792001])
+
+# 3-way matchup
+elo.get_new_ratings(np.array([1200, 900, 1000]))
+#  array([1208.34629612,  910.43382278,  981.21988111])
 ```
 
-See [`demo.ipynb`](https://github.com/djcunningham0/multielo/blob/master/demo.ipynb) 
-for a more in-depth tutorial, including details on parameters that can be tuned
-in the Elo algorithm and examples of how to use the Tracker and Player objects 
-to keep track of Elo ratings for a group of players over time.
+See [`demo.ipynb`](demo.ipynb) for a more in-depth tutorial, including details on parameters that can be tuned in the Elo algorithm and examples of how to use the Tracker and Player objects to keep track of Elo ratings for a group of players over time.
 
 ## Methodology
 
-*Note: This multiplayer extension isn't very mathematically or statistically
-rigorous. It seems to work reasonably well, but I don't think the rating values
-are as interpretable as traditional Elo. Send me a note or open an issue if you
-have ideas for improving the methodology.*
+*Note: This multiplayer extension isn't very mathematically or statistically rigorous.
+It seems to work reasonably well, but I don't think the rating values are as interpretable as traditional Elo.
+Send me a note or open an issue if you have ideas for improving the methodology.*
 
 ### Traditional Elo ratings
 
-Traditional Elo ratings only apply to 1-on-1 matchups. The new ratings for the
-players involved in a matchup are calculated from:
+Traditional Elo ratings only apply to 1-on-1 matchups. The new ratings for the players involved in a matchup are calculated from:
 1. The initial ratings before the matchup.
 2. The matchup result.
 
 There are also a few parameters that must be set for an Elo rating system:
 1. *K* controls how many Elo rating points are gained or lost in a single game.
-Larger *K* results in larger changes after each matchup. A commonly used value
-is *K* = 32.
-2. *D* controls the estimated win probability of each player. A commonly used 
-value is *D* = 400, which means that a player with a 200-point Elo advantage is
-expected to win ~75% of the time. A smaller *D* value means the player with the
-higher Elo rating has a higher estimated win probability.
+Larger *K* results in larger changes after each matchup.
+A commonly used value is *K* = 32.
+2. *D* controls the estimated win probability of each player.
+A commonly used value is *D* = 400, which means that a player with a 200-point Elo advantage is expected to win ~75% of the time.
+A smaller *D* value means the player with the higher Elo rating has a higher estimated win probability.
 
-Suppose we have two players, *A* and *B*, with initial ratings *R<sub>A</sub>* 
-and *R<sub>B</sub>*, respectively. We calculate an "expected score" for each 
-player according to those ratings. The expected score for player *A* is:
+Suppose we have two players, *A* and *B*, with initial ratings *R<sub>A</sub>* and *R<sub>B</sub>*, respectively.
+We calculate an "expected score" for each player according to those ratings.
+The expected score for player *A* is:
 
 ![equation](https://latex.codecogs.com/png.latex?E_A%20%3D%20%5Cfrac%7B1%7D%7B1%20&plus;%2010%5E%7B%28R_B%20-%20R_A%29%20/%20D%7D%7D)
 
 and the expected score for player *B* is defined similarly. 
 
-To calculate the players' new ratings, we compare these expected scores with 
-the "actual scores", or the matchup result. The actual score for player *A* is:
+To calculate the players' new ratings, we compare these expected scores with the "actual scores", or the matchup result.
+The actual score for player *A* is:
 
 ![equation](https://latex.codecogs.com/png.latex?S_A%20%3D%20%5Cleft%5C%7B%5Cbegin%7Bmatrix%7D%201%20%26%20%5Ctext%7Bplayer%20%5Ctextit%7BA%7D%20wins%7D%20%5C%5C%200%20%26%20%5Ctext%7Bplayer%20%5Ctextit%7BA%7D%20loses%7D%20%5Cend%7Bmatrix%7D%5Cright.)
 
-Then the new rating for player *A*, *R'<sub>A</sub>*, is calculated from the
-initial rating, expected score, and actual score:
+Then the new rating for player *A*, *R'<sub>A</sub>*, is calculated from the initial rating, expected score, and actual score:
 
 ![equation](https://latex.codecogs.com/png.latex?R%27_A%20%3D%20R_A&plus;K%28S_A%20-%20E_A%29)
 
 ### Extension to multiplayer
 
-At minimum, a reasonable extension of Elo to multiplayer matchups should have 
-the following properties:
+At minimum, a reasonable extension of Elo to multiplayer matchups should have the following properties:
 1. Changes in ratings should be zero sum, just like traditional Elo.
-2. Coming in first place is better (improves your rating more) than coming in
-second place, is better than third place, and so on. Losing (coming in last 
-place) cannot improve your rating.
-3. It should converge to traditional Elo when there are only two players in the
-matchup.
+2. Coming in first place is better (improves your rating more) than coming in second place, is better than third place, and so on. 
+Losing (coming in last place) cannot improve your rating.
+3. It should converge to traditional Elo when there are only two players in the matchup.
 
 **Expected scores**
 
-The first issue we must address is that the Elo expected score calculation only
-involves the ratings of two players. In order to generalize this calculation to
-multiplayer matchups, we can treat a single multiplayer matchup as a 
-combination set of all pairwise 1-on-1 matchups between every player involved. 
+The first issue we must address is that the Elo expected score calculation only involves the ratings of two players.
+In order to generalize this calculation to multiplayer matchups, we can treat a single multiplayer matchup as a combination set of all pairwise 1-on-1 matchups between every player involved. 
 Specifically, in a multiplayer matchup with *N* players there would be
 
 ![equation](https://latex.codecogs.com/png.latex?%5Cfrac%7BN%28N-1%29%7D%7B2%7D)
 
 pairwise 1-on-1 matchups between the players.
 
-To calculate each player's expected score for the multiplayer matchup, first we
-calculate that player's expected score for each individual matchup just as with
-traditional Elo. Then we scale the scores by *N(N-1)/2* so that the expected 
-scores for all players sum to 1 (the expected scores are meant to represent 
+To calculate each player's expected score for the multiplayer matchup, first we calculate that player's expected score for each individual matchup just as with traditional Elo.
+Then we scale the scores by *N(N-1)/2* so that the expected scores for all players sum to 1 (the expected scores are meant to represent 
 probabilities so they must sum to 1).
 
-The full expression for the expected score for player *A* in a multiplayer 
-matchup with *N* players is:
+The full expression for the expected score for player *A* in a multiplayer matchup with *N* players is:
 
 ![equation](https://latex.codecogs.com/png.latex?E_A%20%3D%20%5Cfrac%7B%5Csum_%7B1%20%5Cle%20i%20%5Cle%20N%2C%20i%20%5Cne%20A%7D%20%5Cfrac%7B1%7D%7B1%20&plus;%2010%5E%7B%28R_i%20-%20R_A%29/D%7D%7D%7D%7B%5Cfrac%7BN%28N-1%29%7D%7B2%7D%7D)
 
 **Actual scores**
 
 The "actual scores" in traditional are binary: 1 point for a win, 0 for a loss.
-In a multiplayer matchup there are more than two options, so we need a 
-different definition for actual scores. We can introduce the idea of a "score
-function", where the actual score for player *A* is given by:
+In a multiplayer matchup there are more than two options, so we need a different definition for actual scores.
+We can introduce the idea of a "score function", where the actual score for player *A* is given by:
 
 ![equation](https://latex.codecogs.com/png.latex?S_A%20%3D%20%5Cleft%5C%7B%5Cbegin%7Bmatrix%7D%20s_1%20%26%20%5Ctext%7Bplayer%20%5Ctextit%7BA%7D%20finishes%201st%20out%20of%20%5Ctextit%7Bn%7D%7D%20%5C%5C%20s_2%20%26%20%5Ctext%7Bplayer%20%5Ctextit%7BA%7D%20finishes%202nd%20out%20of%20%5Ctextit%7Bn%7D%7D%20%5C%5C%20%5Cdots%20%26%20%5Cdots%20%5C%5C%20s_n%20%26%20%5Ctext%7Bplayer%20%5Ctextit%7BA%7D%20finishes%20%5Ctextit%7Bn%7Dth%20out%20of%20%5Ctextit%7Bn%7D%7D%20%5Cend%7Bmatrix%7D%5Cright.)
 
 This scoring function should have a few properties:
 1. The scores must sum to 1 to match the expected scores.
-2. The scores should be monotonically decreasing. That is, 1st place should 
-have a higher score than 2nd, which has a higher score than 3rd, and so on.
-3. Last place should have a score of 0 because a last-place finish should
-never improve a player's rating.
+2. The scores should be monotonically decreasing. 
+That is, 1st place should have a higher score than 2nd, which has a higher score than 3rd, and so on.
+3. Last place should have a score of 0 because a last-place finish should never improve a player's rating.
 
 Note that when there are only two players, the only score function that
 satisfies all three conditions is the binary definition.
 
-With more than two players, there are many possible score functions that
-satisfy all three conditions. Perhaps the most natural score function is what 
-is defined in this implementation as a *linear score function*:
+With more than two players, there are many possible score functions that satisfy all three conditions.
+Perhaps the most natural score function is what is defined in this implementation as a *linear score function*:
 
 ![equation](https://latex.codecogs.com/png.latex?S_A%5E%7Blinear%7D%20%3D%20%5Cfrac%7BN%20-%20p_A%7D%7BN%28N-1%29/2%7D)
 
-where *N* is the number of players and *p<sub>A</sub>* is the place that player
-*A* finishes in (1 for first place, 2 for second, and so on). For example, with
-five players, the actual scores awarded to the players in order of finish are 
-[0.4, 0.3, 0.2, 0.1, 0]. When using the linear score function, each improvement
-in place is weighted equally. That is, improving from second to first has the 
-same impact to the player's actual score as improving from third to second, and
-so on.
+where *N* is the number of players and *p<sub>A</sub>* is the place that player *A* finishes in (1 for first place, 2 for second, and so on). 
+For example, with five players, the actual scores awarded to the players in order of finish are [0.4, 0.3, 0.2, 0.1, 0].
+When using the linear score function, each improvement in place is weighted equally. 
+That is, improving from second to first has the same impact to the player's actual score as improving from third to second, and so on.
 
 In some cases it may be of interest to give more value to the top finishers. 
-For example, in a poker game where only the top three finishers are paid out,
-it may be optimal for players to take risks that improve their chances of
-coming in first place rather than minimizing their chance of finishing in last.
-That is, players will try to finish at the top, but there is very little 
-real-world difference in finishing in last rather than second-to-last. One
-solution to these cases is to use what is defined in this implementation as an
-*exponential score function*:
+For example, in a poker game where only the top three finishers are paid out, it may be optimal for players to take risks that improve their chances of coming in first place rather than minimizing their chance of finishing in last.
+That is, players will try to finish at the top, but there is very little real-world difference in finishing in last rather than second-to-last.
+One solution to these cases is to use what is defined in this implementation as an *exponential score function*:
 
 ![equation](https://latex.codecogs.com/png.latex?S_A%5E%7Bexp%7D%20%3D%20%5Cfrac%7B%5Calpha%5E%7BN-p_A%7D%20-%201%7D%7B%5Csum_%7Bi%3D1%7D%5E%7BN%7D%28%5Calpha%5E%7BN-i%7D%20-%201%29%7D)
 
-where *N* is the number of players, *p<sub>A</sub>* is the place that player 
-*A* finishes in, and ![equation](https://latex.codecogs.com/png.latex?%5Calpha) 
-is the "base" of the score function. When ![equation](https://latex.codecogs.com/png.latex?%5Calpha%20%3E%201),
-this score function places extra weight on finishing in the top places. For
-example, when ![equation](https://latex.codecogs.com/png.latex?%5Calpha%20%3D%201.5)
-and there are five players, the actual scores awarded to the players in order 
-of finish are approximately [0.496, 0.290, 0.153, 0.061, 0]. A larger 
-![equation](https://latex.codecogs.com/png.latex?%5Calpha) value increases the 
-benefit to finishing in the top places. 
+where *N* is the number of players, *p<sub>A</sub>* is the place that player *A* finishes in, and ![equation](https://latex.codecogs.com/png.latex?%5Calpha) is the "base" of the score function.
+When ![equation](https://latex.codecogs.com/png.latex?%5Calpha%20%3E%201), this score function places extra weight on finishing in the top places.
+For example, when ![equation](https://latex.codecogs.com/png.latex?%5Calpha%20%3D%201.5) and there are five players, the actual scores awarded to the players in order of finish are approximately [0.496, 0.290, 0.153, 0.061, 0].
+A larger ![equation](https://latex.codecogs.com/png.latex?%5Calpha) value increases the benefit to finishing in the top places. 
 
-The chart below shows how three different score functions would assign actual 
-scores in a 5-player matchup.
+The chart below shows how three different score functions would assign actual scores in a 5-player matchup.
 
 ![image](images/score_function_plot.png)
 
-It is also worth noting that as ![equation](https://latex.codecogs.com/png.latex?%5Calpha) 
-approaches 1, the exponential score function converges to the linear score
-function.
+It is also worth noting that as ![equation](https://latex.codecogs.com/png.latex?%5Calpha) approaches 1, the exponential score function converges to the linear score function.
 
-The ![equation](https://latex.codecogs.com/png.latex?%5Calpha) value in the 
-exponential score function corresponds to the score_function_base parameter of
-the `MultiElo` object in this package.
+The ![equation](https://latex.codecogs.com/png.latex?%5Calpha) value in the exponential score function corresponds to the score_function_base parameter of the `MultiElo` object in this package.
 
 **Calculating new ratings**
 
-The new rating calculation is very similar to traditional Elo. We compare the
-actual and expected scores for a player, scale that difference by a constant
-factor, and then add it to the player's initial rating. The only difference is
-that rather than scaling by *K*, for a matchup with *N* players we scale by *K* 
-times *N-1*. That is,
+The new rating calculation is very similar to traditional Elo.
+We compare the actual and expected scores for a player, scale that difference by a constant factor, and then add it to the player's initial rating.
+The only difference is that rather than scaling by *K*, for a matchup with *N* players we scale by *K* times *N-1*. That is,
 
 ![equation](https://latex.codecogs.com/png.latex?R%27_A%20%3D%20R_A%20&plus;%20K%28N-1%29%28S_A%20-%20E_A%29)
 
-The additional scaling by *N-1* isn't completely necessary if every matchup
-always has the same number of players -- in that case we could simply use a
-larger value of *K*. But in a scenario where some matchups have different
-number of players, it is important to have larger Elo rating changes in 
-larger matchups. For example, 1st place in a 10-player matchup should result in
-a larger rating increase than 1st place in a 5-player matchup. Scaling by the
-number of players accomplishes this.
\ No newline at end of file
+The additional scaling by *N-1* isn't completely necessary if every matchup always has the same number of players -- in that case we could simply use a larger value of *K*.
+But in a scenario where some matchups have different number of players, it is important to have larger Elo rating changes in 
+larger matchups.
+For example, 1st place in a 10-player matchup should result in a larger rating increase than 1st place in a 5-player matchup.
+Scaling by the number of players accomplishes this.
+
+### Ties
+
+As of version 0.3.0, this Elo implementation handles ties (for both standard and multiplayer Elo).
+See [`demo.ipynb`](demo.ipynb) for syntax.
+
+The only difference in calculation is that the actual scores are averaged between all players who tied.
+In standard Elo this means both players receive an actual score of 0.5.
+In multiplayer Elo, the exact actual scores depend on the scoring function and number of players.
\ No newline at end of file
diff --git a/demo.ipynb b/demo.ipynb
index f4e0191..57bcb07 100644
--- a/demo.ipynb
+++ b/demo.ipynb
@@ -28,9 +28,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Elo has a few parameters that need to be set. I picked some arbitrary but pretty standard values. (Except the scoring function -- that isn't part of standard 1-vs-1 Elo.)\n",
-    "\n",
-    "The parameters are discussed in more detail in the README."
+    "Suppose we have a matchup where a player with an Elo rating of 1200 beats a player with an Elo rating of 1000. We can use the get_new_ratings method to calculate the new Elo ratings for those players. The ratings should be listed in the order of finish."
    ]
   },
   {
@@ -41,10 +39,7 @@
     {
      "data": {
       "text/plain": [
-       "{'INITIAL_RATING': 1000,\n",
-       " 'K_VALUE': 32,\n",
-       " 'D_VALUE': 400,\n",
-       " 'SCORING_FUNCTION_BASE': 1}"
+       "array([1207.68809835,  992.31190165])"
       ]
      },
      "execution_count": 2,
@@ -53,16 +48,17 @@
     }
    ],
    "source": [
-    "from multielo.multielo import defaults\n",
+    "result = [1200, 1000]\n",
     "\n",
-    "defaults"
+    "elo = MultiElo()  # uses the default parameter values if nothing is supplied\n",
+    "elo.get_new_ratings(result)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Suppose we have a matchup where a player with an Elo rating of 1200 beats a player with an Elo rating of 1000. We can use the get_new_ratings method to calculate the new Elo ratings for those players. The ratings should be listed in the order of finish."
+    "We can pass different parameter values to the MultiElo object if we don't want to use the default values."
    ]
   },
   {
@@ -73,7 +69,7 @@
     {
      "data": {
       "text/plain": [
-       "array([1207.68809835,  992.31190165])"
+       "array([1223.03584001,  976.96415999])"
       ]
      },
      "execution_count": 3,
@@ -82,17 +78,15 @@
     }
    ],
    "source": [
-    "result = [1200, 1000]\n",
-    "\n",
-    "elo = MultiElo()  # uses the default parameter values if nothing is supplied\n",
-    "elo.get_new_ratings(result)"
+    "elo_custom = MultiElo(k_value=64, d_value=800)\n",
+    "elo_custom.get_new_ratings(result)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can pass different parameter values to the MultiElo object if we don't want to use the default values."
+    "We can also use the get_expected_scores method to get the expected scores for each player (in 1-on-1 matchups, this can be interpreted as the predicted win probability)."
    ]
   },
   {
@@ -103,7 +97,7 @@
     {
      "data": {
       "text/plain": [
-       "array([1223.03584001,  976.96415999])"
+       "array([0.75974693, 0.24025307])"
       ]
      },
      "execution_count": 4,
@@ -112,51 +106,43 @@
     }
    ],
    "source": [
-    "elo_custom = MultiElo(k_value=64, d_value=800)\n",
-    "elo_custom.get_new_ratings(result)"
+    "elo.get_expected_scores(result)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can also use the get_expected_scores method to get the expected scores for each player (in 1-on-1 matchups, this can be interpreted as the predicted win probability)."
+    "We can calculate expected scores and new Elo ratings for multiplayer matchups using the same `MultiElo` object. The methodology behind this implementation of multiplayer Elo is described in the README. In this four-player example, a player with a 1200 rating comes in 1st, 1000 comes in second, 800 comes in third, and 900 comes in last."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "multiplayer_result = [1200, 1000, 800, 900]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([0.75974693, 0.24025307])"
+       "array([1207.71426754, 1005.75896   ,  804.94244537,  881.58432708])"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "elo.get_expected_scores(result)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can calculate expected scores and new Elo ratings for multiplayer matchups using the same `MultiElo` object. The methodology behind this implementation of multiplayer Elo is described in the README. In this four-player example, a player with a 1200 rating comes in 1st, 1000 comes in second, 800 comes in third, and 900 comes in last."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "multiplayer_result = [1200, 1000, 800, 900]"
+    "elo.get_new_ratings(multiplayer_result)"
    ]
   },
   {
@@ -167,7 +153,7 @@
     {
      "data": {
       "text/plain": [
-       "array([1207.71426754, 1005.75896   ,  804.94244537,  881.58432708])"
+       "array([0.41964305, 0.27334417, 0.11518286, 0.19182993])"
       ]
      },
      "execution_count": 7,
@@ -176,7 +162,15 @@
     }
    ],
    "source": [
-    "elo.get_new_ratings(multiplayer_result)"
+    "# the expected scores are less interpretable than the 1-on-1 case\n",
+    "elo.get_expected_scores(multiplayer_result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Given the ratings of all players involved in a game, we can estimate the probability of each player finishing in each possible place (1st, 2nd, ..., last). **Note:** This calculation is done using a simulation so the probabilities will not be exact and they may change if you use a different random seed."
    ]
   },
   {
@@ -187,7 +181,10 @@
     {
      "data": {
       "text/plain": [
-       "array([0.41964305, 0.27334417, 0.11518286, 0.19182993])"
+       "array([[0.62761, 0.27606, 0.08349, 0.01284],\n",
+       "       [0.19688, 0.37268, 0.30019, 0.13025],\n",
+       "       [0.06217, 0.13046, 0.24477, 0.5626 ],\n",
+       "       [0.11334, 0.2208 , 0.37155, 0.29431]])"
       ]
      },
      "execution_count": 8,
@@ -196,8 +193,47 @@
     }
    ],
    "source": [
-    "# the expected scores are less interpretable than the 1-on-1 case\n",
-    "elo.get_expected_scores(multiplayer_result)"
+    "# (i, j) value is probability that player i finishes in place j\n",
+    "elo.simulate_win_probabilities([1200, 1000, 800, 900])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Default parameter values"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As alluded to above, Elo has a few parameters that need to be set. I picked some arbitrary but pretty standard values. (Except the scoring function -- that isn't part of standard 1-vs-1 Elo.)\n",
+    "\n",
+    "The parameters are discussed in more detail in the README."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DEFAULT_K_VALUE: 32\n",
+      "DEFAULT_D_VALUE: 400\n",
+      "DEFAULT_SCORING_FUNCTION_BASE: 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "from multielo.multielo import DEFAULT_K_VALUE, DEFAULT_D_VALUE, DEFAULT_SCORING_FUNCTION_BASE\n",
+    "\n",
+    "print(f\"DEFAULT_K_VALUE: {DEFAULT_K_VALUE}\")\n",
+    "print(f\"DEFAULT_D_VALUE: {DEFAULT_D_VALUE}\")\n",
+    "print(f\"DEFAULT_SCORING_FUNCTION_BASE: {DEFAULT_SCORING_FUNCTION_BASE}\")"
    ]
   },
   {
@@ -272,8 +308,8 @@
     {
      "data": {
       "text/plain": [
-       "(Player(id = player_A, rating = 1000, n_games = 0),\n",
-       " Player(id = player_B, rating = 1200, n_games = 0))"
+       "(Player(id = player_A, rating = 1000.00, n_games = 0),\n",
+       " Player(id = player_B, rating = 1200.00, n_games = 0))"
       ]
      },
      "execution_count": 11,
@@ -300,7 +336,7 @@
     {
      "data": {
       "text/plain": [
-       "Player(id = player_A, rating = 1075, n_games = 2)"
+       "Player(id = player_A, rating = 1075.00, n_games = 2)"
       ]
      },
      "execution_count": 12,
@@ -745,40 +781,137 @@
    "cell_type": "code",
    "execution_count": 20,
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "import altair as alt\n",
+    "alt.renderers.enable(\"mimetype\");"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "application/vnd.vegalite.v4+json": {
+       "$schema": "https://vega.github.io/schema/vega-lite/v4.8.1.json",
+       "config": {
+        "view": {
+         "continuousHeight": 300,
+         "continuousWidth": 400
+        }
+       },
+       "data": {
+        "name": "data-b5da5ce2817c5050c9c29e21a4a3d7bb"
+       },
+       "datasets": {
+        "data-b5da5ce2817c5050c9c29e21a4a3d7bb": [
+         {
+          "date": "2020-03-29",
+          "player_id": "Bart",
+          "rating": 978.6666666666666
+         },
+         {
+          "date": "2020-04-05",
+          "player_id": "Bart",
+          "rating": 980.6241719618897
+         },
+         {
+          "date": "2020-04-12",
+          "player_id": "Bart",
+          "rating": 958.4036878228786
+         },
+         {
+          "date": "2020-03-29",
+          "player_id": "Homer",
+          "rating": 1021.3333333333334
+         },
+         {
+          "date": "2020-04-05",
+          "player_id": "Homer",
+          "rating": 998.0424947047769
+         },
+         {
+          "date": "2020-04-12",
+          "player_id": "Homer",
+          "rating": 990.2223209086937
+         },
+         {
+          "date": "2020-04-05",
+          "player_id": "Lisa",
+          "rating": 1021.3333333333334
+         },
+         {
+          "date": "2020-04-12",
+          "player_id": "Lisa",
+          "rating": 1043.3741452572547
+         },
+         {
+          "date": "2020-04-19",
+          "player_id": "Lisa",
+          "rating": 1025.7507044362778
+         },
+         {
+          "date": "2020-03-29",
+          "player_id": "Marge",
+          "rating": 1000
+         },
+         {
+          "date": "2020-04-12",
+          "player_id": "Marge",
+          "rating": 1007.9998460111731
+         },
+         {
+          "date": "2020-04-19",
+          "player_id": "Marge",
+          "rating": 1025.62328683215
+         }
+        ]
+       },
+       "encoding": {
+        "color": {
+         "field": "player_id",
+         "type": "nominal"
+        },
+        "x": {
+         "field": "date",
+         "type": "temporal"
+        },
+        "y": {
+         "field": "rating",
+         "scale": {
+          "zero": false
+         },
+         "type": "quantitative"
+        }
+       },
+       "mark": {
+        "point": true,
+        "type": "line"
+       }
+      },
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
+       "<VegaLite 4 object>\n",
+       "\n",
+       "If you see this message, it means the renderer has not been properly enabled\n",
+       "for the frontend that you are using. For more information, see\n",
+       "https://altair-viz.github.io/user_guide/troubleshooting.html\n"
       ]
      },
+     "execution_count": 21,
      "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n"
-     ]
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "# this package emulates the ggplot2 R package in python\n",
-    "# plotting in R >>>>>> plotting in python\n",
-    "from plotnine import *\n",
+    "df = tracker.get_history_df()\n",
     "\n",
-    "df = tracker.get_history_df().copy()\n",
-    "df[\"date\"] = pd.to_datetime(df[\"date\"], format=\"%Y-%m-%d\")\n",
-    "print(\n",
-    "    ggplot(df, aes(x=\"date\", y=\"rating\", color=\"player_id\"))\n",
-    "    + geom_line()\n",
-    "    + geom_point()\n",
-    "    + geom_hline(yintercept=defaults[\"INITIAL_RATING\"], linetype=\"dashed\", alpha=0.5)\n",
-    "    + labs(title=\"Elo ratings over time\")\n",
-    "    + theme_light()\n",
-    "    + theme(axis_text_x=element_text(angle=90, hjust=1))\n",
+    "alt.Chart(df).mark_line(point=True).encode(\n",
+    "    x=\"date:T\",\n",
+    "    y=alt.Y(\"rating:Q\", scale=alt.Scale(zero=False)),\n",
+    "    color=\"player_id:N\",\n",
     ")"
    ]
   },
@@ -786,20 +919,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can add verbose output from the process_data method by setting the logging level to INFO. The changes in Elo after each step will be printed to the screen (or the specified output device)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import logging\n",
-    "\n",
-    "logging.basicConfig()\n",
-    "logger = logging.getLogger(\"my_logger\")\n",
-    "logger.setLevel(logging.INFO)"
+    "By default, the `Tracker` object uses a `MultiElo` object with all default settings to calculate changes in Elo rating. The user can alternatively pass in a `MultiElo` object with any settings, which will affect the results. For example, larger K means rankings change more in each individual matchup."
    ]
   },
   {
@@ -807,33 +927,6 @@
    "execution_count": 22,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:my_logger:Created Tracker with Elo paramers K=32, D=400\n",
-      "INFO:my_logger:created player with ID Homer and rating 1000\n",
-      "INFO:my_logger:created player with ID Marge and rating 1000\n",
-      "INFO:my_logger:created player with ID Bart and rating 1000\n",
-      "INFO:my_logger:processing rating changes for date 2020-03-29...\n",
-      "INFO:my_logger:Updating rating for Homer: 1000.000 --> 1021.333\n",
-      "INFO:my_logger:Updating rating for Marge: 1000.000 --> 1000.000\n",
-      "INFO:my_logger:Updating rating for Bart: 1000.000 --> 978.667\n",
-      "INFO:my_logger:created player with ID Lisa and rating 1000\n",
-      "INFO:my_logger:processing rating changes for date 2020-04-05...\n",
-      "INFO:my_logger:Updating rating for Lisa: 1000.000 --> 1021.333\n",
-      "INFO:my_logger:Updating rating for Bart: 978.667 --> 980.624\n",
-      "INFO:my_logger:Updating rating for Homer: 1021.333 --> 998.042\n",
-      "INFO:my_logger:processing rating changes for date 2020-04-12...\n",
-      "INFO:my_logger:Updating rating for Lisa: 1021.333 --> 1043.374\n",
-      "INFO:my_logger:Updating rating for Marge: 1000.000 --> 1008.000\n",
-      "INFO:my_logger:Updating rating for Homer: 998.042 --> 990.222\n",
-      "INFO:my_logger:Updating rating for Bart: 980.624 --> 958.404\n",
-      "INFO:my_logger:processing rating changes for date 2020-04-19...\n",
-      "INFO:my_logger:Updating rating for Marge: 1008.000 --> 1025.623\n",
-      "INFO:my_logger:Updating rating for Lisa: 1043.374 --> 1025.751\n"
-     ]
-    },
     {
      "data": {
       "text/html": [
@@ -865,30 +958,30 @@
        "    <tr>\n",
        "      <th>0</th>\n",
        "      <td>1</td>\n",
-       "      <td>Lisa</td>\n",
+       "      <td>Marge</td>\n",
        "      <td>3</td>\n",
-       "      <td>1025.750704</td>\n",
+       "      <td>1117.029251</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>2</td>\n",
-       "      <td>Marge</td>\n",
+       "      <td>Lisa</td>\n",
        "      <td>3</td>\n",
-       "      <td>1025.623287</td>\n",
+       "      <td>1065.955505</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
        "      <td>3</td>\n",
        "      <td>Homer</td>\n",
        "      <td>3</td>\n",
-       "      <td>990.222321</td>\n",
+       "      <td>948.872182</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
        "      <td>4</td>\n",
        "      <td>Bart</td>\n",
        "      <td>3</td>\n",
-       "      <td>958.403688</td>\n",
+       "      <td>868.143061</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -896,10 +989,10 @@
       ],
       "text/plain": [
        "   rank player_id  n_games       rating\n",
-       "0     1      Lisa        3  1025.750704\n",
-       "1     2     Marge        3  1025.623287\n",
-       "2     3     Homer        3   990.222321\n",
-       "3     4      Bart        3   958.403688"
+       "0     1     Marge        3  1117.029251\n",
+       "1     2      Lisa        3  1065.955505\n",
+       "2     3     Homer        3   948.872182\n",
+       "3     4      Bart        3   868.143061"
       ]
      },
      "execution_count": 22,
@@ -908,26 +1001,21 @@
     }
    ],
    "source": [
-    "tracker = Tracker(logger=logger)\n",
-    "tracker.process_data(data)\n",
-    "tracker.get_current_ratings()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# turn INFO logging back off\n",
-    "logger.setLevel(logging.WARNING)"
+    "k = 128\n",
+    "bigk_elo = MultiElo(k_value=k)\n",
+    "bigk_tracker = Tracker(elo_rater=bigk_elo)\n",
+    "bigk_tracker.process_data(data)\n",
+    "\n",
+    "bigk_tracker.get_current_ratings()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "By default, the `Tracker` object uses a `MultiElo` object with all default settings to calculate changes in Elo rating. The user can alternatively pass in a `MultiElo` object with any settings, which will affect the results. For example, larger K means rankings change more in each individual matchup."
+    "The chosen scoring function has a large effect on the rankings because it determines the relative value of finishing first, second, third, etc. The default scoring function (the \"linear score function\") used in the example above doesn't provide proportionally more value to finishing first (i.e., moving from 6th to 5th is as good as improving from 2nd to 1st).\n",
+    "\n",
+    "To provide more value to the top finishers, we can use an \"exponential score function\". The example below uses an exponential score function with a base of 1.5. Note that the final rating values are different from the example using the linear score function above."
    ]
   },
   {
@@ -966,30 +1054,30 @@
        "    <tr>\n",
        "      <th>0</th>\n",
        "      <td>1</td>\n",
-       "      <td>Marge</td>\n",
+       "      <td>Lisa</td>\n",
        "      <td>3</td>\n",
-       "      <td>1117.029251</td>\n",
+       "      <td>1035.161374</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>2</td>\n",
-       "      <td>Lisa</td>\n",
+       "      <td>Marge</td>\n",
        "      <td>3</td>\n",
-       "      <td>1065.955505</td>\n",
+       "      <td>1020.663059</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
        "      <td>3</td>\n",
        "      <td>Homer</td>\n",
        "      <td>3</td>\n",
-       "      <td>948.872182</td>\n",
+       "      <td>988.457875</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
        "      <td>4</td>\n",
        "      <td>Bart</td>\n",
        "      <td>3</td>\n",
-       "      <td>868.143061</td>\n",
+       "      <td>955.717692</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -997,10 +1085,10 @@
       ],
       "text/plain": [
        "   rank player_id  n_games       rating\n",
-       "0     1     Marge        3  1117.029251\n",
-       "1     2      Lisa        3  1065.955505\n",
-       "2     3     Homer        3   948.872182\n",
-       "3     4      Bart        3   868.143061"
+       "0     1      Lisa        3  1035.161374\n",
+       "1     2     Marge        3  1020.663059\n",
+       "2     3     Homer        3   988.457875\n",
+       "3     4      Bart        3   955.717692"
       ]
      },
      "execution_count": 24,
@@ -1009,21 +1097,22 @@
     }
    ],
    "source": [
-    "k = 128\n",
-    "bigk_elo = MultiElo(k_value=k)\n",
-    "bigk_tracker = Tracker(elo_rater=bigk_elo)\n",
-    "bigk_tracker.process_data(data)\n",
+    "exp_elo = MultiElo(score_function_base=1.5)\n",
+    "exp_tracker = Tracker(elo_rater=exp_elo)\n",
+    "exp_tracker.process_data(data)\n",
     "\n",
-    "bigk_tracker.get_current_ratings()"
+    "exp_tracker.get_current_ratings()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The chosen scoring function has a large effect on the rankings because it determines the relative value of finishing first, second, third, etc. The default scoring function (the \"linear score function\") used in the example above doesn't provide proportionally more value to finishing first (i.e., moving from 6th to 5th is as good as improving from 2nd to 1st).\n",
+    "# handling ties\n",
     "\n",
-    "To provide more value to the top finishers, we can use an \"exponential score function\". The example below uses an exponential score function with a base of 1.5. Note that the final rating values are different from the example using the linear score function above."
+    "As of version 0.3.0, this Elo implementation can handle ties. The syntax to annotate ties in the `MultiElo` and `Tracker` objects is shown below.\n",
+    "\n",
+    "In `MultiElo`, use the result_order parameter to indicate which place each player finished in, where lower indicates a better finishing position. (Note: the exact values do not matter -- they just need to be increasing)"
    ]
   },
   {
@@ -1031,6 +1120,170 @@
    "execution_count": 25,
    "metadata": {},
    "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1207.68809835,  992.31190165])"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# first player beat the second in a two-player matchup (default)\n",
+    "elo.get_new_ratings([1200, 1000], result_order=[1, 2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1191.68809835, 1008.31190165])"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# two players tied in a two-player matchup\n",
+    "elo.get_new_ratings([1200, 1000], result_order=[1, 1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1196.39812617, 1010.66666667,  792.93520716])"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# tie for first place in three-player matchup\n",
+    "elo.get_new_ratings([1200, 1000, 800], result_order=[1, 1, 2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1207.06479284,  989.33333333,  803.60187383])"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# tie for last place in three-player matchup\n",
+    "elo.get_new_ratings([1200, 1000, 800], result_order=[1, 2, 2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1185.7314595, 1000.       ,  814.2685405])"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# three-way tie in three-player matchup\n",
+    "elo.get_new_ratings([1200, 1000, 800], result_order=[1, 1, 1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# logging"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `MultiElo` and `Tracker` objects have loggers that can optionally output information about the computations. Set the loggers to INFO or DEBUG for verbose output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import logging\n",
+    "\n",
+    "logging.basicConfig()\n",
+    "\n",
+    "logging.getLogger(\"multielo\").setLevel(logging.INFO)\n",
+    "\n",
+    "# Note: This is the default logger, but you can also create your own logger(s) to pass\n",
+    "# to the logger parameter of the MultiElo and Tracker objects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:multielo.player_tracker:Created Tracker with Elo paramers K=32, D=400\n",
+      "INFO:multielo.player_tracker:created player with ID Homer and rating 1000\n",
+      "INFO:multielo.player_tracker:created player with ID Marge and rating 1000\n",
+      "INFO:multielo.player_tracker:created player with ID Bart and rating 1000\n",
+      "INFO:multielo.player_tracker:processing rating changes for date 2020-03-29...\n",
+      "INFO:multielo.player_tracker:Updating rating for Homer: 1000.000 --> 1021.333\n",
+      "INFO:multielo.player_tracker:Updating rating for Marge: 1000.000 --> 1000.000\n",
+      "INFO:multielo.player_tracker:Updating rating for Bart: 1000.000 --> 978.667\n",
+      "INFO:multielo.player_tracker:created player with ID Lisa and rating 1000\n",
+      "INFO:multielo.player_tracker:processing rating changes for date 2020-04-05...\n",
+      "INFO:multielo.player_tracker:Updating rating for Lisa: 1000.000 --> 1021.333\n",
+      "INFO:multielo.player_tracker:Updating rating for Bart: 978.667 --> 980.624\n",
+      "INFO:multielo.player_tracker:Updating rating for Homer: 1021.333 --> 998.042\n",
+      "INFO:multielo.player_tracker:processing rating changes for date 2020-04-12...\n",
+      "INFO:multielo.player_tracker:Updating rating for Lisa: 1021.333 --> 1043.374\n",
+      "INFO:multielo.player_tracker:Updating rating for Marge: 1000.000 --> 1008.000\n",
+      "INFO:multielo.player_tracker:Updating rating for Homer: 998.042 --> 990.222\n",
+      "INFO:multielo.player_tracker:Updating rating for Bart: 980.624 --> 958.404\n",
+      "INFO:multielo.player_tracker:processing rating changes for date 2020-04-19...\n",
+      "INFO:multielo.player_tracker:Updating rating for Marge: 1008.000 --> 1025.623\n",
+      "INFO:multielo.player_tracker:Updating rating for Lisa: 1043.374 --> 1025.751\n"
+     ]
+    },
     {
      "data": {
       "text/html": [
@@ -1064,28 +1317,28 @@
        "      <td>1</td>\n",
        "      <td>Lisa</td>\n",
        "      <td>3</td>\n",
-       "      <td>1035.161374</td>\n",
+       "      <td>1025.750704</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>2</td>\n",
        "      <td>Marge</td>\n",
        "      <td>3</td>\n",
-       "      <td>1020.663059</td>\n",
+       "      <td>1025.623287</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
        "      <td>3</td>\n",
        "      <td>Homer</td>\n",
        "      <td>3</td>\n",
-       "      <td>988.457875</td>\n",
+       "      <td>990.222321</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
        "      <td>4</td>\n",
        "      <td>Bart</td>\n",
        "      <td>3</td>\n",
-       "      <td>955.717692</td>\n",
+       "      <td>958.403688</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -1093,97 +1346,22 @@
       ],
       "text/plain": [
        "   rank player_id  n_games       rating\n",
-       "0     1      Lisa        3  1035.161374\n",
-       "1     2     Marge        3  1020.663059\n",
-       "2     3     Homer        3   988.457875\n",
-       "3     4      Bart        3   955.717692"
+       "0     1      Lisa        3  1025.750704\n",
+       "1     2     Marge        3  1025.623287\n",
+       "2     3     Homer        3   990.222321\n",
+       "3     4      Bart        3   958.403688"
       ]
      },
-     "execution_count": 25,
+     "execution_count": 30,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "exp_elo = MultiElo(score_function_base=1.5)\n",
-    "exp_tracker = Tracker(elo_rater=exp_elo)\n",
-    "exp_tracker.process_data(data)\n",
-    "\n",
-    "exp_tracker.get_current_ratings()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "..."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "These are the packages and versions installed in this environment."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "appnope==0.1.2\n",
-      "attrs==20.3.0\n",
-      "backcall==0.2.0\n",
-      "cycler==0.10.0\n",
-      "decorator==5.0.7\n",
-      "descartes==1.1.0\n",
-      "iniconfig==1.1.1\n",
-      "ipykernel==5.5.3\n",
-      "ipython==7.22.0\n",
-      "ipython-genutils==0.2.0\n",
-      "jedi==0.18.0\n",
-      "jupyter-client==6.1.12\n",
-      "jupyter-core==4.7.1\n",
-      "kiwisolver==1.3.1\n",
-      "matplotlib==3.4.1\n",
-      "mizani==0.7.3\n",
-      "numpy==1.20.2\n",
-      "packaging==20.9\n",
-      "palettable==3.3.0\n",
-      "pandas==1.2.4\n",
-      "parso==0.8.2\n",
-      "patsy==0.5.1\n",
-      "pexpect==4.8.0\n",
-      "pickleshare==0.7.5\n",
-      "Pillow==8.2.0\n",
-      "plotnine==0.8.0\n",
-      "pluggy==0.13.1\n",
-      "prompt-toolkit==3.0.18\n",
-      "ptyprocess==0.7.0\n",
-      "py==1.10.0\n",
-      "Pygments==2.8.1\n",
-      "pyparsing==2.4.7\n",
-      "pytest==6.2.3\n",
-      "python-dateutil==2.8.1\n",
-      "pytz==2021.1\n",
-      "pyzmq==22.0.3\n",
-      "scipy==1.6.2\n",
-      "six==1.15.0\n",
-      "statsmodels==0.12.2\n",
-      "toml==0.10.2\n",
-      "tornado==6.1\n",
-      "traitlets==5.0.5\n",
-      "wcwidth==0.2.5\n",
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    }
-   ],
-   "source": [
-    "pip freeze"
+    "elo = MultiElo()\n",
+    "tracker = Tracker(elo)\n",
+    "tracker.process_data(data)\n",
+    "tracker.get_current_ratings()"
    ]
   }
  ],
@@ -1207,5 +1385,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/multielo/_version.py b/multielo/_version.py
index d3ec452..493f741 100644
--- a/multielo/_version.py
+++ b/multielo/_version.py
@@ -1,1 +1,1 @@
-__version__ = "0.2.0"
+__version__ = "0.3.0"
diff --git a/multielo/config.py b/multielo/config.py
deleted file mode 100644
index cb9e5b4..0000000
--- a/multielo/config.py
+++ /dev/null
@@ -1,6 +0,0 @@
-defaults = {
-    "INITIAL_RATING": 1000,
-    "K_VALUE": 32,
-    "D_VALUE": 400,
-    "SCORING_FUNCTION_BASE": 1,
-}
diff --git a/multielo/multielo.py b/multielo/multielo.py
index 56034fa..c524175 100644
--- a/multielo/multielo.py
+++ b/multielo/multielo.py
@@ -1,9 +1,15 @@
 import numpy as np
-from typing import Union, List
+from typing import Union, List, Callable
 import logging
 
-from .config import defaults
-from .score_functions import create_exponential_score_function
+from multielo.score_functions import create_exponential_score_function
+
+
+DEFAULT_K_VALUE = 32
+DEFAULT_D_VALUE = 400
+DEFAULT_SCORING_FUNCTION_BASE = 1
+
+_default_logger = logging.getLogger("multielo.multielo")
 
 
 class MultiElo:
@@ -14,10 +20,10 @@ class MultiElo:
 
     def __init__(
         self,
-        k_value: float = defaults["K_VALUE"],
-        d_value: float = defaults["D_VALUE"],
-        score_function_base: float = defaults["SCORING_FUNCTION_BASE"],
-        custom_score_function=None,
+        k_value: float = DEFAULT_K_VALUE,
+        d_value: float = DEFAULT_D_VALUE,
+        score_function_base: float = DEFAULT_SCORING_FUNCTION_BASE,
+        custom_score_function: Callable = None,
         log_base: int = 10,
         logger: logging.Logger = None,
     ):
@@ -39,9 +45,13 @@ def __init__(
         self.d = d_value
         self._score_func = custom_score_function or create_exponential_score_function(base=score_function_base)
         self._log_base = log_base
-        self.logger = logger or logging.getLogger(__name__)
+        self.logger = logger or _default_logger
 
-    def get_new_ratings(self, initial_ratings: Union[List[float], np.ndarray]) -> np.ndarray:
+    def get_new_ratings(
+            self,
+            initial_ratings: Union[List[float], np.ndarray],
+            result_order: List[int] = None,
+    ) -> np.ndarray:
         """
         Update ratings based on results. Takes an array of ratings before the matchup and returns an array with
         the updated ratings. Provided array should be ordered by the actual results (first place finisher's
@@ -55,36 +65,58 @@ def get_new_ratings(self, initial_ratings: Union[List[float], np.ndarray]) -> np
         array([1212.01868209, 1012.15595083, 1087.84404917,  887.98131791])
 
         :param initial_ratings: array of ratings (float values) in order of actual results
+        :param result_order: list where each value indicates the place the player in the same index of
+        initial_ratings finished in. Lower is better. Identify ties by entering the same value for players
+        that tied. For example, [1, 2, 3] indicates that the first listed player won, the second listed player
+        finished 2nd, and the third listed player finished 3rd. [1, 2, 2] would indicate that the second
+        and third players tied for 2nd place. (default = range(len(initial_ratings))
         :return: array of updated ratings (float values) in same order as input
         """
         if not isinstance(initial_ratings, np.ndarray):
             initial_ratings = np.array(initial_ratings)
         n = len(initial_ratings)  # number of players
-        actual_scores = self.get_actual_scores(n)
+        actual_scores = self.get_actual_scores(n, result_order)
         expected_scores = self.get_expected_scores(initial_ratings)
         scale_factor = self.k * (n - 1)
         self.logger.debug(f"scale factor: {scale_factor}")
         return initial_ratings + scale_factor * (actual_scores - expected_scores)
 
-    def get_actual_scores(self, n: int) -> np.ndarray:
+    def get_actual_scores(self, n: int, result_order: List[int] = None) -> np.ndarray:
         """
         Return the scores to be awarded to the players based on the results.
 
         :param n: number of players in the matchup
+        :param result_order: list indicating order of finish (see docstring for MultiElo.get_new_ratings
+        for more details
         :return: array of length n of scores to be assigned to first place, second place, and so on
         """
+        # calculate actual scores according to score function, then sort in order of finish
+        result_order = result_order or list(range(n))
         scores = self._score_func(n)
-        self._validate_actual_scores(scores)
+        scores = scores[np.argsort(np.argsort(result_order))]
+
+        # if there are ties, average the scores of all tied players
+        distinct_results = set(result_order)
+        if len(distinct_results) != n:
+            for place in distinct_results:
+                idx = [i for i, x in enumerate(result_order) if x == place]
+                scores[idx] = scores[idx].mean()
+
+        self._validate_actual_scores(scores, result_order)
         self.logger.debug(f"calculated actual scores: {scores}")
         return scores
 
     @staticmethod
-    def _validate_actual_scores(scores: np.ndarray):
+    def _validate_actual_scores(scores: np.ndarray, result_order: List[int]):
         if not np.allclose(1, sum(scores)):
             raise ValueError("scoring function does not return scores summing to 1")
         if min(scores) != 0:
-            raise ValueError("scoring function does not return minimum value of 0")
-        if not np.all(np.diff(scores) < 0):
+            # tie for last place means minimum score doesn't have to be zero,
+            # so only raise error if there isn't a tie for last place
+            last_place = max(result_order)
+            if result_order.count(last_place) == 1:
+                raise ValueError("scoring function does not return minimum value of 0")
+        if not np.all(np.diff(scores[np.argsort(result_order)]) <= 0):
             raise ValueError("scoring function does not return monotonically decreasing values")
 
     def get_expected_scores(self, ratings: Union[List[float], np.ndarray]) -> np.ndarray:
diff --git a/multielo/player_tracker.py b/multielo/player_tracker.py
index 822d26f..a11a59d 100644
--- a/multielo/player_tracker.py
+++ b/multielo/player_tracker.py
@@ -4,8 +4,12 @@
 from typing import Union, List, Tuple
 import logging
 import warnings
-from .multielo import MultiElo
-from .config import defaults
+from multielo.multielo import MultiElo
+
+
+DEFAULT_INITIAL_RATING = 1000
+
+_default_logger = logging.getLogger("multielo.player_tracker")
 
 
 class Player:
@@ -17,7 +21,7 @@ class Player:
     def __init__(
             self,
             player_id: str,
-            rating: float = defaults["INITIAL_RATING"],
+            rating: float = DEFAULT_INITIAL_RATING,
             rating_history: List[Tuple[Union[str, float], float]] = None,
             date: Union[str, float] = None,
             logger: logging.Logger = None,
@@ -39,7 +43,7 @@ def __init__(
         else:
             self.rating_history = rating_history
 
-        self.logger = logger or logging.getLogger(__name__)
+        self.logger = logger or _default_logger
         self.logger.info(f"created player with ID {player_id} and rating {rating}")
 
     def update_rating(self, new_rating: float, date: Union[str, float]):
@@ -56,7 +60,7 @@ def update_rating(self, new_rating: float, date: Union[str, float]):
     def get_rating_as_of_date(
         self,
         date: Union[str, float],
-        default_rating: float = defaults["INITIAL_RATING"]
+        default_rating: float = DEFAULT_INITIAL_RATING
     ) -> float:
         """
         Retrieve a player's rating as of a specified date. Finds an entry in self.rating history for the latest
@@ -96,10 +100,11 @@ def _update_rating_history(self, rating: float, date: Union[str, float]):
         self.rating_history.append((date, rating))
 
     def __str__(self):
-        return f"{self.id}: {round(self.rating, 2)} ({self.count_games()} games)"
+        n_games = self.count_games()
+        return f"{self.id}: {self.rating:.2f} ({n_games} game{'s' * (n_games != 1)})"
 
     def __repr__(self):
-        return f"Player(id = {self.id}, rating = {round(self.rating, 2)}, n_games = {self.count_games()})"
+        return f"Player(id = {self.id}, rating = {self.rating:.2f}, n_games = {self.count_games()})"
 
     def __eq__(self, other):
         return self.rating == other
@@ -127,7 +132,7 @@ class Tracker:
     def __init__(
         self,
         elo_rater: MultiElo = MultiElo(),
-        initial_rating: float = defaults["INITIAL_RATING"],
+        initial_rating: float = DEFAULT_INITIAL_RATING,
         player_df: DataFrame = None,
         logger: logging.Logger = None,
     ):
@@ -149,7 +154,7 @@ def __init__(
         self.player_df = player_df
         self._validate_player_df()
 
-        self.logger = logger or logging.getLogger(__name__)
+        self.logger = logger or _default_logger
         self.logger.info(f"Created Tracker with Elo paramers K={self.elo.k}, D={self.elo.d}")
 
     def process_data(self, matchup_history_df: DataFrame, date_col: str = "date"):
@@ -157,19 +162,64 @@ def process_data(self, matchup_history_df: DataFrame, date_col: str = "date"):
         Process the full matchup history of a group of players. Update the ratings and rating history for all
         players in found in the matchup history.
 
+        Annotate ties using a tuple of player IDs. For example, this data would indicate that Lisa came in
+        first place, Bart and Marge tied for second, and Homer came in 3rd:
+
+        |   date | 1st                        | 2nd               | 3rd   | 4th |
+        |--------|----------------------------|-------------------|-------|-----|
+        |      1 | Lisa                       | ('Bart', 'Marge') | Homer |     |
+
+        Note: Only the order of the players matters, not the specific columns they appear in. For example,
+        Homer could appear in either the 3rd or 4th column in the example data above and the results would
+        be the same.
+
+        Example usage:
+        >>> elo = MultiElo()
+        >>> tracker = Tracker(elo)
+        >>> data = pd.DataFrame([[1, "Lisa", "Homer"], [2, "Marge", "Bart"], [3, "Lisa", "Bart"]])
+        >>> data.columns = ["date", "1st", "2nd"]
+        >>> tracker.process_data(data)
+        >>> tracker.get_current_ratings()
+           rank player_id  n_games       rating
+        0     1      Lisa        2  1030.530498
+        1     2     Marge        1  1016.000000
+        2     3     Homer        1   984.000000
+        3     4      Bart        2   969.469502
+
+
         :param matchup_history_df: dataframe of matchup history with a column for date and one column for each
         possible finishing place (e.g., "date", "1st", "2nd", "3rd", ...). Finishing place columns should be in
-        order of first to last.
+        order of first to last. Column names do not matter.
         :param date_col: name of the date column
         """
         matchup_history_df = matchup_history_df.sort_values(date_col).reset_index(drop=True)
         place_cols = [x for x in matchup_history_df.columns if x != date_col]
         matchup_history_df = matchup_history_df.dropna(how="all", axis=0, subset=place_cols)  # drop rows if all NaN
+
+        # loop through each row of history, then loop through players for each date
         for _, row in matchup_history_df.iterrows():
             date = row[date_col]
-            players = [self._get_or_create_player(row[x]) for x in place_cols if not pd.isna(row[x])]
+            players = []
+            result_order = []
+            for i, col in enumerate(place_cols):
+                current_player = row[col]
+                if current_player is None:
+                    pass
+                elif isinstance(current_player, (tuple, list)):
+                    # multiple players (a tie)
+                    players += [self._get_or_create_player(x) for x in current_player]
+                    result_order += [i] * len(current_player)
+                else:
+                    # one player
+                    players.append(self._get_or_create_player(current_player))
+                    result_order.append(i)
             initial_ratings = np.array([player.rating for player in players])
-            new_ratings = self.elo.get_new_ratings(initial_ratings)
+            self.logger.debug(f"found players: {players}")
+            self.logger.debug(f"found ratings: {list(initial_ratings)}")
+            self.logger.debug(f"found result_order: {result_order}")
+
+            # process data for one date
+            new_ratings = self.elo.get_new_ratings(initial_ratings, result_order=result_order)
             self.logger.info(f"processing rating changes for date {date}...")
             for i, player in enumerate(players):
                 player.update_rating(new_ratings[i], date=date)


Test patch:
diff --git a/tests/test_elo.py b/tests/test_elo.py
index 376c443..10a354b 100644
--- a/tests/test_elo.py
+++ b/tests/test_elo.py
@@ -2,25 +2,7 @@
 from multielo import MultiElo
 import numpy as np
 
-
-def test_elo_defaults():
-    # test if defaults are specified in config.py file
-    try:
-        from multielo.config import defaults
-    except ImportError:
-        assert False, "could not import defaults"
-
-    # test that the expected keys are in defaults
-    expected_keys = [
-        "INITIAL_RATING",
-        "K_VALUE",
-        "D_VALUE",
-        "SCORING_FUNCTION_BASE",
-    ]
-    for key in expected_keys:
-        assert key in defaults, f"{key} is not included in defaults"
-    for key in defaults:
-        assert key in expected_keys, f"{key} is in defaults but is not one of the expected keys"
+from typing import List
 
 
 @pytest.mark.parametrize(
@@ -52,11 +34,6 @@ def test_elo_defaults():
 def test_elo_changes(k, d, s, ratings, true_expected, true_new):
     """
     Test some known values to make sure Elo is calculating the correct updates.
-
-    :param ratings:
-    :param true_expected:
-    :param true_new:
-    :return:
     """
     elo = MultiElo(k_value=k, d_value=d, score_function_base=s)
     assert np.allclose(elo.get_expected_scores(ratings), true_expected)
@@ -64,7 +41,9 @@ def test_elo_changes(k, d, s, ratings, true_expected, true_new):
 
 
 def test_zero_sum():
-    # make sure expected scores sum to 1 and rating changes are zero sum
+    """
+    make sure expected scores sum to 1 and rating changes are zero sum
+    """
     for n_players in [2, 3, 4, 10]:
         for _ in range(10):
             k = np.random.uniform(16, 64)
@@ -75,3 +54,38 @@ def test_zero_sum():
                 f"expected ratings do not sum to 1 for k={k}, d={d}, ratings={ratings}"
             assert np.allclose(elo.get_new_ratings(ratings).sum(), ratings.sum()), \
                 f"rating changes are not zero sum for k={k}, d={d}, ratings={ratings}"
+
+
+@pytest.mark.parametrize(
+    "results, result_order, new_ratings",
+    [
+        ([1000, 1000], [1, 1], [1000, 1000]),
+        ([1200, 1000], [0, 0], [1191.6880983472654, 1008.3119016527346]),
+        ([1200, 1000, 800], [1, 2, 2], [1207.06479284,  989.33333333,  803.60187383]),
+        ([1200, 1000, 800], [1, 1, 2], [1196.39812617, 1010.66666667,  792.93520716]),
+        ([1200, 1000, 800], [1, 1, 1], [1185.7314595, 1000,  814.2685405]),
+    ]
+)
+def test_ties(results: List[float], result_order: List[int], new_ratings: List[float]):
+    elo = MultiElo(k_value=32, d_value=400, score_function_base=1)
+    assert np.allclose(elo.get_new_ratings(results, result_order=result_order), new_ratings)
+
+
+def test_out_of_order_ratings():
+    """If we reverse the change the order of ratings and account for it in result_order,
+    the new ratings should be the same"""
+    elo = MultiElo()
+    result_1 = elo.get_new_ratings([1200, 1000])
+    result_2 = elo.get_new_ratings([1000, 1200], result_order=[2, 1])
+    print(f"result_1: {result_1}")
+    print(f"result_2: {result_2}")
+    assert result_1[0] == result_2[1]
+    assert result_1[1] == result_2[0]
+
+    result_1 = elo.get_new_ratings([1200, 1000, 800], result_order=[1, 2, 2])
+    result_2 = elo.get_new_ratings([1000, 800, 1200], result_order=[2, 2, 1])
+    print(f"result_1: {result_1}")
+    print(f"result_2: {result_2}")
+    assert result_1[0] == result_2[2]
+    assert result_1[1] == result_2[0]
+    assert result_1[2] == result_2[1]
diff --git a/tests/test_player_tracker.py b/tests/test_player_tracker.py
index 54cc349..776d7b3 100644
--- a/tests/test_player_tracker.py
+++ b/tests/test_player_tracker.py
@@ -1,17 +1,17 @@
 from multielo import Player, Tracker, MultiElo
-from multielo.config import defaults
+from multielo.player_tracker import DEFAULT_INITIAL_RATING
 import pandas as pd
 import numpy as np
 
 
 def test_default_player():
     player = Player("test")
-    assert player.rating == defaults["INITIAL_RATING"]
+    assert player.rating == DEFAULT_INITIAL_RATING
 
 
 def test_player_with_history():
     player = Player("test", rating_history=[(1, 1000), (2, 1100)], date=3)
-    assert player.rating == defaults["INITIAL_RATING"]
+    assert player.rating == DEFAULT_INITIAL_RATING
     assert player.get_rating_as_of_date(1) == 1000
     assert player.get_rating_as_of_date(2) == 1100
 
@@ -27,7 +27,7 @@ def test_get_rating_as_of_date():
     player.update_rating(new_rating=1100, date="2020-02-01")
     player.update_rating(new_rating=1200, date="2020-03-01")
     player.update_rating(new_rating=1300, date="2020-04-01")
-    assert player.get_rating_as_of_date("2019-12-31") == defaults["INITIAL_RATING"]
+    assert player.get_rating_as_of_date("2019-12-31") == DEFAULT_INITIAL_RATING
     assert player.get_rating_as_of_date("2020-01-15") == 900
     assert player.get_rating_as_of_date("2020-02-15") == 1100
     assert player.get_rating_as_of_date("2020-03-15") == 1200
@@ -45,7 +45,7 @@ def test_player_equality():
 
 
 def test_tracker():
-    # test with some known results
+    """test with some known results"""
     elo = MultiElo(k_value=32, d_value=400, score_function_base=1)
     tracker = Tracker(elo_rater=elo, initial_rating=1000)
     data = pd.DataFrame({
@@ -68,3 +68,23 @@ def test_tracker():
     assert marge == 1000.5940386640012
     assert bart == 980.6241719618897
     assert lisa == 1041.2985450366014
+
+
+def test_tie_data():
+    elo = MultiElo(k_value=32, d_value=400, score_function_base=1)
+    tracker = Tracker(elo_rater=elo, initial_rating=1000)
+    data = pd.DataFrame({
+        "date": [1, 2, 3, 4, 5],
+        "1st": ["Homer", ("Lisa", "Bart"), ("Lisa", "Marge"), ("Marge", "Homer", "Bart"), "Lisa"],
+        "2nd": ["Marge", None, "Homer", None, ("Bart", "Marge")],
+        "3rd": ["Bart", "Homer", None, None, "Homer"]
+    })
+    tracker.process_data(data)
+    homer = tracker.retrieve_existing_player("Homer")
+    marge = tracker.retrieve_existing_player("Marge")
+    bart = tracker.retrieve_existing_player("Bart")
+    lisa = tracker.retrieve_existing_player("Lisa")
+    assert homer == 956.5862536380732
+    assert marge == 1008.4435164345906
+    assert bart == 992.2443714740361
+    assert lisa == 1042.7258584533
diff --git a/tests/test_score_functions.py b/tests/test_score_functions.py
index e7a350d..08b1ff2 100644
--- a/tests/test_score_functions.py
+++ b/tests/test_score_functions.py
@@ -1,5 +1,9 @@
+import pytest
 import numpy as np
 from multielo.score_functions import linear_score_function, create_exponential_score_function
+from multielo import MultiElo
+
+from typing import List
 
 
 def test_2_player_score_function():
@@ -41,3 +45,27 @@ def test_exponential_score_function():
             # differences should also be monotonically increasing (less negative) for exponential score function
             assert np.all(np.diff(score_diffs) > 0), \
                 f"exponential score function diffs are not monotonically increasing for base={base}, n={n}: {scores}"
+
+
+@pytest.mark.parametrize(
+    "result_order, actual_scores, base",
+    [
+        ([1, 1], [0.5, 0.5], 1),
+        ([1, 1], [0.5, 0.5], 2),
+        ([1, 1, 1], [1/3, 1/3, 1/3], 1),
+        ([1, 2, 2], [2/3, 1/6, 1/6], 1),
+        ([1, 1, 2], [0.5, 0.5, 0], 1),
+        ([1, 1, 1], [1/3, 1/3, 1/3], 2),
+        ([1, 2, 2], [0.75, 0.125, 0.125], 2),
+        ([1, 1, 2], [0.5, 0.5, 0], 2),
+    ]
+)
+def test_tie_actual_scores(
+        result_order: List[int],
+        actual_scores: List[float],
+        base: float,
+):
+    elo = MultiElo(score_function_base=base)
+    n = len(result_order)
+    scores = elo.get_actual_scores(n=n, result_order=result_order)
+    assert np.allclose(scores, actual_scores)