nb0003_project_risk_assessment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Project Risk Assessment\n",
    "\n",
    "#### Author: Charlie Cao\n",
    "\n",
    "In this Notebook, we are going to explore ways to apply Monte Carlo Simulations in predicting a project's completion date and assessing a project's risk. We encourage you to create your own Jupytor Notebook and follow along. You can also download this Notebook along with any accompanying data in the [Notebooks and Data](https://github.com/Master-of-Business-Analytics/Notebooks_and_Data) GitHub Repository. Alternatively, if you do not have Python or Jupyter Notebook installed yet, you may experiment with a virtual Notebook by launching Binder or Syzygy below (learn more about these two tools in the [Resource](https://analytics-at-sauder.github.io/resource.html) tab). \n",
    "\n",
    "<a href=\"https://ubc.syzygy.ca/jupyter/hub/user-redirect/git-pull?repo=https%3A%2F%2Fgithub.com%2FAnalytics-at-Sauder%2FNB0003_Project_Risk_Assessment&urlpath=tree%2FNB0003_Project_Risk_Assessment%2Fnb0003_project_risk_assessment.ipynb&branch=master\" target=\"_blank\" class=\"button\">Launch Syzygy (UBC)</a>\n",
    "\n",
    "<a href=\"https://pims.syzygy.ca/jupyter/hub/user-redirect/git-pull?repo=https%3A%2F%2Fgithub.com%2FAnalytics-at-Sauder%2FNB0003_Project_Risk_Assessment&urlpath=tree%2FNB0003_Project_Risk_Assessment%2Fnb0003_project_risk_assessment.ipynb&branch=master\" target=\"_blank\" class=\"button\">Launch Syzygy (Google)</a>\n",
    "\n",
    "<a href=\"https://mybinder.org/v2/gh/Analytics-at-Sauder/NB0003_Project_Risk_Assessment/master?filepath=nb0003_project_risk_assessment.ipynb\" target=\"_blank\" class=\"button\">Launch Binder</a>\n",
    "\n",
    "## Background\n",
    "\n",
    "---\n",
    "\n",
    "A Monte Carlo Simulation is a great tool for making business decisions under uncertainty, and it is well known in the Project Management domain. Rather than simply providing a predicted average project completion time, we can instead find a range of possible completion dates using a Monte Carlo Simulation. With a simple prediction of the average completion time, there is a chance as high as 50% that the deadline will be missed. On the other hand, to be conservative with a predicted completion time could likely lead us to lose the project bid to a different team with a lower estimate (whether that is a realistic one or not), because no one likes to hear pessimistic estimates. Monte Carlo Simulations, in this case, can give us an idea of the possible distribution of the project completion time, which would then allow us to quote and make decisions that incorporate uncertainty.\n",
    "\n",
    "## Scenario One: Sequential Tasks\n",
    "\n",
    "---\n",
    "\n",
    "A construction project involves three tasks:\n",
    "\n",
    "1. Task 1 is likely to take three days (70% probability), but it might also be completed in two days (with 10% probability) or four days (20% probability)\n",
    "2. Task 2 has a 60% probability of taking six days to finish and a 20% probability each of being completed in five days or eight days\n",
    "3. Task 3 has an 80% probability of being completed in four days, 5% probability of being completed in three days, and a 15% probability of being completed in five days.\n",
    "\n",
    "![Sequential Tasks](nb0003_images/p03_01.png)\n",
    "\n",
    "Each task is dependent on the task before it, meaning that the three tasks must be executed in sequence. Your task is to provide information to the Project Manager concerning the expected completion time of the project and possible delays. Before we begin, install and import the following packages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One simple method is to calculate the expected completion date of each task and then sum up these average predictions for the three tasks, which would lead to the following:\n",
    "\n",
    "\\begin{equation}\n",
    "\\begin{split}\n",
    "E\\,[Project\\:Completion\\:Time] & = \\sum_{n=1}^{3} E\\,[Task_{n}\\:Completion\\:Time]\\\\\n",
    "& = (0.7 \\cdot 3 + 0.1 \\cdot 2 + 0.2 \\cdot 4) + (0.6 \\cdot 6 + 0.2 \\cdot 5 + 0.2 \\cdot 8) + (0.8 \\cdot 4 + 0.05 \\cdot 3 + 0.15 \\cdot 5)\\\\\n",
    "& = 3.1 + 6.2 + 4\\\\\n",
    "& = 13.3\\:(days)\n",
    "\\end{split}\n",
    "\\end{equation}\n",
    "\n",
    "However, without getting into too much detail, there is a fair chance that the actual completion time of the project is shorter or longer than 13.3 days, and it would be helpful to know the probability of different project completion times. Simple scenarios like this might be easy to solve with mathematical equations (learn more about discrete random variables [here](https://www.khanacademy.org/math/ap-statistics/random-variables-ap/discrete-random-variables/v/valid-discrete-probability-distribution-examples)), but real life situations are often much more complex. Therefore, a Monte Carlo Simulation would be very useful, because we will be able to simulate the different scenarios of possible task completion dates without getting deep into calculations. Simulated results also allow us to visualize the different scenarios and look at the actual distribution of those possibilities.\n",
    "\n",
    "Let's start with simulating one instance of Task 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3]\n"
     ]
    }
   ],
   "source": [
    "t1_comp = [3, 2, 4] # the possible completion time for task 1\n",
    "t1_prob = [0.7, 0.1, 0.2] # the probability of each completion time for task 1\n",
    "\n",
    "t1_time = np.random.choice(t1_comp, 1, p=t1_prob) # the second argument means that we only need one instance\n",
    "\n",
    "print(t1_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you know how to simulate the completion for one task, we can also do the same for the other two tasks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6]\n",
      "[4]\n"
     ]
    }
   ],
   "source": [
    "t2_comp = [6, 5, 8]\n",
    "t2_prob = [0.6, 0.2, 0.2]\n",
    "\n",
    "t2_time = np.random.choice(t2_comp, 1, p=t2_prob)\n",
    "\n",
    "t3_comp = [4, 3, 5]\n",
    "t3_prob = [0.8, 0.05, 0.15]\n",
    "\n",
    "t3_time = np.random.choice(t3_comp, 1, p=t3_prob)\n",
    "\n",
    "print(t2_time)\n",
    "print(t3_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now if we sum them up:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[13]\n"
     ]
    }
   ],
   "source": [
    "proj_time = t1_time + t2_time + t3_time\n",
    "\n",
    "print(proj_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that every time you run the above code chunks, there would be a different project completion time; the essence of Monte Carlo Simulations is that we could record all those completion time and visualize their distribution. Thus, we can go ahead and simulate the above scenario a large number of times, let's say 1,000 for now. \n",
    "\n",
    "Note that it is always a good habit to record the intermediate steps of your simulation so that you can go back to inspect and validate your simulation. It is also good practice to define the number of replications (1,000) as a variable so that, in the future, if we want to change how many times we repeate the simulation, we will not have to search the entire document to look for every instance of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "reps = 1000 # a variable specifying number of replications\n",
    "\n",
    "t1_record = [] # Initiate empty lists to record the competion time\n",
    "t2_record = []\n",
    "t3_record = []\n",
    "\n",
    "proj_record = []\n",
    "\n",
    "t1_comp = [3, 2, 4]\n",
    "t1_prob = [0.7, 0.1, 0.2]\n",
    "\n",
    "t2_comp = [6, 5, 8]\n",
    "t2_prob = [0.6, 0.2, 0.2]\n",
    "\n",
    "t3_comp = [4, 3, 5]\n",
    "t3_prob = [0.8, 0.05, 0.15]\n",
    "\n",
    "for i in range(reps):\n",
    "    t1_time = np.random.choice(t1_comp, 1, p=t1_prob)[0]\n",
    "    t2_time = np.random.choice(t2_comp, 1, p=t2_prob)[0]\n",
    "    t3_time = np.random.choice(t3_comp, 1, p=t3_prob)[0]\n",
    "    # Note the np.random.choice generates array outputs\n",
    "    # so we are using index 0 here to extract the first integar in the array\n",
    "    \n",
    "    proj_time = t1_time + t2_time + t3_time\n",
    "    \n",
    "    t1_record.append(t1_time)\n",
    "    t2_record.append(t2_time)\n",
    "    t3_record.append(t3_time)\n",
    "    \n",
    "    proj_record.append(proj_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And there, we have 1,000 replications of our construction project! It is a relatively fast simulation, partially because the problem is fairly simple. For larger problems, however, you might want to look into how you can optimize (or parallel) your replications in order to speed up the process. We will wait until the next scenario to dive deeper into this concept (see Scenario Two: Parallel Tasks, below). For now, let's take a look at the first couple of results from our 1,000 replications:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Task_1  Task_2  Task_3  Project\n",
      "0       3       5       4        8\n",
      "1       3       6       4        9\n",
      "2       3       6       4        9\n",
      "3       3       6       4        9\n",
      "4       3       8       4       11\n"
     ]
    }
   ],
   "source": [
    "proj_df = pd.DataFrame({\"Task_1\": t1_record, # creating a dataframe using the lists of records\n",
    "                        \"Task_2\": t2_record, \n",
    "                        \"Task_3\": t3_record, \n",
    "                        \"Project\": proj_record})\n",
    "\n",
    "print(proj_df.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we count the different instances of our project completion dates and plot out the distribution. As you can see, even though there are around 400 instances where our project is completed in about 13 days, there are quite a few hundred instances where the project is completed in less than AND more than 13 days. In situations like this, it is benefitial to communicate these possibilities to the Project Manager, so that you can manage the expections of stakeholders without losing the bid of a project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Project\n",
      "10      1\n",
      "11     19\n",
      "12    185\n",
      "13    394\n",
      "14    205\n",
      "15    131\n",
      "16     55\n",
      "17     10\n",
      "Name: Project, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(proj_df['Project'].groupby(proj_df['Project']).count())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 8 artists>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(range(10,18),proj_df['Project'].groupby(proj_df['Project']).count())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the graph above, we combine the distribution and the sample statistics of the project completion dates over the 1,000 replications (output of the next cell). We can see that the simulated project completion times are right-skewed; that is, the worst case scenario is further away from the median than the best case scenario. In order to have a 95% chance of meeting the deadline, the quote should actually be around 15 days, as calculated below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    1000.000000\n",
      "mean       13.446000\n",
      "std         1.206872\n",
      "min        10.000000\n",
      "25%        13.000000\n",
      "50%        13.000000\n",
      "75%        14.000000\n",
      "max        17.000000\n",
      "Name: Project, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(proj_df['Project'].describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.0\n"
     ]
    }
   ],
   "source": [
    "print(np.percentile(proj_record,95))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scenario Two: Parallel Tasks\n",
    "\n",
    "---\n",
    "\n",
    "Now, we have received new information that Tasks 2 and 3 can actually be conducted at the same time. \n",
    "\n",
    "![Parallel Tasks](nb0003_images/p03_02.png)\n",
    "\n",
    "With this update, the project completion time is now dependent on the task that gets completed later: `proj_time = t1_time + max(t2_time, t3_time)`. Therefore, we slightly modify our simulation to the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Task_1  Task_2  Task_3  Project\n",
      "0       3       5       4        8\n",
      "1       3       6       4        9\n",
      "2       3       6       4        9\n",
      "3       3       6       4        9\n",
      "4       3       8       4       11\n"
     ]
    }
   ],
   "source": [
    "reps = 1000\n",
    "\n",
    "t1_record = []\n",
    "t2_record = []\n",
    "t3_record = []\n",
    "\n",
    "proj_record = []\n",
    "\n",
    "t1_comp = [3, 2, 4]\n",
    "t1_prob = [0.7, 0.1, 0.2]\n",
    "\n",
    "t2_comp = [6, 5, 8]\n",
    "t2_prob = [0.6, 0.2, 0.2]\n",
    "\n",
    "t3_comp = [4, 3, 5]\n",
    "t3_prob = [0.8, 0.05, 0.15]\n",
    "\n",
    "for i in range(reps):\n",
    "    t1_time = np.random.choice(t1_comp, 1, p=t1_prob)[0]\n",
    "    t2_time = np.random.choice(t2_comp, 1, p=t2_prob)[0]\n",
    "    t3_time = np.random.choice(t3_comp, 1, p=t3_prob)[0]\n",
    "    \n",
    "    proj_time = t1_time + max(t2_time, t3_time) #note the change here\n",
    "    \n",
    "    t1_record.append(t1_time)\n",
    "    t2_record.append(t2_time)\n",
    "    t3_record.append(t3_time)\n",
    "    \n",
    "    proj_record.append(proj_time)\n",
    "    \n",
    "proj_df = pd.DataFrame({\"Task_1\": t1_record,\n",
    "                        \"Task_2\": t2_record, \n",
    "                        \"Task_3\": t3_record, \n",
    "                        \"Project\": proj_record})\n",
    "\n",
    "print(proj_df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 6 artists>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(range(min(proj_record),max(proj_record)+1),proj_df['Project'].groupby(proj_df['Project']).count())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.0"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(np.percentile(proj_record,95))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scenario Three: Correlated Task Risks\n",
    "\n",
    "---\n",
    "\n",
    "When we see \"correlated tasks\", we probably first think of correlation of coefficients. However, the number of correlation coefficients increases exponentially as the number of tasks increases, just like the possible combination of tasks (you can learn more about [combinations](https://www.khanacademy.org/math/precalculus/x9e81a4f98389efdf:prob-comb/x9e81a4f98389efdf:combinations/v/combination-formula) and [permutations](https://www.khanacademy.org/math/precalculus/x9e81a4f98389efdf:prob-comb/x9e81a4f98389efdf:combinatorics-precalc/v/permutation-formula) on Khan Academy), not to mention the amount of work that has to go into deciding the relationships between those tasks. At the same time, correlation coefficients are mathematical concepts which do not carry the most meaningful real-world interpretations, especially when a project manager tries to understand why the correlation in risks exists or how it could be managed. Therefore, more frequently, we would specify a risk event that could potentially impact multiple tasks and the probability of that risk event; we could also specify a risk factor, which would again affect multiple tasks. For now, let's go back to the assumption that the three tasks are sequential, as in Scenario One.\n",
    "\n",
    "![Sequential Tasks](nb0003_images/p03_01.png)\n",
    "\n",
    "\n",
    "In this scenario, the weather would have an impact on all three tasks, while internal communication would affect only Tasks 2 and 3. Let's say that there is a 40% chance of bad weather, in which case the project is going to be delayed for 2 days. On the other hand, the communication factor varies in a way that is similar to a normal distribution, with a mean of 1 and a standard deviation of 0.1. When the communication between team members is efficient, the communication factor is smaller than 1 and reduces the project completion time; otherwise it is larger than 1 and increases the completion time. By modeling the probability of risk events and factors, we arrive at the following equation:\n",
    "\n",
    "\\begin{equation}\n",
    "\\begin{split}\n",
    "& Project\\:Completion\\:Time\\\\\n",
    "=\\: & 2 \\cdot Weather + Task_{1}\\:Completion\\:Time + Communication\\:Factor \\cdot (Task_{2}\\:Completion\\:Time + Task_{3}\\:Completion\\:Time)\n",
    "\\end{split}\n",
    "\\end{equation}\n",
    "\n",
    "In our case, since the weather is a binary event, while the communication factor is normally distributed, we define them as the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0.9500478663155578\n"
     ]
    }
   ],
   "source": [
    "weather = np.random.binomial(1, 0.4) # the arguments are 'number of trials' and 'probability of success'respectively\n",
    "communication = np.random.normal(1, 0.1)  # note that this is technically an indefinite float so rounding is needed\n",
    "\n",
    "print(weather)\n",
    "print(communication)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then modify our simulation, as such:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Weather  Communication  Task_1  Task_2  Task_3  Project\n",
      "0        1           1.03       3       5       4    10.15\n",
      "1        0           0.90       3       6       4     8.40\n",
      "2        0           0.90       2       8       4     9.20\n",
      "3        0           1.12       2       6       5     8.72\n",
      "4        1           1.14       3       6       4    11.84\n"
     ]
    }
   ],
   "source": [
    "reps = 1000\n",
    "\n",
    "weather_record = [] # recording the events\n",
    "communication_record = []\n",
    "\n",
    "t1_record = []\n",
    "t2_record = []\n",
    "t3_record = []\n",
    "\n",
    "proj_record = []\n",
    "\n",
    "t1_comp = [3, 2, 4]\n",
    "t1_prob = [0.7, 0.1, 0.2]\n",
    "\n",
    "t2_comp = [6, 5, 8]\n",
    "t2_prob = [0.6, 0.2, 0.2]\n",
    "\n",
    "t3_comp = [4, 3, 5]\n",
    "t3_prob = [0.8, 0.05, 0.15]\n",
    "\n",
    "for i in range(reps):\n",
    "    weather = np.random.binomial(1, 0.4) # simulate the events\n",
    "    communication = round(np.random.normal(1, 0.1),2)\n",
    "    \n",
    "    t1_time = np.random.choice(t1_comp, 1, p=t1_prob)[0]\n",
    "    t2_time = np.random.choice(t2_comp, 1, p=t2_prob)[0]\n",
    "    t3_time = np.random.choice(t3_comp, 1, p=t3_prob)[0]\n",
    "    \n",
    "    proj_time = 2 * weather + t1_time + communication * max(t2_time, t3_time) # note the changes in calculation\n",
    "    \n",
    "    weather_record.append(weather)\n",
    "    communication_record.append(communication)\n",
    "    \n",
    "    t1_record.append(t1_time)\n",
    "    t2_record.append(t2_time)\n",
    "    t3_record.append(t3_time)\n",
    "    \n",
    "    proj_record.append(proj_time)\n",
    "    \n",
    "proj_df = pd.DataFrame({\"Weather\": weather_record,\n",
    "                        \"Communication\": communication_record,\n",
    "                        \"Task_1\": t1_record,\n",
    "                        \"Task_2\": t2_record, \n",
    "                        \"Task_3\": t3_record, \n",
    "                        \"Project\": proj_record})\n",
    "\n",
    "print(proj_df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 10.,  80., 186., 206., 179., 171.,  97.,  48.,  18.,   5.]),\n",
       " array([ 6.15 ,  7.079,  8.008,  8.937,  9.866, 10.795, 11.724, 12.653,\n",
       "        13.582, 14.511, 15.44 ]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(proj_df['Project']) # note how the distribution is continuous now and not discrete anymore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13.08\n"
     ]
    }
   ],
   "source": [
    "print(np.percentile(proj_record,95))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "---\n",
    "\n",
    "https://risk-engineering.org/notebook/monte-carlo-project-risk.html <br>\n",
    "https://www.vosesoftware.com/riskwiki/Correlationwithprojectscheduleriskanalysis.php"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}