julia_gift_exchange_simulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50e67a88",
   "metadata": {},
   "source": [
    "### Simulation study\n",
    "\n",
    "Simulation studies are used in statistics to estimate the probability of a certain event happening using pseudorandom numbers generated by a computer. Because it can be expensive and time-consuming to collect lots of real-world data on a phenomenon, statisticians sometimes use computers to create many simulated worlds and determine the frequency of an event happening in those simulated worlds. Simulation studies are used when it is difficult or impossible to analytically compute the probability of an event happening. For example, simulation is generally used to model processes happening on complex networks. \n",
    "\n",
    "\n",
    "### Current problem: christmas gift exchange\n",
    "\n",
    "One of my favorite family traditions is our sibling gift draw: we each draw from a hat to choose a sibling to give a gift to. Then, on christmas, we all open gifts from each other one at a time. \n",
    "\n",
    "My youngest sibling will usually open the first gift. Then, whoever gave the youngest sibling the gift opens their gift, and so on. This cycle of opening gifts continues until either we have all opened our gifts, or until someone opens a gift which was given to them by the youngest sibling. If this happens, we have to choose another person to open a gift, and start another cycle of gift-opening. \n",
    "\n",
    "This year, something unusual happened: there were 4 \"cycles\" of gift-giving—the maximum number possible. Six of us had reciprocal gift assignments (they received a gift from the same person that they gave a gift to). This seemed unusual to me, but I wanted to know how unusual this event was. So, I set out to do a simulation study to assess how likely this was. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a246b16",
   "metadata": {},
   "source": [
    "### Step 1: simulate a data-generating process\n",
    "\n",
    "In my family, gift assignments are given essentially at random. There are only two constraints: each person must give a gift to exactly one other person, and nobody can be assigned to give a gift to themselves. So, here, I'll define a function which generates a possible arrangement of gift-giving. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1866db1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "get_valid_selection (generic function with 1 method)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Random\n",
    "function get_valid_selection(num_participants)\n",
    "    selection_found = false\n",
    "    selection = randperm(num_participants)\n",
    "    while !selection_found\n",
    "        no_self_assignments = true\n",
    "        for i in 1:num_participants\n",
    "            if selection[i] == i ## someone got themselves\n",
    "                no_self_assignments = false\n",
    "            end\n",
    "        end\n",
    "        if no_self_assignments\n",
    "            selection_found = true\n",
    "        else\n",
    "            selection = randperm(num_participants)\n",
    "        end\n",
    "    end\n",
    "    return selection\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbe63fbc",
   "metadata": {},
   "source": [
    "This function takes the number of family members and returns a vector saying who is assigned to give to whom. In this simulation, person 1 receives a gift from person 7, person 2 receives a gift to person 8, and so on. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9dee4090",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9-element Vector{Int64}:\n",
       " 8\n",
       " 7\n",
       " 4\n",
       " 3\n",
       " 6\n",
       " 1\n",
       " 9\n",
       " 5\n",
       " 2"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_valid_selection(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07cf676b",
   "metadata": {},
   "source": [
    "### Step 2: Generate a metric from simulated data\n",
    "\n",
    "Now that I can simulate a family gift drawing, I need to figure out how rare my event of having 4 cycles is. To count the number of cycles, I'll define a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "22d8e814",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count_cycles (generic function with 1 method)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function count_cycles(selection)\n",
    "    num_participants = length(selection) # number of people in the drawing\n",
    "    given_gifts = repeat([-1], num_participants) #a vector of placeholders to record who has given a gift already\n",
    "    num_cycles = 1 ## we will always have at least one cycle\n",
    "    current_opener = 1 ## the youngest person will start with opening their gift\n",
    "    final_sum = sum(1:num_participants) ## our given_gifts vector will sum to this once everyone has been found\n",
    "    while sum(given_gifts) != final_sum\n",
    "        if !(current_opener in given_gifts) ## they haven't opened a gift yet, so we'll stay in the current cycle\n",
    "            # Add them to the opened_gifts list to mark that we have to start a new cycle if they're\n",
    "            # assigned to open a gift\n",
    "            given_gifts[current_opener] = current_opener\n",
    "            # Now, they open their gift, and the person who gave them the gift\n",
    "            # opens the next gift \n",
    "            current_opener = selection[current_opener] \n",
    "        else # They've already given a gift, so we need to start a new cycle\n",
    "            num_cycles = num_cycles + 1\n",
    "            # choose someone who hasn't opened a gift yet to open the next gift.\n",
    "            current_opener = findfirst(given_gifts .== -1) \n",
    "            # the .== means that we're comparing each element of given_gifts to -1\n",
    "\n",
    "        end\n",
    "    end\n",
    "    return num_cycles\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a98fb39f",
   "metadata": {},
   "source": [
    "### Step 3: Estimate the probability of an event happening in the real world. \n",
    "\n",
    "Now, we run our simulation lots of times, and estimate the probability that we will see a given number of cycles. Here, I'm just using a for loop to run both get_valid_selection and count_cycles many times. Then, I create a frequency table to estimate the probability of getting 4 cycles. In this function, I will use the [normal approximation](https://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval#Normal_approximation_interval_or_Wald_interval) of the binomial distribution to create a 95% confidence interval around the probabilities I estimate. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "3f0da66e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "estimate_probabilities_for_printing (generic function with 1 method)"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using FreqTables, Distributions\n",
    "function estimate_probabilities(num_participants, num_simulations)\n",
    "    num_cycles = repeat([-1], num_simulations) #create a placeholder vector for each simulation we do\n",
    "\n",
    "    for i in 1:num_simulations\n",
    "        selection = get_valid_selection(num_participants)\n",
    "        num_cycles[i] = count_cycles(selection)\n",
    "    end\n",
    "    prop_table = prop(freqtable(num_cycles)) #create a table showing the frequency of getting given number of cycles\n",
    "    println(\"Results for \", num_participants, \" participants, using \", num_simulations, \" simulations\")\n",
    "    println(prop_table)\n",
    "    max_cycles = maximum(names(prop_table)[1])\n",
    "    z_975 = quantile(Normal(0.0, 1.0), .975)\n",
    "    p_hat = prop_table[max_cycles]\n",
    "    lower_bound = p_hat - z_975 * sqrt(p_hat  * (1 - p_hat) / num_simulations)\n",
    "    upper_bound = p_hat + z_975 * sqrt(p_hat  * (1 - p_hat) / num_simulations)\n",
    "    println(\"95% confidence interval for probability of getting \", max_cycles, \" cycles: [\", \n",
    "        round(lower_bound, digits = 4), \", \", round(upper_bound, digits = 4), \"]\")\n",
    "    \n",
    "end\n",
    "\n",
    "function estimate_probabilities_for_printing(num_participants, num_simulations)\n",
    "    num_cycles = repeat([-1], num_simulations) #create a placeholder vector for each simulation we do\n",
    "\n",
    "    for i in 1:num_simulations\n",
    "        selection = get_valid_selection(num_participants)\n",
    "        num_cycles[i] = count_cycles(selection)\n",
    "    end\n",
    "    prop_table = prop(freqtable(num_cycles)) #create a table showing the frequency of getting given number of cycles\n",
    "    #println(\"Results for \", num_participants, \" participants, using \", num_simulations, \" simulations\")\n",
    "    #println(prop_table)\n",
    "    max_cycles = maximum(names(prop_table)[1])\n",
    "    z_975 = quantile(Normal(0.0, 1.0), .975)\n",
    "    p_hat = prop_table[max_cycles]\n",
    "    lower_bound = p_hat - z_975 * sqrt(p_hat  * (1 - p_hat) / num_simulations)\n",
    "    upper_bound = p_hat + z_975 * sqrt(p_hat  * (1 - p_hat) / num_simulations)\n",
    "    #println(\"95% confidence interval for probability of getting \", max_cycles, \" cycles: [\", \n",
    "    #    round(lower_bound, digits = 4), \", \", round(upper_bound, digits = 4), \"]\")\n",
    "    print(\"\\t\",round(lower_bound, digits = 4),\"\\t\",round(upper_bound, digits = 4), \"\\n\")\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "ec787b70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results for 9 participants, using 1000000 simulations\n",
      "4-element Named Vector{Float64}\n",
      "Dim1  │ \n",
      "──────┼─────────\n",
      "1     │ 0.303011\n",
      "2     │ 0.480495\n",
      "3     │ 0.197632\n",
      "4     │ 0.018862\n",
      "95% confidence interval for probability of getting 4 cycles: [0.0186, 0.0191]\n"
     ]
    }
   ],
   "source": [
    "estimate_probabilities(9, 1000000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9591469b",
   "metadata": {},
   "source": [
    "It's really quite remarkable how quickly Julia runs this simulation. I'm used to running simulations in R or Python which are a lot slower. It almost feels like Julia isn't even running the simulations. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ca72fb6",
   "metadata": {},
   "source": [
    "### Analytical solution\n",
    "\n",
    "Using simulation, I have a pretty good estimate for the probability of this event happening. However, let's double-check our work using analytic techniques. \n",
    "\n",
    "To do this, we need to compute the following fraction:\n",
    " \n",
    "$\\frac{\\text{possible ways to get 4 cycles}}{\\text{possible ways gifts could be assigned}}$\n",
    "\n",
    "Let's start with the denominator. To find the number of different ways a gift exchange could happen, we can use [derangements](https://en.wikipedia.org/wiki/Derangement), which estimate the number of permutations of a set such that no element of the set remains in its original position. We can estimate this according to the following formula: \n",
    "\n",
    "$!n = n! \\sum_{i = 0}^{n}\\frac{(-1)^i}{i!}$\n",
    "\n",
    "And, I'll write this function to easily calculate this quantity:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "137f5179",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "get_derangement (generic function with 1 method)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function get_derangement(num_participants)\n",
    "\n",
    "    sum = 0\n",
    "    for i in 0:num_participants\n",
    "        sum += (-1)^i / factorial(i)\n",
    "    end\n",
    "    return round(sum * factorial(num_participants))\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10249b18",
   "metadata": {},
   "source": [
    "Next, let's figure out the numerator of that fraction. \n",
    "\n",
    "We can think about this as choosing 2 people at random until that is no longer possible, because the maximum number of cycles for a given group of people will always involve mostly groups of 2. \n",
    "\n",
    "If n is even, we can think about just choosing pairs of 2 people until people run out. However, when we do this, we can end up double-counting ways to assign gift pairs because we haven't considered order. To fix this double-counting, we divide by the factorial of the number of pairs we selected. So, we can use the following formula if n is even:\n",
    "\n",
    "$\\frac{\\prod_{i = 1}^{n / 2}{2i \\choose 2}}{(n / 2)!}$\n",
    "\n",
    "We can do a similar thing if n is odd. However, in this case, the last set chosen is a set of 3, so we don't have to worry about double-counting for that set. But, we do have to consider that there are multiple ways to choose how people give others gifts in that last set of 3, so we will multiply by the derangement of 3 to account for that. So, we can use the following equation if n is odd:\n",
    "\n",
    "$\\frac{!3 \\prod_{i = 1}^{(n- 3) / 2}{2i \\choose 2}}{((n-3) / 2)!}$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "62092f3b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "get_numerator (generic function with 1 method)"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function comb(n, k) #number of ways to choose k people from a group of n people\n",
    "    factorial(n) / factorial(k) / factorial(n - k)\n",
    "end\n",
    "\n",
    "function get_numerator(num_participants)\n",
    "    num_participants_left = num_participants\n",
    "    numerator = 1\n",
    "    num_2_pairs = 0 # what we have to divide by in the denominator\n",
    "    while num_participants_left > 3\n",
    "        numerator  = numerator * comb(num_participants_left, 2)\n",
    "        num_participants_left = num_participants_left - 2\n",
    "        num_2_pairs = num_2_pairs + 1\n",
    "    end\n",
    "\n",
    "    if num_participants_left == 3\n",
    "        numerator = numerator * get_derangement(3) / factorial(num_2_pairs)\n",
    "    else # in this case, we have just 2 participants left, so we have to include them as a choice of 2\n",
    "        num_2_pairs = num_2_pairs + 1\n",
    "        numerator = numerator * comb(2, 2) / factorial(num_2_pairs)\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2588a7b",
   "metadata": {},
   "source": [
    "Finally, let's put these together into a function that calculates the proportion of individuals with the maximum number of cycles for a given group size. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "285462a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "analytical_probability_printing (generic function with 1 method)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function analytical_probability(num_participants)\n",
    "    prob = get_numerator(num_participants) / get_derangement(num_participants)\n",
    "    println(\"Actual probability: \", prob)\n",
    "end\n",
    "\n",
    "function analytical_probability_printing(num_participants)\n",
    "    prob = get_numerator(num_participants) / get_derangement(num_participants)\n",
    "    print(round(prob, digits = 4))\n",
    "end\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5146ba2",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "7b09a2c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\t0.3333\t0.3329\t0.3348\n",
      "5\t0.4545\t0.4535\t0.4555\n",
      "6\t0.0566\t0.0565\t0.0574\n",
      "7\t0.1133\t0.1123\t0.1136\n",
      "8\t0.0071\t0.0069\t0.0072\n",
      "9\t0.0189\t0.0185\t0.019\n",
      "10\t0.0007\t0.0007\t0.0008\n",
      "11\t0.0024\t0.0022\t0.0024\n",
      "12\t0.0001\t0.0\t0.0001\n"
     ]
    }
   ],
   "source": [
    "for i in 4:12\n",
    "    print(i, \"\\t\")\n",
    "    analytical_probability_printing(i)\n",
    "    estimate_probabilities_for_printing(i, 1000000)\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ba5c0ab1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numerator: 3.0\n",
      "Denominator: 9.0\n",
      "0.3333333333333333\n"
     ]
    }
   ],
   "source": [
    "num = comb(4, 2) * comb(2, 2) / factorial(2)\n",
    "den = get_derangement(4)\n",
    "println(\"Numerator: \", num)\n",
    "println(\"Denominator: \", den)\n",
    "println(num / den)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "7d01b15f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numerator: 20.0\n",
      "Denominator: 44.0\n",
      "0.45454545454545453\n"
     ]
    }
   ],
   "source": [
    "\n",
    "num = comb(5, 2) * get_derangement(3) / factorial(1)\n",
    "den = get_derangement(5)\n",
    "println(\"Numerator: \", num)\n",
    "println(\"Denominator: \", den)\n",
    "println(num / den)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "aecaf89a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numerator: 15.0\n",
      "Denominator: 265.0\n",
      "0.05660377358490566\n"
     ]
    }
   ],
   "source": [
    "num = comb(6, 2) * comb(4, 2) * comb(2, 2) / factorial(3)\n",
    "den = get_derangement(6)\n",
    "println(\"Numerator: \", num)\n",
    "println(\"Denominator: \", den)\n",
    "println(num / den)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "6942248c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numerator: 210.0\n",
      "Denominator: 1854.0\n",
      "0.11326860841423948\n"
     ]
    }
   ],
   "source": [
    "\n",
    "num = comb(7, 2) * comb(5, 2) *  get_derangement(3) / factorial(2)\n",
    "den = get_derangement(7)\n",
    "println(\"Numerator: \", num)\n",
    "println(\"Denominator: \", den)\n",
    "println(num / den)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d0426ea1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numerator: 105.0\n",
      "Denominator: 14833.0\n",
      "0.0070788107597923545\n"
     ]
    }
   ],
   "source": [
    "\n",
    "num = comb(8, 2) * comb(6, 2) * comb(4, 2) * comb(2, 2) / factorial(4)\n",
    "den = get_derangement(8)\n",
    "\n",
    "println(\"Numerator: \", num)\n",
    "println(\"Denominator: \", den)\n",
    "println(num / den)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a94aa413",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numerator: 2520.0\n",
      "Denominator: 133496.0\n",
      "0.01887697009648229\n"
     ]
    }
   ],
   "source": [
    "num = comb(9, 2) * comb(7, 2) * comb(5, 2) * get_derangement(3) / factorial(3)\n",
    "den = get_derangement(9)\n",
    "println(\"Numerator: \", num)\n",
    "println(\"Denominator: \", den)\n",
    "println(num / den)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "35d10b88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count_cycles (generic function with 2 methods)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Random\n",
    "function get_valid_selection(num_participants)\n",
    "    selection_found = false\n",
    "    selection = randperm(num_participants)\n",
    "    while !selection_found\n",
    "        no_self_assignments = true\n",
    "        for i in 1:num_participants\n",
    "            if selection[i] == i ## someone got themselves\n",
    "                no_self_assignments = false\n",
    "            end\n",
    "        end\n",
    "        if no_self_assignments\n",
    "            selection_found = true\n",
    "        else\n",
    "            selection = randperm(num_participants)\n",
    "        end\n",
    "    end\n",
    "    return selection\n",
    "end\n",
    "\n",
    "function count_cycles(selection)\n",
    "    num_participants = length(selection)\n",
    "    found_members = repeat([-1], num_participants)\n",
    "    num_cycles = 1 ## we have to have at least one cycle\n",
    "    current_giver = 1 ## the first person to get a gift\n",
    "    final_sum = sum(1:num_participants)\n",
    "    while sum(found_members) != final_sum\n",
    "\n",
    "        if !(current_giver in found_members) ## they haven't given a gift yet\n",
    "            found_members[current_giver] = current_giver ## Add them to the current_giver list\n",
    "            current_giver = selection[current_giver] ## The next person opens the gift\n",
    "        else # They've already given a gift, so we need to start a new cycle\n",
    "            num_cycles = num_cycles + 1\n",
    "            current_giver = findfirst(found_members .== -1)\n",
    "\n",
    "        end\n",
    "    end\n",
    "    return num_cycles\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "11620ae8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "estimate_probabilities (generic function with 1 method)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using FreqTables\n",
    "function estimate_probabilities(num_participants, num_simulations)\n",
    "    num_cycles = repeat([-1], num_simulations)\n",
    "\n",
    "    for i in 1:num_simulations\n",
    "        selection = get_valid_selection(num_participants)\n",
    "        num_cycles[i] = count_cycles(selection)\n",
    "    end\n",
    "    table = freqtable(num_cycles)\n",
    "    println(\"Table for \", num_participants, \" participants\")\n",
    "    println(prop(table))\n",
    "end\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "dfe33dbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Table for 9 participants\n",
      "4-element Named Vector{Float64}\n",
      "Dim1  │ \n",
      "──────┼────────\n",
      "1     │ 0.30412\n",
      "2     │ 0.47919\n",
      "3     │ 0.19751\n",
      "4     │ 0.01918\n"
     ]
    }
   ],
   "source": [
    "estimate_probabilities(9, 100000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "8b0b6b0f",
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "DimensionMismatch: column :name has length 1 and column :probability has length 2",
     "output_type": "error",
     "traceback": [
      "DimensionMismatch: column :name has length 1 and column :probability has length 2",
      "",
      "Stacktrace:",
      " [1] DataFrame(columns::Vector{Any}, colindex::DataFrames.Index; copycols::Bool)",
      "   @ DataFrames ~/.julia/packages/DataFrames/dgZn3/src/dataframe/dataframe.jl:206",
      " [2] DataFrame(; kwargs::Base.Pairs{Symbol, AbstractVector, Tuple{Symbol, Symbol}, NamedTuple{(:name, :probability), Tuple{Vector{Vector{Int64}}, NamedArrays.NamedVector{Float64, Vector{Float64}, Tuple{OrderedCollections.OrderedDict{Int64, Int64}}}}}})",
      "   @ DataFrames ~/.julia/packages/DataFrames/dgZn3/src/dataframe/dataframe.jl:326",
      " [3] top-level scope",
      "   @ In[71]:2",
      " [4] eval",
      "   @ ./boot.jl:368 [inlined]",
      " [5] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base ./loading.jl:1428"
     ]
    }
   ],
   "source": [
    "using DataFrames\n",
    "DataFrame(name = names(table), probability = table)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "f4650b72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2-element Named Vector{Float64}\n",
      "Dim1  │ \n",
      "──────┼─────\n",
      "1     │ 0.75\n",
      "2     │ 0.25\n"
     ]
    }
   ],
   "source": [
    "println(table)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34ed7628",
   "metadata": {},
   "outputs": [],
   "source": [
    "x x 3 4 5\n",
    "x 2 x 4 5\n",
    "x 2 3 x 5\n",
    "x 2 3 4 x\n",
    "1 x x 4 5\n",
    "1 x 3 x 5\n",
    "1 x 3 4 x\n",
    "1 2 x x 5\n",
    "1 2 x 4 x\n",
    "1 2 3 x x "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.8.3",
   "language": "julia",
   "name": "julia-1.8"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}