soccer_and_statistics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Soccer and Statistics: Modeling the Group Stage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from collections import defaultdict\n",
    "import string\n",
    "from counting.soccer_functions import standings, standings_n_teams, sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the first part of a soccer tournament (like the World Cup) teams are often divided into groups, and every team in that group will play every other team in that group. The results of this \"round-robin\" play will determine the teams to advance to the single-elimination tournament (or \"knockout round\"). A team will earn three points for a win and one point for a tie.\n",
    "\n",
    "Very often a group will comprise four teams. For a four-team group, how many different game outcomes are possible? How many different sets of final standings are possible? **How many different sets of final standings are possible if we abstract away from the team identities?**\n",
    "\n",
    "This last question is what I want to pursue here. As we shall see, the complexity of this problem grows quickly as we increase the number of teams in our group."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two Teams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we had only two teams in our group, then there would of course be only one game to play ($2\\choose 2$$ = 1$). The game could result either in a win for one team and a loss for the other, or it could result in a tie. In the first case we'd have a set of final standings like:\n",
    "\n",
    "Team | Points\n",
    "-|-\n",
    "Team A | 3\n",
    "Team B | 0\n",
    "\n",
    "In the second case we'd have a set of final standings like:\n",
    "\n",
    "Team | Points\n",
    "-|-\n",
    "Team A | 1\n",
    "Team B | 1\n",
    "\n",
    "Of course, we could also have:\n",
    "\n",
    "Team | Points\n",
    "-|-\n",
    "Team B | 3\n",
    "Team A | 0\n",
    "\n",
    "But if we abstract away from the team identities, then this result is no different from the first. So for two teams there are only two possible sets of final standings: 3-0 and 1-1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Three Teams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The problem is not particularly interesting with only two teams, but observe how much more complex the situation is with three. If we had three teams in our group, then there would be three games to play ($3\\choose 2$$ = 3$). Now there are three games (Team A vs. Team B, Team A vs. Team C, and Team B vs. Team C), each with three potential outcomes (win, lose, or draw). So that makes for 27 different possible scenarios.\n",
    "\n",
    "Let's take a look at the possibilities:\n",
    "\n",
    "I'll use a three-character string to represent the results of our three games. The first character will represent the result of the game played between Teams A and B, the second character will represent the result of the game played between Teams A and C, and the last character will represent the result of the game played between Teams B and C. I'll use a lowercase 'a' to represent a win by Team A (and *mutatis mutandis* for the other two teams). A tie will be represented with a 't'.\n",
    "\n",
    "Thus our 27 possibilities are:\n",
    "\n",
    "1. 'aab'\n",
    "2. 'aac'\n",
    "3. 'aat'\n",
    "4. 'acb'\n",
    "5. 'acc'\n",
    "6. 'act'\n",
    "7. 'atb'\n",
    "8. 'atc'\n",
    "9. 'att'\n",
    "10. 'bab'\n",
    "11. 'bac'\n",
    "12. 'bat'\n",
    "13. 'bcb'\n",
    "14. 'bcc'\n",
    "15. 'bct'\n",
    "16. 'btb'\n",
    "17. 'btc'\n",
    "18. 'btt'\n",
    "19. 'tab'\n",
    "20. 'tac'\n",
    "21. 'tat'\n",
    "22. 'tcb'\n",
    "23. 'tcc'\n",
    "24. 'tct'\n",
    "25. 'ttb'\n",
    "26. 'ttc'\n",
    "27. 'ttt'\n",
    "\n",
    "Each of these sets of game outcomes corresponds to a final set of standings. Let's take the first: The string 'aab' represents the possible world where:\n",
    "\n",
    "- Team A beats Team B,\n",
    "- Team A beats Team C, and\n",
    "- Team B beats Team C.\n",
    "\n",
    "In that case, our final standings are:\n",
    "\n",
    "Team | Points\n",
    "-|-\n",
    "A | 6\n",
    "B | 3\n",
    "C | 0\n",
    "\n",
    "Or, abstracting away from the team identities, we have 6-3-0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unique Sets of Final Standings for Three Teams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many sets of final standings are possible for three teams? If we look at each set of final standings represented by the outcome strings above, we'll find that there are seven unique possibilities:\n",
    "\n",
    "- 'aab' $\\rightarrow$ 6-3-0\n",
    "- 'aac' $\\rightarrow$ 6-3-0\n",
    "- 'aat' $\\rightarrow$ 6-1-1\n",
    "- 'acb' $\\rightarrow$ 3-3-3\n",
    "- 'acc' $\\rightarrow$ 6-3-0\n",
    "- 'act' $\\rightarrow$ 4-3-1\n",
    "- 'atb' $\\rightarrow$ 4-3-1\n",
    "- 'atc' $\\rightarrow$ 4-4-0\n",
    "- 'att' $\\rightarrow$ 4-2-1\n",
    "- 'bab' $\\rightarrow$ 6-3-0\n",
    "- 'bac' $\\rightarrow$ 3-3-3\n",
    "- 'bat' $\\rightarrow$ 4-3-1\n",
    "- 'bcb' $\\rightarrow$ 6-3-0\n",
    "- 'bcc' $\\rightarrow$ 6-3-0\n",
    "- 'bct' $\\rightarrow$ 4-4-0\n",
    "- 'btb' $\\rightarrow$ 6-1-1\n",
    "- 'btc' $\\rightarrow$ 4-3-1\n",
    "- 'btt' $\\rightarrow$ 4-2-1\n",
    "- 'tab' $\\rightarrow$ 4-4-0\n",
    "- 'tac' $\\rightarrow$ 4-3-1\n",
    "- 'tat' $\\rightarrow$ 4-2-1\n",
    "- 'tcb' $\\rightarrow$ 4-3-1\n",
    "- 'tcc' $\\rightarrow$ 6-1-1\n",
    "- 'tct' $\\rightarrow$ 4-2-1\n",
    "- 'ttb' $\\rightarrow$ 4-2-1\n",
    "- 'ttc' $\\rightarrow$ 4-2-1\n",
    "- 'ttt' $\\rightarrow$ 2-2-2\n",
    "\n",
    "The seven unique possibilities are:\n",
    "\n",
    "- 6-3-0\n",
    "- 6-1-1\n",
    "- 4-4-0\n",
    "- 4-3-1\n",
    "- 4-2-1\n",
    "- 3-3-3\n",
    "- 2-2-2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Four Teams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The case of three teams is considerably more complex than the case of two. For four teams we had better try to automate some of our work so that we don't need to write all the possibilities out by hand. In fact, with four teams there are now six games to be played, and so that makes for $3^6 = 729$ possible outcomes!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's bring in our helper function that will output the standings for a given outcome string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>points</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   points\n",
       "a       9\n",
       "b       2\n",
       "c       2\n",
       "d       2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's test out our function for the following possible world:\n",
    "# - Team A beats Team B,\n",
    "# - Team A beats Team C,\n",
    "# - Team A beats Team D,\n",
    "# - Team B and Team C tie,\n",
    "# - Team B and Team D tie, and\n",
    "# - Team C and Team D tie.\n",
    "# We expect the function to show us a set of standings where\n",
    "# Team A has 9 points and the other teams have 2 each.\n",
    "\n",
    "standings('aaattt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "729"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now let's simulate all 729 possible worlds by creating all\n",
    "# of the relevant outcome strings:\n",
    "\n",
    "coll = []\n",
    "\n",
    "for first in ('abt'):\n",
    "    for second in ('act'):\n",
    "        for third in ('adt'):\n",
    "            for fourth in ('bct'):\n",
    "                for fifth in ('bdt'):\n",
    "                    for sixth in ('cdt'):\n",
    "                        coll.append(standings(first+second+third+fourth+fifth+sixth))\n",
    "\n",
    "len(coll)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>points</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   points\n",
       "a       9\n",
       "b       6\n",
       "c       3\n",
       "d       0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We now have a list of 729 DataFrames. Let's look at the first:\n",
    "coll[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 9, 9, ..., 5, 5, 3],\n",
       "       [6, 6, 6, ..., 3, 3, 3],\n",
       "       [3, 3, 1, ..., 3, 3, 3],\n",
       "       [0, 0, 1, ..., 2, 2, 3]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# These DataFrames may prove unwieldy for our purposes. Let's\n",
    "# make a large NumPy array instead:\n",
    "\n",
    "big_arr = np.concatenate([df.values for df in coll], axis=1)\n",
    "\n",
    "big_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The first two outcome strings ('aaabbc' and 'aaabbd') result in the\n",
    "# same standings: 9-6-3-0:\n",
    "\n",
    "big_arr[:, 0] ==  big_arr[:, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int,\n",
       "            {'[9 6 3 0]': 24,\n",
       "             '[9 6 1 1]': 12,\n",
       "             '[9 3 3 3]': 8,\n",
       "             '[9 4 3 1]': 24,\n",
       "             '[9 4 4 0]': 12,\n",
       "             '[9 4 2 1]': 24,\n",
       "             '[9 2 2 2]': 4,\n",
       "             '[6 6 3 3]': 24,\n",
       "             '[6 6 6 0]': 8,\n",
       "             '[6 6 4 1]': 24,\n",
       "             '[7 6 3 1]': 24,\n",
       "             '[6 4 4 3]': 36,\n",
       "             '[7 6 4 0]': 24,\n",
       "             '[6 5 4 1]': 24,\n",
       "             '[6 4 4 2]': 24,\n",
       "             '[7 6 2 1]': 24,\n",
       "             '[6 5 2 2]': 12,\n",
       "             '[7 4 3 3]': 24,\n",
       "             '[7 7 3 0]': 12,\n",
       "             '[7 5 3 1]': 24,\n",
       "             '[7 4 3 2]': 24,\n",
       "             '[7 5 4 0]': 24,\n",
       "             '[7 4 3 1]': 24,\n",
       "             '[7 4 4 1]': 36,\n",
       "             '[7 4 2 2]': 24,\n",
       "             '[7 7 1 1]': 6,\n",
       "             '[7 5 2 1]': 24,\n",
       "             '[7 3 2 2]': 12,\n",
       "             '[5 4 4 3]': 24,\n",
       "             '[5 5 3 2]': 12,\n",
       "             '[4 4 4 3]': 8,\n",
       "             '[4 4 4 4]': 6,\n",
       "             '[5 4 4 2]': 24,\n",
       "             '[5 5 4 1]': 24,\n",
       "             '[5 4 3 2]': 24,\n",
       "             '[5 5 5 0]': 4,\n",
       "             '[5 5 3 1]': 12,\n",
       "             '[5 5 2 2]': 12,\n",
       "             '[5 3 3 2]': 12,\n",
       "             '[3 3 3 3]': 1})"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's now use defaultdict to count how many of each set of final\n",
    "# standings we have:\n",
    "\n",
    "counter = defaultdict(int)\n",
    "\n",
    "# Technical note: We can't use the NumPy arrays themselves as keys,\n",
    "# since they're not hashable. So we'll turn them into strings first!\n",
    "for stand in big_arr.T:\n",
    "    counter[str(stand)] += 1\n",
    "\n",
    "counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unique Sets of Final Standings for Four Teams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of entries in our dictionary is the answer to our question about how many unique sets of final standings there are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(counter.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "729"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This should sum to 729:\n",
    "sum(counter.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exploration of Possible Final Standings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that, when a game results in a win for a team (and a loss for that team's opponent), that's a total of three points that will be recorded and added to the standings. But when a game results in a tie, that's a total of only two points that will be added.\n",
    "\n",
    "It's therefore easy to group these possible final standings according to how many ties happened.\n",
    "\n",
    "First let's create a NumPy array of the unique sets of final standings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 3, 3, 3],\n",
       "       [4, 4, 4, 3],\n",
       "       [4, 4, 4, 4],\n",
       "       [5, 3, 3, 2],\n",
       "       [5, 4, 3, 2],\n",
       "       [5, 4, 4, 2],\n",
       "       [5, 4, 4, 3],\n",
       "       [5, 5, 2, 2],\n",
       "       [5, 5, 3, 1],\n",
       "       [5, 5, 3, 2],\n",
       "       [5, 5, 4, 1],\n",
       "       [5, 5, 5, 0],\n",
       "       [6, 4, 4, 2],\n",
       "       [6, 4, 4, 3],\n",
       "       [6, 5, 2, 2],\n",
       "       [6, 5, 4, 1],\n",
       "       [6, 6, 3, 3],\n",
       "       [6, 6, 4, 1],\n",
       "       [6, 6, 6, 0],\n",
       "       [7, 3, 2, 2],\n",
       "       [7, 4, 2, 2],\n",
       "       [7, 4, 3, 1],\n",
       "       [7, 4, 3, 2],\n",
       "       [7, 4, 3, 3],\n",
       "       [7, 4, 4, 1],\n",
       "       [7, 5, 2, 1],\n",
       "       [7, 5, 3, 1],\n",
       "       [7, 5, 4, 0],\n",
       "       [7, 6, 2, 1],\n",
       "       [7, 6, 3, 1],\n",
       "       [7, 6, 4, 0],\n",
       "       [7, 7, 1, 1],\n",
       "       [7, 7, 3, 0],\n",
       "       [9, 2, 2, 2],\n",
       "       [9, 3, 3, 3],\n",
       "       [9, 4, 2, 1],\n",
       "       [9, 4, 3, 1],\n",
       "       [9, 4, 4, 0],\n",
       "       [9, 6, 1, 1],\n",
       "       [9, 6, 3, 0]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poss = np.unique(big_arr.T, axis=0)\n",
    "poss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll check the possibilities for each number of ties between 0 and 6. If there are no ties, the total points will be 18. If there is exactly one tie, the total points will be 17. Etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([3, 3, 3, 3])]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 6 ties\n",
    "[rec for rec in poss if rec.sum() == 12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([5, 3, 3, 2])]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 5 ties\n",
    "[rec for rec in poss if rec.sum() == 13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([5, 4, 3, 2]),\n",
       " array([5, 5, 2, 2]),\n",
       " array([5, 5, 3, 1]),\n",
       " array([7, 3, 2, 2])]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 4 ties\n",
    "[rec for rec in poss if rec.sum() == 14]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([4, 4, 4, 3]),\n",
       " array([5, 4, 4, 2]),\n",
       " array([5, 5, 3, 2]),\n",
       " array([5, 5, 4, 1]),\n",
       " array([5, 5, 5, 0]),\n",
       " array([6, 5, 2, 2]),\n",
       " array([7, 4, 2, 2]),\n",
       " array([7, 4, 3, 1]),\n",
       " array([7, 5, 2, 1]),\n",
       " array([9, 2, 2, 2])]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3 ties\n",
    "[rec for rec in poss if rec.sum() == 15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([4, 4, 4, 4]),\n",
       " array([5, 4, 4, 3]),\n",
       " array([6, 4, 4, 2]),\n",
       " array([6, 5, 4, 1]),\n",
       " array([7, 4, 3, 2]),\n",
       " array([7, 4, 4, 1]),\n",
       " array([7, 5, 3, 1]),\n",
       " array([7, 5, 4, 0]),\n",
       " array([7, 6, 2, 1]),\n",
       " array([7, 7, 1, 1]),\n",
       " array([9, 4, 2, 1])]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2 ties\n",
    "[rec for rec in poss if rec.sum() == 16]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([6, 4, 4, 3]),\n",
       " array([6, 6, 4, 1]),\n",
       " array([7, 4, 3, 3]),\n",
       " array([7, 6, 3, 1]),\n",
       " array([7, 6, 4, 0]),\n",
       " array([7, 7, 3, 0]),\n",
       " array([9, 4, 3, 1]),\n",
       " array([9, 4, 4, 0]),\n",
       " array([9, 6, 1, 1])]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1 tie\n",
    "[rec for rec in poss if rec.sum() == 17]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([6, 6, 3, 3]),\n",
       " array([6, 6, 6, 0]),\n",
       " array([9, 3, 3, 3]),\n",
       " array([9, 6, 3, 0])]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# No ties\n",
    "[rec for rec in poss if rec.sum() == 18]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "      <th>...</th>\n",
       "      <th>31</th>\n",
       "      <th>32</th>\n",
       "      <th>33</th>\n",
       "      <th>34</th>\n",
       "      <th>35</th>\n",
       "      <th>36</th>\n",
       "      <th>37</th>\n",
       "      <th>38</th>\n",
       "      <th>39</th>\n",
       "      <th>40</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "      <td>...</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "      <td>6</td>\n",
       "      <td>...</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>...</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>4 rows × 40 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   1   2   3   4   5   6   7   8   9   10  ...  31  32  33  34  35  36  37  \\\n",
       "0   9   9   9   9   9   9   9   7   7   7  ...   5   5   5   5   5   5   5   \n",
       "1   6   6   4   4   4   3   2   7   7   6  ...   5   5   5   4   4   4   3   \n",
       "2   3   1   4   3   2   3   2   3   1   4  ...   3   3   2   4   4   3   3   \n",
       "3   0   1   0   1   1   3   2   0   1   0  ...   2   1   2   3   2   2   2   \n",
       "\n",
       "   38  39  40  \n",
       "0   4   4   3  \n",
       "1   4   4   3  \n",
       "2   4   4   3  \n",
       "3   4   3   3  \n",
       "\n",
       "[4 rows x 40 columns]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The 40 possible standings in a DataFrame:\n",
    "df = pd.DataFrame(np.unique(big_arr.T, axis=0).T, columns=range(40, 0, -1))\n",
    "df[df.columns[::-1]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we count the point totals for each set of standings, we can count how many of each we have for a given number of ties:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>index</th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>18</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>17</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>16</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>15</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>14</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>13</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>12</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   index   0\n",
       "3     18   4\n",
       "2     17   9\n",
       "0     16  11\n",
       "1     15  10\n",
       "4     14   4\n",
       "5     13   1\n",
       "6     12   1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.sum().value_counts().reset_index().sort_values('index', ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Larger Groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For four teams there are 40 different sets of final standings. Dare we calculate the number for still larger groups?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll need our more general helper function for the case of a five-team group."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For 5 teams there will be 10 games and so 59049 possibilities.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([12,  9,  4,  2,  1])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "standings_n_teams('aaaabbbctt', n=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For fun, let's generate all the possibilities for a five-team group:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're going to make use of a helper function here that will generate all possible outcome strings for an input array of strings that represent each game."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "standings = np.zeros((5, 59049))\n",
    "\n",
    "five_team_group = ['abt', 'act', 'adt', 'aet', 'bct',\n",
    "                   'bdt', 'bet', 'cdt', 'cet', 'det']\n",
    "\n",
    "results = sequences(five_team_group)\n",
    "\n",
    "for j in range(59049):\n",
    "    standings[:, j] = standings_n_teams(results[j],\n",
    "                                        n=5,\n",
    "                                       verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12.,  9.,  6.,  3.,  0.])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "standings[:, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we find the unique ones and then count the columns, that should be the answer to the question of how many unique sets of final standings there are for a five-team group:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "355"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(standings, axis=1).shape[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Continuing the Sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we build the sequence $a_n$ of sets of different possible standings, where $n$ represents the number of teams in our round-robin group, we have so far found:\n",
    "\n",
    "Teams | Possible Final Standings\n",
    "-|-\n",
    "2 | 2\n",
    "3 | 7\n",
    "4 | 40\n",
    "5 | 355\n",
    "\n",
    "And it turns out that we have [predecessors](https://oeis.org/A064626) in the study of this sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}