Analysis.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": " BenfordAndData.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyM/6hszci76qkXCxjxAuKJi"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uUVQM4RlaTu5"
      },
      "source": [
        "# Boring Setup Stuff"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LsVe3gUtlWZ2"
      },
      "source": [
        "!pip install benford_py\n",
        "!git clone https://github.com/cjph8914/2020_benfords/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CzCXPSQlW2GZ"
      },
      "source": [
        "import requests\n",
        "\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import scipy.stats as stats\n",
        "\n",
        "from bs4 import BeautifulSoup as bs\n",
        "from benford import expected as exp\n",
        "from itertools import tee    \n",
        "from tabulate import tabulate\n",
        "from math import log, log10\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.ticker as ticker\n",
        "import seaborn as sns\n",
        "%matplotlib inline\n",
        "%config InlineBackend.figure_format='retina'"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SGC4c9Mcm0a7"
      },
      "source": [
        "TEST_NAME_MAP = {\n",
        "  'FDT':    \"First Digit Test\",\n",
        "  'SDT':    \"Second Digit Test\",\n",
        "  'F2D':    \"First Two Digit Test\",\n",
        "  'F3D':    \"First Three Digit Test\",\n",
        "  'L2DT':   \"Last Two Digit Test\"\n",
        "}\n",
        "\n",
        "TEST_LEN_MAP = {\n",
        "  'FDT':    9,\n",
        "  'SDT':    10,\n",
        "  'F2D':    99,\n",
        "  'F3D':    99,\n",
        "  'L2DT':   100\n",
        "}\n",
        "\n",
        "def getDigits(df, n=1, leading=True, onlySingle=False):\n",
        "  if leading:\n",
        "    if onlySingle:\n",
        "      slice_object = slice(n-1,n)\n",
        "    else:\n",
        "      slice_object = slice(n)\n",
        "  else:\n",
        "    if onlySingle:\n",
        "      slice_object = slice(-1 *n - 1, -1*n)\n",
        "    else:\n",
        "      slice_object = slice(-1 * n, None)\n",
        "  digitDf = df.apply(lambda x: x.astype(str).str[slice_object]).fillna(0)\n",
        "  digitDf = digitDf.apply(pd.to_numeric).fillna(0).astype(int)\n",
        "  return digitDf\n",
        "\n",
        "def createTestDf(df, operator=\"FDT\"):\n",
        "    actual ={\n",
        "        'FDT':  lambda df: getDigits(df, n=1, leading=True, onlySingle=False),\n",
        "        'SDT':  lambda df: getDigits(df, n=2, leading=True, onlySingle=True),\n",
        "        'F2D':  lambda df: getDigits(df, n=2, leading=True, onlySingle=False),\n",
        "        'F3D':  lambda df: getDigits(df, n=3, leading=True, onlySingle=False),\n",
        "        'L2DT': lambda df: getDigits(df, n=2, leading=False, onlySingle=False)\n",
        "      }\n",
        "\n",
        "    expected ={\n",
        "        'FDT':  lambda: exp.First(1, plot=False),\n",
        "        'SDT':  lambda: exp.Second(plot=False),\n",
        "        'F2D':  lambda: exp.First(2, plot=False),\n",
        "        'F3D':  lambda: exp.First(3, plot=False),\n",
        "        'L2DT': lambda: exp.LastTwo(plot=False)\n",
        "      }\n",
        "\n",
        "\n",
        "    return actual.get(operator)(df), expected.get(operator)()\n",
        "\n",
        "def getAllTestDfs(df):\n",
        "  test_keys = ['FDT', 'SDT', 'F2D', 'L2DT'] #'F3D' not relevant here\n",
        "  test_dfs = {}\n",
        "  for k in test_keys:\n",
        "    len_range = TEST_LEN_MAP[k] + 1\n",
        "    actual, expected = createTestDf(df, k)\n",
        "    if k == \"L2DT\":\n",
        "      expected.loc[expected['Expected'] > 0, 'Expected'] = 0.01\n",
        "    for c in actual.columns:\n",
        "      actual[c] = pd.DataFrame(actual[c].value_counts().sort_index())\n",
        "    actual = actual.reindex(range(1,len_range)).fillna(0)\n",
        "    test_dfs[k] = {}\n",
        "    test_dfs[k][\"actual\"] = actual\n",
        "    test_dfs[k][\"expected\"] = expected\n",
        "  \n",
        "  return test_dfs"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DWgaRPgVggoW"
      },
      "source": [
        "def colPrinter(strings):\n",
        "  strings_by_column = [s.split('\\n') for s in strings]\n",
        "  strings_by_line = zip(*strings_by_column)\n",
        "  max_length_by_column = [\n",
        "      max([len(s) for s in col_strings])\n",
        "      for col_strings in strings_by_column\n",
        "  ]\n",
        "  \n",
        "  for parts in strings_by_line:\n",
        "      padded_strings = [\n",
        "          parts[i].ljust(max_length_by_column[i] + 5)\n",
        "          for i in range(len(parts))\n",
        "      ]\n",
        "      print(''.join(padded_strings))\n",
        "\n",
        "def plot(dfs, test, title):\n",
        "  expected = dfs[test][\"expected\"].reset_index(drop=True)\n",
        "  actual = dfs[test][\"actual\"].reset_index(drop=True)\n",
        "  actual = actual / actual.cumsum().iloc[-1]\n",
        "  ax = expected.plot(figsize=(7,5), title=title)\n",
        "  actual.plot.bar(ax = ax)\n",
        "  plt.show()"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5M7DZC0HtSw9"
      },
      "source": [
        "class StatTests():\n",
        "  def chisq(self, df='dataframe', p=None):\n",
        "      if all(i < 0 for i in df.values.flatten()):\n",
        "          raise ValueError(\"The observation counts for each group must be non-negative number\")\n",
        "      if p is None:\n",
        "          raise ValueError(\"Please pass the expected values\")\n",
        "\n",
        "      assert df.shape[1] == 1, 'dataframe must one-dimensional contingency table of observed counts'\n",
        "      assert len(p) == df.shape[0], 'probability values should be equal to observations'\n",
        "      assert isinstance(p, (tuple, list)) and round(sum(p), 10) == 1, 'probabilities must be list or tuple and ' \\\n",
        "                                                                      'sum to 1'\n",
        "      df['expected_counts'] = [df.sum()[0] * i for i in p]\n",
        "      if all(i < 0 for i in p):\n",
        "          raise ValueError(\"The probabilities for each group must be non-negative number\")\n",
        "      dof = df.shape[0] - 1\n",
        "      chi_gf, p_gf = stats.chisquare(f_obs=df[df.columns[0]].to_numpy(), f_exp=df[df.columns[1]].to_numpy())\n",
        "      return chi_gf, dof, p_gf, df[df.columns[0]].sum()\n",
        "  \n",
        "  def runTests(self, dfs, cis=[0.95]):\n",
        "    self.results = {}\n",
        "    self.cis = cis\n",
        "    thresholds = [1.0 - i for i in cis]\n",
        "    for k in dfs.keys():\n",
        "      df = dfs[k][\"actual\"]\n",
        "      expected = list(dfs[k][\"expected\"].Expected)\n",
        "      self.results[k] = []\n",
        "      for c in df.columns:\n",
        "        vals = df[[c]].fillna(0)\n",
        "        if k == \"F2D\":\n",
        "          vals = vals.loc[10:].copy()\n",
        "        elif k == \"F3D\":\n",
        "          vals = vals.loc[100:].copy()\n",
        "        chi_gf, dof, p_gf, ss = self.chisq(df=vals, p=expected)\n",
        "        data = [c, chi_gf, dof, p_gf, ss]\n",
        "        for i in range(0, len(thresholds)):\n",
        "          data.append(\"Fail\" if p_gf < thresholds[i] else \"Pass\")\n",
        "        self.results[k].append(data)\n",
        "\n",
        "  def print(self, n_columns=3):\n",
        "    strings = []\n",
        "    headers=[\"Data\", \"𝜒2\", \"Df\", \"P\", \"N\"]\n",
        "    for ci in self.cis:\n",
        "      headers.append(f\"P/F @\\n {ci}\")\n",
        "    \n",
        "    for r in self.results:\n",
        "      strings.append(tabulate([[TEST_NAME_MAP[r]]], tablefmt=\"psql\") +\n",
        "                     \"\\n\" + tabulate(self.results[r], headers=headers,\n",
        "                                     tablefmt=\"psql\", numalign=\"right\", floatfmt=(\"\", \".0f\", \".f\", \".8f\")))\n",
        "\n",
        "    if n_columns == 1:\n",
        "      for l in range(0, len(strings)):\n",
        "        colPrinter([strings[l]])\n",
        "      return \n",
        "\n",
        "    for l in range(0, len(strings), n_columns):\n",
        "      if not (l+n_columns < len(strings)-n_columns):\n",
        "        colPrinter(strings[l:l+n_columns])\n",
        "      else: \n",
        "        colPrinter(strings[l-n_columns])"
      ],
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B36fK3mmIAnp"
      },
      "source": [
        "def parseMiamiTable(precincts_tables):\n",
        "  dataset = pd.DataFrame()\n",
        "\n",
        "  index = 1\n",
        "\n",
        "  # for each precinct\n",
        "  for result in precincts_tables:\n",
        "\n",
        "      # each row is a candidate\n",
        "      all_candidate_cols = result.find_all('tr')\n",
        "      \n",
        "      new_row = {}\n",
        "          \n",
        "      # parse the columns\n",
        "      for i in range(1, len(all_candidate_cols)):\n",
        "          candidate_cols = all_candidate_cols[i]\n",
        "\n",
        "          # parse the columns, one is the name the other is the total votes\n",
        "          col_values = candidate_cols.find_all('td')\n",
        "\n",
        "          # each row is a candidate starting from 1\n",
        "\n",
        "          remove_tags = ['REP', 'DEM', 'LPF', 'REF', 'PSL', 'GRE', 'CPF']\n",
        "\n",
        "          # first column is candidate name, remove superfluous white space\n",
        "          candidate = col_values[0].text\n",
        "          for tag in remove_tags:\n",
        "              candidate = candidate.replace('({})'.format(tag), '')\n",
        "          candidate = candidate.strip()\n",
        "\n",
        "          # get the vote count (second to last column)        \n",
        "          votes = int(col_values[-2].text.replace(',', ''))\n",
        "          new_row[candidate] = votes\n",
        "\n",
        "\n",
        "      dataset = dataset.append(pd.Series(new_row, name=index))\n",
        "\n",
        "      index += 1\n",
        "  return dataset\n",
        "\n",
        "def parseMilwTable(precincts_tables):\n",
        "  precinct = precincts[1]\n",
        "  dataset = pd.DataFrame()\n",
        "\n",
        "  # split by table rows\n",
        "  for tr in precinct.find_all('tr'):\n",
        "      \n",
        "      lines = tr.text.split('\\n')\n",
        "      \n",
        "      # second column is ward name\n",
        "      ward_name = lines[2]\n",
        "\n",
        "      # Header line\n",
        "      if ward_name == \"Ward\":\n",
        "          for line in lines[3:]:\n",
        "              dataset[line] = 0    \n",
        "      else:\n",
        "          \n",
        "          # append row\n",
        "          new_row = {}\n",
        "          for i in range(len(dataset.columns)):\n",
        "              col = dataset.columns[i]\n",
        "              value = lines[3+i]\n",
        "              new_row[col] = value\n",
        "\n",
        "          dataset = dataset.append(pd.Series(new_row, name=ward_name))\n",
        "  return dataset\n",
        "\n",
        "def getChicagoData():\n",
        "  data = pd.read_csv('/content/2020_benfords/data/chicago_dataexport.csv', skiprows=10)\n",
        "  data = data.dropna()\n",
        "  data = data[~(data['Precinct'].isin(['Total', 'Precinct']))]\n",
        "  data = data[['Joseph R. Biden & Kamala D. Harris ',\n",
        "       'Donald J. Trump & Michael R. Pence ', \n",
        "       'Howie Hawkins & Angela Walker ', \n",
        "       'Gloria La Riva & Leonard Peltier ', \n",
        "       'Brian Carroll & Amar Patel ', \n",
        "       \"Jo Jorgensen & Jeremy ''Spike'' Cohen \"]]\n",
        "  return data\n",
        "\n",
        "def getFultonData():\n",
        "  data =  pd.read_csv('/content/2020_benfords/data/ga_fulton_county.csv', skiprows=2)\n",
        "  data = data[data.columns[[0, 6, 11, 16]]]\n",
        "  data.columns = ['Precinct', 'Donald Trump', 'Joe Biden', 'Jo Jorgensen']\n",
        "  data = data.set_index('Precinct')\n",
        "  return data\n",
        "\n",
        "def getAlleghenyData():\n",
        "  data = pd.read_csv('/content/2020_benfords/data/pa_allegheny_county.csv', skiprows=2)\n",
        "  data = data[data.columns[[0, 4, 7, 10]]]\n",
        "  data.columns = ['Precinct', 'Joe Biden','Donald Trump', 'Jo Jorgensen']\n",
        "  data = data.set_index('Precinct')\n",
        "  return data\n",
        "\n",
        "def getMilwaukeeCounty():\n",
        "  return pd.read_csv(\"https://raw.githubusercontent.com/FraudAnalysis/Benford2020/main/data/milwaukee_county.csv\")\n",
        "\n",
        "def prepare(df):\n",
        "  relst = ['Jo', 'Donald']\n",
        "  df = df.loc[:,df.columns.str.startswith(tuple(relst))]\n",
        "  df = df.reindex(sorted(df.columns), axis=1)\n",
        "  df = df.reset_index(drop=True)\n",
        "  df = df.astype('int64')\n",
        "  df.columns = ['Trump', 'Jorgensen', 'Biden']\n",
        "  return df\n",
        "\n",
        "def getData():\n",
        "  miami_url = 'https://enr.electionsfl.org/DAD/2779/Precincts/35849/0/865/'\n",
        "\n",
        "  headers = {'User-Agent': \"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 \"\n",
        "            \"(KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36\"}\n",
        "\n",
        "  r = requests.get(miami_url, headers=headers)\n",
        "  bs_data = bs(r.text, 'html.parser')\n",
        "  precincts_tables = bs_data.findAll('table', {'class': 'DetailResults'})\n",
        "  miami_df = parseMiamiTable(precincts_tables)\n",
        "\n",
        "  chicago_df = getChicagoData()\n",
        "  fulton_df = getFultonData()\n",
        "  allegheny_df = getAlleghenyData()\n",
        "  milw_df = getMilwaukeeCounty()\n",
        "  \n",
        "  dataset = {\n",
        "      'Milwaukee':  milw_df,\n",
        "      'MiamiDade':  miami_df,\n",
        "      'Chicago':    chicago_df,\n",
        "      'Fulton':     fulton_df,\n",
        "      'Allegheny':  allegheny_df\n",
        "  }\n",
        "\n",
        "  dataset = {county: prepare(dataset[county]) for county in dataset}\n",
        "  \n",
        "  return dataset"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-wCm23qUaNeL"
      },
      "source": [
        "# The Fun Starts Here"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c92-11oVP34v"
      },
      "source": [
        "dataset = getData()"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HXNa5qWgQC0w",
        "outputId": "f1d5018f-6e3d-4331-8de9-5ca271240094",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "for county in dataset:\n",
        "  dfs = getAllTestDfs(dataset[county])\n",
        "  plot(dfs, \"FDT\", county)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 504x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "image/png": {
              "width": 434,
              "height": 318
            },
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 504x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "image/png": {
              "width": 434,
              "height": 318
            },
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 504x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "image/png": {
              "width": 434,
              "height": 318
            },
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 504x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "image/png": {
              "width": 434,
              "height": 318
            },
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 504x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "image/png": {
              "width": 434,
              "height": 318
            },
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jNjF--82TwoE",
        "outputId": "d3980818-ce29-484a-9098-f3037a588368",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "stat_tests = StatTests()\n",
        "for county in dataset:\n",
        "  print(county)\n",
        "  dfs = getAllTestDfs(dataset[county])\n",
        "  stat_tests.runTests(dfs, cis=[0.95, 0.999, 0.999])\n",
        "  stat_tests.print(n_columns=1) #use n_columns=2 if running in google colab\n",
        "  print(\"\\n\")"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Milwaukee\n",
            "+------------------+                                                               \n",
            "| First Digit Test |                                                               \n",
            "+------------------+                                                               \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |   28 |    8 | 0.00040006 | 475 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |   14 |    8 | 0.07980859 | 454 | Pass    | Pass     | Pass     |     \n",
            "| Biden     |  146 |    8 | 0.00000000 | 474 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "+-------------------+                                                              \n",
            "| Second Digit Test |                                                              \n",
            "+-------------------+                                                              \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |   42 |    9 | 0.00000317 | 413 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |   31 |    9 | 0.00032556 | 153 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |   46 |    9 | 0.00000071 | 422 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "+----------------------+                                                           \n",
            "| First Two Digit Test |                                                           \n",
            "+----------------------+                                                           \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |   93 |   89 | 0.36607047 | 467 | Pass    | Pass     | Pass     |     \n",
            "| Jorgensen |  210 |   89 | 0.00000000 | 177 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |  281 |   89 | 0.00000000 | 473 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "+---------------------+                                                            \n",
            "| Last Two Digit Test |                                                            \n",
            "+---------------------+                                                            \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |  128 |   99 | 0.02674163 | 471 | Fail    | Pass     | Pass     |     \n",
            "| Jorgensen | 2067 |   99 | 0.00000000 | 454 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |  107 |   99 | 0.26914585 | 468 | Pass    | Pass     | Pass     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "\n",
            "\n",
            "MiamiDade\n",
            "+------------------+                                                               \n",
            "| First Digit Test |                                                               \n",
            "+------------------+                                                               \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |   91 |    8 | 0.00000000 | 817 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |   38 |    8 | 0.00000709 | 694 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |   53 |    8 | 0.00000001 | 818 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "+-------------------+                                                              \n",
            "| Second Digit Test |                                                              \n",
            "+-------------------+                                                              \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |   81 |    9 | 0.00000000 | 679 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |   38 |    9 | 0.00001927 |  45 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |   71 |    9 | 0.00000000 | 682 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "+----------------------+                                                           \n",
            "| First Two Digit Test |                                                           \n",
            "+----------------------+                                                           \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |  208 |   89 | 0.00000000 | 789 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |  250 |   89 | 0.00000000 |  65 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |  142 |   89 | 0.00033501 | 793 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "+---------------------+                                                            \n",
            "| Last Two Digit Test |                                                            \n",
            "+---------------------+                                                            \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |  137 |   99 | 0.00657980 | 808 | Fail    | Pass     | Pass     |     \n",
            "| Jorgensen | 6803 |   99 | 0.00000000 | 694 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |   96 |   99 | 0.57580377 | 810 | Pass    | Pass     | Pass     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "\n",
            "\n",
            "Chicago\n",
            "+------------------+                                                                \n",
            "| First Digit Test |                                                                \n",
            "+------------------+                                                                \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |    N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |      |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+------+---------+----------+----------|     \n",
            "| Trump     |  158 |    8 | 0.00000000 | 2054 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |   38 |    8 | 0.00000773 | 1606 | Fail    | Fail     | Fail     |     \n",
            "| Biden     | 1732 |    8 | 0.00000000 | 2054 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "+-------------------+                                                               \n",
            "| Second Digit Test |                                                               \n",
            "+-------------------+                                                               \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |    N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |      |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+------+---------+----------+----------|     \n",
            "| Trump     |  179 |    9 | 0.00000000 | 1667 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |   80 |    9 | 0.00000000 |   77 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |  194 |    9 | 0.00000000 | 1867 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "+----------------------+                                                            \n",
            "| First Two Digit Test |                                                            \n",
            "+----------------------+                                                            \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |    N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |      |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+------+---------+----------+----------|     \n",
            "| Trump     |  234 |   89 | 0.00000000 | 1935 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |  427 |   89 | 0.00000000 |  103 | Fail    | Fail     | Fail     |     \n",
            "| Biden     | 1919 |   89 | 0.00000000 | 2054 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "+---------------------+                                                              \n",
            "| Last Two Digit Test |                                                              \n",
            "+---------------------+                                                              \n",
            "+-----------+-------+------+------------+------+---------+----------+----------+     \n",
            "| Data      |    𝜒2 |   Df |          P |    N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |       |      |            |      |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+-------+------+------------+------+---------+----------+----------|     \n",
            "| Trump     |   712 |   99 | 0.00000000 | 2041 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen | 20934 |   99 | 0.00000000 | 1606 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |   109 |   99 | 0.23907461 | 2033 | Pass    | Pass     | Pass     |     \n",
            "+-----------+-------+------+------------+------+---------+----------+----------+     \n",
            "\n",
            "\n",
            "Fulton\n",
            "+------------------+                                                               \n",
            "| First Digit Test |                                                               \n",
            "+------------------+                                                               \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |   15 |    8 | 0.06934682 | 377 | Pass    | Pass     | Pass     |     \n",
            "| Jorgensen |   10 |    8 | 0.24113649 | 359 | Pass    | Pass     | Pass     |     \n",
            "| Biden     |   37 |    8 | 0.00001189 | 381 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "+-------------------+                                                              \n",
            "| Second Digit Test |                                                              \n",
            "+-------------------+                                                              \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |   35 |    9 | 0.00007034 | 313 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |   21 |    9 | 0.01119430 | 189 | Fail    | Pass     | Pass     |     \n",
            "| Biden     |   39 |    9 | 0.00001084 | 321 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "+----------------------+                                                           \n",
            "| First Two Digit Test |                                                           \n",
            "+----------------------+                                                           \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |   86 |   89 | 0.57051888 | 353 | Pass    | Pass     | Pass     |     \n",
            "| Jorgensen |  113 |   89 | 0.04513873 | 220 | Fail    | Pass     | Pass     |     \n",
            "| Biden     |  101 |   89 | 0.17506365 | 375 | Pass    | Pass     | Pass     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "+---------------------+                                                            \n",
            "| Last Two Digit Test |                                                            \n",
            "+---------------------+                                                            \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |   N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |     |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+-----+---------+----------+----------|     \n",
            "| Trump     |  133 |   99 | 0.01276719 | 376 | Fail    | Pass     | Pass     |     \n",
            "| Jorgensen |  711 |   99 | 0.00000000 | 359 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |   79 |   99 | 0.93497950 | 378 | Pass    | Pass     | Pass     |     \n",
            "+-----------+------+------+------------+-----+---------+----------+----------+     \n",
            "\n",
            "\n",
            "Allegheny\n",
            "+------------------+                                                                \n",
            "| First Digit Test |                                                                \n",
            "+------------------+                                                                \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |    N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |      |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+------+---------+----------+----------|     \n",
            "| Trump     |   59 |    8 | 0.00000000 | 1323 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |   95 |    8 | 0.00000000 | 1255 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |  574 |    8 | 0.00000000 | 1324 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "+-------------------+                                                               \n",
            "| Second Digit Test |                                                               \n",
            "+-------------------+                                                               \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |    N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |      |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+------+---------+----------+----------|     \n",
            "| Trump     |  107 |    9 | 0.00000000 | 1098 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |  104 |    9 | 0.00000000 |  172 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |  124 |    9 | 0.00000000 | 1193 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "+----------------------+                                                            \n",
            "| First Two Digit Test |                                                            \n",
            "+----------------------+                                                            \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |    N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |      |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+------+---------+----------+----------|     \n",
            "| Trump     |  153 |   89 | 0.00003155 | 1253 | Fail    | Fail     | Fail     |     \n",
            "| Jorgensen |  669 |   89 | 0.00000000 |  232 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |  671 |   89 | 0.00000000 | 1323 | Fail    | Fail     | Fail     |     \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "+---------------------+                                                             \n",
            "| Last Two Digit Test |                                                             \n",
            "+---------------------+                                                             \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "| Data      |   𝜒2 |   Df |          P |    N | P/F @   | P/F @    | P/F @    |     \n",
            "|           |      |      |            |      |  0.95   |  0.999   |  0.999   |     \n",
            "|-----------+------+------+------------+------+---------+----------+----------|     \n",
            "| Trump     |  132 |   99 | 0.01594689 | 1305 | Fail    | Pass     | Pass     |     \n",
            "| Jorgensen | 9057 |   99 | 0.00000000 | 1255 | Fail    | Fail     | Fail     |     \n",
            "| Biden     |  118 |   99 | 0.09041176 | 1313 | Pass    | Pass     | Pass     |     \n",
            "+-----------+------+------+------------+------+---------+----------+----------+     \n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JWNnc09eUfSZ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}