From 9afa00f309eefb5e2eb12a13abd1fe92968cafc7 Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Tue, 7 May 2019 19:28:22 -0700 Subject: [PATCH] Add files via upload --- ipynb/Electoral Votes.ipynb | 495 ++++++++++++++++++++++++------------ 1 file changed, 338 insertions(+), 157 deletions(-) diff --git a/ipynb/Electoral Votes.ipynb b/ipynb/Electoral Votes.ipynb index b80eedc..9949d8e 100644 --- a/ipynb/Electoral Votes.ipynb +++ b/ipynb/Electoral Votes.ipynb @@ -4,113 +4,145 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "
Peter Norvig
\n", + "
Peter Norvig
\n", "\n", "# Tracking Trump: Electoral Votes Edition\n", "\n", - "**[Morning Consult](https://morningconsult.com)** has a page called **[Tracking Trump](https://morningconsult.com/tracking-trump/)** that summarizes the presidential approval polls on a state-by-state basis, and summarized the number of states in which Trump currently has a net positive or net negative approval rating (that is, his current percentage of approval minus his percentage of disapproval). But if you're thinking about the 2020 election, you don't care about the number of *states*, you care about the number of *electoral votes*. So I computed that.\n", + "[538](https://projects.fivethirtyeight.com/trump-approval-ratings/) shows presidential approval ratings (currently about 42% (±4) approval and 52% (±4) disapproval). But do approval ratings predict election results? Surely there is a correlation—popular presidents are more likely to be re-elected. But there are three big caveats:\n", "\n", - "# TL;DR for politics nerds\n", + "1. These are approval polls, not votes. We don't know who will be on the ballot and what their approval levels will be, we don't know if there is systematic bias in the polling data, and we don't know how many people will vote for a candidate they disapprove of or against a candidate they approve of.\n", "\n", - "As of Feb 6th 2019, Trump has a net positive approval in states that total **105** electoral votes, net negative for **390** electoral votes, and tied for **43** electoral votes.\n", + "2. This is today, not November 3rd, 2020. Things can change. Key economic, geopolitical, or legal events might happen.\n", "\n", - "Michigan, Wisconsin, and Pennsylvania (which Trump won in 2016) are all double-digit negative now. In the key swing states of Ohio and Florida, he is -6 and -4, respectively. How is he doing in the states that border the proposed wall? Surprisingly poorly: -18 in New Mexico, -8 in Arizona, tied in Texas (which is supposed to be a Republican stronghold), and (not surprisingly), -30 in California.\n", + "3. These are popular votes, not electoral votes. \n", "\n", - "But of course these are just approval polls, not ballots, and don't translate directly to votes. Things can change; the election is a long ways away, we don't know who else will be on the ballot and what their approval levels will be, there might be key economic or geopolitical events, and we don't know if there is systematic bias in the polling data.\n", - "\n", - "Nevertheless, the net approval is correlated to some degree with votes. An important concept is the **swing needed** to win, that is, if we make the (unwarranted) assumption that net approval translates directly to votes, how much of a positive swing in net approval percentage across the board in all states would Truump need to get to the necessary 270?. Today he would need an **11%** swing, whereas at his inauguration date he had good approval numbers, and would have needed a 10% negative swing to slip below 270.\n", - "\n", - "A large swing is more likely when there are many voters who are currently undecided. So I track the number of states in which more than 5% of the poll respondants were undecided. Today there are no such states, which is evidence that most people have made up their minds. (At the inauguration all 50 states plus DC had more than 5% undecided; many people had not made up their minds then.)\n", + "We can't be conclusive about the first two points, but this notebook can take the state-by-state, month-by-month approval data from \n", + "[Morning Consult](https://morningconsult.com/tracking-trump/) and compute electoral votes, under the assumption that Trump wins the electoral votes of states he has positive net approval, and wins half the votes for states with zero net approval (i.e. approval exactly equals disapproval).\n", "\n", "\n", - "The table below summarizes the results over time. From now on I will update this when Morning Consult updates (monthly), but so far I only have results for Jan and Feb 2019, and for the Jan 2017 inauguration. \n", + "# TL;DR for policy wonks\n", "\n", + "As of 1 April 2019, Trump would expect **180 electoral votes** under these assumptions (recall that you need **270** to win). He's been below 270 every month for the last two years.\n", + "I have three ways of understanding the fluidity of the situation:\n", "\n", - "|Date |+ EV |- EV |= EV|Swing needed|5%+ undecided|\n", - "|---------|-----|-----|----|------------|-------------|\n", - "|Feb 2019 | 105 | 390 | 43 | 11% | 0 |\n", - "|Jan 2019 | 164 | 374 | 0 | 7% | 3 |\n", - "|Jan 2017 | 448 | 90 | 0 | -10%| 51|\n", + "- **Undecided**: if many voters are undecided, the numbers could change. So I track the number of states for which at least 5% of voters are undecided. At the inauguration in 2017, all 51 states (including DC) had at least 5% undecided; now there are no such states. **Most people have made up their mind.**\n", + "\n", + "- **Variance**: how much are voters changing their minds from month to month in each state? I track what would happen in each state if the undecided voters broke 60/40 for Trump, and the other voters swung in his favor by an amount equal to two standard deviations of their month-by-month change. The answer is that he would take **259** electoral votes (and if the states all swung the other way, he would take 79 electoral votes).\n", + "\n", + "- **Margin**: Suppose a future event swings voters in one direction or another uniformly, across the board in all states. How much of a swing would be necessary to change the results? We call that the **margin**. Today **Trump's margin is a 7%:** he would need 7% more votes in all states to win. (This could come, for example, by convincing undecided voters to break for him at a 2% to 1% ratio, and then convincing 3% of disapproving voters to switch to approving.)\n", "\n", "\n", "\n", - "# The details for data science nerds" + "# The details for data science nerds\n", + "\n", + "First fetch the web page and cache it locally, then define the code:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 113k 0 113k 0 0 243k 0 --:--:-- --:--:-- --:--:-- 243k\n" + ] + } + ], "source": [ - "import urllib.request\n", - "import re\n", - "from collections import namedtuple, Counter\n", - "\n", - "State = namedtuple('State', 'name ev app dis')\n", - "\n", - "EVs = dict(AL=9, AK=3, AZ=11, AR=6, CA=55, CO=9, CT=7, DE=3, DC=3, FL=29, \n", - " GA=16, HI=4, ID=4, IL=20, IN=11, IA=6, KS=6, KY=8, LA=8, ME=4, \n", - " MD=10, MA=11, MI=16, MN=10, MS=6, MO=10, MT=3, NE=5, NV=6, NH=4, \n", - " NJ=14, NM=5, NY=29, NC=15, ND=3, OH=18, OK=7, OR=7, PA=20, RI=4, \n", - " SC=9, SD=3, TN=11, TX=38, UT=6, VT=3, VA=13, WA=12, WV=5, WI=10, WY=3)\n", - "\n", - "def parse_page(url):\n", - " \"Fetch data from the website and parse into a list of `State`s.\"\n", - " with urllib.request.urlopen(url) as response:\n", - " html = response.read().decode('utf-8')\n", - " rows = re.findall(r'', html, re.S)\n", - " return [parse_row(row) for row in rows[1:]]\n", - " \n", - "def parse_row(row):\n", - " \"Parse an html string into a `State`.\"\n", - " # Rows are: |name|delta|Jan17 app|Jan 17 dis|Jan 17 err|now app|now dis|now err|\n", - " name, *_, app, dis, _ = re.findall('>([^>]*?) 0 else '-' if x < 0 else '='\n", - "\n", - "states = parse_page('https://morningconsult.com/tracking-trump/')\n", - "\n", - "def EV(swing=0, states=states):\n", - " \"Total electoral votes that are net positive, negative, or tied, after applying swing.\"\n", - " return Counter(vote for state in states for vote in state.ev * sign(net(state) + swing))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can compute the number of electoral votes Trump has positive, negative, or tied net approval numbers:" + "! curl -o evs.html https://morningconsult.com/tracking-trump/" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Counter({'+': 105, '-': 390, '=': 43})" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "EV()" + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "import ast\n", + "from collections import namedtuple\n", + "from IPython.display import display, Markdown\n", + "from statistics import stdev\n", + "\n", + "EVs = {\n", + " 'Alaska': 3, 'Alabama': 9, 'Arkansas': 6,\n", + " 'Arizona': 11, 'California': 55, 'Colorado': 9,\n", + " 'Connecticut': 7, 'District of Columbia': 3, 'Delaware': 3,\n", + " 'Florida': 29, 'Georgia': 16, 'Hawaii': 4,\n", + " 'Iowa': 6, 'Idaho': 4, 'Illinois': 20,\n", + " 'Indiana': 11, 'Kansas': 6, 'Kentucky': 8,\n", + " 'Louisiana': 8, 'Massachusetts': 11, 'Maryland': 10,\n", + " 'Maine': 4, 'Michigan': 16, 'Minnesota': 10,\n", + " 'Missouri': 10, 'Mississippi': 6, 'Montana': 3,\n", + " 'North Carolina': 15, 'North Dakota': 3, 'Nebraska': 5,\n", + " 'New Hampshire': 4, 'New Jersey': 14, 'New Mexico': 5,\n", + " 'Nevada': 6, 'New York': 29, 'Ohio': 18,\n", + " 'Oklahoma': 7, 'Oregon': 7, 'Pennsylvania': 20,\n", + " 'Rhode Island': 4, 'South Carolina': 9, 'South Dakota': 3, \n", + " 'Tennessee': 11, 'Texas': 38, 'Utah': 6,\n", + " 'Virginia': 13, 'Vermont': 3, 'Washington': 12,\n", + " 'Wisconsin': 10, 'West Virginia': 5, 'Wyoming': 3}\n", + "\n", + "# net_usa: From https://projects.fivethirtyeight.com/trump-approval-ratings/\n", + "# a dict of {date: country-wide net approval}\n", + "net_usa = {'1-Jan-17': +10, \n", + " '1-Feb-17': 0, '1-Mar-17': -6, '1-Apr-17': -13, '1-May-17': -11,\n", + " '1-Jun-17': -16, '1-Jul-17': -15, '1-Aug-17': -19, '1-Sep-17': -20,\n", + " '1-Oct-17': -17, '1-Nov-17': -19, '1-Dec-17': -18, '1-Jan-18': -18,\n", + " '1-Feb-18': -15, '1-Mar-18': -14, '1-Apr-18': -13, '1-May-18': -12,\n", + " '1-Jun-18': -11, '1-Jul-18': -10, '1-Aug-18': -12, '1-Sep-18': -14,\n", + " '1-Oct-18': -11, '1-Nov-18': -11, '1-Dec-18': -10, '1-Jan-19': -12,\n", + " '1-Feb-19': -16, '1-Mar-19': -11, '1-Apr-19': -11}\n", + "\n", + "State = namedtuple('State', 'name, ev, apps, diss')\n", + "State.__doc__ = '''A State has a name, the number of electoral votes (.ev),\n", + "and two dicts of {date: percent}, .apps (approvals) and .diss (disapprovals)'''\n", + "\n", + "def parse_page(filename='evs.html'):\n", + " \"Read data from the file and return (list of dates, list of `State`s).\"\n", + " # File format: Date headers, then [state, approval, disapproval ...]\n", + " # [[\"Demographic\",\"1-Jan-17\",\"\",\"1-Feb-17\",\"\", ... \"1-Apr-19\",\"\"],\n", + " # [\"Alabama\",\"62\",\"26\",\"65\",\"29\", ... \"61\",\"35\"], ... ]\n", + " text = re.findall(r'\\[\\[.*?\\]\\]', open(filename).read())[0]\n", + " table = ast.literal_eval(text)\n", + " dates = table[0][1::2]\n", + " states = [State(name, EVs[name], \n", + " dict(zip(dates, map(int, numbers[0::2]))),\n", + " dict(zip(dates, map(int, numbers[1::2]))))\n", + " for (name, *numbers) in table[1:]]\n", + " return dates, states\n", + "\n", + "dates, states = parse_page()\n", + "now = dates[-1]\n", + "\n", + "assert len(states) == 51 and sum(s.ev for s in states) == 538\n", + "\n", + "def EV(states, date=now, swing=0):\n", + " \"Total electoral votes with net positive approval (plus half the votes for net zero).\"\n", + " return sum(s.ev * (1/2 if net(s, date) + swing == 0 else int(net(s, date) + swing > 0))\n", + " for s in states)\n", + "\n", + "def margin(states, date=now):\n", + " \"What's the least swing that would lead to a majority?\"\n", + " return next(swing for swing in range(-50, 50) if EV(states, date, swing) >= 270)\n", + "\n", + "def net(state, date=now): return state.apps[date] - state.diss[date]\n", + "def undecided(state, date=now): return 100 - state.apps[date] - state.diss[date]\n", + "def md(lines): display(Markdown('\\n'.join(lines)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "And repeat the computation for a range of across-the-board swings in Trump's favor:" + "# Current expected electoral votes, with various swings" ] }, { @@ -121,23 +153,16 @@ { "data": { "text/plain": [ - "{0: Counter({'+': 105, '-': 390, '=': 43}),\n", - " 1: Counter({'+': 148, '-': 390}),\n", - " 2: Counter({'+': 148, '-': 364, '=': 26}),\n", - " 3: Counter({'+': 174, '-': 364}),\n", - " 4: Counter({'+': 174, '-': 320, '=': 44}),\n", - " 5: Counter({'+': 218, '-': 320}),\n", - " 6: Counter({'+': 218, '-': 296, '=': 24}),\n", - " 7: Counter({'+': 242, '-': 296}),\n", - " 8: Counter({'+': 242, '=': 11, '-': 285}),\n", - " 9: Counter({'+': 253, '-': 285}),\n", - " 10: Counter({'+': 253, '-': 252, '=': 33}),\n", - " 11: Counter({'+': 286, '-': 248, '=': 4}),\n", - " 12: Counter({'+': 290, '-': 248}),\n", - " 13: Counter({'+': 290, '-': 242, '=': 6}),\n", - " 14: Counter({'+': 296, '-': 236, '=': 6}),\n", - " 15: Counter({'+': 302, '-': 217, '=': 19}),\n", - " 16: Counter({'+': 321, '-': 207, '=': 10})}" + "{0: 180,\n", + " 1: 180,\n", + " 2: 202.0,\n", + " 3: 224,\n", + " 4: 233.0,\n", + " 5: 242,\n", + " 6: 251.5,\n", + " 7: 271.0,\n", + " 8: 289.5,\n", + " 9: 298}" ] }, "execution_count": 3, @@ -146,14 +171,24 @@ } ], "source": [ - "{swing: EV(swing) for swing in range(17)}" + "{swing: EV(states, now, swing)\n", + " for swing in range(10)}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Below is each state, sorted by net approval, with their number of electoral votes, net approval, and the three approval percentages: positive, negative, undecided:" + "The first number says that Trump is currently leading in states with only 180 electoral votes, and we see that the margin is 7%, because that leads to 271 electoral votes, and any smaller swing is below 270." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Electoral votes by month\n", + "\n", + "The following plot shows, for each month in office, the expected number of electoral votes (based on net approval) with error bars indicating a 4% swing. Trump hasn't been above 270 since 4 months into his term, and even with the 4% swing, since 13 months in." ] }, { @@ -162,75 +197,39 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "DC: 3 EV, net -65 (+:16 -:81 ?:3)\n", - "VT: 3 EV, net -35 (+:31 -:66 ?:3)\n", - "MA: 11 EV, net -31 (+:33 -:64 ?:3)\n", - "CA: 55 EV, net -30 (+:33 -:63 ?:4)\n", - "MD: 10 EV, net -30 (+:33 -:63 ?:4)\n", - "HI: 4 EV, net -29 (+:34 -:63 ?:3)\n", - "WA: 12 EV, net -26 (+:35 -:61 ?:4)\n", - "CT: 7 EV, net -24 (+:36 -:60 ?:4)\n", - "NY: 29 EV, net -24 (+:36 -:60 ?:4)\n", - "IL: 20 EV, net -23 (+:37 -:60 ?:3)\n", - "OR: 7 EV, net -22 (+:37 -:59 ?:4)\n", - "NH: 4 EV, net -19 (+:39 -:58 ?:3)\n", - "NJ: 14 EV, net -19 (+:39 -:58 ?:3)\n", - "RI: 4 EV, net -19 (+:39 -:58 ?:3)\n", - "CO: 9 EV, net -18 (+:39 -:57 ?:4)\n", - "MN: 10 EV, net -18 (+:39 -:57 ?:4)\n", - "NM: 5 EV, net -18 (+:39 -:57 ?:4)\n", - "WI: 10 EV, net -16 (+:40 -:56 ?:4)\n", - "DE: 3 EV, net -15 (+:41 -:56 ?:3)\n", - "MI: 16 EV, net -15 (+:40 -:55 ?:5)\n", - "IA: 6 EV, net -14 (+:41 -:55 ?:4)\n", - "NV: 6 EV, net -13 (+:42 -:55 ?:3)\n", - "ME: 4 EV, net -11 (+:43 -:54 ?:3)\n", - "PA: 20 EV, net -10 (+:43 -:53 ?:4)\n", - "VA: 13 EV, net -10 (+:43 -:53 ?:4)\n", - "AZ: 11 EV, net -8 (+:44 -:52 ?:4)\n", - "OH: 18 EV, net -6 (+:45 -:51 ?:4)\n", - "UT: 6 EV, net -6 (+:45 -:51 ?:4)\n", - "FL: 29 EV, net -4 (+:46 -:50 ?:4)\n", - "NC: 15 EV, net -4 (+:46 -:50 ?:4)\n", - "GA: 16 EV, net -2 (+:47 -:49 ?:4)\n", - "MO: 10 EV, net -2 (+:47 -:49 ?:4)\n", - "NE: 5 EV, net +0 (+:48 -:48 ?:4)\n", - "TX: 38 EV, net +0 (+:48 -:48 ?:4)\n", - "AK: 3 EV, net +1 (+:48 -:47 ?:5)\n", - "KS: 6 EV, net +1 (+:49 -:48 ?:3)\n", - "MT: 3 EV, net +1 (+:49 -:48 ?:3)\n", - "IN: 11 EV, net +4 (+:50 -:46 ?:4)\n", - "ND: 3 EV, net +4 (+:50 -:46 ?:4)\n", - "SD: 3 EV, net +6 (+:51 -:45 ?:4)\n", - "SC: 9 EV, net +8 (+:52 -:44 ?:4)\n", - "AR: 6 EV, net +10 (+:53 -:43 ?:4)\n", - "OK: 7 EV, net +10 (+:53 -:43 ?:4)\n", - "TN: 11 EV, net +12 (+:54 -:42 ?:4)\n", - "MS: 6 EV, net +13 (+:54 -:41 ?:5)\n", - "KY: 8 EV, net +14 (+:55 -:41 ?:4)\n", - "ID: 4 EV, net +15 (+:56 -:41 ?:3)\n", - "LA: 8 EV, net +15 (+:55 -:40 ?:5)\n", - "AL: 9 EV, net +20 (+:58 -:38 ?:4)\n", - "WV: 5 EV, net +24 (+:60 -:36 ?:4)\n", - "WY: 3 EV, net +30 (+:63 -:33 ?:4)\n" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "for s in sorted(states, key=net):\n", - " print(f'{s.name}: {s.ev:2d} EV, net {net(s):+3d} (+:{s.app} -:{s.dis} ?:{undecided(s)})')" + "def plot(states, dates):\n", + " N = len(dates)\n", + " err = [EV(states, date, swing=4) - EV(states, date) for date in dates]\n", + " plt.errorbar(range(N), [EV(states, date) for date in dates], \n", + " yerr=err, ecolor='grey', capsize=5)\n", + " plt.plot(range(N), [270] * N, color='darkorange')\n", + " plt.xlabel('Months into term')\n", + " plt.ylabel('Electoral Votes with Net Positive Approval')\n", + " plt.grid(True)\n", + " \n", + "plot(states, dates)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ + "# Margin and popular net approval by month\n", "\n", - "\n", - "Below are all the states with more than 5% undecided: the empty set. " + "The next plot gives the swing margin needed to reach 270 for each month, along with the country-wide net approval." ] }, { @@ -240,17 +239,199 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "set()" + "
" ] }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "{s for s in states if undecided(s) > 5}" + "def plot2(states, dates):\n", + " N = len(dates)\n", + " plt.plot(range(N), [-margin(states, date) for date in dates], label='Margin')\n", + " plt.plot(range(N), [0] * N, label='Net zero')\n", + " plt.plot(range(N), [net_usa[date] for date in dates], label='Popular')\n", + " plt.xlabel('Months into term')\n", + " plt.ylabel('Net popularity')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " \n", + "plot2(states, dates)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Month-by-month summary\n", + "\n", + "For each month, we show the expected electoral vote total (**EV**), the swing margin needed to get to 270 (**Margin**), the overall (popular vote) net approval across the whole country (**Pop**), and then the total percentage of undecided voters and in parentheses the number of states with at least 5% undecided.\n", + "Note that the country-wide vote is not all that correlated with the state-by-state margin: recently the state-by-state margin has held at 7% while the country-wide net approval has ranged from -10% to -16%, and when the state-by-state margin jumped to 11%, the country-wide measure stayed right in the middle at 12%." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "| Month| EV|Margin|Pop|Undecided|\n", + "|--------|---|------|---|---------|\n", + "|Apr 2019|180|7%|-11%|4% (0)|\n", + "|Mar 2019|193|7%|-11%|4% (2)|\n", + "|Feb 2019|170|7%|-16%|4% (0)|\n", + "|Jan 2019|126|11%|-12%|4% (0)|\n", + "|Dec 2018|164|7%|-10%|5% (3)|\n", + "|Nov 2018|233|5%|-11%|4% (1)|\n", + "|Oct 2018|247|6%|-11%|4% (3)|\n", + "|Sep 2018|203|8%|-14%|4% (1)|\n", + "|Aug 2018|224|6%|-12%|4% (0)|\n", + "|Jul 2018|225|6%|-10%|4% (1)|\n", + "|Jun 2018|226|5%|-11%|4% (0)|\n", + "|May 2018|232|5%|-12%|4% (0)|\n", + "|Apr 2018|209|7%|-13%|4% (0)|\n", + "|Mar 2018|196|9%|-14%|4% (0)|\n", + "|Feb 2018|247|4%|-15%|4% (2)|\n", + "|Jan 2018|201|4%|-18%|5% (4)|\n", + "|Dec 2017|189|8%|-18%|5% (8)|\n", + "|Nov 2017|174|8%|-19%|5% (7)|\n", + "|Oct 2017|209|8%|-17%|5% (7)|\n", + "|Sep 2017|201|7%|-20%|5% (8)|\n", + "|Aug 2017|163|10%|-19%|7% (33)|\n", + "|Jul 2017|196|3%|-15%|5% (4)|\n", + "|Jun 2017|248|2%|-16%|5% (15)|\n", + "|May 2017|269|1%|-11%|5% (4)|\n", + "|Apr 2017|365|-7%|-13%|4% (4)|\n", + "|Mar 2017|374|-8%|-6%|5% (14)|\n", + "|Feb 2017|402|-8%|0%|6% (48)|\n", + "|Jan 2017|448|-10%|10%|11% (51)|" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def monthly(states, dates=reversed(dates)):\n", + " yield '| Month| EV|Margin|Pop|Undecided|'\n", + " yield '|--------|---|------|---|---------|'\n", + " for date in dates:\n", + " us_un = sum(s.ev * undecided(s, date) for s in states) / 538\n", + " undec = sum(undecided(s, date) > 5 for s in states)\n", + " month = date.replace('1-', '').replace('-', ' 20')\n", + " yield f'|{month}|{int(EV(states, date))}|{margin(states, date)}%|{net_usa[date]}%|{us_un:.0f}% ({undec})|'\n", + " \n", + "md(monthly(states))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# State-by-state net approval\n", + "\n", + "Below is each state sorted by net approval, with the state's electoral vote allotment, and the cumulative running total of electoral votes, followed by the percentages of approval, dissaproval, and undecided, and then the standard deviation of the net approval over the last 12 months (bolded if it is over **5%**). By going down the **Total** column, you can see what it takes to win. \n", + "\n", + "The **bold state names** are the **swing states**, which I define as states in which the absolute value of net approval is less than two standard deviations of the net approval over time, plus a fifth of the undecided voters. The idea is that if we are just dealing with random sampling variation, you could expect future approval to be within two standard deviations 95% of the time, and if the undecideds split 60/40, then a candidate could get a net fifth of them. So it would be very unusual for the non-bold states to flip, unless some events change perception of the candidates.\n", + "\n", + "This analysis says that if we consider all and only the bold swing states to be in play, then the total electoral votes for Trump could be anywhere in the range of 79 (if he lost them all) to 248 + 11 = 259 (if he won them all). It would take winning all the swing states plus a three-standard deviation swing in Virgina for Trump to reach 272.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "|State|Net|EV|Total|+|-|?|𝝈|\n", + "|-----|---|--|-----|-|-|-|-|\n", + "|Wyoming|+28|3|3|62%|34%|4%|3.5\n", + "|Alabama|+26|9|12|61%|35%|4%|3.4\n", + "|Louisiana|+20|8|20|58%|38%|4%|3.7\n", + "|Mississippi|+20|6|26|58%|38%|4%|3.8\n", + "|West Virginia|+20|5|31|58%|38%|4%|3.6\n", + "|Tennessee|+18|11|42|57%|39%|4%|3.1\n", + "|Idaho|+17|4|46|57%|40%|3%|1.8\n", + "|Kentucky|+16|8|54|56%|40%|4%|1.1\n", + "|Oklahoma|+11|7|61|54%|43%|3%|3.4\n", + "|Arkansas|+10|6|67|53%|43%|4%|2.8\n", + "|South Carolina|+10|9|76|53%|43%|4%|2.2\n", + "|South Dakota|+10|3|79|53%|43%|4%|4.3\n", + "|**North Dakota**|+6|3|82|51%|45%|4%|2.8\n", + "|**Utah**|+5|6|88|51%|46%|3%|3.6\n", + "|**Indiana**|+4|11|99|50%|46%|4%|2.0\n", + "|**Missouri**|+4|10|109|50%|46%|4%|3.0\n", + "|**Nebraska**|+4|5|114|50%|46%|4%|2.7\n", + "|**Texas**|+4|38|152|50%|46%|4%|2.6\n", + "|**Georgia**|+3|16|168|49%|46%|5%|3.2\n", + "|**Montana**|+3|3|171|50%|47%|3%|3.4\n", + "|**Kansas**|+2|6|177|49%|47%|4%|2.9\n", + "|**Alaska**|+1|3|180|48%|47%|5%|5.1\n", + "|**Florida**|-2|29|209|47%|49%|4%|3.3\n", + "|**North Carolina**|-2|15|224|47%|49%|4%|2.2\n", + "|**Ohio**|-4|18|242|46%|50%|4%|2.4\n", + "|**Nevada**|-6|6|248|45%|51%|4%|3.1\n", + "|Virginia|-6|13|261|45%|51%|4%|1.8\n", + "|Pennsylvania|-7|20|281|45%|52%|3%|1.6\n", + "|**Arizona**|-8|11|292|44%|52%|4%|3.7\n", + "|Iowa|-8|6|298|44%|52%|4%|2.6\n", + "|Michigan|-10|16|314|43%|53%|4%|2.2\n", + "|New Mexico|-12|5|319|42%|54%|4%|2.9\n", + "|Colorado|-13|9|328|42%|55%|3%|2.4\n", + "|Minnesota|-13|10|338|42%|55%|3%|2.2\n", + "|Wisconsin|-13|10|348|42%|55%|3%|2.4\n", + "|Delaware|-15|3|351|41%|56%|3%|2.0\n", + "|Maine|-15|4|355|41%|56%|3%|4.0\n", + "|New Jersey|-17|14|369|40%|57%|3%|2.4\n", + "|New Hampshire|-19|4|373|39%|58%|3%|3.6\n", + "|Illinois|-22|20|393|37%|59%|4%|1.2\n", + "|Oregon|-22|7|400|37%|59%|4%|2.0\n", + "|Rhode Island|-22|4|404|37%|59%|4%|2.8\n", + "|Connecticut|-23|7|411|37%|60%|3%|3.8\n", + "|New York|-24|29|440|36%|60%|4%|1.8\n", + "|Washington|-26|12|452|35%|61%|4%|2.1\n", + "|Massachusetts|-28|11|463|34%|62%|4%|2.2\n", + "|California|-29|55|518|34%|63%|3%|3.1\n", + "|Maryland|-30|10|528|33%|63%|4%|3.5\n", + "|Hawaii|-34|4|532|31%|65%|4%|4.2\n", + "|Vermont|-37|3|535|30%|67%|3%|4.8\n", + "|District of Columbia|-60|3|538|18%|78%|4%|3.1" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def by_state(states, d=now):\n", + " total = 0\n", + " yield '|State|Net|EV|Total|+|-|?|𝝈|'\n", + " yield '|-----|---|--|-----|-|-|-|-|'\n", + " for s in sorted(states, key=net, reverse=True):\n", + " total += s.ev\n", + " std = stdev(net(s, d) for d in dates[-12:])\n", + " und = f'{undecided(s, now)}%'\n", + " b = '**' if swing(s, std) else ''\n", + " yield f'|{b}{s.name}{b}|{net(s):+d}|{s.ev}|{total}|{s.apps[d]}%|{s.diss[d]}%|{und}|{std:3.1f}'\n", + " \n", + "def swing(s, std): return abs(net(s)) < 2 * std + undecided(s, now) / 5\n", + "\n", + "md(by_state(states))" ] } ], @@ -270,7 +451,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.7.2" } }, "nbformat": 4,