lec16.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/KeivanBolouri/data-science-projects/blob/main/lec16.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gzp09m8Ky8xB"
      },
      "outputs": [],
      "source": [
        "from datascience import *\n",
        "import numpy as np\n",
        "\n",
        "%matplotlib inline\n",
        "import matplotlib.pyplot as plots\n",
        "plots.style.use('fivethirtyeight')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nsuOaYxfy8xC"
      },
      "source": [
        "## Statistics"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "uploaded = files.upload()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 38
        },
        "id": "LzcYTGxl1WvY",
        "outputId": "2afa232d-b582-48e3-9ca1-ed3372aa97cc"
      },
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-f8ee1cee-c1db-4905-8a68-57acce79ab3d\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-f8ee1cee-c1db-4905-8a68-57acce79ab3d\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!ls\n"
      ],
      "metadata": {
        "id": "kr0avLLV2K2j",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "21afd757-81a6-46ed-ec9d-5c800f6f4465"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sample_data\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "this **chanfe**"
      ],
      "metadata": {
        "id": "L-4wiPaM6kCh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from datascience import Table\n",
        "\n",
        "# Read the CSV file into a Table\n",
        "united = Table.read_table('united.csv')\n",
        "\n",
        "# Add a 'Row' column with row numbers and move it to the start\n",
        "united = united.with_column('Row', np.arange(united.num_rows)).move_to_start('Row')\n",
        "\n",
        "# Display the modified table\n",
        "united.show(5)  # Show the first 5 rows to verify\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 235
        },
        "id": "_Meq7gmY2OH3",
        "outputId": "f8c3e607-d47a-49c9-e12f-5085fceefcb0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "<table border=\"1\" class=\"dataframe\">\n",
              "    <thead>\n",
              "        <tr>\n",
              "            <th>Row</th> <th>Date</th> <th>Flight Number</th> <th>Destination</th> <th>Delay</th>\n",
              "        </tr>\n",
              "    </thead>\n",
              "    <tbody>\n",
              "        <tr>\n",
              "            <td>0   </td> <td>6/1/15</td> <td>73           </td> <td>HNL        </td> <td>257  </td>\n",
              "        </tr>\n",
              "        <tr>\n",
              "            <td>1   </td> <td>6/1/15</td> <td>217          </td> <td>EWR        </td> <td>28   </td>\n",
              "        </tr>\n",
              "        <tr>\n",
              "            <td>2   </td> <td>6/1/15</td> <td>237          </td> <td>STL        </td> <td>-3   </td>\n",
              "        </tr>\n",
              "        <tr>\n",
              "            <td>3   </td> <td>6/1/15</td> <td>250          </td> <td>SAN        </td> <td>0    </td>\n",
              "        </tr>\n",
              "        <tr>\n",
              "            <td>4   </td> <td>6/1/15</td> <td>267          </td> <td>PHL        </td> <td>64   </td>\n",
              "        </tr>\n",
              "    </tbody>\n",
              "</table>\n",
              "<p>... (13820 rows omitted)</p>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#this **change**\n"
      ],
      "metadata": {
        "id": "N5h-V-_B6V6o"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Q_e-JQ4ry8xC"
      },
      "outputs": [],
      "source": [
        "united = Table.read_table('united.csv')\n",
        "united = united.with_column('Row', np.arange(united.num_rows)).move_to_start('Row')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9yX7nVy_y8xC",
        "outputId": "0f082b07-326c-468b-d3eb-f90808ef35e5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.0"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ],
      "source": [
        "# (Population) Parameter\n",
        "np.median(united.column('Delay'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZidhUrBPy8xD",
        "outputId": "9ad305f9-4cbc-4db8-ef6c-dc251b525add",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1.0"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ],
      "source": [
        "# (Sample) Statistic\n",
        "np.median(united.sample(10).column('Delay'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QZMSZvRCy8xD",
        "outputId": "e81dd7cb-5f2e-4f98-8171-75b7000f0536",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ],
      "source": [
        "# (Sample) Statistic\n",
        "np.median(united.sample(100).column('Delay'))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E5Qi0UwRy8xD"
      },
      "source": [
        "### Probability & Empirical Distributions of a Statistic"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ztqSRBtry8xE"
      },
      "outputs": [],
      "source": [
        "def sample_median(size):\n",
        "    return np.median(united.sample(size).column('Delay'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b_2Dr25yy8xE",
        "outputId": "9908b304-c22e-42bf-a05c-878b50600c13",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6.0"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ],
      "source": [
        "sample_median(10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VyWYWsEpy8xE"
      },
      "outputs": [],
      "source": [
        "num_simulations = 2000"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xG6yaftVy8xE"
      },
      "outputs": [],
      "source": [
        "sample_medians = make_array()\n",
        "\n",
        "for i in np.arange(num_simulations):\n",
        "    new_median = sample_median(10)\n",
        "    sample_medians = np.append(sample_medians, new_median)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wzJ9eNHmy8xE",
        "outputId": "03226856-99b4-48b3-aaaf-c0667e47e240",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 410
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "Table().with_column('Sample medians (size=10)', sample_medians).hist(bins=20)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vEYH_aWuy8xE"
      },
      "outputs": [],
      "source": [
        "sample_medians = make_array()\n",
        "\n",
        "for i in np.arange(num_simulations):\n",
        "    new_median = sample_median(1000)\n",
        "    sample_medians = np.append(sample_medians, new_median)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eobTl-PZy8xE",
        "outputId": "f563aa90-a66a-46e4-9afb-154abcecc03a"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "Table().with_column('Sample medians (size=1K)', sample_medians).hist()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "73yEQwKJy8xF"
      },
      "source": [
        "#### Empirical Distributions of a Statistic (Overlayed)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pW3Rvli4y8xF"
      },
      "outputs": [],
      "source": [
        "sample_medians_10 = make_array()\n",
        "sample_medians_100 = make_array()\n",
        "sample_medians_1000 = make_array()\n",
        "\n",
        "num_simulations = 2000\n",
        "\n",
        "for i in np.arange(num_simulations):\n",
        "    new_median_10 = sample_median(10)\n",
        "    sample_medians_10 = np.append(sample_medians_10, new_median_10)\n",
        "    new_median_100 = sample_median(100)\n",
        "    sample_medians_100 = np.append(sample_medians_100, new_median_100)\n",
        "    new_median_1000 = sample_median(1000)\n",
        "    sample_medians_1000 = np.append(sample_medians_1000, new_median_1000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_OPeelN9y8xF"
      },
      "outputs": [],
      "source": [
        "sample_medians = Table().with_columns('Size 10', sample_medians_10,\n",
        "                                      'Size 100', sample_medians_100,\n",
        "                                      'Size 1000', sample_medians_1000)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qrisH8E2y8xF",
        "outputId": "23ef3421-676f-4d63-8f37-4b9390436942"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "sample_medians.hist(bins = np.arange(-5, 30))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3UMSDDqOy8xF"
      },
      "source": [
        "## Swain vs. Alabama ##"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "asw6Ityty8xF",
        "outputId": "9f3c3593-dbf2-4bb4-c68b-b61f2932576f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0.26, 0.74])"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "population_proportions = make_array(.26, .74)\n",
        "population_proportions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CZ2ZhuM5y8xF",
        "outputId": "28cc9f6a-574a-42c8-d7c1-0d73338caabc"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([0.22, 0.78])"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "sample_proportions(100, population_proportions)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W-spXms6y8xF"
      },
      "outputs": [],
      "source": [
        "def panel_proportion():\n",
        "    return sample_proportions(100, population_proportions).item(0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "J8cC6Hcty8xF",
        "outputId": "239c7df4-efd6-4980-edf0-994ea65f4d34"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.26"
            ]
          },
          "execution_count": 22,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "panel_proportion()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-3UT-7z9y8xG"
      },
      "outputs": [],
      "source": [
        "panels = make_array()\n",
        "\n",
        "for i in np.arange(10000):\n",
        "    new_panel = panel_proportion() * 100\n",
        "    panels = np.append(panels, new_panel)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "veNxQ3pSy8xG",
        "outputId": "de305724-bc05-47fa-aa86-ab7cf7a596e0"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "Table().with_column(\n",
        "    'Number of Black Men on Panel of 100', panels\n",
        ").hist(bins=np.arange(5.5,40.))\n",
        "\n",
        "# Plotting details; ignore this code\n",
        "plots.ylim(-0.002, 0.09)\n",
        "plots.scatter(8, 0, color='red', s=30);"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1pY9H7J1y8xG"
      },
      "source": [
        "## Mendel and Pea Flowers ##"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_Zbjv02Wy8xG",
        "outputId": "57a28dda-fa1f-4791-bf92-d14028dd65c6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.7631862217438106"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "## Mendel had 929 plants, of which 709 had purple flowers\n",
        "observed_purples = 709 / 929\n",
        "observed_purples"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wuyhiARgy8xG",
        "outputId": "7d46df45-7a6c-4c7f-f18a-b1e3d98c1408"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0.74703983,  0.25296017])"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "predicted_proportions = make_array(.75, .25)\n",
        "sample_proportions(929, predicted_proportions)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oV6OsRFAy8xG"
      },
      "outputs": [],
      "source": [
        "def purple_flowers():\n",
        "    return sample_proportions(929, predicted_proportions).item(0) * 100"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L8SthKVNy8xG",
        "outputId": "53603ffe-746c-4112-c70b-a67a5f6cbb19"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "73.19698600645856"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "purple_flowers()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tMZNjiyGy8xG"
      },
      "outputs": [],
      "source": [
        "purples = make_array()\n",
        "\n",
        "for i in np.arange(10000):\n",
        "    new_purple = purple_flowers()\n",
        "    purples = np.append(purples, new_purple)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true,
        "id": "f-WKEAz9y8xG",
        "outputId": "f9b5c004-877c-4b53-f977-18800a90b1e3"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 600x400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "Table().with_column('Percent of purple flowers in sample of 929', purples).hist()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true,
        "id": "onGP3678y8xH",
        "outputId": "30fa3bb1-f306-4cd2-d98c-f140ae5dc09a"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "Table().with_column('Discrepancy in sample of 929 if the model is true', abs(purples- 75)).hist()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yWrXh2Pky8xH",
        "outputId": "0d53b57e-0920-4ddc-df5e-a6b91d63484d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1.318622174381062"
            ]
          },
          "execution_count": 32,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "abs(observed_purples * 100 - 75)"
      ]
    }
  ],
  "metadata": {
    "anaconda-cloud": {},
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.11"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}