Refactor test for Activity 17

Author: UPstartDeveloper

chapter0-exercises/chapter_0_part2.ipynb

@@ -27,6 +27,7 @@
         "wicked-roberts",
         "close-trinity"
       ],
+      "toc_visible": true,
       "include_colab_link": true
     }
   },
@@ -47,72 +48,146 @@
         "id": "painted-boutique"
       },
       "source": [
-        "## Activity: We have a coin. The probability of getting Head is P(H) = a and probability of getting Tail is P(T) = 1 - a.\n",
+        "## Activity 17: Modelling a Fair Coin\n",
         "\n",
-        "- We toss this coin three times. What is the probability that we get two heads?\n",
+        "Let's say your friend gives you a fair coin. \n",
         "\n",
-        "- Calculate this probability by hand [TODO]: add a binary tree to show how it is 3/8\n",
+        "Let $P(H)$ = a, the probability of getting heads when you flip the coin. Of course, this also makes the probability of getting tails, $P(T)$, equal to 1 - a.\n",
         "\n",
-        "- Write a code that shows you are correct. Your function should take two input arguments: \n",
-        "    - Given probability of Head \n",
-        "    - Given number of trials\n",
-        "    \n",
-        "- For the coding part, we examine the coin flip for 1000 trials, each trial is tossing the coin 3 times.\n",
-        "    - Then only count (C) if the result for each trial be HHT or HTH or THH. Therefore, C/1000 is the answer\n",
-        "\n",
-        "- Hint: For code part, we can generate events with given probability as follows:\n",
+        "Now, say we toss this coin three times. What is the probability that we get heads on two out of the three flips?\n",
         "\n",
-        "TODO: rephrase this question"
+        "Calculate this value by hand, and then please write Python code to verify your answer on 1,000 coin flips (hint: use the `random` module)!\n",
+        "\n"
       ],
       "id": "painted-boutique"
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "GEgcbkprcQnM"
+      },
+      "source": [
+        "### The Mathematical Solution\n",
+        "\n",
+        "Let's start by breaking down the probabilities of 1 coin flip. As you may already know, this only has 2 outcomes, each of which are equally likely: heads or tails.\n",
+        "\n",
+        "To give a visual, observe the following diagram which shows the possible outcomes for 1 random coin toss:\n",
+        "\n",
+        "<img src=\"https://i.postimg.cc/FznFdxdm/Screen-Shot-2021-05-31-at-3-59-29-PM.png\" alt=\"1 random coin toss\" height=\"225px\" width=\"350px\">\n",
+        "\n",
+        "So how many ways can we have 2 heads on 3 of the coin flips?\n",
+        "\n",
+        "As more and more flips happen, we will continue to have either heads or tails. Essentially, this means our original diagram can be expanded, and to show all the possibile results we could have:\n",
+        "\n",
+        "<img src=\"https://i.postimg.cc/G3vZ4KDj/Screen-Shot-2021-05-31-at-4-10-13-PM.png\" alt=\"3 random coin tosses\" height=\"225px\" width=\"355px\">\n",
+        "\n",
+        "As you can see, there are 8 total permutations of what 3 faces our coin will land on. As well, there are 3 in particular which have 2 heads: HHT, HTH, and THH (try to spot them in the diagram above, in case you are not convinced)!\n",
+        "\n",
+        "Since all of the 8 permutations are equally likely to occur, we can then conclude our probability is `3/8`, or 0.375."
+      ],
+      "id": "GEgcbkprcQnM"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "sN8IlbOFcVOj"
+      },
+      "source": [
+        "### The Python Solution\n",
+        "\n",
+        "To model this experiment in code, one approach we can take is:\n",
+        "\n",
+        "```\n",
+        "Pseudocode for Modelling a Fair Coin\n",
+        "1. Examine the results of 1000 trials, where each trial is defined tossing the coin 3 times.\n",
+        "2. Then, we can keep track of an integer called `occurences` to record the number of trials in which we have one of our desired permutations (i.e. either HHT, HTH, or THH).\n",
+        "3. Finally, we can compute the answer by dividing the number of trials where our desired outcome occurred, by the total number of trials: `occurences/1000`.\n",
+        "```\n",
+        "Before actually writing this function though, you may still have several questions. For example, how are we supposed to generate random events in Python?"
+      ],
+      "id": "sN8IlbOFcVOj"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "YoPPT-ZzgydJ"
+      },
+      "source": [
+        "#### Mini-Lesson: How to Simulate Random Events in Python\n",
+        "\n",
+        "The following code snippet provides a straightforward process you can follow for modelling probability. For more on the `random.choices` function, you may read more on the [Python documentation](https://docs.python.org/3/library/random.html?highlight=random#random.choices) as you wish."
+      ],
+      "id": "YoPPT-ZzgydJ"
+    },
     {
       "cell_type": "code",
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
         },
         "id": "english-federation",
-        "outputId": "4d419a11-ba33-4962-e36e-124834c3ae5c"
+        "outputId": "cc8243fd-5a2d-4e39-8f87-5f587f338ad8"
       },
       "source": [
-        "# TODO: add \"Mini-Lesson: How to Simulate Random Events in Python\" cell above\n",
         "from random import choices\n",
         "\n",
-        "event = ['H', 'T']  # these are the events that can occur\n",
-        "weights = [0.3, 0.7]  # these are their corresp\n",
-        "for _ in range(10):  # run 10 trials of the event\n",
+        "# A: first, define the possible outcomes that can occur\n",
+        "event = ['H', 'T'] \n",
+        "# B: then, define their respective probabilities\n",
+        "weights = [0.3, 0.7]  \n",
+        "# C: run the simulation!\n",
+        "for _ in range(10):  \n",
+        "    # D: print the results, to verify it follows our assigned probabilities\n",
         "    print(choices(event, weights))"
       ],
       "id": "english-federation",
-      "execution_count": 2,
+      "execution_count": 46,
       "outputs": [
         {
           "output_type": "stream",
           "text": [
             "['T']\n",
+            "['H']\n",
             "['T']\n",
             "['T']\n",
             "['T']\n",
             "['T']\n",
-            "['H']\n",
-            "['H']\n",
             "['T']\n",
             "['T']\n",
+            "['H']\n",
             "['H']\n"
           ],
           "name": "stdout"
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "89D-ZjmTgvym"
+      },
+      "source": [
+        "#### Code Implementation\n",
+        "\n",
+        "From above, we know modelling a random event needs 3 parameters:\n",
+        "1. The possible events that can happen\n",
+        "2. The probabilities of each of those events\n",
+        "3. The number of trials to simulate\n",
+        "\n",
+        "For this solution, let's leave out 1, since we already know this is for a fair coin.\n",
+        "\n",
+        "Therefore, our function only needs to take in the remaining two input arguments: \n",
+        "1. The probability of landing on heads (since we can already compute the $P(T)$ with that information),\n",
+        "2. And the number of trials to run.\n",
+        "    \n",
+        "Using the pseudocode above and what we now know about the `random` module, we can therefore implement something like the code below to see if our mathematical answer is truly correct:"
+      ],
+      "id": "89D-ZjmTgvym"
+    },
     {
       "cell_type": "code",
       "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "academic-bankruptcy",
-        "outputId": "cdb99386-3594-4dd3-b158-ce39f6ad2a0c"
+        "id": "academic-bankruptcy"
       },
       "source": [
         "def compute_proba(probability_heads, trials):\n",
@@ -124,28 +199,52 @@
         "    for _ in range(trials):\n",
         "        # C: check the results after 1 trial\n",
         "        trial_results = [\n",
-        "          choices(events, weights)[0],  # 1st coin toss\n",
-        "          choices(events, weights)[0],  # 2nd coin toss\n",
-        "          choices(events, weights)[0]   # 3rd coin toss\n",
+        "          choices(events, weights)[0],  # 1st coin flip\n",
+        "          choices(events, weights)[0],  # 2nd coin flip\n",
+        "          choices(events, weights)[0]   # 3rd coin flip\n",
         "        ]\n",
         "        if trial_results.count(\"H\") == 2:\n",
         "            occurences += 1\n",
         "    # D: return the probability\n",
-        "    return (occurences / trials)\n",
-        "\n",
-        "N = 10000\n",
-        "a = 0.6    \n",
-        "print(compute_proba(a, N))  # computed probability after 1,000 trials\n",
-        "print(3*(a**2)*(1-a)) # expected probability"
+        "    return (occurences / trials)\n"
       ],
       "id": "academic-bankruptcy",
-      "execution_count": 12,
+      "execution_count": 48,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "9BXSOLuTkT5D"
+      },
+      "source": [
+        "#### Test Out the Python Solution"
+      ],
+      "id": "9BXSOLuTkT5D"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "QY52_-8-kXo7",
+        "outputId": "1a751a16-7886-4eaa-c969-aa8dab978a98"
+      },
+      "source": [
+        "a = 0.5 # the probability of landing on heads \n",
+        "num_trials = 1000\n",
+        "print(compute_proba(a, num_trials))  # computed probability after 1,000 trials\n",
+        "print(3*(a**2)*(1-a)) # expected probability - does it match with the above?"
+      ],
+      "id": "QY52_-8-kXo7",
+      "execution_count": 49,
       "outputs": [
         {
           "output_type": "stream",
           "text": [
-            "0.4385\n",
-            "0.43200000000000005\n"
+            "0.369\n",
+            "0.375\n"
           ],
           "name": "stdout"
         }