{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Cranberry Sauce Riddler](https://fivethirtyeight.com/features/can-you-pass-the-cranberry-sauce/)\n",
    "\n",
    "Prompt:\n",
    "> To celebrate Thanksgiving, you and 19 of your family members are seated at a circular table (socially distanced, of course). Everyone at the table would like a helping of cranberry sauce, \n",
    "> which happens to be in front of you at the moment.\n",
    ">\n",
    "> Instead of passing the sauce around in a circle, you pass it randomly to the person seated directly to your left or to your right. They then do the same, passing it randomly either to the person to their left or right. This \n",
    "> continues until everyone has, at some point, received the cranberry sauce.\n",
    ">\n",
    "> Of the 20 people in the circle, who has the greatest chance of being the last to receive the cranberry sauce?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# math\n",
    "import numpy as np\n",
    "from math import floor, ceil\n",
    "import networkx as nx\n",
    "from collections import OrderedDict\n",
    "\n",
    "# data manipulation\n",
    "import pandas as pd\n",
    "\n",
    "# plotting\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import matplotlib.ticker as mtick\n",
    "from networkx.drawing.nx_agraph import graphviz_layout"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Auxilliary Markov Process\n",
    "\n",
    "The functions in this section are used to provide terminal properties for a drunkard's walk on a finite interval. We use this in the main cranberry passing Markov process to specify the probability that the next guest to receive the cranberry sauce will be next to the person holding the cranberry sauce, or will be the person sitting next to the furthest person who has already been served. In addition, we also calculate the number of passes that will be made in each case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def drunkard_walk_transition_matrix(n_interval):\n",
    "    # P is the transition matrix\n",
    "    P = np.zeros((n_interval + 2, n_interval + 2))\n",
    "    P[0, 0] = 1\n",
    "    P[n_interval+1, n_interval+1] = 1\n",
    "    for i in range(1, n_interval + 1):\n",
    "        P[i, i-1] = 0.5\n",
    "        P[i, i+1] = 0.5\n",
    "    \n",
    "    return P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def drunkard_walk_exit_distro(n_interval):\n",
    "    '''\n",
    "    Compute the probability that a random walk exits an interval of length \n",
    "    n from the left or right, conditioned on beginning at the left-most end of the \n",
    "    interval.\n",
    "    \n",
    "    Input: \n",
    "    n_interal: length of interval\n",
    "    max_iter : maximum number of iterations to use\n",
    "    \n",
    "    Returns: \n",
    "    (p_near, p_far): where p_near = probability of left-exit, and\n",
    "      p_far = probability of right-exit.\n",
    "    '''\n",
    "    \n",
    "    if n_interval == 1:\n",
    "        return 0.5, 0.5\n",
    "    \n",
    "    # P is the drunkard's walk transition matrix\n",
    "    P = drunkard_walk_transition_matrix(n_interval)\n",
    "        \n",
    "    # Put P in canonical form\n",
    "    n_transient = 2\n",
    "    idxs = list(range(1, n_interval + 1)) + [0, n_interval + 1]\n",
    "    P = P[idxs, :]\n",
    "    P = P[:, idxs]\n",
    "    \n",
    "    # Transient submatrix Q and transition to absorbing matrix R\n",
    "    n_absorbing = 2\n",
    "    Q = P[:-n_absorbing, :-n_absorbing]\n",
    "    R = P[:-n_absorbing, -n_absorbing:]\n",
    "    N_inv = np.eye(n_interval) - Q\n",
    "    \n",
    "    # Solve for B, whose rows represent absorption probabilities\n",
    "    # starting from a given transient state, and columns represent\n",
    "    # probability of absorption into a specific absorbing state.\n",
    "    # see e.g. \n",
    "    #    https://en.wikipedia.org/wiki/Absorbing_Markov_chain#Absorbing_probabilities\n",
    "    B = np.linalg.solve(N_inv, R)\n",
    "    \n",
    "    # We're only interested in absorption from the first state into\n",
    "    # each of the absorbing states.    \n",
    "    p_left = B[0, 0]\n",
    "    p_right = B[0, 1]\n",
    "    \n",
    "    return p_left, p_right    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def drunkard_walk_avg_exit_time_each_side(n_interval):\n",
    "    \n",
    "    P = drunkard_walk_transition_matrix(n_interval)\n",
    "    \n",
    "    # re-order to put P in \"standard form\" with absorbing states at \n",
    "    # the end\n",
    "    idxs = list(range(1, n_interval + 1)) + [0, n_interval + 1]\n",
    "    P = P[idxs, :]\n",
    "    P = P[:, idxs]\n",
    "    \n",
    "    # Important matrices\n",
    "    Q = P.copy()[:-2, :-2]\n",
    "    R = P.copy()[:n_interval, -2:]\n",
    "    #N = np.linalg.inv(np.eye(n_interval) - Q)\n",
    "    N_inv = np.eye(n_interval) - Q\n",
    "        \n",
    "    # Compute B = N*R = (I - Q)^-1 * R\n",
    "    B = np.linalg.solve(np.eye(n_interval) - Q, R)    \n",
    "    \n",
    "    # compute quantities from B for left/right absorbing states\n",
    "    b_left = B[:, 0]\n",
    "    b_right = B[:, 1]\n",
    "    D_left = np.diag(b_left)\n",
    "    D_right = np.diag(b_right)\n",
    "    \n",
    "    # Use theorem 1 from:\n",
    "    #   https://doi.org/10.1016/j.spl.2019.04.001\n",
    "    # which is available for free download on ResearchGate:\n",
    "    #   https://www.researchgate.net/publication/332384778_Applications_of_the_fundamental_matrix_to_mean_absorption_and_conditional_mean_absorption_problems\n",
    "    # Using this theorem, we get alpha, the mean number of steps from \n",
    "    # any starting state as follows:\n",
    "    #  alpha_left = D_left^{-1} * N * D_left * xi\n",
    "    #  alpha_right = D_right^{-1} * N * D_right * xi\n",
    "    # where xi is a vector of ones. we're only interested in the first entry of\n",
    "    # alpha_left and alpha_right.\n",
    "    xi = np.ones(n_interval)\n",
    "    \n",
    "    # compute mu_left. \n",
    "    xi_left = np.dot(D_left, xi)\n",
    "    alpha_left = np.linalg.solve(N_inv, xi_left)\n",
    "    alpha_left = np.linalg.solve(D_left, alpha_left)\n",
    "    mu_left = alpha_left[0]\n",
    "    \n",
    "    # compute mu_right. \n",
    "    xi_right = np.dot(D_right, xi)\n",
    "    alpha_right = np.linalg.solve(N_inv, xi_right)\n",
    "    alpha_right = np.linalg.solve(D_right, alpha_right)\n",
    "    mu_right = alpha_right[0]    \n",
    "    \n",
    "    return mu_left, mu_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def drunkard_walk_avg_exit_time(n_interval):\n",
    "    p_left, p_right = drunkard_walk_exit_distro(n_interval)\n",
    "    mu_left, mu_right = drunkard_walk_avg_exit_time_each_side(n_interval)\n",
    "    \n",
    "    return p_left * mu_left + p_right * mu_right"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Main Cranberry Passing Markov Process\n",
    "\n",
    "In this process, we are only interested in tracking the \"boundary\" of the guests who have already been served. States of this system are either \n",
    "  1. a tuple of the form `(most_recently_served, interval_served, n_served)` \n",
    "  2. an integer representing the last guest to be served.\n",
    "\n",
    "Transition probabilities in this Markov process are governed by a drunkard's walk on `interval_served` (i.e. the auxiliary walk indicated above), and indicate whether the nearest unserved guest receives the sauce next, or whether the furthest unserved guest is served next.\n",
    "\n",
    "Each step in this process represents one new guest being served, and the number of steps in this process does *not* indicate the number of cranberry sauce passes. To compute the average number of passes requies a bit of work using the number of transitions in the drunkard's walk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def table_dist(i, j, n_guests):\n",
    "    '''\n",
    "    Compute number of spaces between position i and j around a table \n",
    "    with n_guests\n",
    "    \n",
    "    Input: \n",
    "    i, j: position indices for two guests to be compared\n",
    "    n_guests: the number of guests at the table\n",
    "           \n",
    "    '''    \n",
    "    diff = abs(i - j)\n",
    "    \n",
    "    if diff <= floor(n_guests / 2):\n",
    "        return diff\n",
    "    else:\n",
    "        return n_guests - diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def receiver_states(state, n_guests):\n",
    "    '''\n",
    "    Generate the states which can be reached from the current state.\n",
    "    \n",
    "    Input: \n",
    "    state: either a tuple of the form (current_pos, interval, n_served)\n",
    "      or an integer representing a terminal state\n",
    "    n_guests: the number of guests at the table\n",
    "    \n",
    "    Return: \n",
    "    receptive_states: either a list of the possible transition states,\n",
    "      if state is not terminal, and None if state is terminal (!!)    \n",
    "    '''\n",
    "    \n",
    "    if state == (0, (0, 0), 1):\n",
    "        receptive_states = [(n_guests-1, (n_guests-1, 0), 2), (1, (0, 1), 2)]\n",
    "    \n",
    "    elif type(state) == tuple:\n",
    "        i, j = state[1]\n",
    "        n_served = state[2]\n",
    "        \n",
    "        if n_served == n_guests - 1:\n",
    "            if [i, j] == [0, n_guests - 2]:\n",
    "                receptive_states = [n_guests - 1]\n",
    "            elif [i, j] == [n_guests - 2, 0]:\n",
    "                receptive_states = [1]            \n",
    "            else:\n",
    "                receptive_states = [(i + j) // 2]\n",
    "        \n",
    "        else:\n",
    "            i_left  = (i - 1) % n_guests\n",
    "            j_right = (j + 1) % n_guests\n",
    "            receptive_states = [(i_left,  (i_left,  j), n_served + 1), \n",
    "                                 (j_right, (i, j_right), n_served + 1)]\n",
    "    else:\n",
    "        receptive_states = None   \n",
    "        \n",
    "    return receptive_states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_states(n_guests):\n",
    "    '''\n",
    "    Generate the transition states for Cranberry passing in sorted order.\n",
    "    \n",
    "    Input: \n",
    "    n_guests: number of guests around the table\n",
    "    \n",
    "    Return: \n",
    "    transition_states: either a list of the possible transition states, \n",
    "      or None if the state is terminal (!)\n",
    "    '''\n",
    "    \n",
    "    starting_state = (0, (0,0), 1)\n",
    "    states = [starting_state]\n",
    "    new_states = list(OrderedDict.fromkeys(states))\n",
    "    \n",
    "    for n_served in range(1, n_guests):\n",
    "        new_states = [s_new for s in new_states for s_new in \n",
    "                      receiver_states(s, n_guests)]\n",
    "        new_states = list(OrderedDict.fromkeys(new_states))\n",
    "        states.extend(new_states)\n",
    "        \n",
    "    # dictionary mapping state to its index\n",
    "    n_states = len(states)    \n",
    "    state_to_idx = dict(zip(states, range(n_states)))    \n",
    "    \n",
    "    return states, state_to_idx, n_states   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cranberry_passing_transition_matrix(n_guests):\n",
    "    '''\n",
    "    Construct the cranberry passing transition matrix.\n",
    "    \n",
    "    Input: \n",
    "    n_guests: the number of guests at the table\n",
    "    \n",
    "    Returns: \n",
    "    (p_near, p_far) where p_near = probability of left-exit, and\n",
    "      p_far = probability of right-exit.\n",
    "    '''\n",
    "    \n",
    "    states, state_to_idx, n_states = generate_states(n_guests)\n",
    "\n",
    "    # list of tuples, containing (p_near, p_far) interval exit probabilities\n",
    "    exit_probs = [None] + [drunkard_walk_exit_distro(i) for i in range(1, n_guests)]\n",
    "    \n",
    "    # compute transition matrix\n",
    "    P = np.zeros((n_states, n_states))\n",
    "    \n",
    "    for state in states:\n",
    "        # non-absorbing states are encoded as tuples\n",
    "        if type(state) == tuple:\n",
    "            idx_state = state_to_idx[state]\n",
    "            n_served = state[2]\n",
    "            receivers = receiver_states(state, n_guests)\n",
    "            \n",
    "            # if only one receiver, then transition is to a final state\n",
    "            if len(receivers) == 1:\n",
    "                state_child = receivers[0]\n",
    "                idx_child = state_to_idx[state_child]\n",
    "                P[idx_state, idx_child] = 1\n",
    "            \n",
    "            # non-terminal states\n",
    "            if len(receivers) == 2:\n",
    "                state_left, state_right = receivers\n",
    "                \n",
    "                # position on table for each state\n",
    "                pos_state = state[0]\n",
    "                pos_left = state_left[0]\n",
    "                pos_right = state_right[0]                \n",
    "                \n",
    "                # determine if left or right is nearest position to the start state\n",
    "                if table_dist(pos_left, pos_state, n_guests) < table_dist(pos_right, pos_state, n_guests):\n",
    "                    state_near, state_far = state_left, state_right\n",
    "                else:\n",
    "                    state_near, state_far = state_right, state_left \n",
    "                \n",
    "                # assign probability that we exit through either the near or far state\n",
    "                idx_near, idx_far = state_to_idx[state_near], state_to_idx[state_far]\n",
    "                p_near, p_far = exit_probs[n_served]\n",
    "                P[idx_state, idx_near] = p_near\n",
    "                P[idx_state, idx_far] = p_far\n",
    "        \n",
    "        # absorbing state\n",
    "        else:\n",
    "            idx_state = state_to_idx[state]            \n",
    "            P[idx_state, idx_state] = 1\n",
    "\n",
    "    return P    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def receive_cranberries_last_probabilities(n_guests):\n",
    "    '''\n",
    "    Calculate the probability that each guest receives the cranberry sauce last, \n",
    "    given that the cranberry sauce starts at position 0.\n",
    "    \n",
    "    Input: \n",
    "    n_guests: the number of guests at the table\n",
    "    max_iter: maximum number of iterations when estimating the terminal distribution\n",
    "    tol: tolerance for convergence\n",
    "    \n",
    "    Returns: \n",
    "    pi_limit: exit distribution for terminal states (and 0)\n",
    "    '''\n",
    "    \n",
    "    # determine all the possible states\n",
    "    states, state_to_idx, n_states = list(generate_states(n_guests))        \n",
    "           \n",
    "    # iterate to compute the limiting distribution beginning from \n",
    "    # starting position (0, (0,0), 0)\n",
    "    pi_old = np.zeros(n_states)\n",
    "    pi_new = np.copy(pi_old)\n",
    "    start_position = (0, (0, 0), 1)\n",
    "    start_idx = state_to_idx[start_position]\n",
    "    pi_new[start_idx] = 1\n",
    "    \n",
    "    # compute transition matrix\n",
    "    # Note: P is in canonical form by construction    \n",
    "    P = cranberry_passing_transition_matrix(n_guests)\n",
    "    \n",
    "    # compute useful quantities\n",
    "    n_absorbing = n_guests - 1\n",
    "    n_transient = n_states - n_absorbing\n",
    "    Q = P[:n_transient, :n_transient]\n",
    "    R = P[:n_transient, -n_absorbing:]\n",
    "    N_inv = np.eye(n_transient) - Q\n",
    "    \n",
    "    # solve for B, the probability of ending up in a \n",
    "    # given absorbing state (col) starting from a given\n",
    "    # transient state (rows)\n",
    "    B = np.linalg.solve(N_inv, R)\n",
    "    \n",
    "    # only interested in root --> terminal state \n",
    "    # probabilities. root, i.e. (0, (0, 0), 0) is\n",
    "    # simply the first row of B\n",
    "    pi_limit = B[0, :]\n",
    "    \n",
    "    # finally, add a zero for the root node's probability\n",
    "    # of being last\n",
    "    pi_limit = np.array([0] + list(pi_limit))\n",
    "    \n",
    "    # create return dataframe\n",
    "    df_pi_limit = pd.DataFrame(zip(list(range(0, n_guests)), pi_limit), \n",
    "                               columns = ['guest_number', 'probability_last'])\n",
    "    df_pi_limit = df_pi_limit[df_pi_limit['guest_number'] > 0]\n",
    "    df_pi_limit.set_index('guest_number', inplace=True)    \n",
    "    \n",
    "    return df_pi_limit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean_passes(n_guests):\n",
    "    '''\n",
    "    Calculate the mean number of passes that required for all guests to receive the \n",
    "    the cranberry sauce, given that the sauce starts at position 0.\n",
    "    \n",
    "    Input: \n",
    "    n_guests: the number of guests at the table\n",
    "    \n",
    "    Returns: \n",
    "    df_mean_passes: dataframe containing mean number of passes until everyone has been served\n",
    "    '''\n",
    "    \n",
    "    # prep work: comute mean number of passes to exit an \n",
    "    # interval of length k from near or far edge, beginning\n",
    "    # on the near edge\n",
    "    mean_passes_near = np.zeros(n_guests + 1)\n",
    "    mean_passes_far = np.zeros(n_guests + 1)\n",
    "    for k in range(1, n_guests + 1):\n",
    "        mean_passes_near[k], mean_passes_far[k] = drunkard_walk_avg_exit_time_each_side(k)\n",
    "        \n",
    "    # for the final transition, we collapse to states into one, so compute the\n",
    "    # mean without conditioning on being near or far\n",
    "    mean_to_terminal = drunkard_walk_avg_exit_time(n_guests - 1)\n",
    "    \n",
    "    # determine all the possible cranbery passing states \n",
    "    states, state_to_idx, n_states = list(generate_states(n_guests))        \n",
    "           \n",
    "    # compute transition matrix for cranberry passing\n",
    "    P = cranberry_passing_transition_matrix(n_guests)\n",
    "        \n",
    "    # compute adjacency graph. first we remove self-loops to form DAG\n",
    "    P_adj = P.copy()\n",
    "    n_terminal = n_guests - 1\n",
    "    P_adj[-n_terminal:, -n_terminal:] = 0 * P_adj[-n_terminal:, -n_terminal:]\n",
    "    G = nx.from_numpy_matrix(P_adj, create_using=nx.DiGraph)\n",
    "    G = nx.relabel_nodes(G, dict(zip(range(len(G.nodes())), states)))\n",
    "    \n",
    "    # terminal nodes are the singleton nodes in G\n",
    "    terminal_nodes = [k for k in range(1, n_guests)]\n",
    "    \n",
    "    # dict to hold\n",
    "    mean_steps_this_node = np.zeros(n_guests)\n",
    "    \n",
    "    # root of graph\n",
    "    state_root = (0, (0,0), 1)\n",
    "    \n",
    "    # iterate over terminal states\n",
    "    for state_end in terminal_nodes:\n",
    "        \n",
    "        # iterate over all paths from root state to terminal state\n",
    "        paths_from_root_to_end = nx.all_simple_paths(G, state_root, state_end)\n",
    "        prob_of_path = []\n",
    "        mean_steps_path = []\n",
    "\n",
    "        for path in paths_from_root_to_end:\n",
    "            prob_this_path = 1\n",
    "            mean_steps_this_path = 0\n",
    "            \n",
    "            state_prev = path[0]\n",
    "            idx_prev = state_to_idx[state_prev]\n",
    "            pos_prev = state_prev[0]\n",
    "            \n",
    "            for state_curr in path[1:]:\n",
    "                idx_curr = state_to_idx[state_curr]\n",
    "                \n",
    "                # Two cases:\n",
    "                # 1) not end ==> not terminal ==> tuple\n",
    "                # 2) end ==> terminal ==> state is integer of position\n",
    "                if state_curr != state_end:\n",
    "                    pos_curr = state_curr[0]\n",
    "                else:\n",
    "                    pos_curr = state_curr\n",
    "                \n",
    "                # the interval of served people has length:\n",
    "                n_already_served = state_prev[2]\n",
    "                \n",
    "                # determine the average number of moves before a new person\n",
    "                # is served\n",
    "                if state_curr in terminal_nodes:\n",
    "                    mean_moves = mean_to_terminal\n",
    "                elif table_dist(pos_curr, pos_prev, n_guests) > 1:\n",
    "                    mean_moves = mean_passes_far[n_already_served]\n",
    "                else:\n",
    "                    mean_moves = mean_passes_near[n_already_served]\n",
    "                \n",
    "                # propagate path probability and number of steps\n",
    "                prob_this_path *= P[idx_prev, idx_curr]\n",
    "                mean_steps_this_path += mean_moves\n",
    "                \n",
    "                # update for next step of iteration\n",
    "                state_prev = state_curr\n",
    "                idx_prev = idx_curr\n",
    "                pos_prev = pos_curr\n",
    "            \n",
    "            # store data for this path\n",
    "            prob_of_path.append(prob_this_path)\n",
    "            mean_steps_path.append(mean_steps_this_path)\n",
    "        \n",
    "        # aggregate data across paths from root to this terminal node to\n",
    "        # compute the mean number of passes for this terminal node\n",
    "        prob_of_path = np.array(prob_of_path)\n",
    "        mean_steps_path = np.array(mean_steps_path)\n",
    "        mean_steps_this_node[state_end] = np.sum(np.multiply(prob_of_path, mean_steps_path) / np.sum(prob_of_path))\n",
    "    \n",
    "    # create return dataframe\n",
    "    df_mean_passes = pd.DataFrame(zip(list(range(0, n_guests)), mean_steps_this_node), \n",
    "                                 columns = ['guest_number', 'mean_number_passes'])\n",
    "    df_mean_passes = df_mean_passes[df_mean_passes['guest_number'] > 0]\n",
    "    df_mean_passes.set_index('guest_number', inplace=True)\n",
    "    \n",
    "    return df_mean_passes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Six Guests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_guests = 6\n",
    "states, state_to_idx, n_states = generate_states(n_guests)\n",
    "state_labels = [str(s) for s in states]\n",
    "P = cranberry_passing_transition_matrix(n_guests)\n",
    "\n",
    "# construct the plot\n",
    "fig, ax = plt.subplots(figsize = (8,6), facecolor = 'w')\n",
    "cm = ax.imshow(P,  cmap='inferno')\n",
    "\n",
    "# major ticks with labels\n",
    "ax.set_yticks(np.arange(n_states))\n",
    "ax.set_xticks(np.arange(n_states))\n",
    "ax.set_xticklabels(state_labels, rotation=90)\n",
    "ax.set_yticklabels(state_labels, rotation=0)\n",
    "\n",
    "# minor ticks + grid\n",
    "ax.set_xticks(np.arange(-.5, n_states, 1), minor=True)\n",
    "ax.set_yticks(np.arange(-.5, n_states, 1), minor=True)        \n",
    "ax.grid(which='minor', color='grey', linestyle='-', linewidth=1.5)\n",
    "ax.set_title(\"Transition Matrix for {} Guests\".format(n_guests))\n",
    "fig.colorbar(cm);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# adjacency matrix is the matrix whose i,j is 1 if there is a transition from i to j\n",
    "# and 0 otherwise\n",
    "P_adjacency = P > 0\n",
    "\n",
    "# construct the adjacency graph (for this problem, it's a directed tree) \n",
    "# from the adjacency matrix\n",
    "G = nx.from_numpy_matrix(P_adjacency, create_using=nx.DiGraph)\n",
    "G = nx.relabel_nodes(G, dict(zip(range(len(G.nodes())), state_labels)))\n",
    "\n",
    "# Create a dictionary of edge labels\n",
    "edge_labels = dict()\n",
    "for i_start, state_start in enumerate(states):\n",
    "    state_label_start = state_labels[i_start]\n",
    "    idx_start = state_to_idx[state_start]\n",
    "    \n",
    "    for i_end, state_end in enumerate(states):\n",
    "        state_label_end = state_labels[i_end]\n",
    "        idx_end = state_to_idx[state_end]\n",
    "                       \n",
    "        # if the graph has an edge, and the nodes are ditinct (i.e. not a terminal node) \n",
    "        # add the probability as the edge label \n",
    "        if P_adjacency[idx_start, idx_end] and idx_start != idx_end:\n",
    "            edge_labels[(state_label_start, state_label_end)] = '{:0.02f}'.format(P[idx_start, idx_end])\n",
    "\n",
    "# get layout for graph\n",
    "pos=graphviz_layout(G, prog='dot')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12, 4), facecolor='w')\n",
    "plt.title(\"Cranberry Passing States for {} Guests\".format(n_guests))\n",
    "\n",
    "# print the transition probability\n",
    "edge_text = nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels,font_color='grey', font_size = 7.5, ax=ax)\n",
    "for _,t in edge_text.items():\n",
    "    t.set_rotation('horizontal')\n",
    "\n",
    "# plot the adjacency graph\n",
    "nx.draw(G, pos, with_labels=True, arrows=True, font_size=10, node_color='lightsteelblue', edge_color='grey', ax=ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_state(state, n_guests, p=(0,0), r=1, ax = None, s=100, s_star=200):\n",
    "    if ax is None:\n",
    "        fig, ax = plt.subplots()\n",
    "    \n",
    "    if type(state) == tuple:\n",
    "        k_left, k_right = state[1]\n",
    "        n_served = state[2]\n",
    "        \n",
    "        if k_left > k_right:\n",
    "            idxs = [(k_left+i)%n_guests for i in range(n_served)]\n",
    "        \n",
    "        else:\n",
    "            idxs = [(k_right-i)%n_guests for i in range(n_served)]\n",
    "        \n",
    "    else:\n",
    "        idx_cur = state\n",
    "        idxs = list(range(0, n_guests + 1))\n",
    "            \n",
    "    thetas_guest = np.linspace(-np.pi/2, 3*np.pi/2, n_guests + 1)\n",
    "    xs_guest, ys_guest = p[0] + r * np.cos(thetas_guest), p[1] + r * np.sin(thetas_guest)\n",
    "    \n",
    "    thetas_table = np.linspace(0, 2*np.pi, 100)\n",
    "    xs_table, ys_table = p[0] + r * np.cos(thetas_table), p[1] + r * np.sin(thetas_table)\n",
    "    \n",
    "    xs_received, ys_received = xs_guest[idxs], ys_guest[idxs]\n",
    "    \n",
    "    ax.plot(xs_table, ys_table, c='k', zorder=100)\n",
    "    ax.scatter(xs_guest, ys_guest, c='lightgrey', edgecolor='k', zorder=101, s = s)\n",
    "    ax.scatter(xs_received, ys_received, c='C0', edgecolor='k', zorder=102, s =s)\n",
    "    \n",
    "    if not type(state) == tuple:\n",
    "        idx_last = state\n",
    "        ax.scatter(xs_received[idx_last], ys_received[idx_last], marker='*', c='y', s=s_star, edgecolor='k', zorder=104)\n",
    "    else:\n",
    "        idx_curr = state[0]        \n",
    "        ax.scatter(xs_guest[idx_curr], ys_guest[idx_curr], c='C3', edgecolor='k', zorder=103, s=s)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the adjacency graph\n",
    "fig, ax = plt.subplots(figsize=(12, 4))\n",
    "plt.title(\"Cranberry Passing States for {} Guests\".format(n_guests))\n",
    "pos=graphviz_layout(G, prog='dot')\n",
    "nx.draw(G, pos, with_labels=False, arrows=True, arrowsize=6, font_size=10, node_size=2, node_color='grey', edge_color='grey')\n",
    "\n",
    "for state, state_label in zip(states, state_labels):\n",
    "    p = pos[state_label]\n",
    "    plot_state(state, n_guests, p=p, r = 27, s=30, ax=ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Guest Number (k)')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p_last = receive_cranberries_last_probabilities(n_guests)\n",
    "fig, ax = plt.subplots(facecolor='w')\n",
    "p_last.plot.bar(ax=ax)\n",
    "ax.get_legend().remove()\n",
    "ax.set_title('Probability Guest k Receives Cranberry Sauce Last\\nNumber of Guests: {}'.format(n_guests))\n",
    "ax.set_xlabel('Guest Number (k)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Twenty Guests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_guests = 20\n",
    "states, state_to_idx, n_states = generate_states(n_guests)\n",
    "state_labels = [str(s) for s in states]\n",
    "P = cranberry_passing_transition_matrix(n_guests)\n",
    "\n",
    "# construct the plot\n",
    "fig, ax = plt.subplots(figsize = (8,6), facecolor = 'w')\n",
    "cm = ax.imshow(P,  cmap='inferno')\n",
    "\n",
    "# major ticks with labels\n",
    "ax.set_yticks([])\n",
    "ax.set_xticks([])\n",
    "ax.set_title(\"Transition Matrix for {} Guests\".format(n_guests))\n",
    "fig.colorbar(cm);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# adjacency matrix is the matrix whose i,j is 1 if there is a transition from i to j\n",
    "# and 0 otherwise\n",
    "P_adjacency = P > 0\n",
    "\n",
    "# construct the adjacency graph (for this problem, it's a directed tree) \n",
    "# from the adjacency matrix\n",
    "G = nx.from_numpy_matrix(P_adjacency, create_using=nx.DiGraph)\n",
    "only_label_terminal = [str(s) if type(s) == int else ('(0,(0,0),1)' if s == (0, (0,0), 1) else ' ') for s in states]\n",
    "labels = dict(zip(range(len(G.nodes())), only_label_terminal))\n",
    "\n",
    "# plot the adjacency graph\n",
    "fig, ax = plt.subplots(figsize=(12, 4))\n",
    "plt.title(\"Cranberry Passing States for {} Guests\".format(n_guests))\n",
    "pos=graphviz_layout(G, prog='dot')\n",
    "nx.draw(G, pos, with_labels=False, arrows=True, font_size=10, node_size=4, arrowsize=4,\n",
    "        node_color='steelblue', edge_color='grey')\n",
    "\n",
    "# manually offset the label positions\n",
    "for k in labels.keys():\n",
    "    tmp = np.array(pos[k])    \n",
    "    if labels[k] == '(0,(0,0),1)':        \n",
    "        tmp += np.array([0, 60])\n",
    "        pos[k] = tmp\n",
    "    else:\n",
    "        tmp += np.array([0, -75])\n",
    "        pos[k] = tmp\n",
    "nx.draw_networkx_labels(G,pos,labels,font_size=10,font_color='k');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p_last = receive_cranberries_last_probabilities(n_guests)\n",
    "fig, ax = plt.subplots(facecolor='w')\n",
    "p_last.plot.bar(ax=ax)\n",
    "ax.set_title('Probability Guest k Receives Cranberry Sauce Last\\nNumber of Guests: {}'.format(n_guests))\n",
    "ax.set_xlabel('Guest Number (k)')\n",
    "ax.get_legend().remove()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute Last Probability and Mean Passes For $n_{guests} = 3,4,...,20$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Completed Calculation for n_guests = 3 in 0.003 seconds\n",
      "Completed Calculation for n_guests = 4 in 0.003 seconds\n",
      "Completed Calculation for n_guests = 5 in 0.003 seconds\n",
      "Completed Calculation for n_guests = 6 in 0.004 seconds\n",
      "Completed Calculation for n_guests = 7 in 0.007 seconds\n",
      "Completed Calculation for n_guests = 8 in 0.008 seconds\n",
      "Completed Calculation for n_guests = 9 in 0.012 seconds\n",
      "Completed Calculation for n_guests = 10 in 0.021 seconds\n",
      "Completed Calculation for n_guests = 11 in 0.042 seconds\n",
      "Completed Calculation for n_guests = 12 in 0.086 seconds\n",
      "Completed Calculation for n_guests = 13 in 0.178 seconds\n",
      "Completed Calculation for n_guests = 14 in 0.386 seconds\n",
      "Completed Calculation for n_guests = 15 in 0.799 seconds\n",
      "Completed Calculation for n_guests = 16 in 1.757 seconds\n",
      "Completed Calculation for n_guests = 17 in 3.680 seconds\n",
      "Completed Calculation for n_guests = 18 in 7.924 seconds\n",
      "Completed Calculation for n_guests = 19 in 17.812 seconds\n",
      "Completed Calculation for n_guests = 20 in 40.032 seconds\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "# code isn't set up to run n = 2 since it's trivial\n",
    "df_p_and_means_all = pd.DataFrame(\n",
    "    [(2, 1, 1, 1)], \n",
    "    columns = ['n_guests', 'guest_number', \n",
    "                'probability_last', 'mean_number_passes']\n",
    ")\n",
    "\n",
    "# range to compute\n",
    "n_guests_lo = 3\n",
    "n_guests_hi = 20\n",
    "\n",
    "for n_guests in range(n_guests_lo, n_guests_hi + 1):\n",
    "    tic = time.time()\n",
    "    df_p_last = receive_cranberries_last_probabilities(n_guests)\n",
    "    df_mean_last = mean_passes(n_guests)\n",
    "    toc = time.time()\n",
    "    print(\"Completed Calculation for n_guests = {} in {:0.03f} seconds\".format(n_guests, toc - tic))\n",
    "    \n",
    "    # Create a temporary dataframe for current step's results\n",
    "    df_tmp = pd.merge(df_p_last, df_mean_last, left_index=True, right_index=True)\n",
    "    df_tmp['n_guests'] = n_guests\n",
    "    df_tmp = df_tmp.reset_index()\n",
    "    \n",
    "    # Concatenate curent step's results on final dataframe\n",
    "    df_p_and_means_all = pd.concat([df_p_and_means_all, df_tmp])\n",
    "        \n",
    "df_p_and_means_all = df_p_and_means_all.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_p_and_means_all.to_csv(\"./output/analytical_prob_and_mean_passes_last.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create dataframe for mean number of passes - without conditioning\n",
    "df_tmp = df_p_and_means_all.copy()\n",
    "\n",
    "# temporary column for computing unconditional expectation\n",
    "df_tmp['TMP'] = df_tmp['probability_last'] * df_tmp['mean_number_passes']\n",
    "df_mean_passes = df_tmp.groupby('n_guests')[['TMP']].sum()['TMP'].reset_index()\n",
    "df_mean_passes = df_mean_passes.rename(columns = {'TMP' : 'mean_number_passes'})\n",
    "df_mean_passes['inefficiency'] = (\n",
    "    df_mean_passes['mean_number_passes'] / (df_mean_passes['n_guests'] - 1) - 1\n",
    ")\n",
    "\n",
    "# export to file\n",
    "df_mean_passes.to_csv('./output/analytical_mean_passes_and_inefficency.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot unconditional mean passes\n",
    "fig, ax = plt.subplots(facecolor='w')\n",
    "df_mean_passes.plot.bar(x = 'n_guests', y='mean_number_passes', ax=ax)\n",
    "ax.set_title('Average Number of Passes vs Number of Guests')\n",
    "ax.set_xlabel('Number of Guests')\n",
    "ax.set_ylabel('Average Number of Passes')\n",
    "ax.get_legend().remove()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEZCAYAAACAZ8KHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de1yOh/8/8Fcnlc4OqYQiUuKDUtjm1JJtFoYcotgsZJ8xNnyWY7OPtpnjpxhjzjK+H0pbYj5sbM7ns8gxiSiVTnf1/v3h4fqJ0n1RNL2ej0ePR/d1X9f7el/3dd/3674O93XriIiAiIhIS7qvugEiIvp7YXAQEZEqDA4iIlKFwUFERKowOIiISBUGBxERqcLgeAmWL1+ON99881W38Uq88847WLFixatu45lSUlLQoUMHmJmZYdy4cRARDB06FFZWVvD09MTu3bvh7OxcZp01a9aga9euL6FjKs2QIUMwadKkVzLvJ583r7MqGxxr166Fh4cHTE1NYWtri3feeQd79ux51W29FEOGDEG1atVgamqKGjVqwMfHB+fOnauQecXFxSEoKKjc6+7atQv29vblUmvx4sWoVasWMjIy8P3332PPnj3Yvn07bty4gQMHDuCtt97C+fPny6wTEBCAbdu2lUtP5WHHjh1wdHSEra0t1q9frwxPT09H69atkZmZWeE9ODg4oE6dOnjw4IEy7Mcff0SnTp0qfN4v25PPm5IkJyfj448/hp2dHUxNTdGwYUMMGTKkwl5/j3Tq1Ak//vhjudWrksExe/ZsjBkzBl9++SVSUlJw7do1hISEIDo6usTxCwoKXnKHpSupl8LCQtV1xo8fj6ysLNy4cQPW1tYYMmRIOXT393T16lW4urpCR0dHue3g4AATE5NX3NmLGTNmDLZs2YKtW7di5MiRyvPkX//6FyZOnAgzM7OX0kdBQQHmzZv3UuZVntS+rsp63ty9exft27dHdnY2du/ejczMTBw5cgQdO3bE9u3by6Pll0eqmPT0dDExMZGff/651HGmTp0qvXv3loCAADEzM5MlS5bI/v37pW3btmJhYSE2NjYyatQoycvLU6YBIAsXLhQnJyextLSUkJAQKSoqEhGRn376Sdq3by+ffPKJmJubi7Ozs/z222/Fevrwww/FxsZG7OzsJDQ0VAoKCopNO2bMGLGyspLQ0FAJCgqSESNGyDvvvCPVq1eXb7/9VqytrUWj0Sg1N27cKP/4xz9KXL6goCAJDQ1VbsfGxoqJiYmIiHz66adib28vZmZm0rp1a/njjz+U8fbv3y/u7u5iZmYm1tbW8tlnn4mISE5OjgQEBEiNGjXEwsJCPDw85NatWyIi0rFjR1myZImyLG+88YaMGzdOLC0txcHBQX799VelfmJiorz11ltiamoq3t7eEhISIgEBASUuw86dO6Vu3brK7Y4dO8qkSZOkffv2YmpqKj4+PnLnzh3l/r1790q7du3EwsJCWrRoITt37lQeC319fTEwMBATExNZtGiRGBoaiq6urpiYmMiUKVOemte1a9ekV69eUqtWLalRo4aMGjWq2PI9cvbsWXn77bfFyspKmjRpIuvXry+2DkJCQuTdd98VU1NT8fT0lIsXLyr3nzp1SpnW2tpavv76a0lOThZjY2NJTU1Vxjt06JDUqlVL8vPzn3qMHB0dlf/r1KkjKSkpsn//fvH19S3xMX1c06ZNZcuWLcptjUYjNWvWlMOHDz9zfT+pQYMGMnPmTLGyspK0tDQREVmyZIl07NhRREQuX74sAIo9d598zjx6/ltYWIijo6P8+eef8tNPP4m9vb3Url1bli9fXuxxHT58uLz99ttiamoqHTp0kCtXrij3l7VOHn9dbd++/anlSUpKkvfff1+srKykUaNGsnjxYhER+fHHH5963jwpNDRUWrRoIYWFhaU+7k8+1x49ho96KSwslJkzZ0rDhg2lRo0a0rdvX7l7966IlP46/PLLL0VXV1cMDQ3FxMRERo0aJUVFRTJmzBipXbu2mJubS/PmzeXkyZOl9vWkKhcccXFxoqenV+yJ+qSpU6eKvr6+bNq0SQoLCyU7O1sOHToke/fuFY1GI5cvX5amTZvKnDlzlGkAyHvvvSdpaWly9epVqVWrlsTFxYnIwye/np6ezJ49W/Lz8yUqKkrMzc2VFd6jRw8JDg6WrKwsSUlJkTZt2siiRYuKTTt//nzRaDSSnZ0tQUFBYm5uLnv27JHCwkLJyckRFxeXYm/CPXv2lFmzZpW4fI8HR2ZmpgwYMEDefPNNERFZtWqVpKamikajkVmzZkmdOnUkJydHRETatm0rK1euVKbbu3eviIgsWrRIunfvLg8ePJCCggI5dOiQ3L9/X0SefhPQ19eXxYsXS0FBgURGRoqtra0SsG3btpVx48ZJXl6e7N69W8zMzFQFR8OGDeX8+fOSnZ0tHTt2lAkTJoiIyI0bN6RGjRryyy+/SGFhoWzbtk1q1Kght2/ffurxeNTn4wHw+LwKCgqkRYsWMmbMGMnKypKcnBzZvXv3U9NlZWWJvb29LFu2TDQajRw+fFhq1qwpp06dUuZpZWUl+/fvF41GIwMHDpR+/fqJiEhGRobY2NjIrFmzJCcnRzIyMmTfvn0iIvLOO+9IZGSk0tuYMWPkk08+KfEx8vLykmPHjsmxY8fE1tZW8vPzpV27dnL+/PkSx3/c9OnTZeDAgcrt2NhYcXZ2FpFnr+8nPXrT69Wrl/IYqw0OPT09WbZsmRQUFEhoaKjUq1dPQkJCJDc3V+Lj48XU1FQyMzOVx9XU1FR+//13yc3NlU8//VTVOnnydfWkDh06yMiRIyUnJ0eOHj0qtWrVUj4EPvm8KWl9TJ069ZmPe1nBMWfOHPHy8pLr169Lbm6uBAcHS//+/UVE+9ehiMjWrVuldevWkpaWJkVFRXLmzBm5efPmM3t7XJXbVXX37l3UqlUL+vr6zxyvXbt26NmzJ3R1dWFsbAx3d3e0bdsW+vr6cHBwwPDhw/H7778Xm2bixImwtLRE/fr10blzZxw7dky5z9raGmPGjIGBgQH69esHZ2dn/PLLL0hJSUFcXBzmzp0LExMTWFtb47PPPkNUVJQyrZ2dHf75z39CX18fxsbGAIAePXrgjTfegK6uLoyMjBAUFITVq1cDAO7du4f4+HgMHDiw1OWbNWsWLC0t4eTkhKysLCxfvhwAMGjQINSsWRP6+voYN24c8vLylP37BgYGuHjxIlJTU2Fqaoq2bdsqw+/evYuLFy9CT08P7u7uMDc3L3G+DRo0wMcffww9PT0EBQUhOTlZ2V148OBBhIWFoVq1anjzzTfh5+f3zHX0pKFDh6JJkyYwNjaGv7+/8vivXr0a7777Lt59913o6urCx8cHHh4e+PXXX1XVB4ADBw7g5s2b+O6772BiYgIjI6MST3yIjY2Fg4MDhg4dCn19fbRu3Rq9e/fGxo0blXE++OADeHp6Ql9fHwEBAUq/sbGxsLGxwbhx42BkZAQzMzN4eXkBQLH1XFhYiHXr1mHw4MEl9rpo0SKMHj0awcHBWLVqFRYuXAhvb2/k5ubC19cXnTt3fuo5/MjAgQMRExOD7OxsAA+PCT56PqlZ34+EhYVhwYIFuHPnzjPHK4mjoyOGDh0KPT099OvXD9evX8eUKVNgaGiIrl27olq1arh48aIy/nvvvYcOHTrA0NAQX3/9Nfbu3Yvr169rtU6efF097vr169izZw+++eYbGBkZoWXLlhg2bBhWrVql1XKkpqbCxsZGuR0TEwNLS0uYmZlpfVLFDz/8gK+//hr29vYwNDTEtGnTsHHjRhQUFKhaLwYGBsjMzMS5c+cgInBxcYGtra1WPQBV8BhHzZo1kZqaWuZxi3r16hW7feHCBXTv3h02NjYwNzfHl19+idTU1GLjPP6kqF69OrKyspTbdevWVfahAw/fQG/evImrV69Co9HA1tYWlpaWsLS0xPDhw3H79u1Seylp2KBBg7BlyxZkZWXh559/xltvvfXMJ8Lnn3+O9PR03Lp1CzExMWjUqBEA4Pvvv4eLiwssLCxgaWmJ+/fvK8u5dOlSXLhwAU2bNkWbNm0QGxsLABg8eDB8fX3Rv39/2NnZYfz48dBoNCXO98nHCACysrJw8+ZN1KhRQxlW2nI/S2mP/9WrV7Fhwwbl8bW0tMSePXuQnJysqj7w8M2jQYMGZX7wuHr1Kvbv319snmvWrMGtW7fK7Pf69evK+nhSjx49cObMGSQmJmL79u2wsLAo9Qyeli1bYteuXdi/fz9cXV2xbNkyfPnllxg2bBimTp2Kn376CYMHD4aUcJ1TJycnuLi4YMuWLcjOzkZMTIwSHGrW9yNubm7o3r07wsPDnzleSerUqaP8/+iD05PDHn+tPf68eXQCyKPXWlnr5FnPuUfP0cePDTVo0ABJSUlaLUfNmjWLPef8/PyQnp6OOXPmID8/X6saV69eRa9evZT+XVxcoKenh5SUFFXrpUuXLvjkk08watQo1KlTB8HBwcjIyNCqB6AKBke7du1gZGSEzZs3P3O8x9/kAWDkyJFo2rQpEhISkJGRgX//+98lvuBKk5SUVGz8a9euwc7ODvXq1YOhoSFSU1ORnp6O9PR0ZGRk4PTp06X2UtKwunXrol27dti0aRNWrVpV6qfQZ9m9eze++eYb/Pzzz0hLS0N6ejosLCyUvhs3box169bh9u3bmDBhAvr06YMHDx7AwMAAU6dOxZkzZ/DXX38hNjYWK1euVDVvW1tb3Lt3T/mECzx8Ay0P9erVw+DBg5XHNz09HQ8ePMDEiROfq9a1a9e0+uDRsWPHYvPMysrCwoULtZrHpUuXSrzPyMgI/v7+WLNmjar1/Nlnn2HGjBkwNjbGyZMn4eHhAQcHB2g0mlK3AgYMGIB169YhOjoarq6ucHJyAoDnXt/Tp0/HkiVLir3RPjqQ/Ph6f/yN/Hk8/rzJysrCvXv3lNdaWeukpNfaI3Z2drh3716xs9GuXbuGunXratWXt7c3Nm/ejKKiolLHMTExKfZYFBYWFls/9erVQ1xcXLFlyM3NRd26dZ+5Xkpark8//RSHDx/G6dOnceHCBXz33XdaLQdQBYPDwsICYWFhGDVqFDZv3ozs7GxoNBrExcVh/PjxpU6XmZkJc3NzmJqa4ty5c1q9ATzu9u3bmD9/PjQaDTZs2ICzZ8/i3Xffha2tLbp27Ypx48YhIyMDRUVFuHTpUqm7EJ4lMDAQ3377LU6ePIlevXqpnj4zMxP6+vqoXbs2CgoKEBYWVuxTyOrVq3Hnzh3o6urC0tISAKCnp4edO3fi5MmTKCwshLm5OQwMDKCnp6dq3g0aNICHhwemTZuG/Px87N27F1u2bFG9DCV5tDUWHx+PwsJC5ObmYteuXbhx44bqWp6enrC1tcXEiRPx4MED5Obm4s8//3xqvO7du+PChQtYtWoVNBoNNBoNDh48iLNnz5Y5j+7du+PWrVuYO3cu8vLykJmZif379yv3BwYGYvny5YiJicGgQYPKrLd9+3bk5uaie/fuAB7u+vnf//6H06dPIy8vDzVr1ixxuv79+2Pbtm1YuHBhsd2ez7u+nZyc0K9fP8yfP18ZVrt2bdStWxerV69GYWEhli1bVmpoauvXX3/Fnj17kJ+fj8mTJ8PLywv16tV7oXUCPHzTbt++Pf71r38hNzcXJ06cwNKlSxEQEKDV9GPHjkVaWhoGDx6MS5cuQUSQmZlZbJd2kyZNkJubi19++QUajQYzZsxAXl6ecv+IESMQGhqKq1evAgDu3LmjnA36rPVSp04dJCYmKnUOHjyI/fv3Q6PRKLtc1bxmq1xwAA9X4OzZszFjxgzUrl0b9erVw3/+8x/07Nmz1GlmzZqFtWvXwszMDB9//DH69eunap5eXl5ISEhArVq1EBoaio0bNyov2JUrVyI/Px+urq6wsrJCnz59nms3Sq9evZRN2ec5ldTX1xfvvPMOmjRpggYNGsDIyKjYpvvWrVvRrFkzmJqaYvTo0YiKioKRkRFu3bqFPn36wNzcHC4uLujYsaNWb2hPWrNmDfbu3YuaNWti0qRJ6NevHwwNDVXXeVK9evUQHR2Nf//738r6/u677575ya80enp62LJlCy5evIj69evD3t6+2HckHjEzM8O2bdsQFRUFOzs72NjYYMKECcXeBEpjZmaG7du3Y8uWLbCxsUHjxo2xc+dO5f5H++Bbt24NBweHZ9bKy8vDF198Uex02AULFmDEiBF4++23ERkZWeobhq2tLdq1a4e//vqr2PP9Rdb3lClTin2nAwCWLFmC7777DjVr1sTp06fRvn17rWqVZuDAgZg+fTpq1KiBw4cPY82aNQBebJ08sm7dOly5cgV2dnbo1asXpk+fDh8fH62mrVWrFvbt26ccFzMzM0PLli2RmZmpfBC1sLBAZGQkhg0bhrp168LExKTY95VGjx4NPz8/dO3aFWZmZmjbtq3yoeJZ62X06NHYuHEjrKys8OmnnyIjIwMff/wxrKys0KBBA9SsWROff/651o+DjqjZ30KVXqNGjfDDDz/g7bffftWtvLB+/fqhadOmmD59+qtupdLp0qULBg4ciGHDhr3qVqgKqpJbHK+r//u//4OOjg66dOnyqlt5LgcPHsSlS5dQVFSErVu3Ijo6+plbgVXVwYMHceTIEdVbvUTl5dmnhtDfRqdOnXDmzBmsWrUKurp/z88Dt27dwgcffIC7d+/C3t4eCxcuRKtWrV51W5VKUFAQNm/ejHnz5r20b34TPYm7qoiISJW/50dTIiJ6ZRgcRESkSpU4xlGrVq0yT1skIqLirly58tQVMoAqEhwODg44dOjQq26DiOhvxcPDo8Th3FVFRESqMDiIiEgVBgcREanC4CAiIlUYHEREpAqDg4iIVGFwEBGRKgwOIiJSpUp8AZCIqCpzmPhLmeNcCX9P63rc4iAiIlUYHEREpAqDg4iIVGFwEBGRKgwOIiJShcFBRESqMDiIiEgVBgcREanC4CAiIlUYHEREpAovOUJEVImVdbkQNZcKKS/c4iAiIlUYHEREpAqDg4iIVGFwEBGRKgwOIiJShcFBRESqMDiIiEgVBgcREalSocExZ84cNGvWDG5ubhgwYAByc3Nx7949+Pj4oHHjxvDx8UFaWpoy/syZM+Hk5ARnZ2fEx8cDAPLy8tCtWze4ubkhMjJSGTc4OBhHjx6tyPaJiKgEFRYcSUlJmD9/Pg4dOoRTp06hsLAQUVFRCA8Ph7e3NxISEuDt7Y3w8HAAwJkzZxAVFYXTp09j69atCAkJQWFhIeLj4+Hu7o4TJ05g8eLFAIDjx4+jqKgIrVq1qqj2iYioFBW6xVFQUICcnBwUFBQgOzsbdnZ2iI6ORlBQEAAgKCgImzdvBgBER0ejf//+MDQ0hKOjI5ycnHDgwAEYGBgoNR6ZPHkywsLCKrJ1IiIqRYVdq6pu3br4/PPPUb9+fRgbG6Nr167o2rUrUlJSYGtrCwCwtbXF7du3ATzcQmnbtq0yvb29PZKSktCzZ0+sWrUKXl5eGD9+PGJiYuDu7g47O7tnzn/x4sXKFsqdO3cqaCmJiEpW1jWmgFdznanyUGHBkZaWhujoaFy+fBmWlpbo27cvVq9eXer4IvLUMB0dHejr62Pt2rUAAI1GA19fX8TExGDs2LG4du0aAgMD4efn99S0wcHBCA4OBgB4eHiU01IREVGF7ar67bff4OjoiNq1a8PAwAAffPAB/vrrL9SpUwfJyckAgOTkZFhbWwN4uIVx/fp1ZfobN248tVURGRmJoKAg7N27F9WqVcP69esxY8aMiloEIiIqQYUFR/369bFv3z5kZ2dDRLBjxw64uLjAz88PK1asAACsWLECPXr0AAD4+fkhKioKeXl5uHz5MhISEuDp6anUS0tLQ2xsLAIDA5GdnQ1dXV3o6OggNze3ohaBiIhKUGG7qry8vNCnTx+0bt0a+vr6aNWqFYKDg5GVlQV/f38sXboU9evXx4YNGwAAzZo1g7+/P1xdXaGvr4+IiAjo6ekp9cLCwjBp0iTo6OjA19cXERERaN68OUaMGFFRi0BERCXQkZIOLrxmPDw8cOjQoVfdBhFVIeV1cLw8fsjpeXsp7b2T3xwnIiJVGBxERKQKg4OIiFRhcBARkSoMDiIiUqXCTsclIvo7ep0vFVJeuMVBRESqMDiIiEgVBgcREanC4CAiIlUYHEREpAqDg4iIVGFwEBGRKgwOIiJShcFBRESqMDiIiEgVBgcREanCa1UR0WuD15l6ObjFQUREqjA4iIhIFQYHERGpwuAgIiJVGBxERKQKg4OIiFRhcBARkSoMDiIiUoXBQUREqjA4iIhIFV5yhIheOV4q5O+FWxxERKQKg4OIiFRhcBARkSpaHeNIS0vDzZs3YWxsDAcHB+jqMm+IiKqqUoPj/v37iIiIwLp165Cfn4/atWsjNzcXKSkpaNu2LUJCQtC5c+eX2SsREVUCpQZHnz59EBgYiN27d8PS0rLYfYcPH8aqVauQmJiIjz76qMKbJCKiyqPU4Ni+fXupE7m7u8Pd3b1CGiIiospN6+9x3LlzB/PmzUNOTg5GjhwJJyeniuyLiIgqKa2Pco8bNw4dOnRAt27dMGDAAK2mSU9PR58+fdC0aVO4uLhg7969uHfvHnx8fNC4cWP4+PggLS1NGX/mzJlwcnKCs7Mz4uPjAQB5eXno1q0b3NzcEBkZqYwbHByMo0ePats+ERGVk1KDo1u3bti9e7dyOz8/Hw4ODnBwcEBeXp5WxUePHo1u3brh3LlzOH78OFxcXBAeHg5vb28kJCTA29sb4eHhAIAzZ84gKioKp0+fxtatWxESEoLCwkLEx8fD3d0dJ06cwOLFiwEAx48fR1FREVq1avUiy05ERM+h1OBYv349oqOjMXDgQFy6dAlfffUVwsLCMHHixGKf/EuTkZGBP/74Qzl4Xq1aNVhaWiI6OhpBQUEAgKCgIGzevBkAEB0djf79+8PQ0BCOjo5wcnLCgQMHYGBggJycHBQUFCi1J0+ejLCwsBdacCIiej6lHuOwsLDArFmzkJiYiNDQUNStWxcRERGwsLDQqnBiYiJq166NoUOH4vjx43B3d8e8efOQkpICW1tbAICtrS1u374NAEhKSkLbtm2V6e3t7ZGUlISePXti1apV8PLywvjx4xETEwN3d3fY2dk9c/6LFy9WtlDu3LmjVc9EpF5Z15niNaZeP6UGR2JiIhYuXAgDAwN8//33uHTpEvz9/dG9e3eEhIRAT0/vmYULCgpw5MgRLFiwAF5eXhg9erSyW6okIvLUMB0dHejr62Pt2rUAAI1GA19fX8TExGDs2LG4du0aAgMD4efn99S0wcHBCA4OBgB4eHg8s1ciItJeqbuqBgwYgG7duqFt27YYPHgw3nrrLcTHx8Pc3Bxdu3Yts7C9vT3s7e3h5eUF4OH3Qo4cOYI6deogOTkZAJCcnAxra2tl/OvXryvT37hx46mtisjISAQFBWHv3r2oVq0a1q9fjxkzZqhfaiIiem6lBkdubi4cHR3h6OiI7OxsZXhQUBBiY2PLLGxjY4N69erh/PnzAIAdO3bA1dUVfn5+WLFiBQBgxYoV6NGjBwDAz88PUVFRyMvLw+XLl5GQkABPT0+lXlpaGmJjYxEYGIjs7Gzo6upCR0cHubm5z7fkRET0XErdVRUZGYkvvvgC1apVw6JFi4rdZ2xsrFXxBQsWICAgAPn5+WjYsCF++uknFBUVwd/fH0uXLkX9+vWxYcMGAECzZs3g7+8PV1dX6OvrIyIiotjusLCwMEyaNAk6Ojrw9fVFREQEmjdvjhEjRjzPchMR0XMqNTjeeOMNvPHGGy9UvGXLljh06NBTw3fs2FHi+KGhoQgNDS3xvjlz5ij/GxkZYdu2bS/UGxERPZ9Sd1W9//77iI2NhUajeeq+xMRETJkyBcuWLavQ5oiIqPIpdYtjyZIlmD17NkaPHo0aNWooV8e9cuUKGjVqhE8++UQ5PkFERFVHqcFhY2ODb7/9Ft9++y2uXLmC5ORkGBsbo0mTJqhevfrL7JGIiCoRrS5y+OhSI0RERPwpPyIiUkXry6oT0eulrEuFALxcCJWszC2O2NhYFBUVvYxeiIjob6DM4IiKikLjxo0xfvx4nD179mX0RERElViZwbF69WocPXoUjRo1wtChQ9GuXTssXrwYmZmZL6M/IiKqZLQ6OG5ubo7evXujf//+SE5OxqZNm9C6dWssWLCgovsjIqJKpszg2LJlC3r16oUuXbpAo9HgwIEDiIuLw/HjxzFr1qyX0SMREVUiZZ5VtWHDBnz22Wfo0KFDseHVq1fnJUeIiKqgMoNj+vTpyi/2AUBOTg5SUlLg4OAAb2/vCm2OiIgqnzJ3VfXt2xe6uv9/ND09PfTt27dCmyIiosqrzOAoKChAtWrVlNvVqlVDfn5+hTZFRESVV5nBUbt2bcTExCi3o6OjUatWrQptioiIKq8yj3EsWrQIAQEB+OSTTyAiqFevHlauXPkyeiMiokqozOBo1KgR9u3bh6ysLIgIzMzMXkZfRFQKXmOKXrUygyMvLw//93//hytXrqCgoEAZPmXKlAptjIiIKqcyg6NHjx6wsLCAu7s7DA0NX0ZPRERUiZUZHDdu3MDWrVtfRi9ERPQ3UOZZVe3bt8fJkydfRi9ERPQ3UOYWx549e7B8+XI4OjrC0NAQIgIdHR2cOHHiZfRHRESVTJnBERcX9zL6ICKiv4kyd1U1aNAA169fx//+9z80aNAA1atX5y8CEhFVYWUGx/Tp0/HNN99g5syZAACNRoNBgwZVeGNERFQ5lRkcmzZtQkxMDExMTAAAdnZ2/PU/IqIqrMzgqFatGnR0dKCjowMAePDgQYU3RURElVeZweHv74/hw4cjPT0dS5Yswdtvv42PP/74ZfRGRESVUJlnVX3++efYvn07zM3Ncf78eYSFhcHHx+dl9Eb02uF1puh1UGZwAICPjw/DgoiIADxjV9Wbb74JADAzM4O5ubny9+g2ERFVTaVucezZswcAeAYVEREVU+bB8X379hULj6ysLOzfv79CmyIiosqrzOAYOXIkTOUJGc4AABuzSURBVE1NldvVq1fHyJEjK7QpIiKqvMoMjkcXNVQm0NUt9oNORERUtZQZHA0bNsT8+fOh0Wig0Wgwb948NGzY8GX0RkRElVCZwbFo0SL89ddfqFu3Luzt7bF//34sXrxY6xkUFhaiVatW6N69OwDg3r178PHxQePGjeHj44O0tDRl3JkzZ8LJyQnOzs6Ij48H8PCna7t16wY3NzdERkYq4wYHB+Po0aNa90FEROWjzOCwtrZGVFQUbt++jZSUFKxduxbW1tZaz2DevHlwcXFRboeHh8Pb2xsJCQnw9vZGeHg4AODMmTOIiorC6dOnsXXrVoSEhKCwsBDx8fFwd3fHiRMnlMA6fvw4ioqK0KpVK7XLS0REL6jU03G//fZbjB8/Hv/85z+LHeN4ZP78+WUWv3HjBn755ReEhoZi9uzZAIDo6Gjs2rULABAUFIROnTrhm2++QXR0NPr37w9DQ0M4OjrCyckJBw4cgIGBAXJycoodV5k8eTIWLVqkdlmJiKgclBocrq6uAAAPD4/nLj5mzBh8++23xU7nTUlJga2tLQDA1tYWt2/fBgAkJSWhbdu2ynj29vZISkpCz549sWrVKnh5eWH8+PGIiYmBu7s77OzsnjnvxYsXK1sod+7cee5lIAJ4qRCix5UaHOvXr0f37t2Rnp6O0aNHqy4cGxsLa2truLu7K1sYzyIiTw3T0dGBvr4+1q5dC+Dhb4H4+voiJiYGY8eOxbVr1xAYGAg/P7+npg0ODkZwcDCAFws/IiIqrtTgOHz4MK5evYply5YhMDDwqTf2GjVqPLPwn3/+iZiYGPz666/Izc1FRkYGBg0ahDp16iA5ORm2trZITk5WjpfY29vj+vXryvQ3btx4aqsiMjISQUFB2Lt3L6pVq4b169ejXbt2JQYHERFVjFIPjo8YMQLdunXDuXPn4O7uXuxPm0/wM2fOxI0bN3DlyhVERUWhS5cuWL16Nfz8/LBixQoAwIoVK9CjRw8AgJ+fH6KiopCXl4fLly8jISEBnp6eSr20tDTExsYiMDAQ2dnZ0NXVhY6ODnJzc1/0MSAiIhVKDY73338fZ8+exYcffojExERcvnxZ+UtMTHzuGU6cOBHbt29H48aNsX37dkycOBEA0KxZM/j7+8PV1RXdunVDREQE9PT0lOnCwsIwadIk6OjowNfXF4cOHULz5s352yBERC9Zqbuq+vTpg8OHD+PChQsvPJNOnTqhU6dOAICaNWtix44dJY4XGhqK0NDQEu+bM2eO8r+RkRG2bdv2wn0REZF6pQZHUVERpk+fjgsXLiin0j5u7NixFdoYERFVTqXuqoqKioKRkREKCgqQmZn51B8REVVNpW5xODs7Y8KECWjRogXeeeedl9kTERFVYmVecqR169b46KOPlPA4c+YMli5dWuGNERFR5VRmcAwZMgS+vr64efMmAKBJkyaYO3duhTdGRESVU5nBkZqaCn9/f+jqPhxVX1+/2GmyRERUtZR6jOMRExMT3L17V7nQ4b59+2BhYVHhjRGVB15jiqj8lRkcs2fPhp+fHy5duoQ33ngDd+7cwcaNG19Gb0REVAmVGRytW7fG77//jvPnz0NE4OzsDAMDg5fRGxERVUJlBgcAHDhwAFeuXEFBQQGOHDkCAAgMDKzQxoiIqHIqMzgGDx6MS5cuoWXLlspBcR0dHQYHEVEVVWZwHDp0CGfOnCnxVwCJiKjqKfN0XDc3N9y6detl9EJERH8DZW5xpKamwtXVFZ6enjA0NFSGx8TEVGhjRERUOZUZHNOmTXsJbRAR0d9FmcHRsWPHl9EHERH9TZQaHGZmZiUeEBcR6OjoICMjo0IbIyKiyqnU4OBvbtCrxsuFEFVOZZ5VRURE9DgGBxERqcLgICIiVRgcRESkCoODiIhUYXAQEZEqDA4iIlKFwUFERKowOIiISBUGBxERqcLgICIiVbT6zXEiNXiNKaLXG7c4iIhIFQYHERGpwuAgIiJVGBxERKQKg4OIiFRhcBARkSoMDiIiUqXCguP69evo3LkzXFxc0KxZM8ybNw8AcO/ePfj4+KBx48bw8fFBWlqaMs3MmTPh5OQEZ2dnxMfHAwDy8vLQrVs3uLm5ITIyUhk3ODgYR48eraj2iYioFBUWHPr6+vj+++9x9uxZ7Nu3DxEREThz5gzCw8Ph7e2NhIQEeHt7Izw8HABw5swZREVF4fTp09i6dStCQkJQWFiI+Ph4uLu748SJE1i8eDEA4Pjx4ygqKkKrVq0qqn0iIipFhQWHra0tWrduDQAwMzODi4sLkpKSEB0djaCgIABAUFAQNm/eDACIjo5G//79YWhoCEdHRzg5OeHAgQMwMDBATk4OCgoKlNqTJ09GWFhYRbVORETP8FIuOXLlyhUcPXoUXl5eSElJga2tLYCH4XL79m0AQFJSEtq2batMY29vj6SkJPTs2ROrVq2Cl5cXxo8fj5iYGLi7u8POzu6Z81y8eLGyhXLnzp0KWrLXT1mXC+GlQoiowoMjKysLvXv3xty5c2Fubl7qeCLy1DAdHR3o6+tj7dq1AACNRgNfX1/ExMRg7NixuHbtGgIDA+Hn5/fUtMHBwQgODgYAeHh4lNPSEBFRhZ5VpdFo0Lt3bwQEBOCDDz4AANSpUwfJyckAgOTkZFhbWwN4uIVx/fp1ZdobN248tVURGRmJoKAg7N27F9WqVcP69esxY8aMilwEIiJ6QoUFh4jgo48+gouLC8aOHasM9/Pzw4oVKwAAK1asQI8ePZThUVFRyMvLw+XLl5GQkABPT09lurS0NMTGxiIwMBDZ2dnQ1dWFjo4OcnNzK2oRiIioBBW2q+rPP//EqlWr0Lx5c7Rs2RIA8O9//xsTJ06Ev78/li5divr162PDhg0AgGbNmsHf3x+urq7Q19dHREQE9PT0lHphYWGYNGkSdHR04Ovri4iICDRv3hwjRoyoqEUgIqISVFhwvPnmmyUetwCAHTt2lDg8NDQUoaGhJd43Z84c5X8jIyNs27btxZskIiLV+M1xIiJShcFBRESqMDiIiEgVBgcREanC4CAiIlUYHEREpMpLuVYVVbyyrjEF8DpTRFQ+uMVBRESqMDiIiEgVBgcREanC4CAiIlUYHEREpAqDg4iIVGFwEBGRKgwOIiJShcFBRESqMDiIiEgVXnLkFeOlQojo74ZbHEREpAqDg4iIVGFwEBGRKgwOIiJShcFBRESqMDiIiEgVBgcREanC4CAiIlUYHEREpAqDg4iIVGFwEBGRKrxW1QvgdaaIqCriFgcREanC4CAiIlUYHEREpAqDg4iIVGFwEBGRKgwOIiJShcFBRESqVLrg2Lp1K5ydneHk5ITw8HAAwIQJE9CiRQsEBgYq461atQrz5s17VW0SEVVZlSo4CgsLMWrUKMTFxeHMmTNYt24djh8/jr/++gsnTpxAYWEhTp48iZycHCxfvhwhISGvumUioiqnUn1z/MCBA3ByckLDhg0BAP3790dMTAzy8/MhIsjJyYGBgQG+++47fPrppzAwMHjFHRMRVT06IiKvuolHNm7ciK1bt+LHH38E8HB31P79+1G/fn2sXbsW3t7e+PzzzxEcHIwtW7Y8s9bixYuxePFiAMC5c+fQtGnTZ45/584d1K5d+4X6L48ar2Mv5VWHvVRsncrUS3nVYS8vVufKlStITU19+g6pRH7++Wf56KOPlNsrV66UTz75pNg4H330kRw5ckSWLFkiffv2la+++qpc5u3u7l4papRXncrUS3nVYS8VW6cy9VJeddhLxdSpVMc47O3tcf36deX2jRs3YGdnp9w+evQoAKBJkyZYuXIlfv75Z5w6dQoJCQkvvVcioqqqUgVHmzZtkJCQgMuXLyM/Px9RUVHw8/NT7p88eTLCwsKg0WhQWFgIANDV1UV2dvarapmIqMrRmzZt2rRX3cQjurq6aNy4MQYNGoQFCxZg0KBB6N27NwBg8+bN0NPTw/vvvw8jIyOcPXsW48aNg42NTbmdXeXu7l4papRXncrUS3nVYS8VW6cy9VJeddhL+depVAfHiYio8qtUu6qIiKjyY3AQEZEqDA4iIlKlSgbHuXPnsGPHDmRlZRUbvnXrVlV1Dhw4gIMHDwIAzpw5g9mzZ+PXX399od4evx7X89qzZw9mz56Nbdu2qZpu//79yMjIAADk5ORg6tSpeP/99zFhwgTcv39fqxrz588vdkr188rPz8fKlSvx22+/AQDWrl2LTz75BBEREdBoNFrXuXTpEmbNmoXRo0dj3LhxWLRokdbLQkQlq3IHx+fPn4+IiAi4uLjg2LFjmDdvHnr06AEAaN26NY4cOaJVnenTpyMuLg4FBQXw8fHB/v370alTJ/z222/w9fVFaGhomTUeP9UYAEQEO3fuRJcuXQAAMTExWvXi6emJAwcOAACWLFmCiIgI9OrVC9u2bcP777+PiRMnalWnWbNmOH78OPT19REcHIzq1aujT58+2LFjB44fP47//ve/ZdawsLCAiYkJGjVqhAEDBqBv377P9S3XgIAAFBQUIDs7G5aWlsjKysIHH3yAHTt2QESwYsWKMmvMnz8fW7ZsQceOHfHrr7+iZcuWsLKywqZNmxAZGYlOnTqp7ovKdvv2bVhbW7/qNgAAd+/eRc2aNV91G6/U/fv3MXPmTGzevBl37twBAFhbW6NHjx6YOHEiLC0t1Rctl68g/o24ublJZmamiIhcvnxZ3N3dZe7cuSIi0rJlS1V1CgoK5MGDB2JmZib3798XEZHs7Gxp3ry5VjVatWolAQEBsnPnTtm1a5fs3LlTbGxsZNeuXbJr1y6te3m8bw8PD7l9+7aIiGRlZYmbm5vWdZo2bVqst8f94x//0LqXwsJCiY+Plw8//FBq1aolvr6+snz5csnIyNC6l0ePoUajEWtraykoKBARkaKiIq0f30frSETkwYMH0rFjRxERuXr1qqp1LSKSnp4uEyZMEGdnZ6lRo4bUqFFDmjZtKhMmTJC0tDRVtUrSrVs3rce9f/++TJw4UQYNGiRr1qwpdt/IkSO1qpGcnCwjRoyQkJAQSU1NlalTp4qbm5v07dtXbt68qXUvd+/eLfaXmpoqDRo0kHv37sndu3e1rhMXF6f8n56eLh9++KE0b95cBgwYILdu3dKqxoQJE+TOnTsiInLw4EFxdHSURo0aSf369VW9nlq1aiVfffWVXLx4UetpSnLw4EHp1KmTBAQEyLVr1+Ttt98Wc3Nz8fDwkCNHjmhVIzMzUyZPniyurq5ibm4utWrVEi8vL/npp5+07qNr164SHh4uycnJyrDk5GQJDw+Xt99+W+1iiUgl++b4y1BYWAhTU1MAgIODA3bt2oW4uDiMHTsWomLjS19fH3p6eqhevToaNWoEc3NzAICxsTF0dbV7WA8dOgR3d3d8/fXXsLCwQKdOnWBsbIyOHTuiY8eOWvdSVFSEtLQ03L17FyKifMI3MTGBvr7217F0c3PDTz/9BAD4xz/+gUOHDgEALly4oPUFJXV0dKCrq4uuXbti6dKluHnzJkJCQrB161bl4pXaLlN+fj4yMzORnZ2t7F7Ky8tTtauqoKBAmS4zMxMAUL9+fVU1AMDf3x9WVlbYtWsX7t69i7t372Lnzp2wsrJC3759tapx5MiREv8OHz6MY8eOad3L0KFDISLo3bs3oqKi0Lt3b+Tl5QEA9u3bp1WNIUOGwNXVFfXq1UPnzp1hbGyMX375BW+99RZGjBihdS+1atWCu7u78ufh4YGkpCS0bt0aHh4eWtf58ssvlf/HjRsHW1tbbNmyBW3atMHw4cO1qvHLL7+gVq1aAIAvvvgC69evx8WLF7F9+3aMGzdO617S0tKQnp6Ozp07w9PTE3PmzMHNmze1nv6RkJAQjB8/Hu+99x7at2+P4cOH4/79+wgPD9f6u2cBAQFo2LAh4uPjMXXqVHz66adYtWoVdu7cWewxe5YrV65gwoQJsLGxUYbZ2NhgwoQJuHbtmurlAlD1tjg6d+4sR48eLTZMo9HI4MGDRVdXV+s6np6e8uDBAxERKSwsVIanp6c/9Wm9LNevX5c+ffrIqFGjpF69eqqmFRFp0KCBODo6ioODgzg6OiqfLDIzM7XeUhB52HtQUJA0bNhQPD09RV9fXxwdHaVDhw5y7NgxrWo865N8dna21r3Mnj1bHB0dpX79+jJv3jzp0qWLDBs2TNzc3GTatGla1Zg7d640b95cPv74Y3F2dpZly5aJiMjt27flrbfe0roXEZEmTZo8132P09XVlc6dO0unTp2e+jMyMtK6lyfX6YwZM6R9+/aSmpqq9XPv8fX05HNOzXPmu+++E19fXzlx4oQyzMHBQevpH3m87yfnr20/zs7OotFoRETEy8ur2H1qtrwf7+WPP/6QkSNHSp06daRTp07yww8/aF3nWY+xtlu8LVq0KHbbw8NDRB6+5zg7O2tVw8fHR7755ptiW263bt2S8PBw8fb21qrGk6pccFy/fr3YJtvj9uzZo3Wd3NzcEoffuXOn2ItIjdjYWPnXv/71XNOW5MGDB5KYmKh6uoyMDDl27JgcOnRI690Ej5w/f171/EqTlJQkSUlJIiKSlpYmGzZskP3796uqcerUKdmwYYOcPXv2hXopjxdfs2bN5MKFCyXeZ29vr3UvTZs2LfZhRURk+fLl4urqKvXr19eqxuNvSKGhocXuU/MmK/L/P/h89tlnkpGRIY6OjqqmFxGpW7eufP/99zJr1ixxdHSUoqIi5T5td03Onz9ffHx8ZMeOHTJ16lQZPXq0/P777zJlyhQZNGiQ1r2UFL4FBQUSFxcnQ4YM0bpO27ZtJT4+Xn7++WepX7++bNq0SUREdu3apfUFBtu1aye7d+8WEZGYmBjp2rWrcp+2H1ju3bsn48ePF2dnZ7G0tBQrKytp2rSpjB8/XtXuxMdVueAgeh6Pv/isrKyKvfju3bunVY0NGzbIuXPnSrzv0ZuKNr744gvZvn37U8Pj4uLEyclJqxqTJ09WjvU9LiEhQXr37q11L4+LiYkRLy8vqVOnjuppp02bVuzv0XG65ORkGTx4sNZ1du7cKf7+/tKyZUtxc3OTd955R3744QdlS0Qb/fr1U91/SY4dOyZdu3aVbt26ydmzZ+XTTz8VCwsLcXV1lT///FOrGsePH5c2bdqIhYWFvPHGG8oHs9u3b8u8efO07uXs2bOyffv2p9b548eW1GBwEL2gR7vAXnWN8qrzIjWys7Pl5MmT5dZLedWpTL2UVx1ta8ybN0+aNGkiPXr0kAYNGsjmzZuV+9TuVn+EwUH0gp7nuFRF1CivOpWpl/KqU5l6Ka862tYorzNJH1epfjqWqLJq0aJFicNFBCkpKS+txuvYS3nVqUy9lFed8qhR0pmkffr0wdWrV1WdSfo4BgeRFlJSUhAfHw8rK6tiw0UE7du3f2k1XsdeyqtOZeqlvOqURw0bGxscO3YMLVu2BACYmpoiNjYWH374IU6ePKlVjScxOIi00L17d2RlZSkvvsdp+w308qjxOvZSXnUqUy/lVac8aqxcufKp73Pp6+tj5cqVWn9H5klV7pIjRET0YqrcN8eJiOjFMDiIiEgVBge9VnR0dIpdl2jWrFmYNm1audQeMmQINm7cWC61nmXDhg1wcXFB586dn7ovISEB3bt3R6NGjeDu7o7OnTvjjz/+KNf5L1++/LmuzURVB4ODXiuGhob473//i9TU1FfdSjGFhYVaj7t06VJERkZi586dxYbn5ubivffeQ3BwMC5duoTDhw9jwYIFSExMLNdeGRxUFgYHvVYe/ZbInDlznrrvyS2GR+e279q1Cx07doS/vz+aNGmCiRMnYs2aNfD09ETz5s1x6dIlZZrffvsNb731Fpo0aYLY2FgAD0Phiy++QJs2bdCiRQv88MMPSt3OnTtj4MCBaN68+VP9rFu3Ds2bN4ebmxsmTJgAAAgLC8OePXswYsQIfPHFF8XGX7NmDdq1a1fsd1zc3NwwZMgQAMC0adMwa9asYvdduXIFALB69Wp4enqiZcuWGD58OAoLC1FYWIghQ4bAzc0NzZs3x5w5c7Bx40YcOnQIAQEBaNmyJXJycjBx4kS4urqiRYsW+Pzzz7VeF/T64um49NoZNWoUWrRogfHjx2s9zfHjx3H27FnUqFEDDRs2xLBhw3DgwAHMmzcPCxYswNy5cwE8vET177//jkuXLqFz5864ePEiVq5cCQsLCxw8eBB5eXl444030LVrVwAPfyXy1KlTcHR0LDa/mzdvYsKECTh8+DCsrKzQtWtXbN68GVOmTMH//vc/zJo166nLkp8+fRqtW7dW/XicPXsW69evx59//gkDAwOEhIRgzZo1aNasGZKSknDq1CkAQHp6OiwtLfGf//xHmf+9e/ewadMmnDt3Djo6OkhPT1c9f3r9cIuDXjvm5uYIDAzE/PnztZ6mTZs2sLW1haGhIRo1aqS88Tdv3lz51A48/F0OXV1dNG7cGA0bNsS5c+ewbds2rFy5Ei1btoSXlxfu3r2LhIQEAA9/nfHJ0ACAgwcPolOnTqhduzb09fUREBCg+lhFr1694Obmhg8++OCZ4+3YsQOHDx9GmzZt0LJlS+zYsQOJiYlo2LAhEhMT8c9//hNbt25VflPmcebm5jAyMsKwYcPw3//+F9WrV1fVI72eGBz0WhozZgyWLl2KBw8eKMP09fVRVFQE4OE3b/Pz85X7DA0Nlf91dXWV27q6usqPQQEPD74/TkdHByKCBQsW4NixYzh27BguX76sBI+JiUmJ/T3P16eaNWtW7KeNN23ahOXLl+PevXtPLR/w8JjIo3kFBQUp/Z0/fx7Tpk2DlZUVjh8/jk6dOiEiIgLDhg17ap76+vo4cOAAevfujc2bN6Nbt26q+6bXD4ODXks1atSAv78/li5dqgxzcHDA4cOHAQDR0dGqfwUQeHjGU1FRES5duoTExEQ4OzvD19cXCxcuVOpduHChWGCVxMvLC7///jtSU1NRWFiIdevWlfmrjwMHDsSff/5Z7Lfos7Oziy3fo2A5cuQILl++DADw9vbGxo0bcfv2bQDAvXv3cPXqVaSmpqKoqAi9e/fGV199pUxrZmam/FpiVlYW7t+/j3fffRdz585V9UuF9PriMQ56bY0bNw7/+c9/lNsff/wxevToAU9PT3h7e5e6NfAszs7O6NixI1JSUrBo0SJlN86VK1fQunVr5ad7N2/e/Mw6tra2mDlzJjp37gwRwbvvvosePXo8cxpjY2PExsZi7NixGDNmDOrUqQMzMzNMmjQJANC7d29ll1mbNm3QpEkTAICrqytmzJiBrl27oqioCAYGBoiIiICxsTGGDh2qbKXMnDkTwMOTCEaMGAFjY2PExcWhR48eyM3NhYiUeNIBVT285AgREanCXVVERKQKg4OIiFRhcBARkSoMDiIiUoXBQUREqjA4iIhIFQYHERGpwuAgIiJV/h/MPgaODkLITQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot inefficiency %\n",
    "fig, ax = plt.subplots(facecolor='w')\n",
    "df_mean_passes.plot.bar(x = 'n_guests', y = 'inefficiency', ax=ax)\n",
    "ax.set_title(\"Cranberry Passing Inefficiency % vs Number of Guests\")\n",
    "ax.set_xlabel(\"Number of Guests\")\n",
    "ax.set_ylabel(\"Inefficiency (%)\")\n",
    "vals = ax.get_yticks()\n",
    "ax.yaxis.set_major_formatter(mtick.PercentFormatter(1))\n",
    "ax.get_legend().remove()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot conditional mean number of passes when n_guests = 6\n",
    "fig, ax = plt.subplots(facecolor='w')\n",
    "df_p_and_means = df_p_and_means_all[df_p_and_means_all['n_guests'] == 6]\n",
    "df_p_and_means.plot.bar(x = 'guest_number', y = 'mean_number_passes', ax =ax)\n",
    "\n",
    "ax.set_title(\"Average Number of Passes When Guest $k$ is Last\\n (Number of Guests = 6)\")\n",
    "ax.set_xlabel(\"Guest Number $(k)$\")\n",
    "ax.set_ylabel(\"Average Number of Passes\")\n",
    "ax.get_legend().remove()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot conditional mean number of passes when n_guests = 20\n",
    "fig, ax = plt.subplots(facecolor='w')\n",
    "df_p_and_means = df_p_and_means_all[df_p_and_means_all['n_guests'] == 20]\n",
    "df_p_and_means.plot.bar(x = 'guest_number', y = 'mean_number_passes', ax =ax)\n",
    "\n",
    "ax.set_title(\"Average Number of Passes When Guest $k$ is Last\\n (Number of Guests = 20)\")\n",
    "ax.set_xlabel(\"Guest Number $(k)$\")\n",
    "ax.set_ylabel(\"Average Number of Passes\")\n",
    "ax.get_legend().remove()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "base"
  },
  "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}