diff --git a/bracelet_and_chord_counts.ipynb b/bracelet_and_chord_counts.ipynb new file mode 100644 index 0000000..995867d --- /dev/null +++ b/bracelet_and_chord_counts.ipynb @@ -0,0 +1,5580 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "e4728203", + "metadata": {}, + "outputs": [], + "source": [ + "for i in 0:num_participants\n", + " sum += (-1)^i / factorial(i)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c5b2728c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General.toml`\n", + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.8/Project.toml`\n", + " \u001b[90m [861a8166] \u001b[39m\u001b[92m+ Combinatorics v1.0.2\u001b[39m\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.8/Manifest.toml`\n", + "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", + "\u001b[32m ✓ \u001b[39m\u001b[90mWinReg\u001b[39m\n", + "\u001b[91m ✗ \u001b[39mRCall\n", + " 1 dependency successfully precompiled in 6 seconds. 163 already precompiled. 3 skipped during auto due to previous errors.\n", + " \u001b[91m1\u001b[39m dependency errored. To see a full report either run `import Pkg; Pkg.precompile()` or load the package\n" + ] + } + ], + "source": [ + "using Pkg\n", + "Pkg.add(\"Combinatorics\")" + ] + }, + { + "cell_type": "markdown", + "id": "6ae604f0", + "metadata": {}, + "source": [ + "One day, my friend texted me a problem out of the blue:\n", + "\n", + "How many different bracelets can be made with 8 beads, where there are 2 red beads, 2 yellow beads, 2 green beads, and 2 blue beads? \n", + "\n", + "(You must use all beads. Bracelets that can be transformed into one another by rotation or reflection do not count as different bracelets. That is, the bracelets have no beginning or end, no front or back. The beads are non-directed, it doesn’t matter which way they face.)\n", + "\n", + "My initial strategy was to take the total number of \"strings\" that could be made from those beads (8! / 2^4) and then divide 8 to account for the number of possible rotational positions, then divide that by the number of axes of symmetry (8). However, my friend pointed out that this was wrong--some of these combinations are over-counted the same number of times. \n", + "\n", + "I thought that it would be easiest to work through the problem if I started with the solution. So, I wrote up some quick code in Julia to count the number of unique combinations. " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b35dcc45", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "is_equivalent (generic function with 1 method)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function is_equivalent(a, b)\n", + "\n", + " for i in 1:length(a)\n", + " if a[i] != b[i]\n", + " return false\n", + " end\n", + " end\n", + " return true\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "56a3123c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "is_rotationally_equivalent (generic function with 1 method)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function is_rotationally_equivalent(a, b)\n", + " a_temp = a\n", + " for i in 1:length(a)\n", + " if is_equivalent(a_temp, b)\n", + " return true\n", + " end\n", + " a_temp = push!(a_temp[2:length(a)], a_temp[1])\n", + " end\n", + " return false\n", + "\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "72171cc9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "is_symmetrically_and_rotationally_equivalent (generic function with 1 method)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function is_symmetrically_and_rotationally_equivalent(a, b)\n", + " a_reversed = reverse(a)\n", + " if is_rotationally_equivalent(a, b)\n", + " return true\n", + " elseif is_rotationally_equivalent(a_reversed, b)\n", + " return true\n", + " else\n", + "\n", + " return false\n", + " end\n", + "end\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "20266d98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "171" + ] + } + ], + "source": [ + "using Combinatorics\n", + "all_perms_list = collect(permutations([\"r\", \"r\", \"g\", \"g\", \"b\", \"b\", \"y\", \"y\"], 8))\n", + "keep_list = []\n", + "for i in 2:length(all_perms_list)\n", + " already_in_list = false\n", + " for j in 1:length(keep_list)\n", + " if is_symmetrically_and_rotationally_equivalent(all_perms_list[i], keep_list[j])\n", + " already_in_list = true\n", + " end\n", + " end\n", + " if !already_in_list \n", + " push!(keep_list, all_perms_list[i])\n", + " end\n", + "end\n", + "print(length(keep_list))" + ] + }, + { + "cell_type": "markdown", + "id": "65df88ea", + "metadata": {}, + "source": [ + "This code only took a couple of minutes to run (Julia's speed always impresses me). The result was 171, and using the combinatorics techniques I had previously, I wasn't able to reverse-engineer the answer. \n", + "\n", + "Eventually, I came across a new technique that would help me solve this problem: [Burnside's lemma](https://en.wikipedia.org/wiki/Burnside%27s_lemma) (also known as the Cauchy–Frobenius lemma). \n", + "\n", + "This lemma is given as:\n", + "\n", + "$|X/G| = \\frac{1}{|G|} \\sum_{g \\in G}|X^g|$\n", + "\n", + "I'll explain some of the terms in this formula to make it more understandable:\n", + "\n", + "X represents the set of all possible (non-unique) bracelets that can be made \n", + "G represents the group of possible reflections/rotations in our situation \n", + "|X/G| represents the number of \"orbits\" (or in our case, the number of unique bracelets that can be made) \n", + "|G| represents the number items in the \"group\" of reflections/rotations in our situation. \n", + "$g \\in G$ indicates that the the summation iterates over all possible reflections/rotations in our situation \n", + "$X^g$ indicates the set of elements in X that are fixed by a given group. That is, the number of possible elements that do not change after the given reflection/rotation configuration is applied.\n", + "\n", + "\n", + "In order to understand how to apply burnside's lemma, let's first consider a simple situation: Imagine we want to determine how many unique combinations of 8 beads can be created, with 4 possible colors, and exactly 2 beads of each color in the string. Reverse sequences of the string count as the same string, so the following strings are equivalent:\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "eb578eda", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "create_graph (generic function with 2 methods)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "using Compose, Cairo, Fontconfig\n", + "using Colors\n", + "\n", + "function create_graph(sequence, circular = true)\n", + " colors_dict = Dict([('r', 1), ('b', 2), ('y', 3), ('g', 4)])\n", + "\n", + " membership_list = []\n", + "\n", + " for letter in sequence\n", + " push!(membership_list, colors_dict[letter])\n", + " end\n", + "\n", + " g = SimpleGraph(8)\n", + " \n", + " for i in 1:7\n", + " add_edge!(g, i, i + 1)\n", + " end\n", + " if circular\n", + " add_edge!(g, 8, 1)\n", + " end\n", + "\n", + " nodelabel = fill(\"\", length(8))\n", + "\n", + "\n", + " nodecolor = [colorant\"red\", colorant\"blue\", colorant\"yellow\", colorant\"green\"]\n", + " # membership color\n", + " nodefillc = nodecolor[membership_list]\n", + " if circular\n", + " locs_x = [0, 1, 2, 3, 3, 2, 1, 0]\n", + " locs_y = [2, 3, 3, 2, 1, 0, 0, 1]\n", + " else\n", + " locs_x = [1, 2, 3, 4, 5, 6, 7, 8]\n", + " locs_y = repeat([0], 8)\n", + " end\n", + "\n", + "\n", + "\n", + " g = gplot(g, locs_x, locs_y, nodefillc=nodefillc, )\n", + " \n", + " draw(PNG(sequence * [\"\",\"circular\"][circular * 1 + 1] * \".png\", 16cm, 16cm),g)\n", + " g\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "d05de2c0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9116116523516815cx, 0.5cy), (-0.8026740619340327cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.6258973666373959cx, 0.5cy), (-0.5169597762197471cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.34018308092311017cx, 0.5cy), (-0.23124549050546134cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.05446879520882447cx, 0.5cy), (0.05446879520882436cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.23124549050546123cx, 0.5cy), (0.34018308092311017cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.5169597762197471cx, 0.5cy), (0.6258973666373957cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8026740619340327cx, 0.5cy), (0.9116116523516815cx, 0.5cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.7142857142857143cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.4285714285714286cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.1428571428571429cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.1428571428571428cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.4285714285714286cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.7142857142857142cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.5cy), 0.035355339059327376w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "create_graph(\"ryygbrbg\", false)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "1a2ca8c1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhcAAAF6CAYAAACqW3pRAAAABmJLR0QA/wD/AP+gvaeTAAAXOUlEQVR4nO3debglZ0Hn8W91AgkkIMhEdAQVBokGCQb0EZBdxI2J4iiLyDKiggIu7ANMcgkIIgqKuDCMjoAoYRAcBQFRVgUEjZJAIi7sKGICJJBAlu6aP+oGYtIJvdzznhPy+TxP/9H36Vu/qq73nHrrXQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAalr3Ceyzra5Z/afq0GpP1+isHtun1nxWA83Xqb50+y/nV2fV9Nk1ntAw83LPr1cdsf2jT1dnTrVnfWc10nyNluu/+vYPzqzpnDWe0FhbXbvls191QdfurB7RZ9Z5SqPMc4e03Psjt390bnXWNHXR+s5qnHnu8JbrP2z7Rx+fpj65xlMaaq5rtVz/ruqilu+989Z7VvtmcysXW31ddXx1p+rY6iv38q/OrN5VvbFdvbITese4E1yleVd15+o7qttXX199yaX+0Z7qg9Up1euqP6zpIyPPclW2P1DHV99WfUt1kz7/YL3Y+dV7qrdVf1a9YuqL5YEz37j63pYycIvqhl32s/qJ6t3VG6tXVW+paR55lisydVK3a0/fWd2xOqa67qX+zVx9qHpnF5f9rd4/9CxXZJ67ZnX3lrJ/m+qmff7BerELqn9qKft/Xv3xNH1xvGjNczeovq+6S3Vc9VUtD9ZLOrs6o3pT9erqjdP0xfGiMS/fd9/V8ty7WZ+vVF/SR1rK/huqP5qW78GNs1mVi612VT9Q/Wx16wM4whlN/Wpz/6etroRv9fN1qodVD65usJ+/vLvlIfuMmv58p89shHmpRD2mumd1zf389XOqF1XPmOp9O31uqzdPLQ+VR1Z3aP8/m++tfq16bk3n7vDJrd5WRzb14OYeWt1oP397bqlk/VJbvXL771cq89yNq0dX922pXO+P86qTq1+Ypv5+p89thHnuri3Xf9cuW5n4Qj5UPbd6zjR19k6f26rNdXj1oOrh1dEHcIi3Vs+q/mCTWnM3p3JxUndsT8+pvmEHjvbh6pFt9ZIdONYA8yHVQ6snVdfZgQO+YTnedPoOHGvl5jqqenr1gPb/i+XSLmp5yJ4wLRWOK4H5m6tfr75pBw72sepx1e9cSVoypp7UjzT3tJZycLDe3q5+shP6mx041srNc19SPaV6SEv338HYU/129bhp6qyDPbcR5rlvaPm83mEHDveJ6oTqN6ap3TtwvJWb697VL7b3lvn9dVr10KnevAPHOmjrr1xsdfXqF6qfaufP52XVg9ra5D66+auqF7c0ge6kC6r/UT1rkx8y89IE+Px25sFySR+q7jPVX+7wcXfQfEi1VT2+g69UXdqfVver6WM7fNyd83Ndvwv73Za31Z20u3pKx/Tk7rm5D5l57g7V77UzD5ZL+lh1v2nqT3f4uDtmnptaWumeWl1thw//l9V9pqkP7fBxd8y8dPX9dksX0A4ful+uHjctz4C1WW/l4mldt/P74+pbV5jyT9V3tNV7V5hxgOZbV69oGbCzKi+uHlDTWgva3sxLM+jTW105vKh6yFS/taLjH4T5iOoPWsbVrMqHq++q6V0rzDgwJ3Xz9vTq6j+vMOVVHdEP9ug2rptonvvxljf2g22tuDx7qkdPU89c0fEP2Dx3WPXC6gdXGHNm9T3T1NtXmHFA5mUM2WuqG68w5s3V8VPre7FeX+XiqV2vC3p9dfMBaR/tkO7U/9ykgS/zHatX9vkZEKv0mur4TapgzPXk6oljonrEtNTmN8R8ZEvLwk63Vu3NJ6q71nTKgKx9c1K3ak+v7bIDNVfhLS0vF58ekLVP5rmfrX6pMd+/J01TJw7I2SfbFYs/qu42IO7c6runqTcNyNonc31dS7f19QfEnVrdeaqPD8i6jPVULp7ZNTqn13VggzYP1Ae6WrfpCf3rwMzLMd+iZQDapWeArNLJ1X02oYtkrp9u7MN+ru4/1e8OzLwc89VaKpXfPjD036rb1rT+1rutbtLSbP1lA1NfU929rfVP35zn7l/9TmO/e39qmvrVgXl7td0VcnKrbbG4tLOr209Tpw3M3Kt56f56S8sMmFHeWt1lavwEh53u59035/TsxlYsqr66C3txL+mQwbmXMh/Z8gEbWbGoulf1iMGZlzEvU2t/cXDsVD1vrm8cnLs3T2lsxaKWt6SXb6+XsT7P7rDqJY2tWNTS9XTS4MzLmOduXv1m41/qnjnP3W5w5t48prEVi1q+Z182z117cO5/MNch1QsaW7GopXV0La224ysXWx1f/ejw3MUdOqNHrSn7Yr/SgU032glPq3knZuMckHnpAnphq+tnviKHVy+cd37w2H6Yb98yzmQdjm0ZPLo+H+8pLWsXrMNj21rfA3aeu1r1+9U6KniHVi/cXkNjLea5Y1u6QtfhJi3dUOv0mJa1O9bhwfMyzX2osTXopTvkjOqrh+b+R+d2aF/fE9cxkni+TUuT8DoH0r6ppjuuI3iup7VMk1ynR06tY5DbfEj1d+3MVOsDdWF1i5rOGJ58UjdrT3/bWit3ndox3XIdM0jmuUe3zIpbp5+bpiHjnC5jnntzrbX1ZE9122nqr0YHz0trxRnt/9o9O+l91TEju0fGtlx8qh9tvRWLqiO6qMeuKfvJrXuGTt2h5tHN8s3LjJiHjc7di8fPn19KeaR7t96KRS0P9v+5luQ9ndh6KxZVx3b68Gb55rkjWt5c1+1n5nnHp3x/QfPcd7beikUtz7onrSn78a23YlHLwnQ/MjJwXOViq13N6+/z3/agtva6rOoKzce1LOm7CdbxRffw1vNQv7TrVQ9cQ+66u+Muds+av2Zo4pO7UfX9QzMv3zrK/oPa+zLOox1R/cQacjel7H/HPI8ddzUv9/2BIzOvwKPmgc/8cZWLqTtXXzMs74od3tS9Bmc+cHDeFblLzTccFTYvrTX3G5W3Dx4wNm4+rs0YTFrLwLKx92J3D9jO3QTHtdWxgzMfODjvivz37VkbQ8xzX92yR86muP/gvB/qsnvDrMuN2pmVUPfJuMrFvDFvLovx5/PfBuddkV3VPQbm3arVLhizv75pHts9t1llf/z5bNr1D/ssbu8Zsq5BrHvzNY2t6N6jdc1K3LvR38ObVvaHnc/Im76ukbKX57ZtdfiYqPmm7fwSvwdr5P3YpDeXi428/k0r+8fWPKaZfqsva/1jTS5N2f/izNoXXzXP3WRE0LzMDBq95MIXMqxrfkzl4hkd0fqmX16ew1u2cx7hVoNy9sctB2Zdha9/3tXmdIlcbNw5TR3X+gcxX9rIc7oKl/3qqn3939DmdIlc7OvmQYNLx6w3cG5f2+Z9wdTU0aeddtpF0zStbG+PXbt2ffiYY7rpqo5/EG5w1FHzka9//bu/eZUhe/bs+buOPXYTr//oU0455airX/3qK3ur3r1790W3uEUfaP0jxffm6NNOO+0j0zR9+aoC5nn+6M1fdvNNvPdHtNVXvvMe77zRIYccsrLvwAsuuOBddctNvP6jTz311Ovu2rVrpRXMm93sTn9dZ37FKjMO0NGnn3761+7Zs+cGqwqY5/msbr6RZX9Xy7ofp646aNRiRqNX5Ns3c0fN8/z06jtXFbF79+5fbbP6HC82HX74+def5/l1qwyZ5/mu7fyOpzvhqEMPPfRO8zy/ZFUBu3btOre606qOf5COqp4wz/N9V5jxouZN3DCw2tVRu3btetU8zyvb2+fQQw+9Zxta9ud5vuU8z3+2ypDzzz/s6MMO28CXyjpq9+7dD2+ZwbYS8zy/ujZ2V9ohZXLMQ28asjnX/pu61qCkTZiCeRmf/eyuUUvibuL9H3XvN/Haa9z1b2TZr2HLQW/i/R9y73ftumATr7189sfc/xEhzV04JGf/jdoldGN2I72kQw6Zzx8UtYn3f9Q92cRrr6t42W9Pyv6KzfOuTbz28tkfcv2jukXOGZSzv85p6XtaZZ/4PzV+s5p9cuihu8+ulW9H/ImW/+dN6xo7e5qmf2+F1z/P83ltdtk/o9Xe/zNadqTdROfM8/zmaZpW9tnfLl+beP/PbvlcrvSzv3v3IWev8vgH4ZzqQ632+k9t+X/eREPK5Jj+sKd0wy7qg0Oy9sfU3Tqx164+aH5YrX/L40s5t7rWiC3Y53ptdddV5+yn35+WBW5WbD6i+lSbN6D53jWdvPKUrX6oetHKc/bP3BFdq0d37sqD5k6u7rnqnP30mmla3Tizi81zu1rK/qYNaP7Jaeo3Vh0yL2P5XrXqnAPwlVP9y6pDxnSLPLEPt4k1+LlRGzidPihnf/z9iIrFtk28/kH3fjq31rFJ3hd0VS77HxhRsdi2idc/5N5PU3uq94zI2k9X5bJ/dvWvI4JGzWKYW3YD3STvbasPD8p6W5vX9/zGgVlvHpi1r1bdHXRJm3b9n6zePSTpmE7bztskyv44m3b9F1RvHxE01QerD4zI2g9vmgZ1VY6cIvnqgVn74jXjoqbzqr8Yl7dPRk6Tel2bVbk6u6XCN8oGlv1pzLbjy/bmK53yuN+mkZ/93tJmtdqeX71+YN6mlf03TlPnDcwbWdb2xbDzGVm5eHGbNHp21/B+4E3qd/5Y9eejwqb6eJvV9/jSqWGzBapeXn16YN4XclUu++c298ejwqapz1Z/MCpvH/zJNA1tSXpt9dGBeV/IVbnsX1S9dFTYyC3XP1a9bFjeFTu1E3rL4MyTqzMHZ16e59Z00eDMXx+cd0V+c2zcdG71wrGZl+v9jX6b/Ipe2eY0Dz+/reEVvZUPHtwPQ89lmrqo+t8jM6/Avzfw4brtzdVpgzMvz0un+rdRYaNXjnxqtWdw5mVNPaXhU+Smc6tfHpu5V5+qfmV06LR0w7xjdO5e/MlUf72G3F9oM7qGfr6msS2ID+7Cpp4+NHPvLqjx5zFNvaPNaB5/2zSNmB13Gb/SZrTcPWuahg3krWp7fMNTR2Zejj3Vz40MHFu52OrU6reGZl7WX3Ti8NrrxZ5ZvW9N2RfbqumsNWU/rPVWLi+oHrWe6On91bPWk/0576p+ey3Jc8+r3rmW7M/7xbbWNiX+ka23W3hP9Yh1BE9TZ1ZPXkf2JXygNbxUbTu5sYOI9+Z/Tcvnf5h17HnxuBo2S+PSzqse3NoW9pk+U/1E63vAvqN69pqym5ZR2utsIn7aNG4a2t48ufqHNWVfWD1oeKvFxba6qHpI63vAvqfBb26XNE29u/r5deVXvzZNvXWN+c+q/mZN2XuqHxs8kPNztlsvHlp9Zh35LVPhHz86dHzlYquPt6sfaj1fMg9ta91zj6fXtDSRj/aJ6l5rGGtxaY+q/nYNua9v7W9P07ktCyqt40vmcTUNmYJ3ubZ6W1NPWEPyedU921rPw+USTmo9b7B/Uz16DbmfM01dWN2r9UxLftqauoM+Z1qmfq9so7QrcGF1n2n5/h9qPbt1ntCbqwc29g3+KW31OwPzrsjjqxcMzPts9b01rbtLpmk5l7s3tnvo3dUPTDVm+uUVmt7ZUsEYWcl7bk3PHJh3+U7sGY1tPdvd1A9vd8mu1fbgxu9tbPfQ+6r/Ok1DZ0ft1TT1z9V319BK3ourEwbmXa5pGRLwtIGRc/Vj05rWmFrfVuBb/V5TP96YL/ynt7UZBWwxzdWPVSvb7vsSPl0dX9PGLGazvfTsXat/HhB3avXt29NhN8T0ipalx0d84T+3pUl2cxzTI6rnDUg6v6l7dWIvH5C1T6aps1sesCNmEPxj9W3TNGZFxn2x3TXz/TVkYOWLqwdsrxS6KZ5QPWNAzkXVj071/AFZe7W+ykXVif1W9X2trsnm/KZ+sq0e18ZtoDRdUN2nZfT6qs7t/dUda1prk+DeTPXe6ltb7WqBr6juMA1a7nb/TP+3Ze+BVU0Nu6ilK+QhwxbM2lf3bHdbPbjli3ZV5/av1d06caPWmKhqmvqX6g7Vn6ww5g3V7aZp7QPIL2NaFjG7U6ubnnzxDI37TtNGzND6nKnmqR7T0kWyqnP7eHX8tK7B29vWW7mo2uoVHdpx7fwqfn9X3bYTN2qO+aVMe2p6XPU97ewHbW5ZV+GWNZ2yg8fdUdtzrr+tpdnyszt46E9VP9PyAdvUnQmr6Q3VN1b/b4cP/J7qzjVtwvTPyzO31VOru7Tzg1xf3tU6rq2hy1zvl+2FrO7eMoNjJ6dpfqZ6YnXXaepjO3jcHTVN/XV1y5ZFpnby5er91XdNU0/YsBaL/2Cq57S8XO10d92fVsdNG7Bo4Wbt1LjVD7Q8aG5+EEf5YFM/39zztkeoX0nM12wZ7PjT1ZcexIHeVD1xk7pB9sVc/6V6UnXv6pADPMwFLc2AT5rqIzt1bmPM391y/d90EAf5aEuT63O2W8auHJ7dYX28h7eU/+sfxJHe3tQJnbgRa0rss3nuBtVWdb/q6gd4mItaugFOnKbeu0OnNsQ8d8eWwda3P4jDnNWyjtAz1zUr5EDMdWjLDMbHVjc8iEOd2vK9tykLVW5Y5WIx9aTu1tz9Wt7or7MPv3Ney3LWv1v9YVub1RS2f+ZrtYyqvm91u5bC94V8tKVQvaCmv1rhya3cXDeuHtDyf3D0Pv7aqS1frC+48lUqLm2+U3X/6vjqevvwC+e3NIG/qHrp9nTnK6dndo3O6Qdbyv4dq8P24bfOrP6oZeXNjW2p2BfblYyLy/6+vmD9fcs6Cs/fxC6Q/THP3brl+u/RvlUyL2zZs+lF1cnTtBELdR2QealU3qP64ZbW3Gvsw699sqXr94XVa0dtSLavNrFy8Xkv6ZBO77iWpuOvbaloXLdlI6BzmvrHpt7VdXp7P7X+0dA7bz6yuk11TMub/ZHVNVua+v+9pfn7lJrG7HA52Fw3qG7dUsm4QXWtlhlGn27ZcfA91VtGLmk7zryrOrY6rqXsX6+l/H96+88/tGzp/LYrdYXi8mx1zZZ7f0zL9R+5/eeT1Vnbn/1T2tNpbW1u8/eBmue+vOWzf3T1VS3XPrXc+w+13P+3TtOVvTJ9WfPc1HLfb1XdtDqq+pKWl8hPtwwEP73l+q+0FYrLMy+V6m+pbtZS9q+9/ecT23/+sWXG0d9uxgw4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgIP1/7SGTEN1ji7IAAAAASUVORK5CYII=", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9116116523516815cx, 0.5cy), (-0.8026740619340327cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.6258973666373959cx, 0.5cy), (-0.5169597762197471cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.34018308092311017cx, 0.5cy), (-0.23124549050546134cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.05446879520882447cx, 0.5cy), (0.05446879520882436cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.23124549050546123cx, 0.5cy), (0.34018308092311017cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.5169597762197471cx, 0.5cy), (0.6258973666373957cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8026740619340327cx, 0.5cy), (0.9116116523516815cx, 0.5cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.7142857142857143cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.4285714285714286cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.1428571428571429cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.1428571428571428cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.4285714285714286cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.7142857142857142cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.5cy), 0.035355339059327376w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "create_graph(reverse(\"ryygbrbg\"), false)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "d1e9f30d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9116116523516815cx, 0.5cy), (-0.8026740619340327cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.6258973666373959cx, 0.5cy), (-0.5169597762197471cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.34018308092311017cx, 0.5cy), (-0.23124549050546134cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.05446879520882447cx, 0.5cy), (0.05446879520882436cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.23124549050546123cx, 0.5cy), (0.34018308092311017cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.5169597762197471cx, 0.5cy), (0.6258973666373957cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8026740619340327cx, 0.5cy), (0.9116116523516815cx, 0.5cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.7142857142857143cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.4285714285714286cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.1428571428571429cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.1428571428571428cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.4285714285714286cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.7142857142857142cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.5cy), 0.035355339059327376w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "create_graph(\"ggbbyyrr\", false)" + ] + }, + { + "cell_type": "markdown", + "id": "02f2256a", + "metadata": {}, + "source": [ + "In this situation, there are two groups *G*: the null group (with no reverse order) and the group which applies the action of reversing the string. The number elements fixed by each group is:\n", + "\n", + "For the null group: 8! / 2^4 \n", + "For the \"reversing string\" group: 4!\n", + "\n", + "A string can be fixed under reversal only if the first four beads are identical to the reverse of the last four beads:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "9726abad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9116116523516815cx, 0.5cy), (-0.8026740619340327cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.6258973666373959cx, 0.5cy), (-0.5169597762197471cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.34018308092311017cx, 0.5cy), (-0.23124549050546134cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.05446879520882447cx, 0.5cy), (0.05446879520882436cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.23124549050546123cx, 0.5cy), (0.34018308092311017cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.5169597762197471cx, 0.5cy), (0.6258973666373957cx, 0.5cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8026740619340327cx, 0.5cy), (0.9116116523516815cx, 0.5cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.7142857142857143cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.4285714285714286cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.1428571428571429cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.1428571428571428cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.4285714285714286cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.7142857142857142cx, 0.5cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.5cy), 0.035355339059327376w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "create_graph(\"rgbyybgr\", false)" + ] + }, + { + "cell_type": "markdown", + "id": "04f9cdbc", + "metadata": {}, + "source": [ + "The first four beads determine which arrangements are fixed under the reversal group, so there are 4! ways for strings to be fixed under reversibility. \n", + "\n", + "So, $\\sum_{g \\in G}|X^g| = 8! / 2^4 + 4! = 2544$ \n", + "\n", + "Next, we just divide this by |G| (which is 2 in this situation) and we end up with 1272 possible strings. \n", + "\n", + "We can double check this result using Julia:" + ] + }, + { + "cell_type": "code", + "execution_count": 273, + "id": "6f9fa1fa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "is_only_symmetrically_equivalent (generic function with 1 method)" + ] + }, + "execution_count": 273, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function is_only_symmetrically_equivalent(a, b)\n", + " a_reversed = reverse(a)\n", + " if is_equivalent(a, b)\n", + " return true\n", + " elseif is_equivalent(a_reversed, b)\n", + " return true\n", + " else\n", + "\n", + " return false\n", + " end\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 274, + "id": "27b19f3f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1272" + ] + } + ], + "source": [ + "\n", + "all_perms_list = collect(permutations([\"r\", \"r\", \"g\", \"g\", \"b\", \"b\", \"y\", \"y\"], 8))\n", + "keep_list = []\n", + "for i in 2:length(all_perms_list)\n", + " already_in_list = false\n", + " for j in 1:length(keep_list)\n", + " if is_only_symmetrically_equivalent(all_perms_list[i], keep_list[j])\n", + " already_in_list = true\n", + " end\n", + " end\n", + " if !already_in_list \n", + " push!(keep_list, all_perms_list[i])\n", + " end\n", + "end\n", + "print(length(keep_list))" + ] + }, + { + "cell_type": "markdown", + "id": "ff597296", + "metadata": {}, + "source": [ + "Next, let's apply burnside's lemma to our original situation: a bracelet of 8 beads, with exactly 2 of each color, and taking into account non-distinctness of rotations and reflections. Here, we have 16 groups: the null group, 7 possible rotations, 4 reflections that intersect a bead, and 4 reflections that do not intersect a bead. \n", + "\n", + "For the null group, we have 8! / 2^4 arrangements that remain \"fixed\". \n", + "When rotating 1-3 or 5-7 beads, there are 0 possible ways for an arrangement to remain \"fixed\" with this number of beads. You would need to have all lbeads be the same color for this to be valid. \n", + "\n", + "however, when rotating 4 beads, it is possible for an arrangement to remain \"fixed\" if the last 4 beads repeat the first 4 beads. So, there are 4! fixed arrangments for that rotation group. \n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "76f057b7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9375cx, 0.39583333333333326cy), (-0.39583333333333337cx, 0.9375cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-1.0cx, 0.24494498568501483cy), (-1.0cx, -0.24494498568501494cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.24494498568501494cx, 1.0cy), (0.24494498568501483cx, 1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.39583333333333326cx, 0.9375cy), (0.9375cx, 0.39583333333333326cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(1.0cx, 0.24494498568501483cy), (1.0cx, -0.24494498568501494cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9375cx, -0.39583333333333337cy), (0.39583333333333326cx, -0.9375cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.24494498568501483cx, -1.0cy), (-0.24494498568501494cx, -1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.39583333333333337cx, -0.9375cy), (-0.9375cx, -0.39583333333333337cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.33333333333333326cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, 1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, 1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.33333333333333326cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, -0.33333333333333337cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, -1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -0.33333333333333337cy), 0.035355339059327376w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "create_graph(\"rgybrgyb\", true) ## RGYBRGYB plot" + ] + }, + { + "cell_type": "markdown", + "id": "f517757e", + "metadata": {}, + "source": [ + "For each of the 8 reflections, there are 4! arrangements that remain fixed across that arrangement. " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "c791a1ea", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9375cx, 0.39583333333333326cy), (-0.39583333333333337cx, 0.9375cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-1.0cx, 0.24494498568501483cy), (-1.0cx, -0.24494498568501494cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.24494498568501494cx, 1.0cy), (0.24494498568501483cx, 1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.39583333333333326cx, 0.9375cy), (0.9375cx, 0.39583333333333326cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(1.0cx, 0.24494498568501483cy), (1.0cx, -0.24494498568501494cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9375cx, -0.39583333333333337cy), (0.39583333333333326cx, -0.9375cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.24494498568501483cx, -1.0cy), (-0.24494498568501494cx, -1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.39583333333333337cx, -0.9375cy), (-0.9375cx, -0.39583333333333337cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.33333333333333326cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, 1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, 1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.33333333333333326cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, -0.33333333333333337cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, -1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -0.33333333333333337cy), 0.035355339059327376w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "create_graph(\"rgybbygr\", true) ## RGYBRGYB plot" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "c4eee7f3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9375cx, 0.39583333333333326cy), (-0.39583333333333337cx, 0.9375cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-1.0cx, 0.24494498568501483cy), (-1.0cx, -0.24494498568501494cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.24494498568501494cx, 1.0cy), (0.24494498568501483cx, 1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.39583333333333326cx, 0.9375cy), (0.9375cx, 0.39583333333333326cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(1.0cx, 0.24494498568501483cy), (1.0cx, -0.24494498568501494cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9375cx, -0.39583333333333337cy), (0.39583333333333326cx, -0.9375cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.24494498568501483cx, -1.0cy), (-0.24494498568501494cx, -1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.39583333333333337cx, -0.9375cy), (-0.9375cx, -0.39583333333333337cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.33333333333333326cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, 1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, 1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.33333333333333326cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, -0.33333333333333337cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, -1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -0.33333333333333337cy), 0.035355339059327376w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "create_graph(\"gybrbygr\", true) ## RGYBRGYB plot" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "a828dd27", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mPrecompiling Plots [91a5bcdd-55d7-5caf-9e0b-520d859cae80]\n", + "\n", + "signal (2): Interrupt: 2\n", + "in expression starting at none:1\n" + ] + }, + { + "ename": "LoadError", + "evalue": "Failed to precompile Plots [91a5bcdd-55d7-5caf-9e0b-520d859cae80] to /Users/zacharyclement/.julia/compiled/v1.8/Plots/jl_TVq3hx.", + "output_type": "error", + "traceback": [ + "Failed to precompile Plots [91a5bcdd-55d7-5caf-9e0b-520d859cae80] to /Users/zacharyclement/.julia/compiled/v1.8/Plots/jl_TVq3hx.", + "", + "Stacktrace:", + " [1] error(s::String)", + " @ Base ./error.jl:35", + " [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool)", + " @ Base ./loading.jl:1707", + " [3] compilecache", + " @ ./loading.jl:1651 [inlined]", + " [4] _require(pkg::Base.PkgId)", + " @ Base ./loading.jl:1337", + " [5] _require_prelocked(uuidkey::Base.PkgId)", + " @ Base ./loading.jl:1200", + " [6] macro expansion", + " @ ./loading.jl:1180 [inlined]", + " [7] macro expansion", + " @ ./lock.jl:223 [inlined]", + " [8] require(into::Module, mod::Symbol)", + " @ Base ./loading.jl:1144" + ] + } + ], + "source": [ + "using Plots\n", + "\n", + "create_graph(\"gybrbygr\", true) ## RGYBRGYB plot\n", + "plot!(0, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "3ae5558a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General.toml`\n", + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m x265_jll ───────────────────── v3.5.0+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m GR_jll ─────────────────────── v0.71.7+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m LERC_jll ───────────────────── v3.0.0+1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m libfdk_aac_jll ─────────────── v2.0.2+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m StatisticalTraits ──────────── v1.1.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_xkbcomp_jll ───────────── v1.4.2+4\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m JpegTurbo_jll ──────────────── v2.1.91+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Opus_jll ───────────────────── v1.3.2+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m RelocatableFolders ─────────── v1.0.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Grisu ──────────────────────── v1.0.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m TimerOutputs ───────────────── v0.5.22\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m JLSO ───────────────────────── v2.7.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Contour ────────────────────── v0.6.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Highlights ─────────────────── v0.5.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m RCall ──────────────────────── v0.13.14\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_xcb_util_wm_jll ───────── v0.4.1+1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m StaticArrays ───────────────── v1.5.16\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_xcb_util_image_jll ────── v0.4.0+1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m PlotUtils ──────────────────── v1.2.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m MLJScientificTypes ─────────── v0.4.5\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m HTTP ───────────────────────── v0.9.17\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Memento ────────────────────── v1.4.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m GPUArrays ──────────────────── v8.3.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m DataFrames ─────────────────── v0.22.7\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_xcb_util_jll ──────────── v0.4.0+1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m BFloat16s ──────────────────── v0.2.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m RecipesPipeline ────────────── v0.6.11\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m CEnum ──────────────────────── v0.4.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m RandomNumbers ──────────────── v1.5.3\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m MLJModels ──────────────────── v0.13.3\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m CodeTracking ───────────────── v1.2.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ColorSchemes ───────────────── v3.20.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Polynomials ────────────────── v3.2.5\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m CUDA_Runtime_jll ───────────── v0.3.1+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_libxkbfile_jll ────────── v1.1.0+4\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_libXinerama_jll ───────── v1.1.4+4\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Distances ──────────────────── v0.10.7\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Fontconfig ─────────────────── v0.4.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m FFMPEG ─────────────────────── v0.4.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m FiniteDiff ─────────────────── v2.18.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Showoff ────────────────────── v1.0.3\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m XGBoost_jll ────────────────── v1.7.4+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m LLVM ───────────────────────── v4.16.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Qt5Base_jll ────────────────── v5.15.3+2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m CUDA_Driver_jll ────────────── v0.3.0+1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_xcb_util_keysyms_jll ──── v0.4.0+1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m xkbcommon_jll ──────────────── v1.4.1+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m SpecialFunctions ───────────── v1.8.8\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ProgressLogging ────────────── v0.1.4\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Term ───────────────────────── v2.0.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Pipe ───────────────────────── v1.3.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m NaNMath ────────────────────── v1.0.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m PlotThemes ─────────────────── v3.1.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m MyterialColors ─────────────── v0.3.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m GR ─────────────────────────── v0.71.7\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m fzf_jll ────────────────────── v0.29.0+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m TranscodingStreams ─────────── v0.9.11\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m SnoopPrecompile ────────────── v1.0.3\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Rmath_jll ──────────────────── v0.4.0+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m UnicodeFun ─────────────────── v0.4.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Random123 ──────────────────── v1.6.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ScikitLearn ────────────────── v0.7.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m MLJBase ────────────────────── v0.16.3\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Graphs ─────────────────────── v1.8.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m GLFW_jll ───────────────────── v3.3.8+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ComputationalResources ─────── v0.3.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m x264_jll ───────────────────── v2021.5.5+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m JLFzf ──────────────────────── v0.1.5\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m LinearAlgebraX ─────────────── v0.1.11\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Compat ─────────────────────── v3.46.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ExprTools ──────────────────── v0.1.8\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m libaom_jll ─────────────────── v3.4.0+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m CodecZlib ──────────────────── v0.7.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m DiffRules ──────────────────── v1.13.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ColorTypes ─────────────────── v0.10.12\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Scratch ────────────────────── v1.1.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Conda ──────────────────────── v1.8.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m JSON3 ──────────────────────── v1.12.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Zstd_jll ───────────────────── v1.5.4+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Parsers ────────────────────── v2.5.7\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m TensorCore ─────────────────── v0.1.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Plots ──────────────────────── v1.38.6\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m MLJ ────────────────────────── v0.15.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m PrettyTables ───────────────── v0.10.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m PersistenceDiagramsBase ────── v0.1.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ScientificTypes ────────────── v1.1.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m PyCall ─────────────────────── v1.95.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m AbstractFFTs ───────────────── v1.2.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ConstructionBase ───────────── v1.5.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m CategoricalArrays ──────────── v0.9.7\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Libtiff_jll ────────────────── v4.4.0+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m LLVMExtra_jll ──────────────── v0.0.16+2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Ogg_jll ────────────────────── v1.3.5+1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_libXi_jll ─────────────── v1.7.10+4\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ColorVectorSpace ───────────── v0.9.10\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m AbstractTrees ──────────────── v0.4.4\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ArrayInterface ─────────────── v7.1.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ChainRulesCore ─────────────── v1.15.7\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m LogExpFunctions ────────────── v0.3.23\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_xcb_util_renderutil_jll ─ v0.3.9+1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_libXcursor_jll ────────── v1.2.0+4\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Wayland_protocols_jll ──────── v1.25.0+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m SparseMatricesCSR ──────────── v0.6.7\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Compose ────────────────────── v0.9.5\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m MLJTuning ──────────────────── v0.6.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m libass_jll ─────────────────── v0.15.1+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m StableRNGs ─────────────────── v1.0.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Rmath ──────────────────────── v0.7.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Adapt ──────────────────────── v3.5.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Latexify ───────────────────── v0.15.18\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m MLJModelInterface ──────────── v0.3.8\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Wayland_jll ────────────────── v1.21.0+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m OpenSSL_jll ────────────────── v1.1.20+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m FFMPEG_jll ─────────────────── v4.4.2+2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m GPUCompiler ────────────────── v0.17.2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m MakieCore ──────────────────── v0.6.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_xkeyboard_config_jll ──── v2.27.0+4\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m RecipesBase ────────────────── v1.3.3\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_libXfixes_jll ─────────── v5.0.3+4\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Xorg_libXrandr_jll ─────────── v1.5.2+4\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m URIs ───────────────────────── v1.4.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m XGBoost ────────────────────── v2.2.5\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m LAME_jll ───────────────────── v3.100.1+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m FilePathsBase ──────────────── v0.9.20\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m libvorbis_jll ──────────────── v1.3.7+1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Libglvnd_jll ───────────────── v1.6.0+0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ForwardDiff ────────────────── v0.10.35\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m FillArrays ─────────────────── v0.11.9\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m LearnBase ──────────────────── v0.4.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m QuadGK ─────────────────────── v2.8.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m BSON ───────────────────────── v0.3.6\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Observables ────────────────── v0.5.4\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Unzip ──────────────────────── v0.2.0\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Lathe ──────────────────────── v0.1.6\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m DecisionTree ───────────────── v0.12.3\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m ChangesOfVariables ─────────── v0.1.6\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m LossFunctions ──────────────── v0.6.2\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m Distributions ──────────────── v0.24.18\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m CUDA ───────────────────────── v3.13.1\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m LatinHypercubeSampling ─────── v1.8.0\n", + "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.8/Project.toml`\n", + " \u001b[90m [a81c6b42] \u001b[39m\u001b[93m↑ Compose v0.9.4 ⇒ v0.9.5\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [a93c6f00] \u001b[39m\u001b[93m↑ DataFrames v0.19.4 ⇒ v0.22.7\u001b[39m\n", + " \u001b[90m [7806a523] \u001b[39m\u001b[93m↑ DecisionTree v0.12.1 ⇒ v0.12.3\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [31c24e10] \u001b[39m\u001b[93m↑ Distributions v0.21.12 ⇒ v0.24.18\u001b[39m\n", + " \u001b[90m [186bb1d3] \u001b[39m\u001b[93m↑ Fontconfig v0.4.0 ⇒ v0.4.1\u001b[39m\n", + " \u001b[90m [da1fdf0e] \u001b[39m\u001b[93m↑ FreqTables v0.3.1 ⇒ v0.4.5\u001b[39m\n", + " \u001b[90m [38e38edf] \u001b[39m\u001b[93m↑ GLM v1.4.2 ⇒ v1.8.1\u001b[39m\n", + " \u001b[90m [86223c79] \u001b[39m\u001b[93m↑ Graphs v1.5.0 ⇒ v1.8.0\u001b[39m\n", + "\u001b[32m⌃\u001b[39m\u001b[90m [38d8eb38] \u001b[39m\u001b[93m↑ Lathe v0.0.9 ⇒ v0.1.6\u001b[39m\n", + "\u001b[32m⌃\u001b[39m\u001b[90m [add582a8] \u001b[39m\u001b[93m↑ MLJ v0.2.3 ⇒ v0.15.2\u001b[39m\n", + " \u001b[90m [91a5bcdd] \u001b[39m\u001b[92m+ Plots v1.38.6\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [08abe8d2] \u001b[39m\u001b[95m↓ PrettyTables v2.2.2 ⇒ v0.10.1\u001b[39m\n", + " \u001b[90m [6f49c342] \u001b[39m\u001b[93m↑ RCall v0.13.5 ⇒ v0.13.14\u001b[39m\n", + " \u001b[90m [3646fa90] \u001b[39m\u001b[93m↑ ScikitLearn v0.5.0 ⇒ v0.7.0\u001b[39m\n", + " \u001b[90m [009559a3] \u001b[39m\u001b[93m↑ XGBoost v1.5.2 ⇒ v2.2.5\u001b[39m\n", + "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.8/Manifest.toml`\n", + " \u001b[90m [621f4979] \u001b[39m\u001b[92m+ AbstractFFTs v1.2.1\u001b[39m\n", + " \u001b[90m [1520ce14] \u001b[39m\u001b[93m↑ AbstractTrees v0.4.3 ⇒ v0.4.4\u001b[39m\n", + " \u001b[90m [79e6a3ab] \u001b[39m\u001b[92m+ Adapt v3.5.0\u001b[39m\n", + " \u001b[90m [7d9fca2a] \u001b[39m\u001b[91m- Arpack v0.4.0\u001b[39m\n", + " \u001b[90m [4fba245c] \u001b[39m\u001b[92m+ ArrayInterface v7.1.0\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [ab4f0b2a] \u001b[39m\u001b[92m+ BFloat16s v0.2.0\u001b[39m\n", + " \u001b[90m [fbb218c0] \u001b[39m\u001b[92m+ BSON v0.3.6\u001b[39m\n", + " \u001b[90m [fa961155] \u001b[39m\u001b[92m+ CEnum v0.4.2\u001b[39m\n", + " \u001b[90m [336ed68f] \u001b[39m\u001b[91m- CSV v0.4.0\u001b[39m\n", + "\u001b[32m⌃\u001b[39m\u001b[90m [052768ef] \u001b[39m\u001b[92m+ CUDA v3.13.1\u001b[39m\n", + " \u001b[90m [49dc2e85] \u001b[39m\u001b[91m- Calculus v0.5.1\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [324d7699] \u001b[39m\u001b[93m↑ CategoricalArrays v0.5.5 ⇒ v0.9.7\u001b[39m\n", + " \u001b[90m [d360d2e6] \u001b[39m\u001b[93m↑ ChainRulesCore v1.15.6 ⇒ v1.15.7\u001b[39m\n", + " \u001b[90m [9e997f8a] \u001b[39m\u001b[93m↑ ChangesOfVariables v0.1.4 ⇒ v0.1.6\u001b[39m\n", + " \u001b[90m [da1fd8a2] \u001b[39m\u001b[92m+ CodeTracking v1.2.1\u001b[39m\n", + " \u001b[90m [944b1d66] \u001b[39m\u001b[92m+ CodecZlib v0.7.1\u001b[39m\n", + " \u001b[90m [35d6a980] \u001b[39m\u001b[92m+ ColorSchemes v3.20.0\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [3da002f7] \u001b[39m\u001b[95m↓ ColorTypes v0.11.4 ⇒ v0.10.12\u001b[39m\n", + " \u001b[90m [c3611d14] \u001b[39m\u001b[92m+ ColorVectorSpace v0.9.10\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [34da2185] \u001b[39m\u001b[93m↑ Compat v2.2.1 ⇒ v3.46.1\u001b[39m\n", + " \u001b[90m [a81c6b42] \u001b[39m\u001b[93m↑ Compose v0.9.4 ⇒ v0.9.5\u001b[39m\n", + " \u001b[90m [ed09eef8] \u001b[39m\u001b[92m+ ComputationalResources v0.3.2\u001b[39m\n", + " \u001b[90m [8f4d0f93] \u001b[39m\u001b[93m↑ Conda v1.7.0 ⇒ v1.8.0\u001b[39m\n", + " \u001b[90m [187b0558] \u001b[39m\u001b[92m+ ConstructionBase v1.5.1\u001b[39m\n", + " \u001b[90m [d38c429a] \u001b[39m\u001b[92m+ Contour v0.6.2\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [a93c6f00] \u001b[39m\u001b[93m↑ DataFrames v0.19.4 ⇒ v0.22.7\u001b[39m\n", + " \u001b[90m [9a8bc11e] \u001b[39m\u001b[91m- DataStreams v0.4.2\u001b[39m\n", + " \u001b[90m [864edb3b] \u001b[39m\u001b[93m↑ DataStructures v0.17.20 ⇒ v0.18.13\u001b[39m\n", + " \u001b[90m [7806a523] \u001b[39m\u001b[93m↑ DecisionTree v0.12.1 ⇒ v0.12.3\u001b[39m\n", + " \u001b[90m [01453d9d] \u001b[39m\u001b[91m- DiffEqDiffTools v0.14.0\u001b[39m\n", + " \u001b[90m [b552c78f] \u001b[39m\u001b[93m↑ DiffRules v1.7.0 ⇒ v1.13.0\u001b[39m\n", + " \u001b[90m [b4f34e82] \u001b[39m\u001b[93m↑ Distances v0.8.2 ⇒ v0.10.7\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [31c24e10] \u001b[39m\u001b[93m↑ Distributions v0.21.12 ⇒ v0.24.18\u001b[39m\n", + " \u001b[90m [e2ba6199] \u001b[39m\u001b[92m+ ExprTools v0.1.8\u001b[39m\n", + " \u001b[90m [c87230d0] \u001b[39m\u001b[92m+ FFMPEG v0.4.1\u001b[39m\n", + " \u001b[90m [5789e2e9] \u001b[39m\u001b[91m- FileIO v1.16.0\u001b[39m\n", + " \u001b[90m [48062228] \u001b[39m\u001b[92m+ FilePathsBase v0.9.20\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [1a297f60] \u001b[39m\u001b[93m↑ FillArrays v0.8.14 ⇒ v0.11.9\u001b[39m\n", + " \u001b[90m [6a86dc24] \u001b[39m\u001b[92m+ FiniteDiff v2.18.0\u001b[39m\n", + " \u001b[90m [186bb1d3] \u001b[39m\u001b[93m↑ Fontconfig v0.4.0 ⇒ v0.4.1\u001b[39m\n", + " \u001b[90m [f6369f11] \u001b[39m\u001b[93m↑ ForwardDiff v0.10.34 ⇒ v0.10.35\u001b[39m\n", + " \u001b[90m [da1fdf0e] \u001b[39m\u001b[93m↑ FreqTables v0.3.1 ⇒ v0.4.5\u001b[39m\n", + " \u001b[90m [38e38edf] \u001b[39m\u001b[93m↑ GLM v1.4.2 ⇒ v1.8.1\u001b[39m\n", + "\u001b[32m⌃\u001b[39m\u001b[90m [0c68f7d7] \u001b[39m\u001b[92m+ GPUArrays v8.3.2\u001b[39m\n", + " \u001b[90m [61eb1bfa] \u001b[39m\u001b[92m+ GPUCompiler v0.17.2\u001b[39m\n", + " \u001b[90m [28b8d3ca] \u001b[39m\u001b[92m+ GR v0.71.7\u001b[39m\n", + " \u001b[90m [86223c79] \u001b[39m\u001b[93m↑ Graphs v1.5.0 ⇒ v1.8.0\u001b[39m\n", + " \u001b[90m [42e2da0e] \u001b[39m\u001b[92m+ Grisu v1.0.2\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [cd3eb016] \u001b[39m\u001b[93m↑ HTTP v0.8.19 ⇒ v0.9.17\u001b[39m\n", + " \u001b[90m [eafb193a] \u001b[39m\u001b[92m+ Highlights v0.5.2\u001b[39m\n", + " \u001b[90m [1019f520] \u001b[39m\u001b[92m+ JLFzf v0.1.5\u001b[39m\n", + " \u001b[90m [9da8a3cd] \u001b[39m\u001b[92m+ JLSO v2.7.0\u001b[39m\n", + " \u001b[90m [0f8b85d8] \u001b[39m\u001b[92m+ JSON3 v1.12.0\u001b[39m\n", + " \u001b[90m [2d691ee1] \u001b[39m\u001b[91m- LIBLINEAR v0.5.1\u001b[39m\n", + " \u001b[90m [b1bec4e5] \u001b[39m\u001b[91m- LIBSVM v0.4.0\u001b[39m\n", + " \u001b[90m [929cbde3] \u001b[39m\u001b[92m+ LLVM v4.16.0\u001b[39m\n", + " \u001b[90m [23fbe1c1] \u001b[39m\u001b[92m+ Latexify v0.15.18\u001b[39m\n", + "\u001b[32m⌃\u001b[39m\u001b[90m [38d8eb38] \u001b[39m\u001b[93m↑ Lathe v0.0.9 ⇒ v0.1.6\u001b[39m\n", + " \u001b[90m [a5e1c1ea] \u001b[39m\u001b[92m+ LatinHypercubeSampling v1.8.0\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [7f8f8fb0] \u001b[39m\u001b[92m+ LearnBase v0.4.1\u001b[39m\n", + " \u001b[90m [d3d80556] \u001b[39m\u001b[93m↑ LineSearches v7.1.1 ⇒ v7.2.0\u001b[39m\n", + " \u001b[90m [9b3f67b0] \u001b[39m\u001b[93m↑ LinearAlgebraX v0.1.10 ⇒ v0.1.11\u001b[39m\n", + " \u001b[90m [2ab3a3ac] \u001b[39m\u001b[93m↑ LogExpFunctions v0.3.19 ⇒ v0.3.23\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [30fc2ffe] \u001b[39m\u001b[92m+ LossFunctions v0.6.2\u001b[39m\n", + "\u001b[32m⌃\u001b[39m\u001b[90m [add582a8] \u001b[39m\u001b[93m↑ MLJ v0.2.3 ⇒ v0.15.2\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [a7f614a8] \u001b[39m\u001b[93m↑ MLJBase v0.2.1 ⇒ v0.16.3\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [e80e1ace] \u001b[39m\u001b[92m+ MLJModelInterface v0.3.8\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [d491faf4] \u001b[39m\u001b[93m↑ MLJModels v0.2.3 ⇒ v0.13.3\u001b[39m\n", + "\u001b[32m⌃\u001b[39m\u001b[90m [2e2323e0] \u001b[39m\u001b[92m+ MLJScientificTypes v0.4.5\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [03970b2e] \u001b[39m\u001b[92m+ MLJTuning v0.6.0\u001b[39m\n", + " \u001b[90m [20f20a25] \u001b[39m\u001b[92m+ MakieCore v0.6.2\u001b[39m\n", + " \u001b[90m [f28f55f0] \u001b[39m\u001b[92m+ Memento v1.4.1\u001b[39m\n", + " \u001b[90m [1c23619d] \u001b[39m\u001b[92m+ MyterialColors v0.3.0\u001b[39m\n", + " \u001b[90m [d41bc354] \u001b[39m\u001b[93m↑ NLSolversBase v7.5.0 ⇒ v7.8.3\u001b[39m\n", + " \u001b[90m [77ba4419] \u001b[39m\u001b[93m↑ NaNMath v0.3.7 ⇒ v1.0.2\u001b[39m\n", + " \u001b[90m [86f7a689] \u001b[39m\u001b[93m↑ NamedArrays v0.9.4 ⇒ v0.9.6\u001b[39m\n", + " \u001b[90m [510215fc] \u001b[39m\u001b[92m+ Observables v0.5.4\u001b[39m\n", + " \u001b[90m [429524aa] \u001b[39m\u001b[93m↑ Optim v0.20.1 ⇒ v1.7.4\u001b[39m\n", + " \u001b[90m [90014a1f] \u001b[39m\u001b[93m↑ PDMats v0.9.12 ⇒ v0.11.16\u001b[39m\n", + " \u001b[90m [69de0a69] \u001b[39m\u001b[93m↑ Parsers v2.5.2 ⇒ v2.5.7\u001b[39m\n", + " \u001b[90m [b1ad91c1] \u001b[39m\u001b[92m+ PersistenceDiagramsBase v0.1.1\u001b[39m\n", + " \u001b[90m [b98c9c47] \u001b[39m\u001b[92m+ Pipe v1.3.0\u001b[39m\n", + " \u001b[90m [ccf2f8ad] \u001b[39m\u001b[92m+ PlotThemes v3.1.0\u001b[39m\n", + "\u001b[32m⌃\u001b[39m\u001b[90m [995b91a9] \u001b[39m\u001b[92m+ PlotUtils v1.2.0\u001b[39m\n", + " \u001b[90m [91a5bcdd] \u001b[39m\u001b[92m+ Plots v1.38.6\u001b[39m\n", + " \u001b[90m [f27b6e38] \u001b[39m\u001b[93m↑ Polynomials v3.2.0 ⇒ v3.2.5\u001b[39m\n", + " \u001b[90m [2dfb63ee] \u001b[39m\u001b[93m↑ PooledArrays v0.5.3 ⇒ v1.4.2\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [08abe8d2] \u001b[39m\u001b[95m↓ PrettyTables v2.2.2 ⇒ v0.10.1\u001b[39m\n", + " \u001b[90m [33c8b6b6] \u001b[39m\u001b[92m+ ProgressLogging v0.1.4\u001b[39m\n", + " \u001b[90m [438e738f] \u001b[39m\u001b[93m↑ PyCall v1.94.1 ⇒ v1.95.1\u001b[39m\n", + " \u001b[90m [1fd47b50] \u001b[39m\u001b[93m↑ QuadGK v2.6.0 ⇒ v2.8.1\u001b[39m\n", + " \u001b[90m [6f49c342] \u001b[39m\u001b[93m↑ RCall v0.13.5 ⇒ v0.13.14\u001b[39m\n", + " \u001b[90m [74087812] \u001b[39m\u001b[92m+ Random123 v1.6.0\u001b[39m\n", + " \u001b[90m [e6cf234a] \u001b[39m\u001b[92m+ RandomNumbers v1.5.3\u001b[39m\n", + " \u001b[90m [3cdcf5f2] \u001b[39m\u001b[93m↑ RecipesBase v0.7.0 ⇒ v1.3.3\u001b[39m\n", + " \u001b[90m [01d81517] \u001b[39m\u001b[92m+ RecipesPipeline v0.6.11\u001b[39m\n", + " \u001b[90m [05181044] \u001b[39m\u001b[92m+ RelocatableFolders v1.0.0\u001b[39m\n", + " \u001b[90m [cbe49d4c] \u001b[39m\u001b[91m- RemoteFiles v0.3.1\u001b[39m\n", + " \u001b[90m [79098fc4] \u001b[39m\u001b[93m↑ Rmath v0.7.0 ⇒ v0.7.1\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [321657f4] \u001b[39m\u001b[92m+ ScientificTypes v1.1.2\u001b[39m\n", + " \u001b[90m [3646fa90] \u001b[39m\u001b[93m↑ ScikitLearn v0.5.0 ⇒ v0.7.0\u001b[39m\n", + " \u001b[90m [6c6a2e73] \u001b[39m\u001b[92m+ Scratch v1.1.1\u001b[39m\n", + " \u001b[90m [efcf1570] \u001b[39m\u001b[92m+ Setfield v1.1.1\u001b[39m\n", + " \u001b[90m [1277b4bf] \u001b[39m\u001b[93m↑ ShiftedArrays v1.0.0 ⇒ v2.0.0\u001b[39m\n", + " \u001b[90m [992d4aef] \u001b[39m\u001b[92m+ Showoff v1.0.3\u001b[39m\n", + " \u001b[90m [66db9d55] \u001b[39m\u001b[93m↑ SnoopPrecompile v1.0.1 ⇒ v1.0.3\u001b[39m\n", + " \u001b[90m [a0a7dd2c] \u001b[39m\u001b[92m+ SparseMatricesCSR v0.6.7\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [276daf66] \u001b[39m\u001b[93m↑ SpecialFunctions v0.9.0 ⇒ v1.8.8\u001b[39m\n", + " \u001b[90m [860ef19b] \u001b[39m\u001b[92m+ StableRNGs v1.0.0\u001b[39m\n", + " \u001b[90m [90137ffa] \u001b[39m\u001b[93m↑ StaticArrays v0.12.5 ⇒ v1.5.16\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [64bff920] \u001b[39m\u001b[92m+ StatisticalTraits v1.1.0\u001b[39m\n", + " \u001b[90m [82ae8749] \u001b[39m\u001b[92m+ StatsAPI v1.5.0\u001b[39m\n", + " \u001b[90m [2913bbd2] \u001b[39m\u001b[93m↑ StatsBase v0.32.2 ⇒ v0.33.21\u001b[39m\n", + " \u001b[90m [3eaba693] \u001b[39m\u001b[93m↑ StatsModels v0.6.21 ⇒ v0.6.33\u001b[39m\n", + " \u001b[90m [892a3eda] \u001b[39m\u001b[91m- StringManipulation v0.3.0\u001b[39m\n", + " \u001b[90m [856f2bd8] \u001b[39m\u001b[92m+ StructTypes v1.10.0\u001b[39m\n", + " \u001b[90m [bd369af6] \u001b[39m\u001b[93m↑ Tables v0.2.11 ⇒ v1.10.0\u001b[39m\n", + " \u001b[90m [62fd8b95] \u001b[39m\u001b[92m+ TensorCore v0.1.1\u001b[39m\n", + " \u001b[90m [22787eb5] \u001b[39m\u001b[92m+ Term v2.0.1\u001b[39m\n", + " \u001b[90m [a759f4b9] \u001b[39m\u001b[92m+ TimerOutputs v0.5.22\u001b[39m\n", + " \u001b[90m [3bb67fe8] \u001b[39m\u001b[92m+ TranscodingStreams v0.9.11\u001b[39m\n", + " \u001b[90m [5c2747f8] \u001b[39m\u001b[92m+ URIs v1.4.2\u001b[39m\n", + " \u001b[90m [1cfade01] \u001b[39m\u001b[92m+ UnicodeFun v0.4.1\u001b[39m\n", + " \u001b[90m [41fe7b60] \u001b[39m\u001b[92m+ Unzip v0.2.0\u001b[39m\n", + " \u001b[90m [ea10d353] \u001b[39m\u001b[91m- WeakRefStrings v0.5.8\u001b[39m\n", + " \u001b[90m [009559a3] \u001b[39m\u001b[93m↑ XGBoost v1.5.2 ⇒ v2.2.5\u001b[39m\n", + " \u001b[90m [68821587] \u001b[39m\u001b[91m- Arpack_jll v3.5.1+1\u001b[39m\n", + " \u001b[90m [4ee394cb] \u001b[39m\u001b[93m↑ CUDA_Driver_jll v0.2.0+0 ⇒ v0.3.0+1\u001b[39m\n", + " \u001b[90m [76a88914] \u001b[39m\u001b[93m↑ CUDA_Runtime_jll v0.2.3+2 ⇒ v0.3.1+0\u001b[39m\n", + " \u001b[90m [b22a6f82] \u001b[39m\u001b[92m+ FFMPEG_jll v4.4.2+2\u001b[39m\n", + " \u001b[90m [0656b61e] \u001b[39m\u001b[92m+ GLFW_jll v3.3.8+0\u001b[39m\n", + " \u001b[90m [d2c73de3] \u001b[39m\u001b[92m+ GR_jll v0.71.7+0\u001b[39m\n", + " \u001b[90m [aacddb02] \u001b[39m\u001b[92m+ JpegTurbo_jll v2.1.91+0\u001b[39m\n", + " \u001b[90m [c1c5ebd0] \u001b[39m\u001b[92m+ LAME_jll v3.100.1+0\u001b[39m\n", + " \u001b[90m [88015f11] \u001b[39m\u001b[92m+ LERC_jll v3.0.0+1\u001b[39m\n", + " \u001b[90m [dad2f222] \u001b[39m\u001b[92m+ LLVMExtra_jll v0.0.16+2\u001b[39m\n", + " \u001b[90m [7e76a0d4] \u001b[39m\u001b[92m+ Libglvnd_jll v1.6.0+0\u001b[39m\n", + " \u001b[90m [89763e89] \u001b[39m\u001b[92m+ Libtiff_jll v4.4.0+0\u001b[39m\n", + " \u001b[90m [e7412a2a] \u001b[39m\u001b[92m+ Ogg_jll v1.3.5+1\u001b[39m\n", + " \u001b[90m [458c3c95] \u001b[39m\u001b[92m+ OpenSSL_jll v1.1.20+0\u001b[39m\n", + " \u001b[90m [91d4177d] \u001b[39m\u001b[92m+ Opus_jll v1.3.2+0\u001b[39m\n", + " \u001b[90m [ea2cea3b] \u001b[39m\u001b[92m+ Qt5Base_jll v5.15.3+2\u001b[39m\n", + " \u001b[90m [f50d1b31] \u001b[39m\u001b[93m↑ Rmath_jll v0.3.0+0 ⇒ v0.4.0+0\u001b[39m\n", + " \u001b[90m [a2964d1f] \u001b[39m\u001b[92m+ Wayland_jll v1.21.0+0\u001b[39m\n", + " \u001b[90m [2381bf8a] \u001b[39m\u001b[92m+ Wayland_protocols_jll v1.25.0+0\u001b[39m\n", + " \u001b[90m [a5c6f535] \u001b[39m\u001b[93m↑ XGBoost_jll v1.7.2+0 ⇒ v1.7.4+0\u001b[39m\n", + " \u001b[90m [935fb764] \u001b[39m\u001b[92m+ Xorg_libXcursor_jll v1.2.0+4\u001b[39m\n", + " \u001b[90m [d091e8ba] \u001b[39m\u001b[92m+ Xorg_libXfixes_jll v5.0.3+4\u001b[39m\n", + " \u001b[90m [a51aa0fd] \u001b[39m\u001b[92m+ Xorg_libXi_jll v1.7.10+4\u001b[39m\n", + " \u001b[90m [d1454406] \u001b[39m\u001b[92m+ Xorg_libXinerama_jll v1.1.4+4\u001b[39m\n", + " \u001b[90m [ec84b674] \u001b[39m\u001b[92m+ Xorg_libXrandr_jll v1.5.2+4\u001b[39m\n", + " \u001b[90m [cc61e674] \u001b[39m\u001b[92m+ Xorg_libxkbfile_jll v1.1.0+4\u001b[39m\n", + " \u001b[90m [12413925] \u001b[39m\u001b[92m+ Xorg_xcb_util_image_jll v0.4.0+1\u001b[39m\n", + " \u001b[90m [2def613f] \u001b[39m\u001b[92m+ Xorg_xcb_util_jll v0.4.0+1\u001b[39m\n", + " \u001b[90m [975044d2] \u001b[39m\u001b[92m+ Xorg_xcb_util_keysyms_jll v0.4.0+1\u001b[39m\n", + " \u001b[90m [0d47668e] \u001b[39m\u001b[92m+ Xorg_xcb_util_renderutil_jll v0.3.9+1\u001b[39m\n", + " \u001b[90m [c22f9ab0] \u001b[39m\u001b[92m+ Xorg_xcb_util_wm_jll v0.4.1+1\u001b[39m\n", + " \u001b[90m [35661453] \u001b[39m\u001b[92m+ Xorg_xkbcomp_jll v1.4.2+4\u001b[39m\n", + " \u001b[90m [33bec58e] \u001b[39m\u001b[92m+ Xorg_xkeyboard_config_jll v2.27.0+4\u001b[39m\n", + " \u001b[90m [3161d3a3] \u001b[39m\u001b[92m+ Zstd_jll v1.5.4+0\u001b[39m\n", + "\u001b[33m⌅\u001b[39m\u001b[90m [214eeab7] \u001b[39m\u001b[92m+ fzf_jll v0.29.0+0\u001b[39m\n", + " \u001b[90m [a4ae2306] \u001b[39m\u001b[92m+ libaom_jll v3.4.0+0\u001b[39m\n", + " \u001b[90m [0ac62f75] \u001b[39m\u001b[92m+ libass_jll v0.15.1+0\u001b[39m\n", + " \u001b[90m [f638f0a6] \u001b[39m\u001b[92m+ libfdk_aac_jll v2.0.2+0\u001b[39m\n", + " \u001b[90m [f27f6e37] \u001b[39m\u001b[92m+ libvorbis_jll v1.3.7+1\u001b[39m\n", + " \u001b[90m [1270edf5] \u001b[39m\u001b[92m+ x264_jll v2021.5.5+0\u001b[39m\n", + " \u001b[90m [dfaa095f] \u001b[39m\u001b[92m+ x265_jll v3.5.0+0\u001b[39m\n", + " \u001b[90m [d8fb68d0] \u001b[39m\u001b[92m+ xkbcommon_jll v1.4.1+0\u001b[39m\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \u001b[90m [9abbd945] \u001b[39m\u001b[91m- Profile\u001b[39m\n", + " \u001b[90m [05823500] \u001b[39m\u001b[92m+ OpenLibm_jll v0.8.1+0\u001b[39m\n", + "\u001b[36m\u001b[1m Info\u001b[22m\u001b[39m Packages marked with \u001b[32m⌃\u001b[39m and \u001b[33m⌅\u001b[39m have new versions available, but those with \u001b[33m⌅\u001b[39m are restricted by compatibility constraints from upgrading. To see why use `status --outdated -m`\n", + "\u001b[32m\u001b[1m Building\u001b[22m\u001b[39m Conda ─→ `~/.julia/scratchspaces/44cfe95a-1eb2-52ea-b672-e2afdf69b78f/e32a90da027ca45d84678b826fffd3110bb3fc90/build.log`\n", + "\u001b[32m\u001b[1m Building\u001b[22m\u001b[39m PyCall → `~/.julia/scratchspaces/44cfe95a-1eb2-52ea-b672-e2afdf69b78f/62f417f6ad727987c755549e9cd88c46578da562/build.log`\n", + "\u001b[32m\u001b[1m Building\u001b[22m\u001b[39m RCall ─→ `~/.julia/scratchspaces/44cfe95a-1eb2-52ea-b672-e2afdf69b78f/2c0ffd39860c9a48259a0f57214ced2024ab63bc/build.log`\n" + ] + }, + { + "ename": "LoadError", + "evalue": "Error building `RCall`: \nERROR: could not load library \"/Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib\"\ndlopen(/Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib, 0x0001): Library not loaded: @rpath/libreadline.6.2.dylib\n Referenced from: <185433D7-8B40-31AA-8BD9-465D23C57257> /Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib\n Reason: tried: '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/julia/libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/libreadline.6.2.dylib' (no such file), '/System/Volumes/Preboot/Cryptexes/OS@rpath/libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/julia/libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/libreadline.6.2.dylib' (no such file), '/usr/local/lib/libreadline.6.2.dylib' (no such file), '/usr/lib/libreadline.6.2.dylib' (no such file, not in dyld cache)\nERROR: LoadError: Try adding /Volumes/SanDisk/opt/anaconda3/lib/R/lib to the \"LD_LIBRARY_PATH\" environmental variable and restarting Julia.\nStacktrace:\n [1] error(s::String)\n @ Base ./error.jl:35\n [2] validate_libR(libR::String)\n @ Main ~/.julia/packages/RCall/Wyd74/deps/setup.jl:26\n [3] locate_libR(Rhome::SubString{String})\n @ Main ~/.julia/packages/RCall/Wyd74/deps/setup.jl:43\n [4] top-level scope\n @ ~/.julia/packages/RCall/Wyd74/deps/build.jl:58\n [5] include(fname::String)\n @ Base.MainInclude ./client.jl:476\n [6] top-level scope\n @ none:5\nin expression starting at /Users/zacharyclement/.julia/packages/RCall/Wyd74/deps/build.jl:11\n\ncaused by: could not load library \"/Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib\"\ndlopen(/Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib, 0x0001): Library not loaded: @rpath/libreadline.6.2.dylib\n Referenced from: <185433D7-8B40-31AA-8BD9-465D23C57257> /Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib\n Reason: tried: '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/julia/libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/libreadline.6.2.dylib' (no such file), '/System/Volumes/Preboot/Cryptexes/OS@rpath/libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/julia/libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/libreadline.6.2.dylib' (no such file), '/usr/local/lib/libreadline.6.2.dylib' (no such file), '/usr/lib/libreadline.6.2.dylib' (no such file, not in dyld cache)\nStacktrace:\n [1] dlopen(s::String, flags::UInt32; throw_error::Bool)\n @ Base.Libc.Libdl ./libdl.jl:117\n [2] dlopen (repeats 2 times)\n @ ./libdl.jl:116 [inlined]\n [3] validate_libR(libR::String)\n @ Main ~/.julia/packages/RCall/Wyd74/deps/setup.jl:16\n [4] locate_libR(Rhome::SubString{String})\n @ Main ~/.julia/packages/RCall/Wyd74/deps/setup.jl:43\n [5] top-level scope\n @ ~/.julia/packages/RCall/Wyd74/deps/build.jl:58\n [6] include(fname::String)\n @ Base.MainInclude ./client.jl:476\n [7] top-level scope\n @ none:5", + "output_type": "error", + "traceback": [ + "Error building `RCall`: \nERROR: could not load library \"/Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib\"\ndlopen(/Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib, 0x0001): Library not loaded: @rpath/libreadline.6.2.dylib\n Referenced from: <185433D7-8B40-31AA-8BD9-465D23C57257> /Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib\n Reason: tried: '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/julia/libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/libreadline.6.2.dylib' (no such file), '/System/Volumes/Preboot/Cryptexes/OS@rpath/libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/julia/libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/libreadline.6.2.dylib' (no such file), '/usr/local/lib/libreadline.6.2.dylib' (no such file), '/usr/lib/libreadline.6.2.dylib' (no such file, not in dyld cache)\nERROR: LoadError: Try adding /Volumes/SanDisk/opt/anaconda3/lib/R/lib to the \"LD_LIBRARY_PATH\" environmental variable and restarting Julia.\nStacktrace:\n [1] error(s::String)\n @ Base ./error.jl:35\n [2] validate_libR(libR::String)\n @ Main ~/.julia/packages/RCall/Wyd74/deps/setup.jl:26\n [3] locate_libR(Rhome::SubString{String})\n @ Main ~/.julia/packages/RCall/Wyd74/deps/setup.jl:43\n [4] top-level scope\n @ ~/.julia/packages/RCall/Wyd74/deps/build.jl:58\n [5] include(fname::String)\n @ Base.MainInclude ./client.jl:476\n [6] top-level scope\n @ none:5\nin expression starting at /Users/zacharyclement/.julia/packages/RCall/Wyd74/deps/build.jl:11\n\ncaused by: could not load library \"/Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib\"\ndlopen(/Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib, 0x0001): Library not loaded: @rpath/libreadline.6.2.dylib\n Referenced from: <185433D7-8B40-31AA-8BD9-465D23C57257> /Volumes/SanDisk/opt/anaconda3/lib/R/lib/libR.dylib\n Reason: tried: '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/julia/libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/libreadline.6.2.dylib' (no such file), '/System/Volumes/Preboot/Cryptexes/OS@rpath/libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Volumes/SanDisk/opt/anaconda3/lib/R/lib/../../libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/julia/libreadline.6.2.dylib' (no such file), '/Applications/Julia-1.8.app/Contents/Resources/julia/lib/libreadline.6.2.dylib' (no such file), '/usr/local/lib/libreadline.6.2.dylib' (no such file), '/usr/lib/libreadline.6.2.dylib' (no such file, not in dyld cache)\nStacktrace:\n [1] dlopen(s::String, flags::UInt32; throw_error::Bool)\n @ Base.Libc.Libdl ./libdl.jl:117\n [2] dlopen (repeats 2 times)\n @ ./libdl.jl:116 [inlined]\n [3] validate_libR(libR::String)\n @ Main ~/.julia/packages/RCall/Wyd74/deps/setup.jl:16\n [4] locate_libR(Rhome::SubString{String})\n @ Main ~/.julia/packages/RCall/Wyd74/deps/setup.jl:43\n [5] top-level scope\n @ ~/.julia/packages/RCall/Wyd74/deps/build.jl:58\n [6] include(fname::String)\n @ Base.MainInclude ./client.jl:476\n [7] top-level scope\n @ none:5", + "", + "Stacktrace:", + " [1] pkgerror(msg::String)", + " @ Pkg.Types /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/Types.jl:67", + " [2] (::Pkg.Operations.var\"#66#73\"{Bool, Pkg.Types.Context, String, Pkg.Types.PackageSpec, String})()", + " @ Pkg.Operations /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/Operations.jl:1060", + " [3] withenv(::Pkg.Operations.var\"#66#73\"{Bool, Pkg.Types.Context, String, Pkg.Types.PackageSpec, String}, ::Pair{String, String}, ::Vararg{Pair{String}})", + " @ Base ./env.jl:172", + " [4] (::Pkg.Operations.var\"#107#112\"{String, Bool, Bool, Bool, Pkg.Operations.var\"#66#73\"{Bool, Pkg.Types.Context, String, Pkg.Types.PackageSpec, String}, Pkg.Types.PackageSpec})()", + " @ Pkg.Operations /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/Operations.jl:1619", + " [5] with_temp_env(fn::Pkg.Operations.var\"#107#112\"{String, Bool, Bool, Bool, Pkg.Operations.var\"#66#73\"{Bool, Pkg.Types.Context, String, Pkg.Types.PackageSpec, String}, Pkg.Types.PackageSpec}, temp_env::String)", + " @ Pkg.Operations /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/Operations.jl:1493", + " [6] (::Pkg.Operations.var\"#105#110\"{Dict{String, Any}, Bool, Bool, Bool, Pkg.Operations.var\"#66#73\"{Bool, Pkg.Types.Context, String, Pkg.Types.PackageSpec, String}, Pkg.Types.Context, Pkg.Types.PackageSpec, String, Pkg.Types.Project, String})(tmp::String)", + " @ Pkg.Operations /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/Operations.jl:1582", + " [7] mktempdir(fn::Pkg.Operations.var\"#105#110\"{Dict{String, Any}, Bool, Bool, Bool, Pkg.Operations.var\"#66#73\"{Bool, Pkg.Types.Context, String, Pkg.Types.PackageSpec, String}, Pkg.Types.Context, Pkg.Types.PackageSpec, String, Pkg.Types.Project, String}, parent::String; prefix::String)", + " @ Base.Filesystem ./file.jl:764", + " [8] mktempdir(fn::Function, parent::String) (repeats 2 times)", + " @ Base.Filesystem ./file.jl:760", + " [9] sandbox(fn::Function, ctx::Pkg.Types.Context, target::Pkg.Types.PackageSpec, target_path::String, sandbox_path::String, sandbox_project_override::Pkg.Types.Project; preferences::Dict{String, Any}, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool)", + " @ Pkg.Operations /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/Operations.jl:1540", + " [10] build_versions(ctx::Pkg.Types.Context, uuids::Set{Base.UUID}; verbose::Bool)", + " @ Pkg.Operations /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/Operations.jl:1041", + " [11] build_versions", + " @ /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/Operations.jl:956 [inlined]", + " [12] add(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec}, new_git::Set{Base.UUID}; preserve::Pkg.Types.PreserveLevel, platform::Base.BinaryPlatforms.Platform)", + " @ Pkg.Operations /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/Operations.jl:1286", + " [13] add(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec}; preserve::Pkg.Types.PreserveLevel, platform::Base.BinaryPlatforms.Platform, kwargs::Base.Pairs{Symbol, IJulia.IJuliaStdio{Base.PipeEndpoint}, Tuple{Symbol}, NamedTuple{(:io,), Tuple{IJulia.IJuliaStdio{Base.PipeEndpoint}}}})", + " @ Pkg.API /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/API.jl:275", + " [14] add(pkgs::Vector{Pkg.Types.PackageSpec}; io::IJulia.IJuliaStdio{Base.PipeEndpoint}, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})", + " @ Pkg.API /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/API.jl:156", + " [15] add(pkgs::Vector{Pkg.Types.PackageSpec})", + " @ Pkg.API /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/API.jl:145", + " [16] #add#27", + " @ /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/API.jl:144 [inlined]", + " [17] add", + " @ /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/API.jl:144 [inlined]", + " [18] #add#26", + " @ /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/API.jl:143 [inlined]", + " [19] add(pkg::String)", + " @ Pkg.API /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/Pkg/src/API.jl:143", + " [20] top-level scope", + " @ In[37]:1" + ] + } + ], + "source": [ + "import Pkg; Pkg.add(\"Plots\")" + ] + }, + { + "cell_type": "markdown", + "id": "eee2d926", + "metadata": {}, + "source": [ + "Now, we can put this together:\n", + "\n", + "$\\frac{1}{|G|} \\sum_{g \\in G}|X^g| = \\frac{8! / 2^4 + 4! + 8 * 4!}{ 16} = 2736 / 16 = 171$ \n", + "\n", + "So, $\\frac{1}{|G|} \\sum_{g \\in G}|X^g| = 2736 / 16 = 171$\n", + "\n", + "\n", + "This corresponds to our brute-force solution. \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 289, + "id": "a343befd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9292733321308227cx, -0.9469883177768986cy), (0.7492287427300398cx, -0.8120396930663802cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.6091907439756581cx, -0.7041787682694591cy), (0.3801380973616516cx, -0.5229188787845082cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.2437508835798995cx, -0.41050813923876633cy), (0.023572728587076347cx, -0.22156117865309966cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.10604114768294835cx, -0.10153769816464994cy), (-0.2978117802155702cx, 0.08999985272336473cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.41725443414773cx, 0.22009584844308094cy), (-0.5617022591210773cx, 0.3917792547063795cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.6711703556023584cx, 0.5304737003730007cy), (-0.7842898651306247cx, 0.6833998026941323cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8857688434741904cx, 0.82807932138458cy), (-0.9510844575790326cx, 0.9263809147729848cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.0606601717798212mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, -1.0cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.6785020748608626cx, -0.7590280108432788cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.31082676647644725cx, -0.46806963621068853cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.04350315430947138cx, -0.1639996816811774cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.3603497735890472cx, 0.15246183623989218cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.6186069196797601cx, 0.4594132669095683cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.836853301053223cx, 0.7544602361575647cy), 0.035355339059327376w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 1.0cy), 0.035355339059327376w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,0.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,1.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(1.0,1.0,0.0,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.0,0.5019607843137255,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 289, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "using Compose, Cairo, Fontconfig\n", + "using Colors\n", + "\n", + "g = SimpleGraph(8)\n", + "for i in 1:7\n", + " add_edge!(g, i, i + 1)\n", + "end\n", + "#add_edge!(g, 8, 1)\n", + "\n", + "nodelabel = fill(\"\", length(8))\n", + "\n", + "membership = [1, 2, 3, 4, 1, 2, 3, 4]\n", + "\n", + "nodecolor = [colorant\"red\", colorant\"blue\", colorant\"yellow\", colorant\"green\"]\n", + "# membership color\n", + "nodefillc = nodecolor[membership]\n", + "\n", + "locs_x = [0, 2, 3, 2]\n", + "locs_y = [0, -1, 1, 0]\n", + "\n", + "nodestrokelw = [0, 0, 0, 0, 0]\n", + "\n", + "g = gplot(g, nodefillc=nodefillc)#, locs_x, locs_y, #nodelabel=nodelabel, \n", + " #nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15)\n", + "draw(PNG(\"smoking.png\", 16cm, 16cm),g)\n", + "g" + ] + }, + { + "cell_type": "code", + "execution_count": 286, + "id": "c6d3656a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.8/Project.toml`\n", + " \u001b[90m [5ae59095] \u001b[39m\u001b[92m+ Colors v0.12.10\u001b[39m\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.8/Manifest.toml`\n" + ] + } + ], + "source": [ + "import Pkg; Pkg.add(\"Colors\")" + ] + }, + { + "cell_type": "code", + "execution_count": 275, + "id": "477aac79", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2736.0" + ] + }, + "execution_count": 275, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "factorial(8) / 2^4 + factorial(4) * 9" + ] + }, + { + "cell_type": "code", + "execution_count": 234, + "id": "4bb09736", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Combinatorics.Permutations{Vector{String}}([\"r\", \"r\", \"g\", \"g\", \"b\", \"b\"], 6)" + ] + }, + "execution_count": 234, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Combinatorics\n", + "all_permutations = permutations([\"r\", \"r\", \"g\", \"g\", \"b\", \"b\"], 6)" + ] + }, + { + "cell_type": "code", + "execution_count": 243, + "id": "c32c99d9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "720-element Vector{Vector{String}}:\n", + " [\"r\", \"r\", \"g\", \"g\", \"b\", \"b\"]\n", + " [\"r\", \"r\", \"g\", \"g\", \"b\", \"b\"]\n", + " [\"r\", \"r\", \"g\", \"b\", \"g\", \"b\"]\n", + " [\"r\", \"r\", \"g\", \"b\", \"b\", \"g\"]\n", + " [\"r\", \"r\", \"g\", \"b\", \"g\", \"b\"]\n", + " [\"r\", \"r\", \"g\", \"b\", \"b\", \"g\"]\n", + " [\"r\", \"r\", \"g\", \"g\", \"b\", \"b\"]\n", + " [\"r\", \"r\", \"g\", \"g\", \"b\", \"b\"]\n", + " [\"r\", \"r\", \"g\", \"b\", \"g\", \"b\"]\n", + " [\"r\", \"r\", \"g\", \"b\", \"b\", \"g\"]\n", + " [\"r\", \"r\", \"g\", \"b\", \"g\", \"b\"]\n", + " [\"r\", \"r\", \"g\", \"b\", \"b\", \"g\"]\n", + " [\"r\", \"r\", \"b\", \"g\", \"g\", \"b\"]\n", + " ⋮\n", + " [\"b\", \"b\", \"g\", \"r\", \"r\", \"g\"]\n", + " [\"b\", \"b\", \"g\", \"r\", \"g\", \"r\"]\n", + " [\"b\", \"b\", \"g\", \"r\", \"r\", \"g\"]\n", + " [\"b\", \"b\", \"g\", \"r\", \"g\", \"r\"]\n", + " [\"b\", \"b\", \"g\", \"g\", \"r\", \"r\"]\n", + " [\"b\", \"b\", \"g\", \"g\", \"r\", \"r\"]\n", + " [\"b\", \"b\", \"g\", \"r\", \"r\", \"g\"]\n", + " [\"b\", \"b\", \"g\", \"r\", \"g\", \"r\"]\n", + " [\"b\", \"b\", \"g\", \"r\", \"r\", \"g\"]\n", + " [\"b\", \"b\", \"g\", \"r\", \"g\", \"r\"]\n", + " [\"b\", \"b\", \"g\", \"g\", \"r\", \"r\"]\n", + " [\"b\", \"b\", \"g\", \"g\", \"r\", \"r\"]" + ] + }, + "execution_count": 243, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_perms_list" + ] + }, + { + "cell_type": "code", + "execution_count": 251, + "id": "082beb1a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "48-element Vector{String}:\n", + " \"rrggbb\"\n", + " \"rrgbgb\"\n", + " \"rrgbbg\"\n", + " \"rrbggb\"\n", + " \"rrbgbg\"\n", + " \"rrbbgg\"\n", + " \"rgrgbb\"\n", + " \"rgrbgb\"\n", + " \"rgrbbg\"\n", + " \"rggrbb\"\n", + " \"rggbrb\"\n", + " \"rggbbr\"\n", + " \"rgbrgb\"\n", + " ⋮\n", + " \"grbbrg\"\n", + " \"ggrrbb\"\n", + " \"ggrbrb\"\n", + " \"ggbrrb\"\n", + " \"gbrrgb\"\n", + " \"gbrrbg\"\n", + " \"gbrgrb\"\n", + " \"gbgrrb\"\n", + " \"brrggb\"\n", + " \"brgrgb\"\n", + " \"brggrb\"\n", + " \"bgrrgb\"" + ] + }, + "execution_count": 251, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "keep_list_symmetry = [join(x) for x in keep_list]" + ] + }, + { + "cell_type": "code", + "execution_count": 245, + "id": "3ef21235", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "90" + ] + } + ], + "source": [ + "all_perms_list = collect(permutations([\"r\", \"r\", \"g\", \"g\", \"b\", \"b\"], 6))\n", + "keep_list = []\n", + "for i in 2:length(all_perms_list)\n", + " already_in_list = false\n", + " for j in 1:length(keep_list)\n", + " if is_equivalent(all_perms_list[i], keep_list[j])\n", + " already_in_list = true\n", + " end\n", + " end\n", + " if !already_in_list \n", + " push!(keep_list, all_perms_list[i])\n", + " end\n", + "end\n", + "print(length(keep_list))" + ] + }, + { + "cell_type": "code", + "execution_count": 249, + "id": "05448617", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "90-element Vector{String}:\n", + " \"rrggbb\"\n", + " \"rrgbgb\"\n", + " \"rrgbbg\"\n", + " \"rrbggb\"\n", + " \"rrbgbg\"\n", + " \"rrbbgg\"\n", + " \"rgrgbb\"\n", + " \"rgrbgb\"\n", + " \"rgrbbg\"\n", + " \"rggrbb\"\n", + " \"rggbrb\"\n", + " \"rggbbr\"\n", + " \"rgbrgb\"\n", + " ⋮\n", + " \"bggrrb\"\n", + " \"bggrbr\"\n", + " \"bggbrr\"\n", + " \"bgbrrg\"\n", + " \"bgbrgr\"\n", + " \"bgbgrr\"\n", + " \"bbrrgg\"\n", + " \"bbrgrg\"\n", + " \"bbrggr\"\n", + " \"bbgrrg\"\n", + " \"bbgrgr\"\n", + " \"bbggrr\"" + ] + }, + "execution_count": 249, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "keep_list_no_symmetry = [join(x) for x in keep_list]" + ] + }, + { + "cell_type": "code", + "execution_count": 256, + "id": "151eaa59", + "metadata": {}, + "outputs": [], + "source": [ + "double_counted_list = []\n", + "for x in keep_list_no_symmetry \n", + " if !(x in keep_list_symmetry)\n", + " push!(double_counted_list, x)\n", + " end\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 265, + "id": "b4122b0a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6-element Vector{Any}:\n", + " \"rgbbgr\"\n", + " \"rbggbr\"\n", + " \"grbbrg\"\n", + " \"gbrrbg\"\n", + " \"brggrb\"\n", + " \"bgrrgb\"" + ] + }, + "execution_count": 265, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "single_counted_list = []\n", + "for x in keep_list_symmetry \n", + " if !(reverse(x) in double_counted_list)\n", + " push!(single_counted_list, x)\n", + " end\n", + "end\n", + "single_counted_list" + ] + }, + { + "cell_type": "code", + "execution_count": 262, + "id": "c591e45c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "false" + ] + }, + "execution_count": 262, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reverse(\"rrbbgg\") in keep_list_symmetry" + ] + }, + { + "cell_type": "code", + "execution_count": 263, + "id": "72994e1e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"ggbbrr\"" + ] + }, + "execution_count": 263, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reverse(\"rrbbgg\")" + ] + }, + { + "cell_type": "code", + "execution_count": 261, + "id": "57c4e8c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "90.0" + ] + }, + "execution_count": 261, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "factorial(6) / factorial(4) / factorial(2) * factorial(4) / factorial(2) / 2" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "id": "e9b49a9c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Combinatorics.Permutations{Vector{String}}([\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"d\"], 8)" + ] + }, + "execution_count": 153, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Combinatorics\n", + "all_permutations = permutations([\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"d\"], 8)" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "id": "117806ad", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Combinatorics.Permutations{Vector{String}}([\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"d\", \"e\", \"e\"], 10)" + ] + }, + "execution_count": 160, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Combinatorics\n", + "all_permutations = permutations([\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"d\", \"e\", \"e\"], 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "id": "263d1701", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3628800-element Vector{Vector{String}}:\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"d\", \"e\", \"e\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"d\", \"e\", \"e\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"e\", \"d\", \"e\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"e\", \"e\", \"d\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"e\", \"d\", \"e\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"e\", \"e\", \"d\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"d\", \"e\", \"e\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"d\", \"e\", \"e\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"e\", \"d\", \"e\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"e\", \"e\", \"d\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"e\", \"d\", \"e\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"e\", \"e\", \"d\"]\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"e\", \"d\", \"d\", \"e\"]\n", + " ⋮\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"a\", \"a\", \"b\"]\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"a\", \"b\", \"a\"]\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"a\", \"a\", \"b\"]\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"a\", \"b\", \"a\"]\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"b\", \"a\", \"a\"]\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"b\", \"a\", \"a\"]\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"a\", \"a\", \"b\"]\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"a\", \"b\", \"a\"]\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"a\", \"a\", \"b\"]\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"a\", \"b\", \"a\"]\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"b\", \"a\", \"a\"]\n", + " [\"e\", \"e\", \"d\", \"d\", \"c\", \"c\", \"b\", \"b\", \"a\", \"a\"]" + ] + }, + "execution_count": 161, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "all_perms_list = collect(all_permutations)" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "id": "5513d8b3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1-element Vector{Vector{String}}:\n", + " [\"a\", \"a\", \"b\", \"b\", \"c\", \"c\", \"d\", \"d\", \"e\", \"e\"]" + ] + }, + "execution_count": 162, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "keep_list = [all_perms_list[1]]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ae15dbd", + "metadata": {}, + "outputs": [], + "source": [ + "for i in 2:length(all_perms_list)\n", + " already_in_list = false\n", + " for j in 1:length(keep_list)\n", + " if is_symmetrically_equivalent(all_perms_list[i], keep_list[j])\n", + " already_in_list = true\n", + " end\n", + " end\n", + " if !already_in_list \n", + " push!(keep_list, all_perms_list[i])\n", + " end\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44db18f5", + "metadata": {}, + "outputs": [], + "source": [ + "keep_list" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f44f7a25", + "metadata": {}, + "outputs": [], + "source": [ + "[\"r\", \"g\", \"g\", \"b\", \"r\", \"b\"] ?rbrggb\n", + "\n", + "\n", + "\"r\", \"g\", \"b\", \"r\", \"b\", \"g\"]\n", + "\n", + "\n", + "[\"r\", \"g\", \"b\", \"g\", \"r\", \"b\"] ?rbrgbg\n", + "\n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "id": "07f1f048", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "57.0" + ] + }, + "execution_count": 159, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "171 / 3\n" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "113ebfa8", + "metadata": {}, + "outputs": [], + "source": [ + "is_symmetrically_equivalent(all_perms_list[i], keep_list[j])" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "8f854864", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8-element Vector{String}:\n", + " \"d\"\n", + " \"d\"\n", + " \"c\"\n", + " \"c\"\n", + " \"b\"\n", + " \"b\"\n", + " \"a\"\n", + " \"a\"" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reverse(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "bc116d0d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8-element Vector{String}:\n", + " \"a\"\n", + " \"b\"\n", + " \"b\"\n", + " \"c\"\n", + " \"c\"\n", + " \"d\"\n", + " \"d\"\n", + " \"a\"" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_temp = push!(a[2:8], a[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "763191f2", + "metadata": {}, + "outputs": [ + { + "ename": "LoadError", + "evalue": "MethodError: no method matching +(::Vector{String}, ::String)\n\u001b[0mClosest candidates are:\n\u001b[0m +(::Any, ::Any, \u001b[91m::Any\u001b[39m, \u001b[91m::Any...\u001b[39m) at operators.jl:591\n\u001b[0m +(::Array, \u001b[91m::Array...\u001b[39m) at arraymath.jl:12\n\u001b[0m +(::Array, \u001b[91m::SparseArrays.AbstractSparseMatrixCSC\u001b[39m) at /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/SparseArrays/src/sparsematrix.jl:1833\n\u001b[0m ...", + "output_type": "error", + "traceback": [ + "MethodError: no method matching +(::Vector{String}, ::String)\n\u001b[0mClosest candidates are:\n\u001b[0m +(::Any, ::Any, \u001b[91m::Any\u001b[39m, \u001b[91m::Any...\u001b[39m) at operators.jl:591\n\u001b[0m +(::Array, \u001b[91m::Array...\u001b[39m) at arraymath.jl:12\n\u001b[0m +(::Array, \u001b[91m::SparseArrays.AbstractSparseMatrixCSC\u001b[39m) at /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/SparseArrays/src/sparsematrix.jl:1833\n\u001b[0m ...", + "", + "Stacktrace:", + " [1] top-level scope", + " @ In[31]:1" + ] + } + ], + "source": [ + "a[2:8] + a[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "c2fe571f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "true" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = true" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "0cb3fc84", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8-element Vector{String}:\n", + " \"d\"\n", + " \"d\"\n", + " \"c\"\n", + " \"c\"\n", + " \"b\"\n", + " \"b\"\n", + " \"a\"\n", + " \"a\"" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reverse(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fa2148d4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General.toml`\n", + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.8/Project.toml`\n", + " \u001b[90m [27ebfcd6] \u001b[39m\u001b[92m+ Primes v0.5.3\u001b[39m\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.8/Manifest.toml`\n" + ] + } + ], + "source": [ + "import Pkg; Pkg.add(\"Primes\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "dced4c81", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Set{Int64} with 2 elements:\n", + " 2\n", + " 3" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Primes\n", + "my_factor = Set([i[1] for i in collect(factor(18))])" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "19af8b2d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "length(union!(my_factor, [3, 2, 5]))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "f139c48c", + "metadata": {}, + "outputs": [ + { + "ename": "LoadError", + "evalue": "UndefVarError: set not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: set not defined", + "", + "Stacktrace:", + " [1] top-level scope", + " @ In[23]:1" + ] + } + ], + "source": [ + "my_factor" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "62e7b103", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "search: \u001b[0m\u001b[1mf\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22m \u001b[0m\u001b[1mf\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22mial my_\u001b[0m\u001b[1mf\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22m each\u001b[0m\u001b[1mf\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22m prod\u001b[0m\u001b[1mf\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22ms Task\u001b[0m\u001b[1mF\u001b[22m\u001b[0m\u001b[1ma\u001b[22miledEx\u001b[0m\u001b[1mc\u001b[22mep\u001b[0m\u001b[1mt\u001b[22mi\u001b[0m\u001b[1mo\u001b[22mn\n", + "\n" + ] + }, + { + "data": { + "text/latex": [ + "\\begin{verbatim}\n", + "factor(n::Integer) -> Primes.Factorization\n", + "\\end{verbatim}\n", + "Compute the prime factorization of an integer \\texttt{n}. The returned object, of type \\texttt{Factorization}, is an associative container whose keys correspond to the factors, in sorted order. The value associated with each key indicates the multiplicity (i.e. the number of times the factor appears in the factorization).\n", + "\n", + "\\begin{verbatim}\n", + "julia> factor(100)\n", + "2^2 ⋅ 5^2\n", + "\\end{verbatim}\n", + "For convenience, a negative number \\texttt{n} is factored as \\texttt{-1*(-n)} (i.e. \\texttt{-1} is considered to be a factor), and \\texttt{0} is factored as \\texttt{0\\^{}1}:\n", + "\n", + "\\begin{verbatim}\n", + "julia> factor(-9)\n", + "-1 ⋅ 3^2\n", + "\n", + "julia> factor(0)\n", + "0\n", + "\n", + "julia> collect(factor(0))\n", + "1-element Array{Pair{Int64,Int64},1}:\n", + " 0=>1\n", + "\\end{verbatim}\n", + "\\rule{\\textwidth}{1pt}\n", + "\\begin{verbatim}\n", + "factor(ContainerType, n::Integer) -> ContainerType\n", + "\\end{verbatim}\n", + "Return the factorization of \\texttt{n} stored in a \\texttt{ContainerType}, which must be a subtype of \\texttt{AbstractDict} or \\texttt{AbstractArray}, a \\texttt{Set}, or an \\texttt{BitSet}.\n", + "\n", + "\\begin{verbatim}\n", + "julia> factor(DataStructures.SortedDict, 100)\n", + "DataStructures.SortedDict{Int64,Int64,Base.Order.ForwardOrdering} with 2 entries:\n", + " 2 => 2\n", + " 5 => 2\n", + "\\end{verbatim}\n", + "When \\texttt{ContainerType <: AbstractArray}, this returns the list of all prime factors of \\texttt{n} with multiplicities, in sorted order.\n", + "\n", + "\\begin{verbatim}\n", + "julia> factor(Vector, 100)\n", + "4-element Array{Int64,1}:\n", + " 2\n", + " 2\n", + " 5\n", + " 5\n", + "\n", + "julia> prod(factor(Vector, 100)) == 100\n", + "true\n", + "\\end{verbatim}\n", + "When \\texttt{ContainerType == Set}, this returns the distinct prime factors as a set.\n", + "\n", + "\\begin{verbatim}\n", + "julia> factor(Set, 100)\n", + "Set([2,5])\n", + "\\end{verbatim}\n" + ], + "text/markdown": [ + "```\n", + "factor(n::Integer) -> Primes.Factorization\n", + "```\n", + "\n", + "Compute the prime factorization of an integer `n`. The returned object, of type `Factorization`, is an associative container whose keys correspond to the factors, in sorted order. The value associated with each key indicates the multiplicity (i.e. the number of times the factor appears in the factorization).\n", + "\n", + "```julia\n", + "julia> factor(100)\n", + "2^2 ⋅ 5^2\n", + "```\n", + "\n", + "For convenience, a negative number `n` is factored as `-1*(-n)` (i.e. `-1` is considered to be a factor), and `0` is factored as `0^1`:\n", + "\n", + "```julia\n", + "julia> factor(-9)\n", + "-1 ⋅ 3^2\n", + "\n", + "julia> factor(0)\n", + "0\n", + "\n", + "julia> collect(factor(0))\n", + "1-element Array{Pair{Int64,Int64},1}:\n", + " 0=>1\n", + "```\n", + "\n", + "---\n", + "\n", + "```\n", + "factor(ContainerType, n::Integer) -> ContainerType\n", + "```\n", + "\n", + "Return the factorization of `n` stored in a `ContainerType`, which must be a subtype of `AbstractDict` or `AbstractArray`, a `Set`, or an `BitSet`.\n", + "\n", + "```julia\n", + "julia> factor(DataStructures.SortedDict, 100)\n", + "DataStructures.SortedDict{Int64,Int64,Base.Order.ForwardOrdering} with 2 entries:\n", + " 2 => 2\n", + " 5 => 2\n", + "```\n", + "\n", + "When `ContainerType <: AbstractArray`, this returns the list of all prime factors of `n` with multiplicities, in sorted order.\n", + "\n", + "```julia\n", + "julia> factor(Vector, 100)\n", + "4-element Array{Int64,1}:\n", + " 2\n", + " 2\n", + " 5\n", + " 5\n", + "\n", + "julia> prod(factor(Vector, 100)) == 100\n", + "true\n", + "```\n", + "\n", + "When `ContainerType == Set`, this returns the distinct prime factors as a set.\n", + "\n", + "```julia\n", + "julia> factor(Set, 100)\n", + "Set([2,5])\n", + "```\n" + ], + "text/plain": [ + "\u001b[36m factor(n::Integer) -> Primes.Factorization\u001b[39m\n", + "\n", + " Compute the prime factorization of an integer \u001b[36mn\u001b[39m. The returned object, of\n", + " type \u001b[36mFactorization\u001b[39m, is an associative container whose keys correspond to the\n", + " factors, in sorted order. The value associated with each key indicates the\n", + " multiplicity (i.e. the number of times the factor appears in the\n", + " factorization).\n", + "\n", + "\u001b[36m julia> factor(100)\u001b[39m\n", + "\u001b[36m 2^2 ⋅ 5^2\u001b[39m\n", + "\n", + " For convenience, a negative number \u001b[36mn\u001b[39m is factored as \u001b[36m-1*(-n)\u001b[39m (i.e. \u001b[36m-1\u001b[39m is\n", + " considered to be a factor), and \u001b[36m0\u001b[39m is factored as \u001b[36m0^1\u001b[39m:\n", + "\n", + "\u001b[36m julia> factor(-9)\u001b[39m\n", + "\u001b[36m -1 ⋅ 3^2\u001b[39m\n", + "\u001b[36m \u001b[39m\n", + "\u001b[36m julia> factor(0)\u001b[39m\n", + "\u001b[36m 0\u001b[39m\n", + "\u001b[36m \u001b[39m\n", + "\u001b[36m julia> collect(factor(0))\u001b[39m\n", + "\u001b[36m 1-element Array{Pair{Int64,Int64},1}:\u001b[39m\n", + "\u001b[36m 0=>1\u001b[39m\n", + "\n", + " ────────────────────────────────────────────────────────────────────────────\n", + "\n", + "\u001b[36m factor(ContainerType, n::Integer) -> ContainerType\u001b[39m\n", + "\n", + " Return the factorization of \u001b[36mn\u001b[39m stored in a \u001b[36mContainerType\u001b[39m, which must be a\n", + " subtype of \u001b[36mAbstractDict\u001b[39m or \u001b[36mAbstractArray\u001b[39m, a \u001b[36mSet\u001b[39m, or an \u001b[36mBitSet\u001b[39m.\n", + "\n", + "\u001b[36m julia> factor(DataStructures.SortedDict, 100)\u001b[39m\n", + "\u001b[36m DataStructures.SortedDict{Int64,Int64,Base.Order.ForwardOrdering} with 2 entries:\u001b[39m\n", + "\u001b[36m 2 => 2\u001b[39m\n", + "\u001b[36m 5 => 2\u001b[39m\n", + "\n", + " When \u001b[36mContainerType <: AbstractArray\u001b[39m, this returns the list of all prime\n", + " factors of \u001b[36mn\u001b[39m with multiplicities, in sorted order.\n", + "\n", + "\u001b[36m julia> factor(Vector, 100)\u001b[39m\n", + "\u001b[36m 4-element Array{Int64,1}:\u001b[39m\n", + "\u001b[36m 2\u001b[39m\n", + "\u001b[36m 2\u001b[39m\n", + "\u001b[36m 5\u001b[39m\n", + "\u001b[36m 5\u001b[39m\n", + "\u001b[36m \u001b[39m\n", + "\u001b[36m julia> prod(factor(Vector, 100)) == 100\u001b[39m\n", + "\u001b[36m true\u001b[39m\n", + "\n", + " When \u001b[36mContainerType == Set\u001b[39m, this returns the distinct prime factors as a set.\n", + "\n", + "\u001b[36m julia> factor(Set, 100)\u001b[39m\n", + "\u001b[36m Set([2,5])\u001b[39m" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "?factor\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "faae009e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "is_relative_prime (generic function with 1 method)" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Primes\n", + "function is_relative_prime(x, y)\n", + " x_factors = factor(Set, x)\n", + " y_factors = factor(Set,y)\n", + " for factor in y_factors\n", + " if factor in x_factors\n", + " return false\n", + " end\n", + " end\n", + " ## none of them had a match\n", + " return true\n", + " \n", + " \n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82f21ef3", + "metadata": {}, + "outputs": [], + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f89a83d5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "euler_totient (generic function with 1 method)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function euler_totient(x)\n", + " output_sum = 0\n", + " for i in 1:x\n", + " if is_relative_prime(i, x)\n", + " output_sum += 1\n", + " end\n", + " end\n", + " return output_sum\n", + " \n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3ce41db6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_factors (generic function with 1 method)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Combinatorics\n", + "function get_factors(x)\n", + " prime_factors = factor(Vector, x)\n", + " all_prime_factors = vcat(prime_factors, fill(1, length(prime_factors))) ## add 1s so smaller numbers are included\n", + "\n", + " factor_list = [prod(i) for i in combinations(all_prime_factors, length(prime_factors))]\n", + " return Set(factor_list)\n", + "\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9872e1b5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Set{Int64} with 6 elements:\n", + " 12\n", + " 1\n", + " 4\n", + " 6\n", + " 2\n", + " 3" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "get_factors(12)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "47d1d527", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "70.0" + ] + } + ], + "source": [ + "num_beads = 4\n", + "necklace_size = 4\n", + "\n", + "sum = 0\n", + "\n", + "for d in get_factors(num_beads)\n", + " sum = sum + euler_totient(d) * necklace_size ^ (num_beads / d)\n", + "end\n", + "\n", + "sum = sum / num_beads\n", + "print(sum)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "40d65e3c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_number_necklaces (generic function with 1 method)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function get_number_necklaces(n, k)\n", + " sum = 0\n", + "\n", + " for d in get_factors(n)\n", + " sum = sum + euler_totient(d) * k ^ (n / d)\n", + " end\n", + "\n", + " sum = sum / n\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "3f5a1944", + "metadata": {}, + "source": [ + "You can check your work here https://oeis.org/A000031" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "95906817", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_number_bracelets (generic function with 1 method)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function get_number_bracelets(n, k)\n", + " if round(n / 2) == n / 2\n", + " return get_number_necklaces(n, k) / 2 + (k + 1) * k^(n / 2)/4\n", + " else\n", + " return get_number_necklaces(n, k) / 2 + k^((n+1) / 2)/2\n", + " end\n", + "end\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "5cbfe263", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "352.0" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "get_number_necklaces(12, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3354c577", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12.0\n", + "78.0\n", + "584.0\n", + "5226.0\n", + "49776.0\n", + "498004.0\n", + "5.11884e6\n", + "5.3750346e7\n", + "5.7330932e8\n", + "6.191761368e9\n", + "6.7546215528e10\n", + "7.43008623292e11\n" + ] + } + ], + "source": [ + "for i in 1:12\n", + " println(get_number_necklaces(i, 12))\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 186, + "id": "7221571c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2259.0" + ] + }, + "execution_count": 186, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(get_number_bracelets(8, 4) \n", + "- 4 ### bracelets of all of each of the 4 colors\n", + "- 6 * get_number_bracelets(8, 2)\n", + "- 4 * get_number_bracelets(8, 3)\n", + "\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 184, + "id": "44059b15", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8.0" + ] + }, + "execution_count": 184, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "get_number_bracelets(5, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "cff97684", + "metadata": {}, + "outputs": [ + { + "ename": "LoadError", + "evalue": "UndefVarError: tril! not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: tril! not defined", + "", + "Stacktrace:", + " [1] top-level scope", + " @ In[78]:1" + ] + } + ], + "source": [ + "tril!(prime_factors * transpose(prime_factors))" + ] + }, + { + "cell_type": "markdown", + "id": "d0adc063", + "metadata": {}, + "source": [ + "Burnside's lemma takes into account rotations, and it also works for reflections. \n", + "\n", + "https://math.stackexchange.com/questions/3246995/number-of-bracelets-with-6-white-3-blue-and-5-red-beads?rq=1" + ] + }, + { + "cell_type": "code", + "execution_count": 228, + "id": "c95f6382", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "171.0" + ] + }, + "execution_count": 228, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(factorial(8) / (2 ^ 4) + factorial(4) * 9) / 16" + ] + }, + { + "cell_type": "code", + "execution_count": 230, + "id": "f017a8e8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "11.0" + ] + }, + "execution_count": 230, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(factorial(6) / (2 ^ 3) + factorial(3) * 7) / 12" + ] + }, + { + "cell_type": "code", + "execution_count": 227, + "id": "a579eebf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "360.0" + ] + }, + "execution_count": 227, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "24 * 171 - factorial(8) / (2 ^ 4) - factorial(4) * 17 * 3" + ] + }, + { + "cell_type": "code", + "execution_count": 222, + "id": "f6576371", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5-element Vector{Int64}:\n", + " 2\n", + " 2\n", + " 2\n", + " 3\n", + " 83" + ] + }, + "execution_count": 222, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "factor(Vector, 1992)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "id": "8074a855", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "search: \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mm\u001b[22m\u001b[0m\u001b[1mb\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1ms\u001b[22m all_\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mm\u001b[22m\u001b[0m\u001b[1mb\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1ms\u001b[22m multiset_\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mm\u001b[22m\u001b[0m\u001b[1mb\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1ms\u001b[22m \u001b[0m\u001b[1mC\u001b[22m\u001b[0m\u001b[1mo\u001b[22molLexCo\u001b[0m\u001b[1mm\u001b[22m\u001b[0m\u001b[1mb\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\n", + "\n" + ] + }, + { + "data": { + "text/latex": [ + "\\begin{verbatim}\n", + "combinations(a, n)\n", + "\\end{verbatim}\n", + "Generate all combinations of \\texttt{n} elements from an indexable object \\texttt{a}. Because the number of combinations can be very large, this function returns an iterator object. Use \\texttt{collect(combinations(a, n))} to get an array of all combinations.\n", + "\n", + "\\rule{\\textwidth}{1pt}\n", + "\\begin{verbatim}\n", + "combinations(a)\n", + "\\end{verbatim}\n", + "Generate combinations of the elements of \\texttt{a} of all orders. Chaining of order iterators is eager, but the sequence at each order is lazy.\n", + "\n" + ], + "text/markdown": [ + "```\n", + "combinations(a, n)\n", + "```\n", + "\n", + "Generate all combinations of `n` elements from an indexable object `a`. Because the number of combinations can be very large, this function returns an iterator object. Use `collect(combinations(a, n))` to get an array of all combinations.\n", + "\n", + "---\n", + "\n", + "```\n", + "combinations(a)\n", + "```\n", + "\n", + "Generate combinations of the elements of `a` of all orders. Chaining of order iterators is eager, but the sequence at each order is lazy.\n" + ], + "text/plain": [ + "\u001b[36m combinations(a, n)\u001b[39m\n", + "\n", + " Generate all combinations of \u001b[36mn\u001b[39m elements from an indexable object \u001b[36ma\u001b[39m. Because\n", + " the number of combinations can be very large, this function returns an\n", + " iterator object. Use \u001b[36mcollect(combinations(a, n))\u001b[39m to get an array of all\n", + " combinations.\n", + "\n", + " ────────────────────────────────────────────────────────────────────────────\n", + "\n", + "\u001b[36m combinations(a)\u001b[39m\n", + "\n", + " Generate combinations of the elements of \u001b[36ma\u001b[39m of all orders. Chaining of order\n", + " iterators is eager, but the sequence at each order is lazy." + ] + }, + "execution_count": 210, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "?combinations\n" + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "id": "f0daf432", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "168168.0" + ] + }, + "execution_count": 213, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "factorial(14) / factorial(14 - 6) / factorial(6) * factorial(8) / factorial(5) / factorial(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 214, + "id": "fc815bc1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "168168.0" + ] + }, + "execution_count": 214, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "factorial(14) / factorial(14 - 3) / factorial(3) * factorial(11) / factorial(6) / factorial(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 215, + "id": "4d8ef646", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2520.0" + ] + }, + "execution_count": 215, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "factorial(8) / 2 ^4" + ] + }, + { + "cell_type": "code", + "execution_count": 216, + "id": "9d0df4dd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2520.0" + ] + }, + "execution_count": 216, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "factorial(8) / factorial(6) * factorial(6) / factorial(4) * factorial(4) / factorial(2) / 2^3" + ] + }, + { + "cell_type": "markdown", + "id": "4c7d43fb", + "metadata": {}, + "source": [ + "## How many possible chords are there, accounting for transposition?\n", + "\n", + "1: 1 \n", + "2: 6 \n", + "3: 19 \n", + "4: 43 \n", + "5: 66 \n", + "6: 80 \n", + "7: 66 \n", + "8: 43 \n", + "9: 19 \n", + "10: 6 \n", + "11: 1 \n", + "12: 1" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "3e761933", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "351" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(1 + 6 + 19 + 43 + 66) * 2 + 80 + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d38f1839", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "comb (generic function with 1 method)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function comb(n, k)\n", + " return factorial(n) / factorial(k) / factorial(n - k)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7e4a56ce", + "metadata": {}, + "outputs": [], + "source": [ + "## 2/10\n", + "(comb(12, 2) + 6)/ 12 # at 6 o clock, there are 6 different fixed points" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "6b98bf8f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19.0" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## 3 / 9\n", + "(comb(12, 3) + 4*2)/ 12\n", + "## 4 and 8 o clock both have 4 fixed" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "615e0630", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "43.0" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## 4/8\n", + "(comb(12, 4) + \n", + " comb(6, 2) + #rotation at half\n", + " 3*2 #at 3 and 9 o clock there are 3 possible combinations\n", + " )/ 12" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "75b5b389", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "66.0" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## 5/7\n", + "(comb(12, 5))/ 12 ## no way for there to be any fixed points beyond the null" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "210dee47", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "77.0" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "comb(12, 6) / 12" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "936eaef6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "80.0" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## 6\n", + "(comb(12, 6) + \n", + " 2 * 2 + #2, and 10 o clock both have 2 choices\n", + " comb(4, 2) * 2 + #4 and 8 o clock rotations can distribute 1/3 the beads (2) among 4 possible slots\n", + " \n", + " comb(6, 3) # 6 o clock can distribute 3 beads among 6 possible slots\n", + " )/ 12" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "b8049eb8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 1.0\n", + "2 11.0\n", + "3 55.0\n", + "4 165.0\n", + "5 330.0\n", + "6 462.0\n", + "7 462.0\n", + "8 330.0\n", + "9 165.0\n", + "10 55.0\n", + "11 11.0\n", + "12 1.0\n", + "2048.0" + ] + } + ], + "source": [ + "sum = 0 ## chord of 1\n", + "for i in 1:12\n", + " current_number = factorial(11) / factorial(i - 1) / factorial(11 - i + 1)\n", + " sum += current_number\n", + " println(i, \" \", current_number)\n", + "end\n", + "print(sum)" + ] + }, + { + "cell_type": "markdown", + "id": "cd4e4bd4", + "metadata": {}, + "source": [ + "If there were 4 different notes \n", + "0. 1 option \n", + "1. 1 options. \n", + "2. 2 options\n", + "3. 1 option\n", + "4. 1 option" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "732287e4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6.0" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "get_number_necklaces(4, 2)" + ] + }, + { + "cell_type": "markdown", + "id": "10b926e5", + "metadata": {}, + "source": [ + "If there were 5 notes: \n", + "\n", + "0. 1 option \n", + "1. 1 option \n", + "2. 4 options \n", + "3. 4 options \n", + "4. 1 option \n", + "5. 1 option \n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "d71985cb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8.0" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "get_number_necklaces(5, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dd90bad4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "1299fae2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Combinatorics.Permutations{Vector{Bool}}(Bool[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 12)" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Combinatorics\n", + "n_played = 1\n", + "n_notes = 12\n", + "perms = permutations(\n", + " vcat(repeat([true], n_played), repeat([false], n_notes - n_played)), \n", + " n_notes)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "5d5161d3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "479001600" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "length(perms)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "94431ca7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12-element Vector{Any}:\n", + " Bool[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n", + " Bool[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n", + " Bool[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n", + " Bool[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]\n", + " Bool[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]\n", + " Bool[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]\n", + " Bool[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]\n", + " Bool[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]\n", + " Bool[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]\n", + " Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]\n", + " Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]\n", + " Bool[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "output_list = []\n", + "for arrangement in perms\n", + " if !( arrangement in output_list)\n", + " push!(output_list, arrangement)\n", + " end\n", + " \n", + "end\n", + "output_list" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "0992c6a1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1-element Vector{Vector{Int64}}:\n", + " [1, 2, 3]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "collect(combinations([1, 2, 3], 3))" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "ae7f9b20", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_all_perms_list (generic function with 2 methods)" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function get_all_perms_list(n_played, n_notes = 12)\n", + " perms = permutations(\n", + " vcat(repeat([true], n_played - 1), repeat([false], n_notes - n_played)), \n", + " n_notes - 1)\n", + " output_list = []\n", + " for arrangement in perms\n", + " if !( arrangement in output_list)\n", + " push!(output_list, arrangement)\n", + " end\n", + "\n", + " end\n", + " for i in 1:length(output_list)\n", + " push!(output_list[i], true) #endlways end with a note played\n", + " \n", + " end\n", + " return output_list\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "1bf6b4d9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4-element Vector{Any}:\n", + " Bool[1, 0, 0, 0, 1]\n", + " Bool[0, 1, 0, 0, 1]\n", + " Bool[0, 0, 1, 0, 1]\n", + " Bool[0, 0, 0, 1, 1]" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "get_all_perms_list(2, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "f42ec2fa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_num_note_combinations (generic function with 1 method)" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Combinatorics\n", + "function get_num_note_combinations(n_played)\n", + " all_perms_list = get_all_perms_list(n_played)\n", + " keep_list = []\n", + " for i in 2:length(all_perms_list)\n", + " already_in_list = false\n", + " for j in 1:length(keep_list)\n", + " if is_rotationally_equivalent(all_perms_list[i], keep_list[j])\n", + " already_in_list = true\n", + " end\n", + " end\n", + " if !already_in_list \n", + " push!(keep_list, all_perms_list[i])\n", + " end\n", + " end\n", + " println(n_played, \": \", length(keep_list))\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "2f50edf0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2: 6\n", + "3: 19\n", + "4: 43\n", + "5: 66\n", + "6: 80\n", + "7: 66\n", + "8: 43\n", + "9: 19\n" + ] + }, + { + "ename": "LoadError", + "evalue": "InterruptException:", + "output_type": "error", + "traceback": [ + "InterruptException:", + "", + "Stacktrace:", + " [1] copy", + " @ ./array.jl:369 [inlined]", + " [2] nextpermutation(m::Vector{Bool}, t::Int64, state::Vector{Int64})", + " @ Combinatorics ~/.julia/packages/Combinatorics/Udg6X/src/permutations.jl:53", + " [3] iterate", + " @ ~/.julia/packages/Combinatorics/Udg6X/src/permutations.jl:44 [inlined]", + " [4] get_all_perms_list(n_played::Int64, n_notes::Int64)", + " @ Main ./In[42]:11", + " [5] get_all_perms_list", + " @ ./In[42]:2 [inlined]", + " [6] get_num_note_combinations(n_played::Int64)", + " @ Main ./In[44]:3", + " [7] top-level scope", + " @ ./In[45]:2" + ] + } + ], + "source": [ + "for i in 2:12\n", + " get_num_note_combinations(i)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "162a77fe", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.8.3", + "language": "julia", + "name": "julia-1.8" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/chord_frequencies_blog_post.ipynb b/chord_frequencies_blog_post.ipynb new file mode 100644 index 0000000..7da2234 --- /dev/null +++ b/chord_frequencies_blog_post.ipynb @@ -0,0 +1,24331 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2e5aaaaa", + "metadata": {}, + "source": [ + "In my last post, I wrote about using burnside's lemma to count the number of unique ways beads could be arranged if strung on a bracelet. After writing the post, I had two other questions: how many unique possible chords could be played using the Western 12-note scale? And, as someone who listens to a lot of music, it is likely that I have heard every possible chord which can be composed?" + ] + }, + { + "cell_type": "markdown", + "id": "0002ee89", + "metadata": {}, + "source": [ + "The question of how many unique notes could be played using the 12-note scale was fairly easy. I simply considered each note orientation to be a necklace (allowing rotations but not reflections) with 12 possible beads. I considered notes that were played to be of one color, and notes that were not played to be of a different color. " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "423e8832", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "comb (generic function with 1 method)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Combinatorics\n", + "function comb(n, k)\n", + " return factorial(n) / factorial(k) / factorial(n - k)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "aeaa86c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are 1 unique orientations in which 0, 1, 11, or 12 notes can be played, 6 unique orientations in which 2/10 notes can be played, 19 unique orientations in which 3/9 notes can be played, 43 unique orientations in which 4/8 notes can be played, 66 unique orientations in which 5/7 notes can be played, and 80 unique orientations in which 6 notes can be played\n", + "In total, there are 352 orientations in which any number of notes can be played \n" + ] + } + ], + "source": [ + "\n", + "n_orientations_0_1_11_12 = 1 ## there is only one way to play all notes, play one note, or leave one note out.\n", + "\n", + "print(\"There are \", Int(n_orientations_0_1_11_12), \" unique orientations in which 0, 1, 11, or 12 notes can be played\")\n", + "\n", + "## 2/10\n", + "n_orientations_2_10 = (comb(12, 2) + 6)/ 12 # at 6 o clock, there are 6 different fixed points\n", + "print(\", \", Int(n_orientations_2_10), \" unique orientations in which 2/10 notes can be played\")\n", + "\n", + "## 3 / 9\n", + "n_orientations_3_9 = (comb(12, 3) + 4*2)/ 12\n", + "print(\", \", Int(n_orientations_3_9), \" unique orientations in which 3/9 notes can be played\")\n", + "\n", + "\n", + "## 4/8\n", + "n_orientations_4_8 = (comb(12, 4) + \n", + " comb(6, 2) + #rotation at half\n", + " 3*2 #at 3 and 9 o clock there are 3 possible combinations\n", + " )/ 12\n", + "print(\", \", Int(n_orientations_4_8), \" unique orientations in which 4/8 notes can be played\")\n", + "\n", + "## 5/7\n", + "n_orientations_5_7 = (comb(12, 5))/ 12 ## no way for there to be any fixed points beyond the null\n", + "\n", + "print(\", \", Int(n_orientations_5_7), \" unique orientations in which 5/7 notes can be played\")\n", + "\n", + "n_orientations_6 = (comb(12, 6) + \n", + " 2 * 2 + #2, and 10 o clock both have 2 choices\n", + " comb(4, 2) * 2 + #4 and 8 o clock rotations can distribute 1/3 the beads (2) among 4 possible slots\n", + " \n", + " comb(6, 3) # 6 o clock can distribute 3 beads among 6 possible slots\n", + " )/ 12\n", + "print(\", and \", Int(n_orientations_6), \" unique orientations in which 6 notes can be played\")\n", + "println(\"\")\n", + "println(\"In total, there are \", Int(n_orientations_0_1_11_12 * 4 + (\n", + " n_orientations_2_10 \n", + " + n_orientations_3_9 \n", + " + n_orientations_4_8\n", + " + n_orientations_5_7) * 2 + n_orientations_6), \" orientations in which any number of notes can be played \")" + ] + }, + { + "cell_type": "markdown", + "id": "03bea1f2", + "metadata": {}, + "source": [ + "My second question of \"it is likely that I have heard every possible chord which can be composed?\" was more difficult to answer. Eventually I found the [musicnet](https://zenodo.org/record/5120004#.ZEP5Mi-B3BI) dataset, which was originally designed for training musicala ML models, but which had some labels which could be used to answer my question. \n", + "\n", + "First, I'll write a function to read the labels from the musicnet dataset into one dataframe:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "6ce11307", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "read_all_notes_data" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using CSV\n", + "using DataFrames\n", + "\"\"\"\n", + "Read musicnet notes data from all songs into one dataframe\n", + "\"\"\"\n", + "function read_all_notes_data(labels_input_dir::String = \"/Volumes/SanDisk/julia_testing/frequency_chords/musicnet\", \n", + " metadata_input_dir::String = \"/Volumes/SanDisk/julia_testing/frequency_chords/musicnet_metadata.csv\")\n", + " dataframe_list = []\n", + " track_names = CSV.read(metadata_input_dir, DataFrame)\n", + " \n", + " for labels_dir = [\"train_labels\", \"test_labels\"]\n", + " current_dir = labels_input_dir * \"/\" * labels_dir\n", + " for csv_file in readdir(current_dir)\n", + " if string(csv_file)[1] == '.'\n", + " continue\n", + " end\n", + " current_df = CSV.read(current_dir * \"/\" * csv_file, DataFrame)\n", + " insertcols!(current_df, \"id\" => parse(Int, csv_file[1:4]))\n", + " push!(dataframe_list, current_df)\n", + " end\n", + " end\n", + " full_dataframe = dataframe_list[1]\n", + " for i in 2:length(dataframe_list)\n", + " full_dataframe = vcat(full_dataframe, dataframe_list[i])\n", + " end\n", + " full_dataframe = leftjoin(full_dataframe, track_names, on = :id)\n", + " return full_dataframe\n", + " \n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "94e129a7", + "metadata": {}, + "source": [ + "Our resulting dataframe has a column \"note\" which contains an integer corresponding to the note which was played at a given time. \"start_time\" and \"end_time\" tell us when the note started and stopped being played. A \"chord\" may be defined a group of notes which all start at the same time. However, it could also be defined as a group of notes that are all being played at the same time. We'll look at the frequencies that chords have been played in both of these ways. \n" + ] + }, + { + "cell_type": "markdown", + "id": "6b219744", + "metadata": {}, + "source": [ + "However, before we can easily count up the frequencies of chords from this dataframe, we need to first get note a set of integer notes into a single \"chord\". We want to make sure that the set of notes are transformed into the same chord regardless of whether the chord is transposed (i.e., a single integer is added to every note in the list) or if the chord was modulated (i.e., a note in the chord is replaced with a note in the chord from a different octave).\n", + "\n", + "I'll do this by defining a function *get_aligned_chord* that takes a set of notes and returns a given chord orientation in the same orientation every time, regardless of transpositions or modulations. I'll need a couple of other helper functions to do this." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "841ca5e7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_aligned_chord" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Take a list of notes, and get the number of \"unique\" notes, \n", + "so notes in different octaves are considered the \"same\" note. \n", + "Also, account for transpositions of the same chord by making each returned note set start at 0\n", + "\"\"\" \n", + "function get_unique_notes(note_set::Vector{Int64})\n", + " unique_notes = unique(note_set .% 12)\n", + " return sort(unique_notes .- minimum(unique_notes))\n", + "end\n", + "\n", + "\"\"\"\n", + "Get the \"gaps\" between each note and the next note in a set. \n", + "\"\"\" \n", + "function get_note_gaps(note_set::Vector{Int64})\n", + " ## Get the gaps that happen after each note\n", + " vcat(note_set[2:length(note_set)], [12]) - note_set\n", + "end\n", + "\"\"\"\n", + "Score the gaps of a note list.\n", + "\"\"\" \n", + "function gap_score(gap_list::Vector{Int64})\n", + " score = 0\n", + " for gap in gap_list\n", + " score = score * 10 + gap\n", + " end\n", + " return score\n", + "end\n", + "\"\"\"\n", + "Get an aligned chord orientation corresponding to a note set.\n", + "\n", + "This orientation will be the same even if a note set were transposed \n", + "(i.e., by adding an integer to each note), and it only conntains notes in one octave starting at zero\n", + "\"\"\" \n", + "function get_aligned_chord(note_set::Vector{Int64})\n", + " note_set_unique = get_unique_notes(note_set)\n", + " possible_orientations = [get_unique_notes((note_set_unique .+ i)) for i in 1:12]\n", + " gaps_lists = [get_note_gaps(orientation) for orientation in possible_orientations]\n", + " gap_scores = [gap_score(gap_list) for gap_list in gaps_lists]\n", + " return string(possible_orientations[argmin(gap_scores)])\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "9028887a", + "metadata": {}, + "source": [ + "And lastly, I'll define a function that creates a frequency table dataframe from a list of chords. These chord frequencies will be the thing that we will eventually use to answer our question." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5063afed", + "metadata": {}, + "outputs": [], + "source": [ + "using DataFrames, FreqTables\n", + "function freqtable_as_df(notes_list::Vector{String}, song_id::Int)\n", + " temp_freqtable = freqtable(notes_list)\n", + " output_df = DataFrame(values = names(temp_freqtable)[1], frequencies = Vector(temp_freqtable))\n", + " output_df[!,:song_id] .= song_id\n", + " return output_df\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "74198034", + "metadata": {}, + "source": [ + "Finally, we can look at the different chords that have appeared in music pieces. We will look at notes, start times, and end times for each song in our dataset, and look at chords as defined by notes with the same start time, and notes whose start/end times overlap with another note's end time." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "d5aa8bf9", + "metadata": {}, + "outputs": [ + { + "ename": "LoadError", + "evalue": "UndefVarError: notes_df not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: notes_df not defined", + "", + "Stacktrace:", + " [1] top-level scope", + " @ In[45]:6" + ] + } + ], + "source": [ + "using DataFrames\n", + "chords_df = DataFrame()\n", + "chords_overlapping_df = DataFrame()\n", + "\n", + "\n", + "for song_id in unique(notes_df.id)\n", + " ## defining a chord as a set of notes that all start at the same time\n", + " unique_chord_list = [\n", + " get_aligned_chord(notes_df[(notes_df.id .== song_id) .& (notes_df.start_time .== start_time),:note]) \n", + " for start_time in \n", + " unique(notes_df[(notes_df.id .== song_id) ,:start_time])\n", + " ]\n", + "\n", + " chords_df = vcat(chords_df, freqtable_as_df(unique_chord_list, song_id))\n", + " \n", + " unique_chord_list_overlapping = [\n", + " get_aligned_chord(\n", + " notes_df[(notes_df.id .== song_id) .& \n", + " (notes_df.start_time .<= start_time) .& \n", + " (notes_df.end_time .>= start_time),:note]\n", + " ) \n", + " for start_time in \n", + " unique(notes_df[(notes_df.id .== song_id) ,:start_time])\n", + " ]\n", + " \n", + " \n", + " ## defining a chord as a set of notes that are all played at the same time, but which may not all start at the same time\n", + "\n", + " chords_overlapping_df = vcat(chords_overlapping_df, freqtable_as_df(unique_chord_list_overlapping, song_id))\n", + " \n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "9119c136", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "transform_ids (generic function with 1 method)" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## don't put this one in the post, this just saves on time for making these graphs\n", + "function transform_ids(df)\n", + " df[!,\"old_chords\"] = df.values\n", + " df.values = [ \n", + " get_aligned_chord(\n", + " [parse(Int, replace(x, r\"\\D\"=> \"\")) for x in split(chord_str, \",\")]\n", + " )\n", + " \n", + " for chord_str in df[!,\"old_chords\"]]\n", + " return df\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "b632aac6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

25,206 rows × 12 columns (omitted printing of 7 columns)

valuesfrequenciessong_idold_chordscomposer
StringInt64Int64String31String15?
1[0, 1, 2, 6, 7]21727[0, 1, 2, 6, 7]Schubert
2[0, 1, 3, 4, 6, 8, 9]21727[0, 1, 3, 4, 6, 8, 9]Schubert
3[0, 1, 3, 4, 6, 8]61727[0, 1, 3, 4, 6, 8]Schubert
4[0, 1, 3, 4, 6, 9]41727[0, 1, 3, 4, 6, 9]Schubert
5[0, 1, 3, 4, 6]21727[0, 1, 3, 4, 6]Schubert
6[0, 1, 3, 4, 7, 8]41727[0, 1, 3, 4, 7, 8]Schubert
7[0, 1, 3, 4, 8]51727[0, 1, 3, 4, 8]Schubert
8[0, 1, 3, 5, 6, 8, 10]11727[0, 1, 3, 5, 6, 8, 10]Schubert
9[0, 1, 3, 5, 6, 8]311727[0, 1, 3, 5, 6, 8]Schubert
10[0, 1, 3, 5, 6, 9]41727[0, 1, 3, 5, 6, 9]Schubert
11[0, 1, 3, 5, 6]141727[0, 1, 3, 5, 6]Schubert
12[0, 1, 3, 5, 7, 8]21727[0, 1, 3, 5, 7, 8]Schubert
13[0, 1, 3, 5, 7, 9]21727[0, 1, 3, 5, 7, 9]Schubert
14[0, 1, 3, 5, 8]161727[0, 1, 3, 5, 8]Schubert
15[0, 1, 3, 5]161727[0, 1, 3, 5]Schubert
16[0, 1, 3, 6, 8]521727[0, 1, 3, 6, 8]Schubert
17[0, 1, 3, 6, 9]121727[0, 1, 3, 6, 9]Schubert
18[0, 1, 3, 6]81727[0, 1, 3, 6]Schubert
19[0, 1, 3, 7, 8]161727[0, 1, 3, 7, 8]Schubert
20[0, 1, 3, 7]81727[0, 1, 3, 7]Schubert
21[0, 1, 3]61727[0, 1, 3]Schubert
22[0, 1, 2, 4, 8, 9]21727[0, 1, 4, 5, 6, 8]Schubert
23[0, 1, 4, 6, 7]21727[0, 1, 4, 6, 7]Schubert
24[0, 1, 4, 6, 8]81727[0, 1, 4, 6, 8]Schubert
25[0, 1, 4, 7, 8]41727[0, 1, 4, 7, 8]Schubert
26[0, 1, 4, 7]41727[0, 1, 4, 7]Schubert
27[0, 1, 4]21727[0, 1, 4]Schubert
28[0, 1, 5]21727[0, 1, 5]Schubert
29[0, 1]41727[0, 1]Schubert
30[0, 1, 3, 5, 6, 10]41727[0, 2, 3, 5, 7, 8]Schubert
" + ], + "text/latex": [ + "\\begin{tabular}{r|cccccc}\n", + "\t& values & frequencies & song\\_id & old\\_chords & composer & \\\\\n", + "\t\\hline\n", + "\t& String & Int64 & Int64 & String31 & String15? & \\\\\n", + "\t\\hline\n", + "\t1 & [0, 1, 2, 6, 7] & 2 & 1727 & [0, 1, 2, 6, 7] & Schubert & $\\dots$ \\\\\n", + "\t2 & [0, 1, 3, 4, 6, 8, 9] & 2 & 1727 & [0, 1, 3, 4, 6, 8, 9] & Schubert & $\\dots$ \\\\\n", + "\t3 & [0, 1, 3, 4, 6, 8] & 6 & 1727 & [0, 1, 3, 4, 6, 8] & Schubert & $\\dots$ \\\\\n", + "\t4 & [0, 1, 3, 4, 6, 9] & 4 & 1727 & [0, 1, 3, 4, 6, 9] & Schubert & $\\dots$ \\\\\n", + "\t5 & [0, 1, 3, 4, 6] & 2 & 1727 & [0, 1, 3, 4, 6] & Schubert & $\\dots$ \\\\\n", + "\t6 & [0, 1, 3, 4, 7, 8] & 4 & 1727 & [0, 1, 3, 4, 7, 8] & Schubert & $\\dots$ \\\\\n", + "\t7 & [0, 1, 3, 4, 8] & 5 & 1727 & [0, 1, 3, 4, 8] & Schubert & $\\dots$ \\\\\n", + "\t8 & [0, 1, 3, 5, 6, 8, 10] & 1 & 1727 & [0, 1, 3, 5, 6, 8, 10] & Schubert & $\\dots$ \\\\\n", + "\t9 & [0, 1, 3, 5, 6, 8] & 31 & 1727 & [0, 1, 3, 5, 6, 8] & Schubert & $\\dots$ \\\\\n", + "\t10 & [0, 1, 3, 5, 6, 9] & 4 & 1727 & [0, 1, 3, 5, 6, 9] & Schubert & $\\dots$ \\\\\n", + "\t11 & [0, 1, 3, 5, 6] & 14 & 1727 & [0, 1, 3, 5, 6] & Schubert & $\\dots$ \\\\\n", + "\t12 & [0, 1, 3, 5, 7, 8] & 2 & 1727 & [0, 1, 3, 5, 7, 8] & Schubert & $\\dots$ \\\\\n", + "\t13 & [0, 1, 3, 5, 7, 9] & 2 & 1727 & [0, 1, 3, 5, 7, 9] & Schubert & $\\dots$ \\\\\n", + "\t14 & [0, 1, 3, 5, 8] & 16 & 1727 & [0, 1, 3, 5, 8] & Schubert & $\\dots$ \\\\\n", + "\t15 & [0, 1, 3, 5] & 16 & 1727 & [0, 1, 3, 5] & Schubert & $\\dots$ \\\\\n", + "\t16 & [0, 1, 3, 6, 8] & 52 & 1727 & [0, 1, 3, 6, 8] & Schubert & $\\dots$ \\\\\n", + "\t17 & [0, 1, 3, 6, 9] & 12 & 1727 & [0, 1, 3, 6, 9] & Schubert & $\\dots$ \\\\\n", + "\t18 & [0, 1, 3, 6] & 8 & 1727 & [0, 1, 3, 6] & Schubert & $\\dots$ \\\\\n", + "\t19 & [0, 1, 3, 7, 8] & 16 & 1727 & [0, 1, 3, 7, 8] & Schubert & $\\dots$ \\\\\n", + "\t20 & [0, 1, 3, 7] & 8 & 1727 & [0, 1, 3, 7] & Schubert & $\\dots$ \\\\\n", + "\t21 & [0, 1, 3] & 6 & 1727 & [0, 1, 3] & Schubert & $\\dots$ \\\\\n", + "\t22 & [0, 1, 2, 4, 8, 9] & 2 & 1727 & [0, 1, 4, 5, 6, 8] & Schubert & $\\dots$ \\\\\n", + "\t23 & [0, 1, 4, 6, 7] & 2 & 1727 & [0, 1, 4, 6, 7] & Schubert & $\\dots$ \\\\\n", + "\t24 & [0, 1, 4, 6, 8] & 8 & 1727 & [0, 1, 4, 6, 8] & Schubert & $\\dots$ \\\\\n", + "\t25 & [0, 1, 4, 7, 8] & 4 & 1727 & [0, 1, 4, 7, 8] & Schubert & $\\dots$ \\\\\n", + "\t26 & [0, 1, 4, 7] & 4 & 1727 & [0, 1, 4, 7] & Schubert & $\\dots$ \\\\\n", + "\t27 & [0, 1, 4] & 2 & 1727 & [0, 1, 4] & Schubert & $\\dots$ \\\\\n", + "\t28 & [0, 1, 5] & 2 & 1727 & [0, 1, 5] & Schubert & $\\dots$ \\\\\n", + "\t29 & [0, 1] & 4 & 1727 & [0, 1] & Schubert & $\\dots$ \\\\\n", + "\t30 & [0, 1, 3, 5, 6, 10] & 4 & 1727 & [0, 2, 3, 5, 7, 8] & Schubert & $\\dots$ \\\\\n", + "\t$\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m25206×12 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m frequencies \u001b[0m\u001b[1m song_id \u001b[0m\u001b[1m old_chords \u001b[0m\u001b[1m\u001b[0m ⋯\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m String31 \u001b[0m\u001b[90m\u001b[0m ⋯\n", + "───────┼────────────────────────────────────────────────────────────────────────\n", + " 1 │ [0, 1, 2, 6, 7] 2 1727 [0, 1, 2, 6, 7] ⋯\n", + " 2 │ [0, 1, 3, 4, 6, 8, 9] 2 1727 [0, 1, 3, 4, 6, 8, 9]\n", + " 3 │ [0, 1, 3, 4, 6, 8] 6 1727 [0, 1, 3, 4, 6, 8]\n", + " 4 │ [0, 1, 3, 4, 6, 9] 4 1727 [0, 1, 3, 4, 6, 9]\n", + " 5 │ [0, 1, 3, 4, 6] 2 1727 [0, 1, 3, 4, 6] ⋯\n", + " 6 │ [0, 1, 3, 4, 7, 8] 4 1727 [0, 1, 3, 4, 7, 8]\n", + " 7 │ [0, 1, 3, 4, 8] 5 1727 [0, 1, 3, 4, 8]\n", + " 8 │ [0, 1, 3, 5, 6, 8, 10] 1 1727 [0, 1, 3, 5, 6, 8, 10]\n", + " 9 │ [0, 1, 3, 5, 6, 8] 31 1727 [0, 1, 3, 5, 6, 8] ⋯\n", + " 10 │ [0, 1, 3, 5, 6, 9] 4 1727 [0, 1, 3, 5, 6, 9]\n", + " 11 │ [0, 1, 3, 5, 6] 14 1727 [0, 1, 3, 5, 6]\n", + " ⋮ │ ⋮ ⋮ ⋮ ⋮ ⋱\n", + " 25197 │ [0, 3, 6] 18 2628 [0, 3, 6]\n", + " 25198 │ [0, 1, 5, 8] 6 2628 [0, 3, 7, 8] ⋯\n", + " 25199 │ [0, 3, 7] 96 2628 [0, 3, 7]\n", + " 25200 │ [0, 3] 55 2628 [0, 3]\n", + " 25201 │ [0, 1, 3, 8] 33 2628 [0, 4, 5, 7]\n", + " 25202 │ [0, 1, 8] 2 2628 [0, 4, 5] ⋯\n", + " 25203 │ [0, 3, 8] 73 2628 [0, 4, 7]\n", + " 25204 │ [0, 4] 31 2628 [0, 4]\n", + " 25205 │ [0, 5] 14 2628 [0, 5]\n", + " 25206 │ [0] 32 2628 [0] ⋯\n", + "\u001b[31m 8 columns and 25185 rows omitted\u001b[0m" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using CSV\n", + "musicnet_metadata = CSV.read(\"/Volumes/SanDisk/julia_testing/frequency_chords/musicnet_metadata.csv\", DataFrame)\n", + "chords_df = leftjoin(chords_df, musicnet_metadata, on = :song_id=>:id)\n", + "chords_df_overlapping = leftjoin(chords_df_overlapping, musicnet_metadata, on = :song_id=>:id)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 247, + "id": "7b575778", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"Add 6\"" + ] + }, + "execution_count": 247, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "values_dict = Dict()\n", + "\n", + "values_dict[get_aligned_chord([0, 4, 10])] = \"Augmented Sixth (Italian)\"\n", + "values_dict[get_aligned_chord([0, 4, 6, 10])] = \"Augmented Sixth (French)\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 10])] = \"Augmented Sixth (German)\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 10, 2, 6])] = \"Augmented Eleventh\"\n", + "values_dict[get_aligned_chord([0, 4, 8, 11])] = \"Augmented Major Seventh\"\n", + "values_dict[get_aligned_chord([0, 4, 8, 10])] = \"Augmented Seventh\"\n", + "values_dict[get_aligned_chord([0, 3, 6, 11])] = \"Diminished Major Seventh\"\n", + "values_dict[get_aligned_chord([0, 3, 6, 9])] = \"Diminished Seventh\"\n", + "values_dict[get_aligned_chord([0, 4, 7])] = \"Dominant\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 10, 2, 5])] = \"Dominant Eleventh\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 10, 1])] = \"Dominant Minor Ninth\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 10, 2])] = \"Dominant Ninth\"\n", + "values_dict[get_aligned_chord([0, 3, 7])] = \"Dominant Parallel\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 10])] = \"Dominant Seventh\"\n", + "values_dict[get_aligned_chord([0, 4, 6, 10])] = \"Dominant Seventh Flat Five\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 10, 3])] = \"Dominant Seventh Sharp Nine\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 10, 2, 5, 9])] = \"Dominant Thirteenth\"\n", + "values_dict[get_aligned_chord([0, 5, 6, 7])] = \"Dream\"\n", + "values_dict[get_aligned_chord([0, 7, 9, 1, 4])] = \"Elektra\"\n", + "values_dict[get_aligned_chord([0, 8, 11, 4, 9])] = \"Farben\"\n", + "values_dict[get_aligned_chord([0, 3, 6, 10])] = \"Half Diminished Seventh Chord\"\n", + "values_dict[get_aligned_chord([0,4, 7, 10])] = \"Harmonic Seventh Chord\"\n", + "values_dict[get_aligned_chord([0,3, 6])] = \"Leading Tone Triad\"\n", + "values_dict[get_aligned_chord([0,4, 7, 11, 6])] = \"Lydian\"\n", + "values_dict[get_aligned_chord([0, 1, 5, 6, 10, 0, 3, 5])] = \"Magic\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 11, 2, 5])] = \"Major Eleventh\"\n", + "values_dict[get_aligned_chord([0, 4, 8, 11, 6])] = \"Major Seventh Sharp Eleventh\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 9])] = \"Major Sixth\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 9, 2])] = \"Major Sixth Ninth\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 11, 2])] = \"Major Ninth\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 11, 2, 6, 9])] = \"Major Thirteenth\"\n", + "values_dict[get_aligned_chord([0, 3, 7])] = \"Mediant\"\n", + "values_dict[get_aligned_chord([0, 3, 7, 10, 2, 5])] = \"Minor Eleventh\"\n", + "values_dict[get_aligned_chord([0, 3, 7, 11])] = \"Minor Major Seventh\"\n", + "values_dict[get_aligned_chord([0, 3, 7, 10, 2])] = \"Minor Ninth\"\n", + "values_dict[get_aligned_chord([0, 3, 7, 9])] = \"Minor Sixth\"\n", + "values_dict[get_aligned_chord([0, 3, 7, 9, 2])] = \"Minor Sixth Ninth\"\n", + "values_dict[get_aligned_chord([0, 3, 7, 10, 2, 5, 9])] = \"Minor Thirteenth Chord\"\n", + "values_dict[get_aligned_chord([0, 6, 10, 4, 9, 2])] = \"Mystic\"\n", + "values_dict[get_aligned_chord([1, 5, 8])] = \"Neapolitan\"\n", + "values_dict[get_aligned_chord([0, 4, 8, 10, 2])] = \"Ninth Augmented Fifth\"\n", + "values_dict[get_aligned_chord([0, 4, 6, 10, 2])] = \"Ninth Flat Fifth\"\n", + "values_dict[get_aligned_chord([1, 2, 8, 0, 3, 6, 7, 10, 11, 4, 7])] = \"Northern Lights\"\n", + "values_dict[get_aligned_chord([0, 1, 4, 5, 8, 9])] = \"Ode To Napoleon\"\n", + "values_dict[get_aligned_chord([0, 1, 4, 6, 7, 10])] = \"Petrushka\"\n", + "values_dict[get_aligned_chord([0, 7])] = \"Power Chord\"\n", + "values_dict[get_aligned_chord([0, 3, 7])] = \"Psalms Chord\"\n", + "values_dict[get_aligned_chord([0, 4, 7])] = \"Secondary Dominant\"\n", + "values_dict[get_aligned_chord([0, 3, 6])] = \"Secondary Leading Tone\"\n", + "values_dict[get_aligned_chord([0, 3, 7])] = \"Secondary Supertonic\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 9, 10])] = \"Seven Six\"\n", + "values_dict[get_aligned_chord([0, 5, 7, 10])] = \"Seventh Suspension\"\n", + "values_dict[get_aligned_chord([0, 5, 7, 10, 3])] = \"So What\"\n", + "values_dict[get_aligned_chord([0, 5, 7])] = \"Suspended\"\n", + "values_dict[get_aligned_chord([0, 4, 7])] = \"Subdominant\"\n", + "values_dict[get_aligned_chord([0, 3, 7])] = \"Subdominant Parallel\"\n", + "values_dict[get_aligned_chord([0, 4, 7])] = \"Subtonic\"\n", + "values_dict[get_aligned_chord([0, 3, 7])] = \"Supertonic\"\n", + "values_dict[get_aligned_chord([0, 4, 7])] = \"Tonic\"\n", + "values_dict[get_aligned_chord([0, 3, 7])] = \"Tonic parallel\"\n", + "values_dict[get_aligned_chord([0, 3, 6, 10])] = \"Tristan\"\n", + "values_dict[get_aligned_chord([0, 6, 7])] = \"Viennese Trichord 2\"\n", + "values_dict[get_aligned_chord([0, 1, 6])] = \"Viennese Trichord\"\n", + "values_dict[get_aligned_chord([0,3,5])] = \"Blues trichord\"\n", + "\n", + "## These ones come last because their names seem more common\n", + "values_dict[\"[0]\"] = \"Single Tone\"\n", + "values_dict[\"[0, 1]\"] = \"Minor Second\"\n", + "values_dict[\"[0, 2]\"] = \"Major Second\"\n", + "values_dict[\"[0, 3]\"] = \"Minor Third\"\n", + "values_dict[\"[0, 4]\"] = \"Major Third\"\n", + "values_dict[\"[0, 5]\"] = \"Fourth\"\n", + "values_dict[\"[0, 6]\"] = \"Diminished Fifth\"\n", + "values_dict[get_aligned_chord([0, 4, 9])] = \"Minor Triad\"\n", + "values_dict[get_aligned_chord([0, 5, 7])] = \"Suspended 4\"\n", + "values_dict[get_aligned_chord([0, 2, 7])] = \"Suspended 2\"\n", + "values_dict[get_aligned_chord([0, 4, 7])] = \"Major Triad\"\n", + "values_dict[get_aligned_chord([0, 4, 8])] = \"Diminished Triad\"\n", + "values_dict[get_aligned_chord([0, 5, 10])] = \"Augmented Triad\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 11])] = \"Major 7th\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 10])] = \"Dominant 7th\"\n", + "values_dict[get_aligned_chord([0, 3, 7, 10])] = \"Minor 7th\"\n", + "values_dict[get_aligned_chord([0, 3, 6, 9])] = \"Diminished 7th\"\n", + "values_dict[get_aligned_chord([0, 4, 7, 9])] = \"Add 6\"\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 248, + "id": "d5a13d17", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "most_common_chords (generic function with 1 method)" + ] + }, + "execution_count": 248, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function most_common_chords(input_df)\n", + " aggregated_df = combine(groupby(input_df, :values), :frequencies => sum => :sum_freq)\n", + " aggregated_df[!,\"proportion_of_chords\"] = aggregated_df.sum_freq ./ sum(aggregated_df.sum_freq)\n", + " sort!(aggregated_df, :sum_freq, rev = true)\n", + " aggregated_df[!,\"chord_name\"] = [\n", + " if chord in keys(values_dict) values_dict[chord] else chord end\n", + " for chord in aggregated_df.values\n", + " ]\n", + " \n", + " return aggregated_df\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 249, + "id": "0ff5a7a4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

10 rows × 4 columns

valuessum_freqproportion_of_chordschord_name
StringInt64Float64String
1[0, 2]61140.122899Major Second
2[0, 3]41120.0826566Minor Third
3[0]41090.0825963Single Tone
4[0, 1]38970.0783348Minor Second
5[0, 4]26430.0531278Major Third
6[0, 5]24590.0494291Fourth
7[0, 3, 8]14820.0297901Major Triad
8[0, 3, 7]12810.0257498Minor Triad
9[0, 2, 4]10690.0214883[0, 2, 4]
10[0, 2, 5]10420.0209456[0, 2, 5]
" + ], + "text/latex": [ + "\\begin{tabular}{r|cccc}\n", + "\t& values & sum\\_freq & proportion\\_of\\_chords & chord\\_name\\\\\n", + "\t\\hline\n", + "\t& String & Int64 & Float64 & String\\\\\n", + "\t\\hline\n", + "\t1 & [0, 2] & 6114 & 0.122899 & Major Second \\\\\n", + "\t2 & [0, 3] & 4112 & 0.0826566 & Minor Third \\\\\n", + "\t3 & [0] & 4109 & 0.0825963 & Single Tone \\\\\n", + "\t4 & [0, 1] & 3897 & 0.0783348 & Minor Second \\\\\n", + "\t5 & [0, 4] & 2643 & 0.0531278 & Major Third \\\\\n", + "\t6 & [0, 5] & 2459 & 0.0494291 & Fourth \\\\\n", + "\t7 & [0, 3, 8] & 1482 & 0.0297901 & Major Triad \\\\\n", + "\t8 & [0, 3, 7] & 1281 & 0.0257498 & Minor Triad \\\\\n", + "\t9 & [0, 2, 4] & 1069 & 0.0214883 & [0, 2, 4] \\\\\n", + "\t10 & [0, 2, 5] & 1042 & 0.0209456 & [0, 2, 5] \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼─────────────────────────────────────────────────────────\n", + " 1 │ [0, 2] 6114 0.122899 Major Second\n", + " 2 │ [0, 3] 4112 0.0826566 Minor Third\n", + " 3 │ [0] 4109 0.0825963 Single Tone\n", + " 4 │ [0, 1] 3897 0.0783348 Minor Second\n", + " 5 │ [0, 4] 2643 0.0531278 Major Third\n", + " 6 │ [0, 5] 2459 0.0494291 Fourth\n", + " 7 │ [0, 3, 8] 1482 0.0297901 Major Triad\n", + " 8 │ [0, 3, 7] 1281 0.0257498 Minor Triad\n", + " 9 │ [0, 2, 4] 1069 0.0214883 [0, 2, 4]\n", + " 10 │ [0, 2, 5] 1042 0.0209456 [0, 2, 5]" + ] + }, + "execution_count": 249, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aggregated_df = most_common_chords(\n", + " chords_df_overlapping[chords_df_overlapping[!,\"composer\"] .== \"Bach\",:]\n", + ")\n", + "aggregated_df[1:10,:]" + ] + }, + { + "cell_type": "code", + "execution_count": 250, + "id": "421e586c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

10 rows × 4 columns

valuessum_freqproportion_of_chordschord_name
StringInt64Float64String
1[0, 3, 8]350180.120902Major Triad
2[0]244250.0843288Single Tone
3[0, 3, 7]179090.0618319Minor Triad
4[0, 4]172920.0597017Major Third
5[0, 3]164860.0569189Minor Third
6[0, 5]133260.0460088Fourth
7[0, 2, 6, 9]129310.0446451Dominant 7th
8[0, 2]128910.044507Major Second
9[0, 1]92050.0317808Minor Second
10[0, 2, 9]76230.0263189Blues trichord
" + ], + "text/latex": [ + "\\begin{tabular}{r|cccc}\n", + "\t& values & sum\\_freq & proportion\\_of\\_chords & chord\\_name\\\\\n", + "\t\\hline\n", + "\t& String & Int64 & Float64 & String\\\\\n", + "\t\\hline\n", + "\t1 & [0, 3, 8] & 35018 & 0.120902 & Major Triad \\\\\n", + "\t2 & [0] & 24425 & 0.0843288 & Single Tone \\\\\n", + "\t3 & [0, 3, 7] & 17909 & 0.0618319 & Minor Triad \\\\\n", + "\t4 & [0, 4] & 17292 & 0.0597017 & Major Third \\\\\n", + "\t5 & [0, 3] & 16486 & 0.0569189 & Minor Third \\\\\n", + "\t6 & [0, 5] & 13326 & 0.0460088 & Fourth \\\\\n", + "\t7 & [0, 2, 6, 9] & 12931 & 0.0446451 & Dominant 7th \\\\\n", + "\t8 & [0, 2] & 12891 & 0.044507 & Major Second \\\\\n", + "\t9 & [0, 1] & 9205 & 0.0317808 & Minor Second \\\\\n", + "\t10 & [0, 2, 9] & 7623 & 0.0263189 & Blues trichord \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼──────────────────────────────────────────────────────────────\n", + " 1 │ [0, 3, 8] 35018 0.120902 Major Triad\n", + " 2 │ [0] 24425 0.0843288 Single Tone\n", + " 3 │ [0, 3, 7] 17909 0.0618319 Minor Triad\n", + " 4 │ [0, 4] 17292 0.0597017 Major Third\n", + " 5 │ [0, 3] 16486 0.0569189 Minor Third\n", + " 6 │ [0, 5] 13326 0.0460088 Fourth\n", + " 7 │ [0, 2, 6, 9] 12931 0.0446451 Dominant 7th\n", + " 8 │ [0, 2] 12891 0.044507 Major Second\n", + " 9 │ [0, 1] 9205 0.0317808 Minor Second\n", + " 10 │ [0, 2, 9] 7623 0.0263189 Blues trichord" + ] + }, + "execution_count": 250, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aggregated_df = most_common_chords(\n", + " chords_df_overlapping[chords_df_overlapping[!,\"composer\"] .== \"Beethoven\",:]\n", + ")\n", + "aggregated_df[1:10,:]" + ] + }, + { + "cell_type": "code", + "execution_count": 251, + "id": "b6bc03f8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

10 rows × 4 columns

valuessum_freqproportion_of_chordschord_name
StringInt64Float64String
1[0, 3, 8]45230.124852Major Triad
2[0]25860.0713832Single Tone
3[0, 2, 6, 9]21050.0581058Dominant 7th
4[0, 4]17890.0493831Major Third
5[0, 3]16640.0459326Minor Third
6[0, 3, 7]14960.0412952Minor Triad
7[0, 5]12080.0333453Fourth
8[0, 2]11930.0329312Major Second
9[0, 1]10100.0278798Minor Second
10[0, 1, 5, 8]7590.0209512Major 7th
" + ], + "text/latex": [ + "\\begin{tabular}{r|cccc}\n", + "\t& values & sum\\_freq & proportion\\_of\\_chords & chord\\_name\\\\\n", + "\t\\hline\n", + "\t& String & Int64 & Float64 & String\\\\\n", + "\t\\hline\n", + "\t1 & [0, 3, 8] & 4523 & 0.124852 & Major Triad \\\\\n", + "\t2 & [0] & 2586 & 0.0713832 & Single Tone \\\\\n", + "\t3 & [0, 2, 6, 9] & 2105 & 0.0581058 & Dominant 7th \\\\\n", + "\t4 & [0, 4] & 1789 & 0.0493831 & Major Third \\\\\n", + "\t5 & [0, 3] & 1664 & 0.0459326 & Minor Third \\\\\n", + "\t6 & [0, 3, 7] & 1496 & 0.0412952 & Minor Triad \\\\\n", + "\t7 & [0, 5] & 1208 & 0.0333453 & Fourth \\\\\n", + "\t8 & [0, 2] & 1193 & 0.0329312 & Major Second \\\\\n", + "\t9 & [0, 1] & 1010 & 0.0278798 & Minor Second \\\\\n", + "\t10 & [0, 1, 5, 8] & 759 & 0.0209512 & Major 7th \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼────────────────────────────────────────────────────────────\n", + " 1 │ [0, 3, 8] 4523 0.124852 Major Triad\n", + " 2 │ [0] 2586 0.0713832 Single Tone\n", + " 3 │ [0, 2, 6, 9] 2105 0.0581058 Dominant 7th\n", + " 4 │ [0, 4] 1789 0.0493831 Major Third\n", + " 5 │ [0, 3] 1664 0.0459326 Minor Third\n", + " 6 │ [0, 3, 7] 1496 0.0412952 Minor Triad\n", + " 7 │ [0, 5] 1208 0.0333453 Fourth\n", + " 8 │ [0, 2] 1193 0.0329312 Major Second\n", + " 9 │ [0, 1] 1010 0.0278798 Minor Second\n", + " 10 │ [0, 1, 5, 8] 759 0.0209512 Major 7th" + ] + }, + "execution_count": 251, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aggregated_df = most_common_chords(\n", + " chords_df_overlapping[chords_df_overlapping[!,\"composer\"] .== \"Mozart\",:]\n", + ")\n", + "aggregated_df[1:10,:]" + ] + }, + { + "cell_type": "code", + "execution_count": 252, + "id": "1b0c2eb0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Schubert\n", + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼──────────────────────────────────────────────────────────────────────\n", + " 1 │ [0] 35420 0.553965 Single Tone\n", + " 2 │ [0, 3, 8] 5512 0.0862072 Major Triad\n", + " 3 │ [0, 3] 4705 0.0735858 Minor Third\n", + " 4 │ [0, 4] 4301 0.0672672 Major Third\n", + " 5 │ [0, 3, 7] 2358 0.0368789 Minor Triad\n", + " 6 │ [0, 5] 2275 0.0355808 Fourth\n", + " 7 │ [0, 2, 6, 9] 1934 0.0302476 Dominant 7th\n", + " 8 │ [0, 2] 1152 0.0180172 Major Second\n", + " 9 │ [0, 3, 6] 859 0.0134347 Secondary Leading Tone\n", + " 10 │ [0, 2, 9] 783 0.012246 Blues trichord\n", + "Mozart\n", + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼──────────────────────────────────────────────────────────────────────\n", + " 1 │ [0] 17885 0.493693 Single Tone\n", + " 2 │ [0, 3] 3926 0.108372 Minor Third\n", + " 3 │ [0, 4] 3092 0.0853507 Major Third\n", + " 4 │ [0, 3, 8] 2897 0.079968 Major Triad\n", + " 5 │ [0, 5] 1256 0.0346703 Fourth\n", + " 6 │ [0, 3, 7] 1137 0.0313854 Minor Triad\n", + " 7 │ [0, 2, 6, 9] 817 0.0225522 Dominant 7th\n", + " 8 │ [0, 3, 6] 809 0.0223314 Secondary Leading Tone\n", + " 9 │ [0, 2] 593 0.016369 Major Second\n", + " 10 │ [0, 2, 9] 506 0.0139675 Blues trichord\n", + "Dvorak\n", + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼──────────────────────────────────────────────────────────────────────\n", + " 1 │ [0] 6203 0.44565 Single Tone\n", + " 2 │ [0, 3] 1626 0.116819 Minor Third\n", + " 3 │ [0, 3, 8] 1355 0.0973489 Major Triad\n", + " 4 │ [0, 4] 1220 0.08765 Major Third\n", + " 5 │ [0, 3, 7] 773 0.0555356 Minor Triad\n", + " 6 │ [0, 5] 664 0.0477046 Fourth\n", + " 7 │ [0, 3, 6] 278 0.0199727 Secondary Leading Tone\n", + " 8 │ [0, 2] 253 0.0181766 Major Second\n", + " 9 │ [0, 2, 9] 235 0.0168834 Blues trichord\n", + " 10 │ [0, 2, 6, 9] 209 0.0150154 Dominant 7th\n", + "Cambini\n", + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼──────────────────────────────────────────────────────────────────────\n", + " 1 │ [0] 5537 0.48337 Single Tone\n", + " 2 │ [0, 3] 1432 0.125011 Minor Third\n", + " 3 │ [0, 4] 1337 0.116718 Major Third\n", + " 4 │ [0, 3, 8] 906 0.0790921 Major Triad\n", + " 5 │ [0, 5] 497 0.0433872 Fourth\n", + " 6 │ [0, 3, 7] 347 0.0302924 Minor Triad\n", + " 7 │ [0, 2] 232 0.0202532 Major Second\n", + " 8 │ [0, 3, 6] 161 0.014055 Secondary Leading Tone\n", + " 9 │ [0, 2, 6, 9] 137 0.0119598 Dominant 7th\n", + " 10 │ [0, 2, 9] 118 0.0103012 Blues trichord\n", + "Haydn\n", + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼─────────────────────────────────────────────────────────────────────────\n", + " 1 │ [0] 1401 0.482438 Single Tone\n", + " 2 │ [0, 4] 297 0.102273 Major Third\n", + " 3 │ [0, 3, 8] 286 0.0984848 Major Triad\n", + " 4 │ [0, 3] 273 0.0940083 Minor Third\n", + " 5 │ [0, 3, 6] 118 0.0406336 Secondary Leading Tone\n", + " 6 │ [0, 3, 7] 101 0.0347796 Minor Triad\n", + " 7 │ [0, 2, 6, 9] 87 0.0299587 Dominant 7th\n", + " 8 │ [0, 5] 54 0.018595 Fourth\n", + " 9 │ [0, 2, 6] 44 0.0151515 Augmented Sixth (Italian)\n", + " 10 │ [0, 2, 9] 41 0.0141185 Blues trichord\n", + "Brahms\n", + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼──────────────────────────────────────────────────────────────────────\n", + " 1 │ [0] 24311 0.500329 Single Tone\n", + " 2 │ [0, 3] 4975 0.102387 Minor Third\n", + " 3 │ [0, 3, 8] 3901 0.080284 Major Triad\n", + " 4 │ [0, 4] 3848 0.0791932 Major Third\n", + " 5 │ [0, 5] 2273 0.0467792 Fourth\n", + " 6 │ [0, 3, 7] 1964 0.0404198 Minor Triad\n", + " 7 │ [0, 3, 6] 1075 0.0221239 Secondary Leading Tone\n", + " 8 │ [0, 2] 894 0.0183988 Major Second\n", + " 9 │ [0, 2, 6, 9] 816 0.0167936 Dominant 7th\n", + " 10 │ [0, 2, 9] 582 0.0119778 Blues trichord\n", + "Faure\n", + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼───────────────────────────────────────────────────────────────────\n", + " 1 │ [0] 6939 0.623899 Single Tone\n", + " 2 │ [0, 3] 676 0.0607804 Minor Third\n", + " 3 │ [0, 4] 668 0.0600611 Major Third\n", + " 4 │ [0, 5] 666 0.0598813 Fourth\n", + " 5 │ [0, 2] 343 0.0308398 Major Second\n", + " 6 │ [0, 3, 8] 342 0.0307499 Major Triad\n", + " 7 │ [0, 3, 7] 225 0.0202302 Minor Triad\n", + " 8 │ [0, 6] 175 0.0157346 Diminished Fifth\n", + " 9 │ [0, 1] 129 0.0115986 Minor Second\n", + " 10 │ [0, 3, 6] 112 0.0100701 Secondary Leading Tone\n", + "Ravel\n", + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼──────────────────────────────────────────────────────────────────────\n", + " 1 │ [0] 4579 0.455124 Single Tone\n", + " 2 │ [0, 5] 802 0.0797137 Fourth\n", + " 3 │ [0, 4] 750 0.0745453 Major Third\n", + " 4 │ [0, 3] 639 0.0635126 Minor Third\n", + " 5 │ [0, 3, 8] 526 0.0522811 Major Triad\n", + " 6 │ [0, 3, 7] 417 0.0414472 Minor Triad\n", + " 7 │ [0, 6] 417 0.0414472 Diminished Fifth\n", + " 8 │ [0, 2] 238 0.0236557 Major Second\n", + " 9 │ [0, 3, 6] 206 0.0204751 Secondary Leading Tone\n", + " 10 │ [0, 2, 6] 142 0.0141139 Augmented Sixth (Italian)\n", + "Bach\n", + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼───────────────────────────────────────────────────────────────────\n", + " 1 │ [0] 40158 0.807228 Single Tone\n", + " 2 │ [0, 3] 3430 0.0689475 Minor Third\n", + " 3 │ [0, 4] 2234 0.0449063 Major Third\n", + " 4 │ [0, 5] 1073 0.0215687 Fourth\n", + " 5 │ [0, 2] 535 0.0107542 Major Second\n", + " 6 │ [0, 3, 8] 486 0.00976924 Major Triad\n", + " 7 │ [0, 3, 7] 416 0.00836215 Minor Triad\n", + " 8 │ [0, 3, 6] 323 0.00649272 Secondary Leading Tone\n", + " 9 │ [0, 6] 276 0.00554796 Diminished Fifth\n", + " 10 │ [0, 1] 180 0.00361824 Minor Second\n", + "Beethoven\n", + "\u001b[1m10×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼──────────────────────────────────────────────────────────────────────\n", + " 1 │ [0] 170155 0.587471 Single Tone\n", + " 2 │ [0, 3] 25082 0.0865972 Minor Third\n", + " 3 │ [0, 4] 20964 0.0723795 Major Third\n", + " 4 │ [0, 3, 8] 17302 0.0597362 Major Triad\n", + " 5 │ [0, 5] 10996 0.0379644 Fourth\n", + " 6 │ [0, 3, 7] 7475 0.0258079 Minor Triad\n", + " 7 │ [0, 2] 5763 0.0198971 Major Second\n", + " 8 │ [0, 2, 6, 9] 4954 0.017104 Dominant 7th\n", + " 9 │ [0, 3, 6] 4766 0.0164549 Secondary Leading Tone\n", + " 10 │ [0, 2, 9] 3054 0.0105441 Blues trichord\n" + ] + } + ], + "source": [ + "chords_df_overlapping_thirds = chords_df_overlapping[\n", + " [count(\",\", notes_string) for notes_string in chords_df_overlapping.values] .== 2,:]\n", + "chords_df_overlapping_thirds = chords_df\n", + "\n", + "\n", + "for composer in unique(chords_df_overlapping[!,\"composer\"])\n", + "\n", + " aggregated_df = most_common_chords(\n", + " chords_df_overlapping_thirds[\n", + " (chords_df_overlapping_thirds[!,\"composer\"] .== composer) ,:]\n", + " )\n", + " println(composer)\n", + " println(aggregated_df[1:10,:])\n", + " \n", + "\n", + " \n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 241, + "id": "18b7bbfa", + "metadata": {}, + "outputs": [], + "source": [ + "chords_df_overlapping_thirds = chords_df_overlapping[\n", + " [count(\",\", notes_string) for notes_string in chords_df_overlapping.values] .== 2,:]\n", + "#chords_df_overlapping_thirds = chords_df_overlapping\n", + "proportion_major_list = []\n", + "proportion_minor_list = []\n", + "proportion_major_of_all_list = []\n", + "proportion_minor_of_all_list = []\n", + "composer_list = []\n", + "song_id_list = []\n", + "\n", + "for composer in unique(chords_df_overlapping[!,\"composer\"])\n", + " for song_id in unique(chords_df_overlapping[chords_df_overlapping[!,\"composer\"] .== composer, \"song_id\"])\n", + " \n", + "\n", + " aggregated_df = most_common_chords(\n", + " chords_df_overlapping_thirds[\n", + " (chords_df_overlapping_thirds[!,\"composer\"] .== composer) .&\n", + " (chords_df_overlapping_thirds[!,\"song_id\"] .== song_id),:]\n", + " )\n", + " if (\"Major Triad\" in aggregated_df.chord_name ) & (\"Minor Triad\" in aggregated_df.chord_name )\n", + "\n", + " major_triad_prop = aggregated_df[(aggregated_df.chord_name .== \"Major Triad\"), \"proportion_of_chords\"][1]\n", + " minor_triad_prop = aggregated_df[(aggregated_df.chord_name .== \"Minor Triad\"), \"proportion_of_chords\"][1]\n", + " push!(proportion_major_list, major_triad_prop / minor_triad_prop)\n", + " push!(proportion_major_of_all_list, major_triad_prop)\n", + " push!(proportion_minor_of_all_list, minor_triad_prop)\n", + " push!(proportion_minor_list, minor_triad_prop/ major_triad_prop )\n", + " \n", + " push!(composer_list, composer)\n", + " push!(song_id_list, song_id)\n", + " end\n", + " \n", + " end\n", + " \n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 229, + "id": "2bc7e7b4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

312 rows × 6 columns (omitted printing of 1 columns)

proportion_majorcomposersong_idproportion_major_of_allproportion_minor_of_all
AnyAnyAnyAnyAny
11.30992Schubert17270.3635320.277523
210.12Schubert17280.6950550.0686813
37.66216Schubert17290.5216190.0680773
42.65909Schubert17300.5358780.201527
50.568182Schubert17330.1442310.253846
69.925Schubert17340.6174180.0622084
74.68125Schubert17350.4675410.0998752
87.32609Schubert17390.4560220.0622463
91.43434Schubert17420.3636360.253521
101.28571Schubert17490.3443880.267857
112.55446Schubert17500.3146340.123171
121.3908Schubert17510.4773180.343195
131.12632Schubert17520.2301080.204301
142.05882Schubert17550.4069770.197674
152.42254Schubert17560.2492750.102899
161.57619Schubert17570.2417820.153397
170.916667Schubert17580.2900610.31643
180.920705Schubert17600.2474840.268798
193.20619Schubert17630.5157550.160862
202.93333Schubert17640.5261580.179372
214.61321Schubert17650.4604520.0998117
223.01042Schubert17660.4515620.15
231.34483Schubert17680.3183670.236735
242.68421Schubert17710.4015750.149606
250.95Schubert17720.2714290.285714
262.84091Schubert17730.5274260.185654
278.01754Schubert17750.4892930.0610278
284.0Schubert17760.6283050.157076
293.92727Schubert17770.5517240.140485
301.8Schubert17590.3284670.182482
" + ], + "text/latex": [ + "\\begin{tabular}{r|cccccc}\n", + "\t& proportion\\_major & composer & song\\_id & proportion\\_major\\_of\\_all & proportion\\_minor\\_of\\_all & \\\\\n", + "\t\\hline\n", + "\t& Any & Any & Any & Any & Any & \\\\\n", + "\t\\hline\n", + "\t1 & 1.30992 & Schubert & 1727 & 0.363532 & 0.277523 & $\\dots$ \\\\\n", + "\t2 & 10.12 & Schubert & 1728 & 0.695055 & 0.0686813 & $\\dots$ \\\\\n", + "\t3 & 7.66216 & Schubert & 1729 & 0.521619 & 0.0680773 & $\\dots$ \\\\\n", + "\t4 & 2.65909 & Schubert & 1730 & 0.535878 & 0.201527 & $\\dots$ \\\\\n", + "\t5 & 0.568182 & Schubert & 1733 & 0.144231 & 0.253846 & $\\dots$ \\\\\n", + "\t6 & 9.925 & Schubert & 1734 & 0.617418 & 0.0622084 & $\\dots$ \\\\\n", + "\t7 & 4.68125 & Schubert & 1735 & 0.467541 & 0.0998752 & $\\dots$ \\\\\n", + "\t8 & 7.32609 & Schubert & 1739 & 0.456022 & 0.0622463 & $\\dots$ \\\\\n", + "\t9 & 1.43434 & Schubert & 1742 & 0.363636 & 0.253521 & $\\dots$ \\\\\n", + "\t10 & 1.28571 & Schubert & 1749 & 0.344388 & 0.267857 & $\\dots$ \\\\\n", + "\t11 & 2.55446 & Schubert & 1750 & 0.314634 & 0.123171 & $\\dots$ \\\\\n", + "\t12 & 1.3908 & Schubert & 1751 & 0.477318 & 0.343195 & $\\dots$ \\\\\n", + "\t13 & 1.12632 & Schubert & 1752 & 0.230108 & 0.204301 & $\\dots$ \\\\\n", + "\t14 & 2.05882 & Schubert & 1755 & 0.406977 & 0.197674 & $\\dots$ \\\\\n", + "\t15 & 2.42254 & Schubert & 1756 & 0.249275 & 0.102899 & $\\dots$ \\\\\n", + "\t16 & 1.57619 & Schubert & 1757 & 0.241782 & 0.153397 & $\\dots$ \\\\\n", + "\t17 & 0.916667 & Schubert & 1758 & 0.290061 & 0.31643 & $\\dots$ \\\\\n", + "\t18 & 0.920705 & Schubert & 1760 & 0.247484 & 0.268798 & $\\dots$ \\\\\n", + "\t19 & 3.20619 & Schubert & 1763 & 0.515755 & 0.160862 & $\\dots$ \\\\\n", + "\t20 & 2.93333 & Schubert & 1764 & 0.526158 & 0.179372 & $\\dots$ \\\\\n", + "\t21 & 4.61321 & Schubert & 1765 & 0.460452 & 0.0998117 & $\\dots$ \\\\\n", + "\t22 & 3.01042 & Schubert & 1766 & 0.451562 & 0.15 & $\\dots$ \\\\\n", + "\t23 & 1.34483 & Schubert & 1768 & 0.318367 & 0.236735 & $\\dots$ \\\\\n", + "\t24 & 2.68421 & Schubert & 1771 & 0.401575 & 0.149606 & $\\dots$ \\\\\n", + "\t25 & 0.95 & Schubert & 1772 & 0.271429 & 0.285714 & $\\dots$ \\\\\n", + "\t26 & 2.84091 & Schubert & 1773 & 0.527426 & 0.185654 & $\\dots$ \\\\\n", + "\t27 & 8.01754 & Schubert & 1775 & 0.489293 & 0.0610278 & $\\dots$ \\\\\n", + "\t28 & 4.0 & Schubert & 1776 & 0.628305 & 0.157076 & $\\dots$ \\\\\n", + "\t29 & 3.92727 & Schubert & 1777 & 0.551724 & 0.140485 & $\\dots$ \\\\\n", + "\t30 & 1.8 & Schubert & 1759 & 0.328467 & 0.182482 & $\\dots$ \\\\\n", + "\t$\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m312×6 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m proportion_major \u001b[0m\u001b[1m composer \u001b[0m\u001b[1m song_id \u001b[0m\u001b[1m proportion_major_of_all \u001b[0m\u001b[1m proporti\u001b[0m ⋯\n", + "\u001b[1m \u001b[0m│\u001b[90m Any \u001b[0m\u001b[90m Any \u001b[0m\u001b[90m Any \u001b[0m\u001b[90m Any \u001b[0m\u001b[90m Any \u001b[0m ⋯\n", + "─────┼──────────────────────────────────────────────────────────────────────────\n", + " 1 │ 1.30992 Schubert 1727 0.363532 0.277523 ⋯\n", + " 2 │ 10.12 Schubert 1728 0.695055 0.068681\n", + " 3 │ 7.66216 Schubert 1729 0.521619 0.068077\n", + " 4 │ 2.65909 Schubert 1730 0.535878 0.201527\n", + " 5 │ 0.568182 Schubert 1733 0.144231 0.253846 ⋯\n", + " 6 │ 9.925 Schubert 1734 0.617418 0.062208\n", + " 7 │ 4.68125 Schubert 1735 0.467541 0.099875\n", + " 8 │ 7.32609 Schubert 1739 0.456022 0.062246\n", + " 9 │ 1.43434 Schubert 1742 0.363636 0.253521 ⋯\n", + " 10 │ 1.28571 Schubert 1749 0.344388 0.267857\n", + " 11 │ 2.55446 Schubert 1750 0.314634 0.123171\n", + " ⋮ │ ⋮ ⋮ ⋮ ⋮ ⋱\n", + " 303 │ 5.05128 Beethoven 2627 0.613707 0.121495\n", + " 304 │ 10.2927 Beethoven 2629 0.522924 0.050805 ⋯\n", + " 305 │ 3.63265 Beethoven 2632 0.502825 0.138418\n", + " 306 │ 3.9697 Beethoven 2633 0.274059 0.069037\n", + " 307 │ 4.58462 Beethoven 2677 0.473768 0.103339\n", + " 308 │ 3.15714 Beethoven 2678 0.278689 0.088272 ⋯\n", + " 309 │ 1.21569 Beethoven 2382 0.324607 0.267016\n", + " 310 │ 3.57895 Beethoven 2416 0.402367 0.112426\n", + " 311 │ 1.29167 Beethoven 2556 0.191358 0.148148\n", + " 312 │ 0.760417 Beethoven 2628 0.287402 0.377953 ⋯\n", + "\u001b[31m 2 columns and 291 rows omitted\u001b[0m" + ] + }, + "execution_count": 229, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prop_major_df = DataFrame(proportion_major = proportion_major_list, \n", + " composer = composer_list, \n", + " song_id = song_id_list,\n", + " proportion_major_of_all = proportion_major_of_all_list,\n", + " proportion_minor_of_all = proportion_minor_of_all_list,\n", + " proportion_minor = proportion_minor_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 230, + "id": "33be74db", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " composer\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Schubert\n", + " \n", + " \n", + " \n", + " \n", + " Mozart\n", + " \n", + " \n", + " \n", + " \n", + " Dvorak\n", + " \n", + " \n", + " \n", + " \n", + " Cambini\n", + " \n", + " \n", + " \n", + " \n", + " Haydn\n", + " \n", + " \n", + " \n", + " \n", + " Brahms\n", + " \n", + " \n", + " \n", + " \n", + " Faure\n", + " \n", + " \n", + " \n", + " \n", + " Ravel\n", + " \n", + " \n", + " \n", + " \n", + " Bach\n", + " \n", + " \n", + " \n", + " \n", + " Beethoven\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 5\n", + " \n", + " \n", + " \n", + " \n", + " 10\n", + " \n", + " \n", + " \n", + " \n", + " 15\n", + " \n", + " \n", + " \n", + " \n", + " 20\n", + " \n", + " \n", + " \n", + " \n", + " 25\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " proportion_major\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " composer\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Schubert\n", + " \n", + " \n", + " \n", + " \n", + " Mozart\n", + " \n", + " \n", + " \n", + " \n", + " Dvorak\n", + " \n", + " \n", + " \n", + " \n", + " Cambini\n", + " \n", + " \n", + " \n", + " \n", + " Haydn\n", + " \n", + " \n", + " \n", + " \n", + " Brahms\n", + " \n", + " \n", + " \n", + " \n", + " Faure\n", + " \n", + " \n", + " \n", + " \n", + " Ravel\n", + " \n", + " \n", + " \n", + " \n", + " Bach\n", + " \n", + " \n", + " \n", + " \n", + " Beethoven\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " h,j,k,l,arrows,drag to pan\n", + " \n", + " \n", + " \n", + " \n", + " i,o,+,-,scroll,shift-drag to zoom\n", + " \n", + " \n", + " \n", + " \n", + " r,dbl-click to reset\n", + " \n", + " \n", + " \n", + " \n", + " c for coordinates\n", + " \n", + " \n", + " \n", + " \n", + " ? for help\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " ?\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -30\n", + " \n", + " \n", + " \n", + " \n", + " -25\n", + " \n", + " \n", + " \n", + " \n", + " -20\n", + " \n", + " \n", + " \n", + " \n", + " -15\n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " \n", + " \n", + " \n", + " \n", + " -5\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 5\n", + " \n", + " \n", + " \n", + " \n", + " 10\n", + " \n", + " \n", + " \n", + " \n", + " 15\n", + " \n", + " \n", + " \n", + " \n", + " 20\n", + " \n", + " \n", + " \n", + " \n", + " 25\n", + " \n", + " \n", + " \n", + " \n", + " 30\n", + " \n", + " \n", + " \n", + " \n", + " 35\n", + " \n", + " \n", + " \n", + " \n", + " 40\n", + " \n", + " \n", + " \n", + " \n", + " 45\n", + " \n", + " \n", + " \n", + " \n", + " 50\n", + " \n", + " \n", + " \n", + " \n", + " 55\n", + " \n", + " \n", + " \n", + " \n", + " -26\n", + " \n", + " \n", + " \n", + " \n", + " -24\n", + " \n", + " \n", + " \n", + " \n", + " -22\n", + " \n", + " \n", + " \n", + " \n", + " -20\n", + " \n", + " \n", + " \n", + " \n", + " -18\n", + " \n", + " \n", + " \n", + " \n", + " -16\n", + " \n", + " \n", + " \n", + " \n", + " -14\n", + " \n", + " \n", + " \n", + " \n", + " -12\n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " \n", + " \n", + " \n", + " \n", + " -8\n", + " \n", + " \n", + " \n", + " \n", + " -6\n", + " \n", + " \n", + " \n", + " \n", + " -4\n", + " \n", + " \n", + " \n", + " \n", + " -2\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 2\n", + " \n", + " \n", + " \n", + " \n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " 6\n", + " \n", + " \n", + " \n", + " \n", + " 8\n", + " \n", + " \n", + " \n", + " \n", + " 10\n", + " \n", + " \n", + " \n", + " \n", + " 12\n", + " \n", + " \n", + " \n", + " \n", + " 14\n", + " \n", + " \n", + " \n", + " \n", + " 16\n", + " \n", + " \n", + " \n", + " \n", + " 18\n", + " \n", + " \n", + " \n", + " \n", + " 20\n", + " \n", + " \n", + " \n", + " \n", + " 22\n", + " \n", + " \n", + " \n", + " \n", + " 24\n", + " \n", + " \n", + " \n", + " \n", + " 26\n", + " \n", + " \n", + " \n", + " \n", + " 28\n", + " \n", + " \n", + " \n", + " \n", + " 30\n", + " \n", + " \n", + " \n", + " \n", + " 32\n", + " \n", + " \n", + " \n", + " \n", + " 34\n", + " \n", + " \n", + " \n", + " \n", + " 36\n", + " \n", + " \n", + " \n", + " \n", + " 38\n", + " \n", + " \n", + " \n", + " \n", + " 40\n", + " \n", + " \n", + " \n", + " \n", + " 42\n", + " \n", + " \n", + " \n", + " \n", + " 44\n", + " \n", + " \n", + " \n", + " \n", + " 46\n", + " \n", + " \n", + " \n", + " \n", + " 48\n", + " \n", + " \n", + " \n", + " \n", + " 50\n", + " \n", + " \n", + " \n", + " \n", + " -25\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 25\n", + " \n", + " \n", + " \n", + " \n", + " 50\n", + " \n", + " \n", + " \n", + " \n", + " -25\n", + " \n", + " \n", + " \n", + " \n", + " -24\n", + " \n", + " \n", + " \n", + " \n", + " -23\n", + " \n", + " \n", + " \n", + " \n", + " -22\n", + " \n", + " \n", + " \n", + " \n", + " -21\n", + " \n", + " \n", + " \n", + " \n", + " -20\n", + " \n", + " \n", + " \n", + " \n", + " -19\n", + " \n", + " \n", + " \n", + " \n", + " -18\n", + " \n", + " \n", + " \n", + " \n", + " -17\n", + " \n", + " \n", + " \n", + " \n", + " -16\n", + " \n", + " \n", + " \n", + " \n", + " -15\n", + " \n", + " \n", + " \n", + " \n", + " -14\n", + " \n", + " \n", + " \n", + " \n", + " -13\n", + " \n", + " \n", + " \n", + " \n", + " -12\n", + " \n", + " \n", + " \n", + " \n", + " -11\n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " \n", + " \n", + " \n", + " \n", + " -9\n", + " \n", + " \n", + " \n", + " \n", + " -8\n", + " \n", + " \n", + " \n", + " \n", + " -7\n", + " \n", + " \n", + " \n", + " \n", + " -6\n", + " \n", + " \n", + " \n", + " \n", + " -5\n", + " \n", + " \n", + " \n", + " \n", + " -4\n", + " \n", + " \n", + " \n", + " \n", + " -3\n", + " \n", + " \n", + " \n", + " \n", + " -2\n", + " \n", + " \n", + " \n", + " \n", + " -1\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 1\n", + " \n", + " \n", + " \n", + " \n", + " 2\n", + " \n", + " \n", + " \n", + " \n", + " 3\n", + " \n", + " \n", + " \n", + " \n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " 5\n", + " \n", + " \n", + " \n", + " \n", + " 6\n", + " \n", + " \n", + " \n", + " \n", + " 7\n", + " \n", + " \n", + " \n", + " \n", + " 8\n", + " \n", + " \n", + " \n", + " \n", + " 9\n", + " \n", + " \n", + " \n", + " \n", + " 10\n", + " \n", + " \n", + " \n", + " \n", + " 11\n", + " \n", + " \n", + " \n", + " \n", + " 12\n", + " \n", + " \n", + " \n", + " \n", + " 13\n", + " \n", + " \n", + " \n", + " \n", + " 14\n", + " \n", + " \n", + " \n", + " \n", + " 15\n", + " \n", + " \n", + " \n", + " \n", + " 16\n", + " \n", + " \n", + " \n", + " \n", + " 17\n", + " \n", + " \n", + " \n", + " \n", + " 18\n", + " \n", + " \n", + " \n", + " \n", + " 19\n", + " \n", + " \n", + " \n", + " \n", + " 20\n", + " \n", + " \n", + " \n", + " \n", + " 21\n", + " \n", + " \n", + " \n", + " \n", + " 22\n", + " \n", + " \n", + " \n", + " \n", + " 23\n", + " \n", + " \n", + " \n", + " \n", + " 24\n", + " \n", + " \n", + " \n", + " \n", + " 25\n", + " \n", + " \n", + " \n", + " \n", + " 26\n", + " \n", + " \n", + " \n", + " \n", + " 27\n", + " \n", + " \n", + " \n", + " \n", + " 28\n", + " \n", + " \n", + " \n", + " \n", + " 29\n", + " \n", + " \n", + " \n", + " \n", + " 30\n", + " \n", + " \n", + " \n", + " \n", + " 31\n", + " \n", + " \n", + " \n", + " \n", + " 32\n", + " \n", + " \n", + " \n", + " \n", + " 33\n", + " \n", + " \n", + " \n", + " \n", + " 34\n", + " \n", + " \n", + " \n", + " \n", + " 35\n", + " \n", + " \n", + " \n", + " \n", + " 36\n", + " \n", + " \n", + " \n", + " \n", + " 37\n", + " \n", + " \n", + " \n", + " \n", + " 38\n", + " \n", + " \n", + " \n", + " \n", + " 39\n", + " \n", + " \n", + " \n", + " \n", + " 40\n", + " \n", + " \n", + " \n", + " \n", + " 41\n", + " \n", + " \n", + " \n", + " \n", + " 42\n", + " \n", + " \n", + " \n", + " \n", + " 43\n", + " \n", + " \n", + " \n", + " \n", + " 44\n", + " \n", + " \n", + " \n", + " \n", + " 45\n", + " \n", + " \n", + " \n", + " \n", + " 46\n", + " \n", + " \n", + " \n", + " \n", + " 47\n", + " \n", + " \n", + " \n", + " \n", + " 48\n", + " \n", + " \n", + " \n", + " \n", + " 49\n", + " \n", + " \n", + " \n", + " \n", + " 50\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " proportion_major\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Plot(...)" + ] + }, + "execution_count": 230, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Gadfly\n", + "plot(prop_major_df, x = :composer, y = :proportion_major,\n", + " Stat.x_jitter(range=0.5),\n", + " Geom.point#, Scale.y_log10\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 231, + "id": "a2ed23e4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " composer\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Schubert\n", + " \n", + " \n", + " \n", + " \n", + " Mozart\n", + " \n", + " \n", + " \n", + " \n", + " Dvorak\n", + " \n", + " \n", + " \n", + " \n", + " Cambini\n", + " \n", + " \n", + " \n", + " \n", + " Haydn\n", + " \n", + " \n", + " \n", + " \n", + " Brahms\n", + " \n", + " \n", + " \n", + " \n", + " Faure\n", + " \n", + " \n", + " \n", + " \n", + " Ravel\n", + " \n", + " \n", + " \n", + " \n", + " Bach\n", + " \n", + " \n", + " \n", + " \n", + " Beethoven\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 1\n", + " \n", + " \n", + " \n", + " \n", + " 2\n", + " \n", + " \n", + " \n", + " \n", + " 3\n", + " \n", + " \n", + " \n", + " \n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " 5\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " proportion_minor\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " composer\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Schubert\n", + " \n", + " \n", + " \n", + " \n", + " Mozart\n", + " \n", + " \n", + " \n", + " \n", + " Dvorak\n", + " \n", + " \n", + " \n", + " \n", + " Cambini\n", + " \n", + " \n", + " \n", + " \n", + " Haydn\n", + " \n", + " \n", + " \n", + " \n", + " Brahms\n", + " \n", + " \n", + " \n", + " \n", + " Faure\n", + " \n", + " \n", + " \n", + " \n", + " Ravel\n", + " \n", + " \n", + " \n", + " \n", + " Bach\n", + " \n", + " \n", + " \n", + " \n", + " Beethoven\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " h,j,k,l,arrows,drag to pan\n", + " \n", + " \n", + " \n", + " \n", + " i,o,+,-,scroll,shift-drag to zoom\n", + " \n", + " \n", + " \n", + " \n", + " r,dbl-click to reset\n", + " \n", + " \n", + " \n", + " \n", + " c for coordinates\n", + " \n", + " \n", + " \n", + " \n", + " ? for help\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " ?\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -6\n", + " \n", + " \n", + " \n", + " \n", + " -5\n", + " \n", + " \n", + " \n", + " \n", + " -4\n", + " \n", + " \n", + " \n", + " \n", + " -3\n", + " \n", + " \n", + " \n", + " \n", + " -2\n", + " \n", + " \n", + " \n", + " \n", + " -1\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 1\n", + " \n", + " \n", + " \n", + " \n", + " 2\n", + " \n", + " \n", + " \n", + " \n", + " 3\n", + " \n", + " \n", + " \n", + " \n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " 5\n", + " \n", + " \n", + " \n", + " \n", + " 6\n", + " \n", + " \n", + " \n", + " \n", + " 7\n", + " \n", + " \n", + " \n", + " \n", + " 8\n", + " \n", + " \n", + " \n", + " \n", + " 9\n", + " \n", + " \n", + " \n", + " \n", + " 10\n", + " \n", + " \n", + " \n", + " \n", + " 11\n", + " \n", + " \n", + " \n", + " \n", + " -5.0\n", + " \n", + " \n", + " \n", + " \n", + " -4.5\n", + " \n", + " \n", + " \n", + " \n", + " -4.0\n", + " \n", + " \n", + " \n", + " \n", + " -3.5\n", + " \n", + " \n", + " \n", + " \n", + " -3.0\n", + " \n", + " \n", + " \n", + " \n", + " -2.5\n", + " \n", + " \n", + " \n", + " \n", + " -2.0\n", + " \n", + " \n", + " \n", + " \n", + " -1.5\n", + " \n", + " \n", + " \n", + " \n", + " -1.0\n", + " \n", + " \n", + " \n", + " \n", + " -0.5\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 0.5\n", + " \n", + " \n", + " \n", + " \n", + " 1.0\n", + " \n", + " \n", + " \n", + " \n", + " 1.5\n", + " \n", + " \n", + " \n", + " \n", + " 2.0\n", + " \n", + " \n", + " \n", + " \n", + " 2.5\n", + " \n", + " \n", + " \n", + " \n", + " 3.0\n", + " \n", + " \n", + " \n", + " \n", + " 3.5\n", + " \n", + " \n", + " \n", + " \n", + " 4.0\n", + " \n", + " \n", + " \n", + " \n", + " 4.5\n", + " \n", + " \n", + " \n", + " \n", + " 5.0\n", + " \n", + " \n", + " \n", + " \n", + " 5.5\n", + " \n", + " \n", + " \n", + " \n", + " 6.0\n", + " \n", + " \n", + " \n", + " \n", + " 6.5\n", + " \n", + " \n", + " \n", + " \n", + " 7.0\n", + " \n", + " \n", + " \n", + " \n", + " 7.5\n", + " \n", + " \n", + " \n", + " \n", + " 8.0\n", + " \n", + " \n", + " \n", + " \n", + " 8.5\n", + " \n", + " \n", + " \n", + " \n", + " 9.0\n", + " \n", + " \n", + " \n", + " \n", + " 9.5\n", + " \n", + " \n", + " \n", + " \n", + " 10.0\n", + " \n", + " \n", + " \n", + " \n", + " -5\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 5\n", + " \n", + " \n", + " \n", + " \n", + " 10\n", + " \n", + " \n", + " \n", + " \n", + " -5.0\n", + " \n", + " \n", + " \n", + " \n", + " -4.8\n", + " \n", + " \n", + " \n", + " \n", + " -4.6\n", + " \n", + " \n", + " \n", + " \n", + " -4.4\n", + " \n", + " \n", + " \n", + " \n", + " -4.2\n", + " \n", + " \n", + " \n", + " \n", + " -4.0\n", + " \n", + " \n", + " \n", + " \n", + " -3.8\n", + " \n", + " \n", + " \n", + " \n", + " -3.6\n", + " \n", + " \n", + " \n", + " \n", + " -3.4\n", + " \n", + " \n", + " \n", + " \n", + " -3.2\n", + " \n", + " \n", + " \n", + " \n", + " -3.0\n", + " \n", + " \n", + " \n", + " \n", + " -2.8\n", + " \n", + " \n", + " \n", + " \n", + " -2.6\n", + " \n", + " \n", + " \n", + " \n", + " -2.4\n", + " \n", + " \n", + " \n", + " \n", + " -2.2\n", + " \n", + " \n", + " \n", + " \n", + " -2.0\n", + " \n", + " \n", + " \n", + " \n", + " -1.8\n", + " \n", + " \n", + " \n", + " \n", + " -1.6\n", + " \n", + " \n", + " \n", + " \n", + " -1.4\n", + " \n", + " \n", + " \n", + " \n", + " -1.2\n", + " \n", + " \n", + " \n", + " \n", + " -1.0\n", + " \n", + " \n", + " \n", + " \n", + " -0.8\n", + " \n", + " \n", + " \n", + " \n", + " -0.6\n", + " \n", + " \n", + " \n", + " \n", + " -0.4\n", + " \n", + " \n", + " \n", + " \n", + " -0.2\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 0.2\n", + " \n", + " \n", + " \n", + " \n", + " 0.4\n", + " \n", + " \n", + " \n", + " \n", + " 0.6\n", + " \n", + " \n", + " \n", + " \n", + " 0.8\n", + " \n", + " \n", + " \n", + " \n", + " 1.0\n", + " \n", + " \n", + " \n", + " \n", + " 1.2\n", + " \n", + " \n", + " \n", + " \n", + " 1.4\n", + " \n", + " \n", + " \n", + " \n", + " 1.6\n", + " \n", + " \n", + " \n", + " \n", + " 1.8\n", + " \n", + " \n", + " \n", + " \n", + " 2.0\n", + " \n", + " \n", + " \n", + " \n", + " 2.2\n", + " \n", + " \n", + " \n", + " \n", + " 2.4\n", + " \n", + " \n", + " \n", + " \n", + " 2.6\n", + " \n", + " \n", + " \n", + " \n", + " 2.8\n", + " \n", + " \n", + " \n", + " \n", + " 3.0\n", + " \n", + " \n", + " \n", + " \n", + " 3.2\n", + " \n", + " \n", + " \n", + " \n", + " 3.4\n", + " \n", + " \n", + " \n", + " \n", + " 3.6\n", + " \n", + " \n", + " \n", + " \n", + " 3.8\n", + " \n", + " \n", + " \n", + " \n", + " 4.0\n", + " \n", + " \n", + " \n", + " \n", + " 4.2\n", + " \n", + " \n", + " \n", + " \n", + " 4.4\n", + " \n", + " \n", + " \n", + " \n", + " 4.6\n", + " \n", + " \n", + " \n", + " \n", + " 4.8\n", + " \n", + " \n", + " \n", + " \n", + " 5.0\n", + " \n", + " \n", + " \n", + " \n", + " 5.2\n", + " \n", + " \n", + " \n", + " \n", + " 5.4\n", + " \n", + " \n", + " \n", + " \n", + " 5.6\n", + " \n", + " \n", + " \n", + " \n", + " 5.8\n", + " \n", + " \n", + " \n", + " \n", + " 6.0\n", + " \n", + " \n", + " \n", + " \n", + " 6.2\n", + " \n", + " \n", + " \n", + " \n", + " 6.4\n", + " \n", + " \n", + " \n", + " \n", + " 6.6\n", + " \n", + " \n", + " \n", + " \n", + " 6.8\n", + " \n", + " \n", + " \n", + " \n", + " 7.0\n", + " \n", + " \n", + " \n", + " \n", + " 7.2\n", + " \n", + " \n", + " \n", + " \n", + " 7.4\n", + " \n", + " \n", + " \n", + " \n", + " 7.6\n", + " \n", + " \n", + " \n", + " \n", + " 7.8\n", + " \n", + " \n", + " \n", + " \n", + " 8.0\n", + " \n", + " \n", + " \n", + " \n", + " 8.2\n", + " \n", + " \n", + " \n", + " \n", + " 8.4\n", + " \n", + " \n", + " \n", + " \n", + " 8.6\n", + " \n", + " \n", + " \n", + " \n", + " 8.8\n", + " \n", + " \n", + " \n", + " \n", + " 9.0\n", + " \n", + " \n", + " \n", + " \n", + " 9.2\n", + " \n", + " \n", + " \n", + " \n", + " 9.4\n", + " \n", + " \n", + " \n", + " \n", + " 9.6\n", + " \n", + " \n", + " \n", + " \n", + " 9.8\n", + " \n", + " \n", + " \n", + " \n", + " 10.0\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " proportion_minor\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Plot(...)" + ] + }, + "execution_count": 231, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Gadfly\n", + "plot(prop_major_df, x = :composer, y = :proportion_minor,\n", + " Stat.x_jitter(range=0.5),\n", + " Geom.point#, Scale.y_log10\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 232, + "id": "44b07ea4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " Composer\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Schubert\n", + " \n", + " \n", + " \n", + " \n", + " Mozart\n", + " \n", + " \n", + " \n", + " \n", + " Dvorak\n", + " \n", + " \n", + " \n", + " \n", + " Cambini\n", + " \n", + " \n", + " \n", + " \n", + " Haydn\n", + " \n", + " \n", + " \n", + " \n", + " Brahms\n", + " \n", + " \n", + " \n", + " \n", + " Faure\n", + " \n", + " \n", + " \n", + " \n", + " Ravel\n", + " \n", + " \n", + " \n", + " \n", + " Bach\n", + " \n", + " \n", + " \n", + " \n", + " Beethoven\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -0.5\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 0.5\n", + " \n", + " \n", + " \n", + " \n", + " 1.0\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Proportion Major Triads\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Proportion of all chords in songs that are major triads\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " Composer\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Schubert\n", + " \n", + " \n", + " \n", + " \n", + " Mozart\n", + " \n", + " \n", + " \n", + " \n", + " Dvorak\n", + " \n", + " \n", + " \n", + " \n", + " Cambini\n", + " \n", + " \n", + " \n", + " \n", + " Haydn\n", + " \n", + " \n", + " \n", + " \n", + " Brahms\n", + " \n", + " \n", + " \n", + " \n", + " Faure\n", + " \n", + " \n", + " \n", + " \n", + " Ravel\n", + " \n", + " \n", + " \n", + " \n", + " Bach\n", + " \n", + " \n", + " \n", + " \n", + " Beethoven\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " h,j,k,l,arrows,drag to pan\n", + " \n", + " \n", + " \n", + " \n", + " i,o,+,-,scroll,shift-drag to zoom\n", + " \n", + " \n", + " \n", + " \n", + " r,dbl-click to reset\n", + " \n", + " \n", + " \n", + " \n", + " c for coordinates\n", + " \n", + " \n", + " \n", + " \n", + " ? for help\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " ?\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -2.5\n", + " \n", + " \n", + " \n", + " \n", + " -2.0\n", + " \n", + " \n", + " \n", + " \n", + " -1.5\n", + " \n", + " \n", + " \n", + " \n", + " -1.0\n", + " \n", + " \n", + " \n", + " \n", + " -0.5\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 0.5\n", + " \n", + " \n", + " \n", + " \n", + " 1.0\n", + " \n", + " \n", + " \n", + " \n", + " 1.5\n", + " \n", + " \n", + " \n", + " \n", + " 2.0\n", + " \n", + " \n", + " \n", + " \n", + " 2.5\n", + " \n", + " \n", + " \n", + " \n", + " 3.0\n", + " \n", + " \n", + " \n", + " \n", + " -2.0\n", + " \n", + " \n", + " \n", + " \n", + " -1.9\n", + " \n", + " \n", + " \n", + " \n", + " -1.8\n", + " \n", + " \n", + " \n", + " \n", + " -1.7\n", + " \n", + " \n", + " \n", + " \n", + " -1.6\n", + " \n", + " \n", + " \n", + " \n", + " -1.5\n", + " \n", + " \n", + " \n", + " \n", + " -1.4\n", + " \n", + " \n", + " \n", + " \n", + " -1.3\n", + " \n", + " \n", + " \n", + " \n", + " -1.2\n", + " \n", + " \n", + " \n", + " \n", + " -1.1\n", + " \n", + " \n", + " \n", + " \n", + " -1.0\n", + " \n", + " \n", + " \n", + " \n", + " -0.9\n", + " \n", + " \n", + " \n", + " \n", + " -0.8\n", + " \n", + " \n", + " \n", + " \n", + " -0.7\n", + " \n", + " \n", + " \n", + " \n", + " -0.6\n", + " \n", + " \n", + " \n", + " \n", + " -0.5\n", + " \n", + " \n", + " \n", + " \n", + " -0.4\n", + " \n", + " \n", + " \n", + " \n", + " -0.3\n", + " \n", + " \n", + " \n", + " \n", + " -0.2\n", + " \n", + " \n", + " \n", + " \n", + " -0.1\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 0.1\n", + " \n", + " \n", + " \n", + " \n", + " 0.2\n", + " \n", + " \n", + " \n", + " \n", + " 0.3\n", + " \n", + " \n", + " \n", + " \n", + " 0.4\n", + " \n", + " \n", + " \n", + " \n", + " 0.5\n", + " \n", + " \n", + " \n", + " \n", + " 0.6\n", + " \n", + " \n", + " \n", + " \n", + " 0.7\n", + " \n", + " \n", + " \n", + " \n", + " 0.8\n", + " \n", + " \n", + " \n", + " \n", + " 0.9\n", + " \n", + " \n", + " \n", + " \n", + " 1.0\n", + " \n", + " \n", + " \n", + " \n", + " 1.1\n", + " \n", + " \n", + " \n", + " \n", + " 1.2\n", + " \n", + " \n", + " \n", + " \n", + " 1.3\n", + " \n", + " \n", + " \n", + " \n", + " 1.4\n", + " \n", + " \n", + " \n", + " \n", + " 1.5\n", + " \n", + " \n", + " \n", + " \n", + " 1.6\n", + " \n", + " \n", + " \n", + " \n", + " 1.7\n", + " \n", + " \n", + " \n", + " \n", + " 1.8\n", + " \n", + " \n", + " \n", + " \n", + " 1.9\n", + " \n", + " \n", + " \n", + " \n", + " 2.0\n", + " \n", + " \n", + " \n", + " \n", + " 2.1\n", + " \n", + " \n", + " \n", + " \n", + " 2.2\n", + " \n", + " \n", + " \n", + " \n", + " 2.3\n", + " \n", + " \n", + " \n", + " \n", + " 2.4\n", + " \n", + " \n", + " \n", + " \n", + " 2.5\n", + " \n", + " \n", + " \n", + " \n", + " -2\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 2\n", + " \n", + " \n", + " \n", + " \n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " -2.00\n", + " \n", + " \n", + " \n", + " \n", + " -1.95\n", + " \n", + " \n", + " \n", + " \n", + " -1.90\n", + " \n", + " \n", + " \n", + " \n", + " -1.85\n", + " \n", + " \n", + " \n", + " \n", + " -1.80\n", + " \n", + " \n", + " \n", + " \n", + " -1.75\n", + " \n", + " \n", + " \n", + " \n", + " -1.70\n", + " \n", + " \n", + " \n", + " \n", + " -1.65\n", + " \n", + " \n", + " \n", + " \n", + " -1.60\n", + " \n", + " \n", + " \n", + " \n", + " -1.55\n", + " \n", + " \n", + " \n", + " \n", + " -1.50\n", + " \n", + " \n", + " \n", + " \n", + " -1.45\n", + " \n", + " \n", + " \n", + " \n", + " -1.40\n", + " \n", + " \n", + " \n", + " \n", + " -1.35\n", + " \n", + " \n", + " \n", + " \n", + " -1.30\n", + " \n", + " \n", + " \n", + " \n", + " -1.25\n", + " \n", + " \n", + " \n", + " \n", + " -1.20\n", + " \n", + " \n", + " \n", + " \n", + " -1.15\n", + " \n", + " \n", + " \n", + " \n", + " -1.10\n", + " \n", + " \n", + " \n", + " \n", + " -1.05\n", + " \n", + " \n", + " \n", + " \n", + " -1.00\n", + " \n", + " \n", + " \n", + " \n", + " -0.95\n", + " \n", + " \n", + " \n", + " \n", + " -0.90\n", + " \n", + " \n", + " \n", + " \n", + " -0.85\n", + " \n", + " \n", + " \n", + " \n", + " -0.80\n", + " \n", + " \n", + " \n", + " \n", + " -0.75\n", + " \n", + " \n", + " \n", + " \n", + " -0.70\n", + " \n", + " \n", + " \n", + " \n", + " -0.65\n", + " \n", + " \n", + " \n", + " \n", + " -0.60\n", + " \n", + " \n", + " \n", + " \n", + " -0.55\n", + " \n", + " \n", + " \n", + " \n", + " -0.50\n", + " \n", + " \n", + " \n", + " \n", + " -0.45\n", + " \n", + " \n", + " \n", + " \n", + " -0.40\n", + " \n", + " \n", + " \n", + " \n", + " -0.35\n", + " \n", + " \n", + " \n", + " \n", + " -0.30\n", + " \n", + " \n", + " \n", + " \n", + " -0.25\n", + " \n", + " \n", + " \n", + " \n", + " -0.20\n", + " \n", + " \n", + " \n", + " \n", + " -0.15\n", + " \n", + " \n", + " \n", + " \n", + " -0.10\n", + " \n", + " \n", + " \n", + " \n", + " -0.05\n", + " \n", + " \n", + " \n", + " \n", + " 0.00\n", + " \n", + " \n", + " \n", + " \n", + " 0.05\n", + " \n", + " \n", + " \n", + " \n", + " 0.10\n", + " \n", + " \n", + " \n", + " \n", + " 0.15\n", + " \n", + " \n", + " \n", + " \n", + " 0.20\n", + " \n", + " \n", + " \n", + " \n", + " 0.25\n", + " \n", + " \n", + " \n", + " \n", + " 0.30\n", + " \n", + " \n", + " \n", + " \n", + " 0.35\n", + " \n", + " \n", + " \n", + " \n", + " 0.40\n", + " \n", + " \n", + " \n", + " \n", + " 0.45\n", + " \n", + " \n", + " \n", + " \n", + " 0.50\n", + " \n", + " \n", + " \n", + " \n", + " 0.55\n", + " \n", + " \n", + " \n", + " \n", + " 0.60\n", + " \n", + " \n", + " \n", + " \n", + " 0.65\n", + " \n", + " \n", + " \n", + " \n", + " 0.70\n", + " \n", + " \n", + " \n", + " \n", + " 0.75\n", + " \n", + " \n", + " \n", + " \n", + " 0.80\n", + " \n", + " \n", + " \n", + " \n", + " 0.85\n", + " \n", + " \n", + " \n", + " \n", + " 0.90\n", + " \n", + " \n", + " \n", + " \n", + " 0.95\n", + " \n", + " \n", + " \n", + " \n", + " 1.00\n", + " \n", + " \n", + " \n", + " \n", + " 1.05\n", + " \n", + " \n", + " \n", + " \n", + " 1.10\n", + " \n", + " \n", + " \n", + " \n", + " 1.15\n", + " \n", + " \n", + " \n", + " \n", + " 1.20\n", + " \n", + " \n", + " \n", + " \n", + " 1.25\n", + " \n", + " \n", + " \n", + " \n", + " 1.30\n", + " \n", + " \n", + " \n", + " \n", + " 1.35\n", + " \n", + " \n", + " \n", + " \n", + " 1.40\n", + " \n", + " \n", + " \n", + " \n", + " 1.45\n", + " \n", + " \n", + " \n", + " \n", + " 1.50\n", + " \n", + " \n", + " \n", + " \n", + " 1.55\n", + " \n", + " \n", + " \n", + " \n", + " 1.60\n", + " \n", + " \n", + " \n", + " \n", + " 1.65\n", + " \n", + " \n", + " \n", + " \n", + " 1.70\n", + " \n", + " \n", + " \n", + " \n", + " 1.75\n", + " \n", + " \n", + " \n", + " \n", + " 1.80\n", + " \n", + " \n", + " \n", + " \n", + " 1.85\n", + " \n", + " \n", + " \n", + " \n", + " 1.90\n", + " \n", + " \n", + " \n", + " \n", + " 1.95\n", + " \n", + " \n", + " \n", + " \n", + " 2.00\n", + " \n", + " \n", + " \n", + " \n", + " 2.05\n", + " \n", + " \n", + " \n", + " \n", + " 2.10\n", + " \n", + " \n", + " \n", + " \n", + " 2.15\n", + " \n", + " \n", + " \n", + " \n", + " 2.20\n", + " \n", + " \n", + " \n", + " \n", + " 2.25\n", + " \n", + " \n", + " \n", + " \n", + " 2.30\n", + " \n", + " \n", + " \n", + " \n", + " 2.35\n", + " \n", + " \n", + " \n", + " \n", + " 2.40\n", + " \n", + " \n", + " \n", + " \n", + " 2.45\n", + " \n", + " \n", + " \n", + " \n", + " 2.50\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Proportion Major Triads\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Proportion of all chords in songs that are major triads\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Plot(...)" + ] + }, + "execution_count": 232, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Gadfly\n", + "plot(prop_major_df, x = :composer, y = :proportion_major_of_all,\n", + " \n", + " Guide.xlabel( \"Composer\"),\n", + " Guide.ylabel( \"Proportion Major Triads\"),\n", + " Guide.title( \"Proportion of all chords in songs that are major triads\"),\n", + " #alpha = [.3 for x in prop_major_df.composer],\n", + " #Stat.x_jitter(range=0.5),\n", + " #Geom.point,\n", + " Geom.violin, \n", + " \n", + " \n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 233, + "id": "95a30d2a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " Composer\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Schubert\n", + " \n", + " \n", + " \n", + " \n", + " Mozart\n", + " \n", + " \n", + " \n", + " \n", + " Dvorak\n", + " \n", + " \n", + " \n", + " \n", + " Cambini\n", + " \n", + " \n", + " \n", + " \n", + " Haydn\n", + " \n", + " \n", + " \n", + " \n", + " Brahms\n", + " \n", + " \n", + " \n", + " \n", + " Faure\n", + " \n", + " \n", + " \n", + " \n", + " Ravel\n", + " \n", + " \n", + " \n", + " \n", + " Bach\n", + " \n", + " \n", + " \n", + " \n", + " Beethoven\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -0.2\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 0.2\n", + " \n", + " \n", + " \n", + " \n", + " 0.4\n", + " \n", + " \n", + " \n", + " \n", + " 0.6\n", + " \n", + " \n", + " \n", + " \n", + " 0.8\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Proportion Major Triads\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Proportion of all chords in songs that are major triads\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " Composer\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Schubert\n", + " \n", + " \n", + " \n", + " \n", + " Mozart\n", + " \n", + " \n", + " \n", + " \n", + " Dvorak\n", + " \n", + " \n", + " \n", + " \n", + " Cambini\n", + " \n", + " \n", + " \n", + " \n", + " Haydn\n", + " \n", + " \n", + " \n", + " \n", + " Brahms\n", + " \n", + " \n", + " \n", + " \n", + " Faure\n", + " \n", + " \n", + " \n", + " \n", + " Ravel\n", + " \n", + " \n", + " \n", + " \n", + " Bach\n", + " \n", + " \n", + " \n", + " \n", + " Beethoven\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " h,j,k,l,arrows,drag to pan\n", + " \n", + " \n", + " \n", + " \n", + " i,o,+,-,scroll,shift-drag to zoom\n", + " \n", + " \n", + " \n", + " \n", + " r,dbl-click to reset\n", + " \n", + " \n", + " \n", + " \n", + " c for coordinates\n", + " \n", + " \n", + " \n", + " \n", + " ? for help\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " ?\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -1.4\n", + " \n", + " \n", + " \n", + " \n", + " -1.2\n", + " \n", + " \n", + " \n", + " \n", + " -1.0\n", + " \n", + " \n", + " \n", + " \n", + " -0.8\n", + " \n", + " \n", + " \n", + " \n", + " -0.6\n", + " \n", + " \n", + " \n", + " \n", + " -0.4\n", + " \n", + " \n", + " \n", + " \n", + " -0.2\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 0.2\n", + " \n", + " \n", + " \n", + " \n", + " 0.4\n", + " \n", + " \n", + " \n", + " \n", + " 0.6\n", + " \n", + " \n", + " \n", + " \n", + " 0.8\n", + " \n", + " \n", + " \n", + " \n", + " 1.0\n", + " \n", + " \n", + " \n", + " \n", + " 1.2\n", + " \n", + " \n", + " \n", + " \n", + " 1.4\n", + " \n", + " \n", + " \n", + " \n", + " 1.6\n", + " \n", + " \n", + " \n", + " \n", + " 1.8\n", + " \n", + " \n", + " \n", + " \n", + " 2.0\n", + " \n", + " \n", + " \n", + " \n", + " -1.3\n", + " \n", + " \n", + " \n", + " \n", + " -1.2\n", + " \n", + " \n", + " \n", + " \n", + " -1.1\n", + " \n", + " \n", + " \n", + " \n", + " -1.0\n", + " \n", + " \n", + " \n", + " \n", + " -0.9\n", + " \n", + " \n", + " \n", + " \n", + " -0.8\n", + " \n", + " \n", + " \n", + " \n", + " -0.7\n", + " \n", + " \n", + " \n", + " \n", + " -0.6\n", + " \n", + " \n", + " \n", + " \n", + " -0.5\n", + " \n", + " \n", + " \n", + " \n", + " -0.4\n", + " \n", + " \n", + " \n", + " \n", + " -0.3\n", + " \n", + " \n", + " \n", + " \n", + " -0.2\n", + " \n", + " \n", + " \n", + " \n", + " -0.1\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 0.1\n", + " \n", + " \n", + " \n", + " \n", + " 0.2\n", + " \n", + " \n", + " \n", + " \n", + " 0.3\n", + " \n", + " \n", + " \n", + " \n", + " 0.4\n", + " \n", + " \n", + " \n", + " \n", + " 0.5\n", + " \n", + " \n", + " \n", + " \n", + " 0.6\n", + " \n", + " \n", + " \n", + " \n", + " 0.7\n", + " \n", + " \n", + " \n", + " \n", + " 0.8\n", + " \n", + " \n", + " \n", + " \n", + " 0.9\n", + " \n", + " \n", + " \n", + " \n", + " 1.0\n", + " \n", + " \n", + " \n", + " \n", + " 1.1\n", + " \n", + " \n", + " \n", + " \n", + " 1.2\n", + " \n", + " \n", + " \n", + " \n", + " 1.3\n", + " \n", + " \n", + " \n", + " \n", + " 1.4\n", + " \n", + " \n", + " \n", + " \n", + " 1.5\n", + " \n", + " \n", + " \n", + " \n", + " 1.6\n", + " \n", + " \n", + " \n", + " \n", + " 1.7\n", + " \n", + " \n", + " \n", + " \n", + " 1.8\n", + " \n", + " \n", + " \n", + " \n", + " -2\n", + " \n", + " \n", + " \n", + " \n", + " -1\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 1\n", + " \n", + " \n", + " \n", + " \n", + " 2\n", + " \n", + " \n", + " \n", + " \n", + " -1.20\n", + " \n", + " \n", + " \n", + " \n", + " -1.15\n", + " \n", + " \n", + " \n", + " \n", + " -1.10\n", + " \n", + " \n", + " \n", + " \n", + " -1.05\n", + " \n", + " \n", + " \n", + " \n", + " -1.00\n", + " \n", + " \n", + " \n", + " \n", + " -0.95\n", + " \n", + " \n", + " \n", + " \n", + " -0.90\n", + " \n", + " \n", + " \n", + " \n", + " -0.85\n", + " \n", + " \n", + " \n", + " \n", + " -0.80\n", + " \n", + " \n", + " \n", + " \n", + " -0.75\n", + " \n", + " \n", + " \n", + " \n", + " -0.70\n", + " \n", + " \n", + " \n", + " \n", + " -0.65\n", + " \n", + " \n", + " \n", + " \n", + " -0.60\n", + " \n", + " \n", + " \n", + " \n", + " -0.55\n", + " \n", + " \n", + " \n", + " \n", + " -0.50\n", + " \n", + " \n", + " \n", + " \n", + " -0.45\n", + " \n", + " \n", + " \n", + " \n", + " -0.40\n", + " \n", + " \n", + " \n", + " \n", + " -0.35\n", + " \n", + " \n", + " \n", + " \n", + " -0.30\n", + " \n", + " \n", + " \n", + " \n", + " -0.25\n", + " \n", + " \n", + " \n", + " \n", + " -0.20\n", + " \n", + " \n", + " \n", + " \n", + " -0.15\n", + " \n", + " \n", + " \n", + " \n", + " -0.10\n", + " \n", + " \n", + " \n", + " \n", + " -0.05\n", + " \n", + " \n", + " \n", + " \n", + " 0.00\n", + " \n", + " \n", + " \n", + " \n", + " 0.05\n", + " \n", + " \n", + " \n", + " \n", + " 0.10\n", + " \n", + " \n", + " \n", + " \n", + " 0.15\n", + " \n", + " \n", + " \n", + " \n", + " 0.20\n", + " \n", + " \n", + " \n", + " \n", + " 0.25\n", + " \n", + " \n", + " \n", + " \n", + " 0.30\n", + " \n", + " \n", + " \n", + " \n", + " 0.35\n", + " \n", + " \n", + " \n", + " \n", + " 0.40\n", + " \n", + " \n", + " \n", + " \n", + " 0.45\n", + " \n", + " \n", + " \n", + " \n", + " 0.50\n", + " \n", + " \n", + " \n", + " \n", + " 0.55\n", + " \n", + " \n", + " \n", + " \n", + " 0.60\n", + " \n", + " \n", + " \n", + " \n", + " 0.65\n", + " \n", + " \n", + " \n", + " \n", + " 0.70\n", + " \n", + " \n", + " \n", + " \n", + " 0.75\n", + " \n", + " \n", + " \n", + " \n", + " 0.80\n", + " \n", + " \n", + " \n", + " \n", + " 0.85\n", + " \n", + " \n", + " \n", + " \n", + " 0.90\n", + " \n", + " \n", + " \n", + " \n", + " 0.95\n", + " \n", + " \n", + " \n", + " \n", + " 1.00\n", + " \n", + " \n", + " \n", + " \n", + " 1.05\n", + " \n", + " \n", + " \n", + " \n", + " 1.10\n", + " \n", + " \n", + " \n", + " \n", + " 1.15\n", + " \n", + " \n", + " \n", + " \n", + " 1.20\n", + " \n", + " \n", + " \n", + " \n", + " 1.25\n", + " \n", + " \n", + " \n", + " \n", + " 1.30\n", + " \n", + " \n", + " \n", + " \n", + " 1.35\n", + " \n", + " \n", + " \n", + " \n", + " 1.40\n", + " \n", + " \n", + " \n", + " \n", + " 1.45\n", + " \n", + " \n", + " \n", + " \n", + " 1.50\n", + " \n", + " \n", + " \n", + " \n", + " 1.55\n", + " \n", + " \n", + " \n", + " \n", + " 1.60\n", + " \n", + " \n", + " \n", + " \n", + " 1.65\n", + " \n", + " \n", + " \n", + " \n", + " 1.70\n", + " \n", + " \n", + " \n", + " \n", + " 1.75\n", + " \n", + " \n", + " \n", + " \n", + " 1.80\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Proportion Major Triads\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " Proportion of all chords in songs that are major triads\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Plot(...)" + ] + }, + "execution_count": 233, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Gadfly\n", + "plot(prop_major_df, x = :composer, y = :proportion_minor_of_all,\n", + " \n", + " Guide.xlabel( \"Composer\"),\n", + " Guide.ylabel( \"Proportion Major Triads\"),\n", + " Guide.title( \"Proportion of all chords in songs that are major triads\"),\n", + " #alpha = [.3 for x in prop_major_df.composer],\n", + " #Stat.x_jitter(range=0.5),\n", + " #Geom.point,\n", + " Geom.violin, \n", + " \n", + " \n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "id": "148a79e1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " proportion_major\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 2\n", + " \n", + " \n", + " \n", + " \n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " 6\n", + " \n", + " \n", + " \n", + " \n", + " 8\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 2.5\n", + " \n", + " \n", + " \n", + " \n", + " 5.0\n", + " \n", + " \n", + " \n", + " \n", + " 7.5\n", + " \n", + " \n", + " \n", + " \n", + " 10.0\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " proportion_major\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " \n", + " \n", + " \n", + " \n", + " -8\n", + " \n", + " \n", + " \n", + " \n", + " -6\n", + " \n", + " \n", + " \n", + " \n", + " -4\n", + " \n", + " \n", + " \n", + " \n", + " -2\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 2\n", + " \n", + " \n", + " \n", + " \n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " 6\n", + " \n", + " \n", + " \n", + " \n", + " 8\n", + " \n", + " \n", + " \n", + " \n", + " 10\n", + " \n", + " \n", + " \n", + " \n", + " 12\n", + " \n", + " \n", + " \n", + " \n", + " 14\n", + " \n", + " \n", + " \n", + " \n", + " 16\n", + " \n", + " \n", + " \n", + " \n", + " 18\n", + " \n", + " \n", + " \n", + " \n", + " -8.0\n", + " \n", + " \n", + " \n", + " \n", + " -7.5\n", + " \n", + " \n", + " \n", + " \n", + " -7.0\n", + " \n", + " \n", + " \n", + " \n", + " -6.5\n", + " \n", + " \n", + " \n", + " \n", + " -6.0\n", + " \n", + " \n", + " \n", + " \n", + " -5.5\n", + " \n", + " \n", + " \n", + " \n", + " -5.0\n", + " \n", + " \n", + " \n", + " \n", + " -4.5\n", + " \n", + " \n", + " \n", + " \n", + " -4.0\n", + " \n", + " \n", + " \n", + " \n", + " -3.5\n", + " \n", + " \n", + " \n", + " \n", + " -3.0\n", + " \n", + " \n", + " \n", + " \n", + " -2.5\n", + " \n", + " \n", + " \n", + " \n", + " -2.0\n", + " \n", + " \n", + " \n", + " \n", + " -1.5\n", + " \n", + " \n", + " \n", + " \n", + " -1.0\n", + " \n", + " \n", + " \n", + " \n", + " -0.5\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 0.5\n", + " \n", + " \n", + " \n", + " \n", + " 1.0\n", + " \n", + " \n", + " \n", + " \n", + " 1.5\n", + " \n", + " \n", + " \n", + " \n", + " 2.0\n", + " \n", + " \n", + " \n", + " \n", + " 2.5\n", + " \n", + " \n", + " \n", + " \n", + " 3.0\n", + " \n", + " \n", + " \n", + " \n", + " 3.5\n", + " \n", + " \n", + " \n", + " \n", + " 4.0\n", + " \n", + " \n", + " \n", + " \n", + " 4.5\n", + " \n", + " \n", + " \n", + " \n", + " 5.0\n", + " \n", + " \n", + " \n", + " \n", + " 5.5\n", + " \n", + " \n", + " \n", + " \n", + " 6.0\n", + " \n", + " \n", + " \n", + " \n", + " 6.5\n", + " \n", + " \n", + " \n", + " \n", + " 7.0\n", + " \n", + " \n", + " \n", + " \n", + " 7.5\n", + " \n", + " \n", + " \n", + " \n", + " 8.0\n", + " \n", + " \n", + " \n", + " \n", + " 8.5\n", + " \n", + " \n", + " \n", + " \n", + " 9.0\n", + " \n", + " \n", + " \n", + " \n", + " 9.5\n", + " \n", + " \n", + " \n", + " \n", + " 10.0\n", + " \n", + " \n", + " \n", + " \n", + " 10.5\n", + " \n", + " \n", + " \n", + " \n", + " 11.0\n", + " \n", + " \n", + " \n", + " \n", + " 11.5\n", + " \n", + " \n", + " \n", + " \n", + " 12.0\n", + " \n", + " \n", + " \n", + " \n", + " 12.5\n", + " \n", + " \n", + " \n", + " \n", + " 13.0\n", + " \n", + " \n", + " \n", + " \n", + " 13.5\n", + " \n", + " \n", + " \n", + " \n", + " 14.0\n", + " \n", + " \n", + " \n", + " \n", + " 14.5\n", + " \n", + " \n", + " \n", + " \n", + " 15.0\n", + " \n", + " \n", + " \n", + " \n", + " 15.5\n", + " \n", + " \n", + " \n", + " \n", + " 16.0\n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 10\n", + " \n", + " \n", + " \n", + " \n", + " 20\n", + " \n", + " \n", + " \n", + " \n", + " -8.0\n", + " \n", + " \n", + " \n", + " \n", + " -7.5\n", + " \n", + " \n", + " \n", + " \n", + " -7.0\n", + " \n", + " \n", + " \n", + " \n", + " -6.5\n", + " \n", + " \n", + " \n", + " \n", + " -6.0\n", + " \n", + " \n", + " \n", + " \n", + " -5.5\n", + " \n", + " \n", + " \n", + " \n", + " -5.0\n", + " \n", + " \n", + " \n", + " \n", + " -4.5\n", + " \n", + " \n", + " \n", + " \n", + " -4.0\n", + " \n", + " \n", + " \n", + " \n", + " -3.5\n", + " \n", + " \n", + " \n", + " \n", + " -3.0\n", + " \n", + " \n", + " \n", + " \n", + " -2.5\n", + " \n", + " \n", + " \n", + " \n", + " -2.0\n", + " \n", + " \n", + " \n", + " \n", + " -1.5\n", + " \n", + " \n", + " \n", + " \n", + " -1.0\n", + " \n", + " \n", + " \n", + " \n", + " -0.5\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 0.5\n", + " \n", + " \n", + " \n", + " \n", + " 1.0\n", + " \n", + " \n", + " \n", + " \n", + " 1.5\n", + " \n", + " \n", + " \n", + " \n", + " 2.0\n", + " \n", + " \n", + " \n", + " \n", + " 2.5\n", + " \n", + " \n", + " \n", + " \n", + " 3.0\n", + " \n", + " \n", + " \n", + " \n", + " 3.5\n", + " \n", + " \n", + " \n", + " \n", + " 4.0\n", + " \n", + " \n", + " \n", + " \n", + " 4.5\n", + " \n", + " \n", + " \n", + " \n", + " 5.0\n", + " \n", + " \n", + " \n", + " \n", + " 5.5\n", + " \n", + " \n", + " \n", + " \n", + " 6.0\n", + " \n", + " \n", + " \n", + " \n", + " 6.5\n", + " \n", + " \n", + " \n", + " \n", + " 7.0\n", + " \n", + " \n", + " \n", + " \n", + " 7.5\n", + " \n", + " \n", + " \n", + " \n", + " 8.0\n", + " \n", + " \n", + " \n", + " \n", + " 8.5\n", + " \n", + " \n", + " \n", + " \n", + " 9.0\n", + " \n", + " \n", + " \n", + " \n", + " 9.5\n", + " \n", + " \n", + " \n", + " \n", + " 10.0\n", + " \n", + " \n", + " \n", + " \n", + " 10.5\n", + " \n", + " \n", + " \n", + " \n", + " 11.0\n", + " \n", + " \n", + " \n", + " \n", + " 11.5\n", + " \n", + " \n", + " \n", + " \n", + " 12.0\n", + " \n", + " \n", + " \n", + " \n", + " 12.5\n", + " \n", + " \n", + " \n", + " \n", + " 13.0\n", + " \n", + " \n", + " \n", + " \n", + " 13.5\n", + " \n", + " \n", + " \n", + " \n", + " 14.0\n", + " \n", + " \n", + " \n", + " \n", + " 14.5\n", + " \n", + " \n", + " \n", + " \n", + " 15.0\n", + " \n", + " \n", + " \n", + " \n", + " 15.5\n", + " \n", + " \n", + " \n", + " \n", + " 16.0\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " h,j,k,l,arrows,drag to pan\n", + " \n", + " \n", + " \n", + " \n", + " i,o,+,-,scroll,shift-drag to zoom\n", + " \n", + " \n", + " \n", + " \n", + " r,dbl-click to reset\n", + " \n", + " \n", + " \n", + " \n", + " c for coordinates\n", + " \n", + " \n", + " \n", + " \n", + " ? for help\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " ?\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " -12.5\n", + " \n", + " \n", + " \n", + " \n", + " -10.0\n", + " \n", + " \n", + " \n", + " \n", + " -7.5\n", + " \n", + " \n", + " \n", + " \n", + " -5.0\n", + " \n", + " \n", + " \n", + " \n", + " -2.5\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 2.5\n", + " \n", + " \n", + " \n", + " \n", + " 5.0\n", + " \n", + " \n", + " \n", + " \n", + " 7.5\n", + " \n", + " \n", + " \n", + " \n", + " 10.0\n", + " \n", + " \n", + " \n", + " \n", + " 12.5\n", + " \n", + " \n", + " \n", + " \n", + " 15.0\n", + " \n", + " \n", + " \n", + " \n", + " 17.5\n", + " \n", + " \n", + " \n", + " \n", + " 20.0\n", + " \n", + " \n", + " \n", + " \n", + " 22.5\n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " \n", + " \n", + " \n", + " \n", + " -9\n", + " \n", + " \n", + " \n", + " \n", + " -8\n", + " \n", + " \n", + " \n", + " \n", + " -7\n", + " \n", + " \n", + " \n", + " \n", + " -6\n", + " \n", + " \n", + " \n", + " \n", + " -5\n", + " \n", + " \n", + " \n", + " \n", + " -4\n", + " \n", + " \n", + " \n", + " \n", + " -3\n", + " \n", + " \n", + " \n", + " \n", + " -2\n", + " \n", + " \n", + " \n", + " \n", + " -1\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 1\n", + " \n", + " \n", + " \n", + " \n", + " 2\n", + " \n", + " \n", + " \n", + " \n", + " 3\n", + " \n", + " \n", + " \n", + " \n", + " 4\n", + " \n", + " \n", + " \n", + " \n", + " 5\n", + " \n", + " \n", + " \n", + " \n", + " 6\n", + " \n", + " \n", + " \n", + " \n", + " 7\n", + " \n", + " \n", + " \n", + " \n", + " 8\n", + " \n", + " \n", + " \n", + " \n", + " 9\n", + " \n", + " \n", + " \n", + " \n", + " 10\n", + " \n", + " \n", + " \n", + " \n", + " 11\n", + " \n", + " \n", + " \n", + " \n", + " 12\n", + " \n", + " \n", + " \n", + " \n", + " 13\n", + " \n", + " \n", + " \n", + " \n", + " 14\n", + " \n", + " \n", + " \n", + " \n", + " 15\n", + " \n", + " \n", + " \n", + " \n", + " 16\n", + " \n", + " \n", + " \n", + " \n", + " 17\n", + " \n", + " \n", + " \n", + " \n", + " 18\n", + " \n", + " \n", + " \n", + " \n", + " 19\n", + " \n", + " \n", + " \n", + " \n", + " 20\n", + " \n", + " \n", + " \n", + " \n", + " -10\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " \n", + " \n", + " \n", + " \n", + " 10\n", + " \n", + " \n", + " \n", + " \n", + " 20\n", + " \n", + " \n", + " \n", + " \n", + " -10.0\n", + " \n", + " \n", + " \n", + " \n", + " -9.5\n", + " \n", + " \n", + " \n", + " \n", + " -9.0\n", + " \n", + " \n", + " \n", + " \n", + " -8.5\n", + " \n", + " \n", + " \n", + " \n", + " -8.0\n", + " \n", + " \n", + " \n", + " \n", + " -7.5\n", + " \n", + " \n", + " \n", + " \n", + " -7.0\n", + " \n", + " \n", + " \n", + " \n", + " -6.5\n", + " \n", + " \n", + " \n", + " \n", + " -6.0\n", + " \n", + " \n", + " \n", + " \n", + " -5.5\n", + " \n", + " \n", + " \n", + " \n", + " -5.0\n", + " \n", + " \n", + " \n", + " \n", + " -4.5\n", + " \n", + " \n", + " \n", + " \n", + " -4.0\n", + " \n", + " \n", + " \n", + " \n", + " -3.5\n", + " \n", + " \n", + " \n", + " \n", + " -3.0\n", + " \n", + " \n", + " \n", + " \n", + " -2.5\n", + " \n", + " \n", + " \n", + " \n", + " -2.0\n", + " \n", + " \n", + " \n", + " \n", + " -1.5\n", + " \n", + " \n", + " \n", + " \n", + " -1.0\n", + " \n", + " \n", + " \n", + " \n", + " -0.5\n", + " \n", + " \n", + " \n", + " \n", + " 0.0\n", + " \n", + " \n", + " \n", + " \n", + " 0.5\n", + " \n", + " \n", + " \n", + " \n", + " 1.0\n", + " \n", + " \n", + " \n", + " \n", + " 1.5\n", + " \n", + " \n", + " \n", + " \n", + " 2.0\n", + " \n", + " \n", + " \n", + " \n", + " 2.5\n", + " \n", + " \n", + " \n", + " \n", + " 3.0\n", + " \n", + " \n", + " \n", + " \n", + " 3.5\n", + " \n", + " \n", + " \n", + " \n", + " 4.0\n", + " \n", + " \n", + " \n", + " \n", + " 4.5\n", + " \n", + " \n", + " \n", + " \n", + " 5.0\n", + " \n", + " \n", + " \n", + " \n", + " 5.5\n", + " \n", + " \n", + " \n", + " \n", + " 6.0\n", + " \n", + " \n", + " \n", + " \n", + " 6.5\n", + " \n", + " \n", + " \n", + " \n", + " 7.0\n", + " \n", + " \n", + " \n", + " \n", + " 7.5\n", + " \n", + " \n", + " \n", + " \n", + " 8.0\n", + " \n", + " \n", + " \n", + " \n", + " 8.5\n", + " \n", + " \n", + " \n", + " \n", + " 9.0\n", + " \n", + " \n", + " \n", + " \n", + " 9.5\n", + " \n", + " \n", + " \n", + " \n", + " 10.0\n", + " \n", + " \n", + " \n", + " \n", + " 10.5\n", + " \n", + " \n", + " \n", + " \n", + " 11.0\n", + " \n", + " \n", + " \n", + " \n", + " 11.5\n", + " \n", + " \n", + " \n", + " \n", + " 12.0\n", + " \n", + " \n", + " \n", + " \n", + " 12.5\n", + " \n", + " \n", + " \n", + " \n", + " 13.0\n", + " \n", + " \n", + " \n", + " \n", + " 13.5\n", + " \n", + " \n", + " \n", + " \n", + " 14.0\n", + " \n", + " \n", + " \n", + " \n", + " 14.5\n", + " \n", + " \n", + " \n", + " \n", + " 15.0\n", + " \n", + " \n", + " \n", + " \n", + " 15.5\n", + " \n", + " \n", + " \n", + " \n", + " 16.0\n", + " \n", + " \n", + " \n", + " \n", + " 16.5\n", + " \n", + " \n", + " \n", + " \n", + " 17.0\n", + " \n", + " \n", + " \n", + " \n", + " 17.5\n", + " \n", + " \n", + " \n", + " \n", + " 18.0\n", + " \n", + " \n", + " \n", + " \n", + " 18.5\n", + " \n", + " \n", + " \n", + " \n", + " 19.0\n", + " \n", + " \n", + " \n", + " \n", + " 19.5\n", + " \n", + " \n", + " \n", + " \n", + " 20.0\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Plot(...)" + ] + }, + "execution_count": 163, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot(prop_major_df[prop_major_df.composer .== \"Bach\",:], x = :proportion_major, Geom.histogram)" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "id": "7aa6d380", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "22" + ] + }, + "execution_count": 167, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sum(prop_major_df[prop_major_df.composer .== \"Bach\",\"proportion_major\"] .< 1) \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "id": "38aaa303", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8×3 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m proportion_major \u001b[0m\u001b[1m composer \u001b[0m\u001b[1m song_id \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m Any \u001b[0m\u001b[90m Any \u001b[0m\u001b[90m Any \u001b[0m\n", + "─────┼──────────────────────────────────────\n", + " 1 │ 0.361111 Bach 2208\n", + " 2 │ 0.232558 Bach 2209\n", + " 3 │ 0.448276 Bach 2230\n", + " 4 │ 0.318182 Bach 2282\n", + " 5 │ 0.333333 Bach 2304\n", + " 6 │ 0.375 Bach 2305\n", + " 7 │ 0.448617 Beethoven 2390\n", + " 8 │ 0.44227 Beethoven 2393\n" + ] + } + ], + "source": [ + " println(prop_major_df[prop_major_df.proportion_major .< .5,:])" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "id": "1815477c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1×3 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m proportion_major \u001b[0m\u001b[1m composer \u001b[0m\u001b[1m song_id \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m Any \u001b[0m\u001b[90m Any \u001b[0m\u001b[90m Any \u001b[0m\n", + "─────┼──────────────────────────────────────\n", + " 1 │ 25.0 Beethoven 2538\n" + ] + }, + { + "data": { + "text/html": [ + "

44 rows × 4 columns

valuessum_freqproportion_of_chordschord_name
StringInt64Float64String
1[0, 3, 8]1250.154895Major Triad
2[0, 4]1210.149938Major Third
3[0]1180.146221Single Tone
4[0, 5]830.10285Fourth
5[0, 2]700.086741Major Second
6[0, 3]350.0433705Minor Third
7[0, 2, 6, 9]320.039653Dominant 7th
8[0, 3, 6]230.0285006[0, 3, 6]
9[0, 1, 8]220.0272615[0, 1, 8]
10[0, 1]190.023544Minor Second
11[0, 1, 2]140.0173482[0, 1, 2]
12[0, 2, 6]130.016109[0, 2, 6]
13[0, 2, 9]130.016109[0, 2, 9]
14[0, 2, 4]110.0136307[0, 2, 4]
15[0, 2, 5, 9]90.0111524Add 6
16[0, 1, 3, 5, 8]80.00991326[0, 1, 3, 5, 8]
17[0, 2, 4, 7]80.00991326[0, 2, 4, 7]
18[0, 2, 7]80.00991326Augmented Triad
19[0, 1, 3, 8, 10]70.0086741[0, 1, 3, 8, 10]
20[0, 1, 3]60.00743494[0, 1, 3]
21[0, 1, 3, 8]60.00743494[0, 1, 3, 8]
22[0, 6]60.00743494Diminished Fifth
23[0, 1, 5]50.00619579[0, 1, 5]
24[0, 2, 5]50.00619579[0, 2, 5]
25[0, 3, 7]50.00619579Minor Triad
26[0, 1, 5, 8]40.00495663Major 7th
27[0, 1, 3, 6, 8]30.00371747[0, 1, 3, 6, 8]
28[0, 1, 3, 7, 8]30.00371747[0, 1, 3, 7, 8]
29[0, 1, 4]30.00371747[0, 1, 4]
30[0, 1, 5, 10]30.00371747[0, 1, 5, 10]
" + ], + "text/latex": [ + "\\begin{tabular}{r|cccc}\n", + "\t& values & sum\\_freq & proportion\\_of\\_chords & chord\\_name\\\\\n", + "\t\\hline\n", + "\t& String & Int64 & Float64 & String\\\\\n", + "\t\\hline\n", + "\t1 & [0, 3, 8] & 125 & 0.154895 & Major Triad \\\\\n", + "\t2 & [0, 4] & 121 & 0.149938 & Major Third \\\\\n", + "\t3 & [0] & 118 & 0.146221 & Single Tone \\\\\n", + "\t4 & [0, 5] & 83 & 0.10285 & Fourth \\\\\n", + "\t5 & [0, 2] & 70 & 0.086741 & Major Second \\\\\n", + "\t6 & [0, 3] & 35 & 0.0433705 & Minor Third \\\\\n", + "\t7 & [0, 2, 6, 9] & 32 & 0.039653 & Dominant 7th \\\\\n", + "\t8 & [0, 3, 6] & 23 & 0.0285006 & [0, 3, 6] \\\\\n", + "\t9 & [0, 1, 8] & 22 & 0.0272615 & [0, 1, 8] \\\\\n", + "\t10 & [0, 1] & 19 & 0.023544 & Minor Second \\\\\n", + "\t11 & [0, 1, 2] & 14 & 0.0173482 & [0, 1, 2] \\\\\n", + "\t12 & [0, 2, 6] & 13 & 0.016109 & [0, 2, 6] \\\\\n", + "\t13 & [0, 2, 9] & 13 & 0.016109 & [0, 2, 9] \\\\\n", + "\t14 & [0, 2, 4] & 11 & 0.0136307 & [0, 2, 4] \\\\\n", + "\t15 & [0, 2, 5, 9] & 9 & 0.0111524 & Add 6 \\\\\n", + "\t16 & [0, 1, 3, 5, 8] & 8 & 0.00991326 & [0, 1, 3, 5, 8] \\\\\n", + "\t17 & [0, 2, 4, 7] & 8 & 0.00991326 & [0, 2, 4, 7] \\\\\n", + "\t18 & [0, 2, 7] & 8 & 0.00991326 & Augmented Triad \\\\\n", + "\t19 & [0, 1, 3, 8, 10] & 7 & 0.0086741 & [0, 1, 3, 8, 10] \\\\\n", + "\t20 & [0, 1, 3] & 6 & 0.00743494 & [0, 1, 3] \\\\\n", + "\t21 & [0, 1, 3, 8] & 6 & 0.00743494 & [0, 1, 3, 8] \\\\\n", + "\t22 & [0, 6] & 6 & 0.00743494 & Diminished Fifth \\\\\n", + "\t23 & [0, 1, 5] & 5 & 0.00619579 & [0, 1, 5] \\\\\n", + "\t24 & [0, 2, 5] & 5 & 0.00619579 & [0, 2, 5] \\\\\n", + "\t25 & [0, 3, 7] & 5 & 0.00619579 & Minor Triad \\\\\n", + "\t26 & [0, 1, 5, 8] & 4 & 0.00495663 & Major 7th \\\\\n", + "\t27 & [0, 1, 3, 6, 8] & 3 & 0.00371747 & [0, 1, 3, 6, 8] \\\\\n", + "\t28 & [0, 1, 3, 7, 8] & 3 & 0.00371747 & [0, 1, 3, 7, 8] \\\\\n", + "\t29 & [0, 1, 4] & 3 & 0.00371747 & [0, 1, 4] \\\\\n", + "\t30 & [0, 1, 5, 10] & 3 & 0.00371747 & [0, 1, 5, 10] \\\\\n", + "\t$\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m44×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\u001b[1m proportion_of_chords \u001b[0m\u001b[1m chord_name \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m String \u001b[0m\n", + "─────┼────────────────────────────────────────────────────────────────────────\n", + " 1 │ [0, 3, 8] 125 0.154895 Major Triad\n", + " 2 │ [0, 4] 121 0.149938 Major Third\n", + " 3 │ [0] 118 0.146221 Single Tone\n", + " 4 │ [0, 5] 83 0.10285 Fourth\n", + " 5 │ [0, 2] 70 0.086741 Major Second\n", + " 6 │ [0, 3] 35 0.0433705 Minor Third\n", + " 7 │ [0, 2, 6, 9] 32 0.039653 Dominant 7th\n", + " 8 │ [0, 3, 6] 23 0.0285006 [0, 3, 6]\n", + " 9 │ [0, 1, 8] 22 0.0272615 [0, 1, 8]\n", + " 10 │ [0, 1] 19 0.023544 Minor Second\n", + " 11 │ [0, 1, 2] 14 0.0173482 [0, 1, 2]\n", + " ⋮ │ ⋮ ⋮ ⋮ ⋮\n", + " 35 │ [0, 1, 9] 2 0.00247831 [0, 1, 9]\n", + " 36 │ [0, 1, 3, 5, 7, 8] 1 0.00123916 [0, 1, 3, 5, 7, 8]\n", + " 37 │ [0, 1, 3, 6] 1 0.00123916 [0, 1, 3, 6]\n", + " 38 │ [0, 1, 3, 4, 8, 9] 1 0.00123916 [0, 1, 3, 4, 8, 9]\n", + " 39 │ [0, 1, 5, 6] 1 0.00123916 [0, 1, 5, 6]\n", + " 40 │ [0, 1, 2, 10] 1 0.00123916 [0, 1, 2, 10]\n", + " 41 │ [0, 1, 10] 1 0.00123916 [0, 1, 10]\n", + " 42 │ [0, 1, 6, 8, 10] 1 0.00123916 [0, 1, 6, 8, 10]\n", + " 43 │ [0, 2, 5, 7] 1 0.00123916 [0, 2, 5, 7]\n", + " 44 │ [0, 2, 4, 9] 1 0.00123916 [0, 2, 4, 9]\n", + "\u001b[31m 23 rows omitted\u001b[0m" + ] + }, + "execution_count": 173, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + " println(prop_major_df[prop_major_df.proportion_major .> 20,:])\n", + "most_common_chords(\n", + " chords_df_overlapping_thirds[\n", + " (chords_df_overlapping_thirds[!,\"song_id\"] .== prop_major_df[prop_major_df.proportion_major .> 20,:song_id]),:]\n", + " )\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "id": "6a2990df", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "26" + ] + }, + "execution_count": 168, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sum(prop_major_df[prop_major_df.composer .== \"Bach\",\"proportion_major\"] .> 1) " + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "7e27ca34", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10-element Vector{Union{Missing, String15}}:\n", + " \"Schubert\"\n", + " \"Mozart\"\n", + " \"Dvorak\"\n", + " \"Cambini\"\n", + " \"Haydn\"\n", + " \"Brahms\"\n", + " \"Faure\"\n", + " \"Ravel\"\n", + " \"Bach\"\n", + " \"Beethoven\"" + ] + }, + "execution_count": 119, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unique(chords_df_overlapping[!,\"composer\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "ce1b130a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

119 rows × 2 columns

valuessum_freq
StringInt64
1[0]312588
2[0, 3]46764
3[0, 4]38711
4[0, 3, 8]33513
5[0, 5]20556
6[0, 3, 7]15213
7[0, 2]10031
8[0, 2, 6, 9]9106
9[0, 3, 6]8707
10[0, 2, 9]5597
11[0, 6]5475
12[0, 2, 6]4264
13[0, 1]3178
14[0, 2, 5]2705
15[0, 3, 6, 9]2220
16[0, 2, 7]1760
17[0, 2, 5, 9]1344
18[0, 2, 4]1068
19[0, 2, 5, 8]1024
20[0, 2, 8]940
21[0, 1, 5]913
22[0, 2, 5, 7]877
23[0, 2, 4, 7]835
24[0, 1, 8]688
25[0, 1, 5, 8]640
26[0, 4, 8]636
27[0, 1, 3]619
28[0, 1, 10]523
29[0, 1, 3, 8]434
30[0, 2, 4, 9]425
" + ], + "text/latex": [ + "\\begin{tabular}{r|cc}\n", + "\t& values & sum\\_freq\\\\\n", + "\t\\hline\n", + "\t& String & Int64\\\\\n", + "\t\\hline\n", + "\t1 & [0] & 312588 \\\\\n", + "\t2 & [0, 3] & 46764 \\\\\n", + "\t3 & [0, 4] & 38711 \\\\\n", + "\t4 & [0, 3, 8] & 33513 \\\\\n", + "\t5 & [0, 5] & 20556 \\\\\n", + "\t6 & [0, 3, 7] & 15213 \\\\\n", + "\t7 & [0, 2] & 10031 \\\\\n", + "\t8 & [0, 2, 6, 9] & 9106 \\\\\n", + "\t9 & [0, 3, 6] & 8707 \\\\\n", + "\t10 & [0, 2, 9] & 5597 \\\\\n", + "\t11 & [0, 6] & 5475 \\\\\n", + "\t12 & [0, 2, 6] & 4264 \\\\\n", + "\t13 & [0, 1] & 3178 \\\\\n", + "\t14 & [0, 2, 5] & 2705 \\\\\n", + "\t15 & [0, 3, 6, 9] & 2220 \\\\\n", + "\t16 & [0, 2, 7] & 1760 \\\\\n", + "\t17 & [0, 2, 5, 9] & 1344 \\\\\n", + "\t18 & [0, 2, 4] & 1068 \\\\\n", + "\t19 & [0, 2, 5, 8] & 1024 \\\\\n", + "\t20 & [0, 2, 8] & 940 \\\\\n", + "\t21 & [0, 1, 5] & 913 \\\\\n", + "\t22 & [0, 2, 5, 7] & 877 \\\\\n", + "\t23 & [0, 2, 4, 7] & 835 \\\\\n", + "\t24 & [0, 1, 8] & 688 \\\\\n", + "\t25 & [0, 1, 5, 8] & 640 \\\\\n", + "\t26 & [0, 4, 8] & 636 \\\\\n", + "\t27 & [0, 1, 3] & 619 \\\\\n", + "\t28 & [0, 1, 10] & 523 \\\\\n", + "\t29 & [0, 1, 3, 8] & 434 \\\\\n", + "\t30 & [0, 2, 4, 9] & 425 \\\\\n", + "\t$\\dots$ & $\\dots$ & $\\dots$ \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m119×2 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m sum_freq \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\n", + "─────┼───────────────────────────────\n", + " 1 │ [0] 312588\n", + " 2 │ [0, 3] 46764\n", + " 3 │ [0, 4] 38711\n", + " 4 │ [0, 3, 8] 33513\n", + " 5 │ [0, 5] 20556\n", + " 6 │ [0, 3, 7] 15213\n", + " 7 │ [0, 2] 10031\n", + " 8 │ [0, 2, 6, 9] 9106\n", + " 9 │ [0, 3, 6] 8707\n", + " 10 │ [0, 2, 9] 5597\n", + " 11 │ [0, 6] 5475\n", + " ⋮ │ ⋮ ⋮\n", + " 110 │ [0, 1, 2, 8] 1\n", + " 111 │ [0, 1, 2, 5, 8, 10] 1\n", + " 112 │ [0, 1, 3, 5, 7, 10] 1\n", + " 113 │ [0, 1, 5, 6, 10] 1\n", + " 114 │ [0, 1, 2, 5, 10] 1\n", + " 115 │ [0, 1, 2, 5, 7] 1\n", + " 116 │ [0, 1, 3, 4, 7, 10] 1\n", + " 117 │ [0, 1, 3, 5, 8, 9] 1\n", + " 118 │ [0, 1, 3, 4, 7] 1\n", + " 119 │ [0, 1, 2, 9, 10] 1\n", + "\u001b[31m 98 rows omitted\u001b[0m" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "most_common_chords(chords_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "134a22a0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

8,746 rows × 5 columns

valuesfrequenciessong_idnum_notesold_chords
StringInt64Int64Int64String31
1[0, 1, 3, 5]617274[0, 1, 3, 5]
2[0, 1, 3, 6, 8]2217275[0, 1, 3, 6, 8]
3[0, 1, 3, 6, 9]917275[0, 1, 3, 6, 9]
4[0, 1, 3, 6]617274[0, 1, 3, 6]
5[0, 1, 3, 7]217274[0, 1, 3, 7]
6[0, 1, 4, 7]217274[0, 1, 4, 7]
7[0, 1, 5]217273[0, 1, 5]
8[0, 1]117272[0, 1]
9[0, 1, 4, 10]617274[0, 2, 3, 6]
10[0, 1, 5, 10]117274[0, 2, 3, 7]
11[0, 1, 10]217273[0, 2, 3]
12[0, 2, 4, 6, 9]1017275[0, 2, 4, 6, 9]
13[0, 2, 4, 7, 9]117275[0, 2, 4, 7, 9]
14[0, 2, 4, 7]417274[0, 2, 4, 7]
15[0, 2, 4, 8]1017274[0, 2, 4, 8]
16[0, 2, 5, 7]1617274[0, 2, 5, 7]
17[0, 2, 5, 8]2017274[0, 2, 5, 8]
18[0, 2, 5]1417273[0, 2, 5]
19[0, 1, 6, 8]1017274[0, 2, 6, 7]
20[0, 2, 6]2617273[0, 2, 6]
21[0, 2, 7]217273[0, 2, 7]
22[0, 2]2617272[0, 2]
23[0, 1, 3, 9]217274[0, 3, 4, 6]
24[0, 1, 5, 9]517274[0, 3, 4, 8]
25[0, 1, 3, 7, 10]1117275[0, 3, 5, 6, 8]
26[0, 1, 7, 10]2517274[0, 3, 5, 6]
27[0, 2, 4, 9]417274[0, 3, 5, 7]
28[0, 2, 5, 9]817274[0, 3, 5, 8]
29[0, 2, 9]7817273[0, 3, 5]
30[0, 1, 6, 9]1217274[0, 3, 6, 7]
" + ], + "text/latex": [ + "\\begin{tabular}{r|ccccc}\n", + "\t& values & frequencies & song\\_id & num\\_notes & old\\_chords\\\\\n", + "\t\\hline\n", + "\t& String & Int64 & Int64 & Int64 & String31\\\\\n", + "\t\\hline\n", + "\t1 & [0, 1, 3, 5] & 6 & 1727 & 4 & [0, 1, 3, 5] \\\\\n", + "\t2 & [0, 1, 3, 6, 8] & 22 & 1727 & 5 & [0, 1, 3, 6, 8] \\\\\n", + "\t3 & [0, 1, 3, 6, 9] & 9 & 1727 & 5 & [0, 1, 3, 6, 9] \\\\\n", + "\t4 & [0, 1, 3, 6] & 6 & 1727 & 4 & [0, 1, 3, 6] \\\\\n", + "\t5 & [0, 1, 3, 7] & 2 & 1727 & 4 & [0, 1, 3, 7] \\\\\n", + "\t6 & [0, 1, 4, 7] & 2 & 1727 & 4 & [0, 1, 4, 7] \\\\\n", + "\t7 & [0, 1, 5] & 2 & 1727 & 3 & [0, 1, 5] \\\\\n", + "\t8 & [0, 1] & 1 & 1727 & 2 & [0, 1] \\\\\n", + "\t9 & [0, 1, 4, 10] & 6 & 1727 & 4 & [0, 2, 3, 6] \\\\\n", + "\t10 & [0, 1, 5, 10] & 1 & 1727 & 4 & [0, 2, 3, 7] \\\\\n", + "\t11 & [0, 1, 10] & 2 & 1727 & 3 & [0, 2, 3] \\\\\n", + "\t12 & [0, 2, 4, 6, 9] & 10 & 1727 & 5 & [0, 2, 4, 6, 9] \\\\\n", + "\t13 & [0, 2, 4, 7, 9] & 1 & 1727 & 5 & [0, 2, 4, 7, 9] \\\\\n", + "\t14 & [0, 2, 4, 7] & 4 & 1727 & 4 & [0, 2, 4, 7] \\\\\n", + "\t15 & [0, 2, 4, 8] & 10 & 1727 & 4 & [0, 2, 4, 8] \\\\\n", + "\t16 & [0, 2, 5, 7] & 16 & 1727 & 4 & [0, 2, 5, 7] \\\\\n", + "\t17 & [0, 2, 5, 8] & 20 & 1727 & 4 & [0, 2, 5, 8] \\\\\n", + "\t18 & [0, 2, 5] & 14 & 1727 & 3 & [0, 2, 5] \\\\\n", + "\t19 & [0, 1, 6, 8] & 10 & 1727 & 4 & [0, 2, 6, 7] \\\\\n", + "\t20 & [0, 2, 6] & 26 & 1727 & 3 & [0, 2, 6] \\\\\n", + "\t21 & [0, 2, 7] & 2 & 1727 & 3 & [0, 2, 7] \\\\\n", + "\t22 & [0, 2] & 26 & 1727 & 2 & [0, 2] \\\\\n", + "\t23 & [0, 1, 3, 9] & 2 & 1727 & 4 & [0, 3, 4, 6] \\\\\n", + "\t24 & [0, 1, 5, 9] & 5 & 1727 & 4 & [0, 3, 4, 8] \\\\\n", + "\t25 & [0, 1, 3, 7, 10] & 11 & 1727 & 5 & [0, 3, 5, 6, 8] \\\\\n", + "\t26 & [0, 1, 7, 10] & 25 & 1727 & 4 & [0, 3, 5, 6] \\\\\n", + "\t27 & [0, 2, 4, 9] & 4 & 1727 & 4 & [0, 3, 5, 7] \\\\\n", + "\t28 & [0, 2, 5, 9] & 8 & 1727 & 4 & [0, 3, 5, 8] \\\\\n", + "\t29 & [0, 2, 9] & 78 & 1727 & 3 & [0, 3, 5] \\\\\n", + "\t30 & [0, 1, 6, 9] & 12 & 1727 & 4 & [0, 3, 6, 7] \\\\\n", + "\t$\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m8746×5 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m values \u001b[0m\u001b[1m frequencies \u001b[0m\u001b[1m song_id \u001b[0m\u001b[1m num_notes \u001b[0m\u001b[1m old_chords \u001b[0m\n", + "\u001b[1m \u001b[0m│\u001b[90m String \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m String31 \u001b[0m\n", + "──────┼───────────────────────────────────────────────────────────────────\n", + " 1 │ [0, 1, 3, 5] 6 1727 4 [0, 1, 3, 5]\n", + " 2 │ [0, 1, 3, 6, 8] 22 1727 5 [0, 1, 3, 6, 8]\n", + " 3 │ [0, 1, 3, 6, 9] 9 1727 5 [0, 1, 3, 6, 9]\n", + " 4 │ [0, 1, 3, 6] 6 1727 4 [0, 1, 3, 6]\n", + " 5 │ [0, 1, 3, 7] 2 1727 4 [0, 1, 3, 7]\n", + " 6 │ [0, 1, 4, 7] 2 1727 4 [0, 1, 4, 7]\n", + " 7 │ [0, 1, 5] 2 1727 3 [0, 1, 5]\n", + " 8 │ [0, 1] 1 1727 2 [0, 1]\n", + " 9 │ [0, 1, 4, 10] 6 1727 4 [0, 2, 3, 6]\n", + " 10 │ [0, 1, 5, 10] 1 1727 4 [0, 2, 3, 7]\n", + " 11 │ [0, 1, 10] 2 1727 3 [0, 2, 3]\n", + " ⋮ │ ⋮ ⋮ ⋮ ⋮ ⋮\n", + " 8737 │ [0, 2, 4, 9] 3 2628 4 [0, 3, 5, 7]\n", + " 8738 │ [0, 2, 9] 4 2628 3 [0, 3, 5]\n", + " 8739 │ [0, 2, 6, 9] 14 2628 4 [0, 3, 6, 8]\n", + " 8740 │ [0, 3, 6] 14 2628 3 [0, 3, 6]\n", + " 8741 │ [0, 3, 7] 51 2628 3 [0, 3, 7]\n", + " 8742 │ [0, 3] 110 2628 2 [0, 3]\n", + " 8743 │ [0, 3, 8] 44 2628 3 [0, 4, 7]\n", + " 8744 │ [0, 4] 83 2628 2 [0, 4]\n", + " 8745 │ [0, 5] 25 2628 2 [0, 5]\n", + " 8746 │ [0] 231 2628 1 [0]\n", + "\u001b[31m 8725 rows omitted\u001b[0m" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using CSV\n", + "chords_df_overlapping = CSV.read(\"chords_overlapping_df.csv\", DataFrame)\n", + "chords_df = CSV.read(\"chords_df.csv\", DataFrame)\n", + "\n", + "chords_df_overlapping = transform_ids(chords_df_overlapping)\n", + "chords_df = transform_ids(chords_df)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4baa2c6f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.8.3", + "language": "julia", + "name": "julia-1.8" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/julia_causal_simulation.ipynb b/julia_causal_simulation.ipynb new file mode 100644 index 0000000..a9f1391 --- /dev/null +++ b/julia_causal_simulation.ipynb @@ -0,0 +1,6077 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "617f71fa", + "metadata": {}, + "source": [ + "## Introduction to DAGs, and modeling of causal effects using Julia\n", + "In this blog post, I'll introduce the concept of Directed Acyclic Graphs (DAGs) and I'll show how you can use simulation studies to demonstrate that unbiased effects can be estimated by blocking the backdoor paths identified in DAGs.\n" + ] + }, + { + "cell_type": "markdown", + "id": "2ff7bf24", + "metadata": {}, + "source": [ + "A DAG is a diagram which demonstrates which things cause other things in a situation of interest. Here, we have a DAG showing the relationship between social factors, smoking, and heart disease. We believe that social factors might cause smoking (for example, people of lower incomes might be more likely to smoke than people of higher incomes). We also believe that social factors might cause heart disease (for example, people who have more money might be able to access more preventative care for heart disease). Finally, we believe that exercise influences risk of heart disease (more exercise lowers your risk for heart disease)." + ] + }, + { + "cell_type": "code", + "execution_count": 186, + "id": "0ce0a415", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " SocialFactors\n", + " \n", + " \n", + " \n", + " \n", + " Smoking\n", + " \n", + " \n", + " \n", + " \n", + " HeartDisease\n", + " \n", + " \n", + " \n", + " \n", + " Exercise\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " SocialFactors\n", + " \n", + " \n", + " \n", + " \n", + " Smoking\n", + " \n", + " \n", + " \n", + " \n", + " HeartDisease\n", + " \n", + " \n", + " \n", + " \n", + " Exercise\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.88cx, -0.09cy), (0.21333333333333326cx, -0.91cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8658359213500126cx, 0.06708203932499368cy), (0.8658359213500126cx, 0.9329179606750063cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.3807674982358589cx, -0.857697505292423cy), (0.9525658350974743cx, 0.857697505292423cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.41653836276711764cx, 0.12480754415067653cy), (0.9167949705662156cx, 0.8751924558493235cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.5mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.11763671507092047cx, -0.880980054218899cy), (0.21333333333333326cx, -0.91cy), (0.15867913227000072cx, -0.8262568312867921cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.797082864031732cx, 0.8603024175083452cy), (0.8658359213500126cx, 0.9329179606750063cy), (0.7664916524257154cx, 0.9214848407203785cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9552970250331012cx, 0.7577348092426688cy), (0.9525658350974743cx, 0.857697505292423cy), (0.8904032655191203cx, 0.7793660624139958cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8931279985444407cx, 0.778033439616549cy), (0.9167949705662156cx, 0.8751924558493235cy), (0.8362124063597218cx, 0.815977167739695cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.5mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, 0.0cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.0cy), \"Social\\nFactors\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -1.0cy), \"Smoking\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Heart\\nDisease\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, 0.0cy), \"Exercise\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 186, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "using Compose, Cairo, Fontconfig\n", + "\n", + "g = SimpleDiGraph(4)\n", + "add_edge!(g, 1, 2)\n", + "add_edge!(g, 1, 3)\n", + "add_edge!(g, 2, 3)\n", + "add_edge!(g, 4, 3)\n", + "nodelabel = [\"Social\\nFactors\", \"Smoking\", \"Heart\\nDisease\", \"Exercise\"]\n", + "\n", + "locs_x = [0, 2, 3, 2]\n", + "locs_y = [0, -1, 1, 0]\n", + "\n", + "nodestrokelw = [0, 0, 0, 0, 0]\n", + "\n", + "g = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15)\n", + "draw(PNG(\"smoking.png\", 16cm, 16cm),g)\n", + "g" + ] + }, + { + "cell_type": "markdown", + "id": "bec29b61", + "metadata": {}, + "source": [ + "Note that in this DAG, there are no arrows between social factors and exercise (demonstrating that we believe that people of high and low socioeconomic status get the same amount of exercise) and that there are no arrows between smoking and exercise (we do not believe that smokers are more or less likely than non-smokers to exercise). And, note that each connection between components in a DAG only shows a causal effect going one way. The \"Acyclic\" in DAG means that there can be no cycles, so there can be no path from one component back to itself. \n", + "\n", + "Also, note that this DAG is just a representation of how we believe the world to be. By creating a DAG, we do not claim that we have the exact correct understanding of which things cause which other things. However, by using a DAG, we clearly present our assumptions, and make it easy for others to see where our assumptions may have been inaccurate." + ] + }, + { + "cell_type": "markdown", + "id": "3caa9a19", + "metadata": {}, + "source": [ + "### A brief introduction to DAGS\n", + "When there are two arrows going into a component of a graph, that component is called a collider. Here, L is a collider. \n", + "\n", + "If a collider is conditioned upon (designated by drawing a circle around the collider), the path between X and Y is open. If a collider is not conditioned upon, the path is closed. " + ] + }, + { + "cell_type": "code", + "execution_count": 217, + "id": "144263d5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " L\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " L\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.88cx, -0.09cy), (0.21333333333333326cx, -0.91cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9525658350974743cx, 0.857697505292423cy), (0.380767498235859cx, -0.857697505292423cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.7320508075688774mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.11763671507092047cx, -0.880980054218899cy), (0.21333333333333326cx, -0.91cy), (0.15867913227000072cx, -0.8262568312867921cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.37803630830023205cx, -0.7577348092426688cy), (0.380767498235859cx, -0.857697505292423cy), (0.442930067814213cx, -0.7793660624139958cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.7320508075688774mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.0cy), \"X\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -1.0cy), \"L\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Y\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 217, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "using Compose, Cairo, Fontconfig\n", + "\n", + "g = SimpleDiGraph(3)\n", + "add_edge!(g, 1, 2)\n", + "add_edge!(g, 3, 2)\n", + "\n", + "nodelabel = [\"X\", \"L\", \"Y\"]\n", + "\n", + "locs_x = [0, 2, 3]\n", + "locs_y = [0, -1, 1]\n", + "\n", + "nodestrokelw = [0, 0, 0]\n", + "\n", + "g = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15)\n", + "draw(PNG(\"collider_conditioned.png\", 16cm, 16cm),g)\n", + "g" + ] + }, + { + "cell_type": "code", + "execution_count": 219, + "id": "fcea064c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " L\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " L\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.88cx, -0.09cy), (0.21333333333333326cx, -0.91cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9525658350974743cx, 0.857697505292423cy), (0.380767498235859cx, -0.857697505292423cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.7320508075688774mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.11763671507092047cx, -0.880980054218899cy), (0.21333333333333326cx, -0.91cy), (0.15867913227000072cx, -0.8262568312867921cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.37803630830023205cx, -0.7577348092426688cy), (0.380767498235859cx, -0.857697505292423cy), (0.442930067814213cx, -0.7793660624139958cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.7320508075688774mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.7320508075688774mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.0cy), \"X\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -1.0cy), \"L\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Y\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 219, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "using Compose, Cairo, Fontconfig\n", + "\n", + "g = SimpleDiGraph(3)\n", + "add_edge!(g, 1, 2)\n", + "add_edge!(g, 3, 2)\n", + "\n", + "nodelabel = [\"X\", \"L\", \"Y\"]\n", + "\n", + "locs_x = [0, 2, 3]\n", + "locs_y = [0, -1, 1]\n", + "\n", + "nodestrokelw = [0, 1, 0]\n", + "\n", + "g = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15)\n", + "draw(PNG(\"collider_conditioned.png\", 16cm, 16cm),g)\n", + "g" + ] + }, + { + "cell_type": "markdown", + "id": "dfeae9c6", + "metadata": {}, + "source": [ + "A component is a non-collider if there is at least one arrow coming out of the component to another component. \n", + "\n", + "For non-colliders, a path is closed if the component is conditioned upon, and the path is open if the component is not conditioned upon.\n", + "\n", + "In the DAG below, L is a non-collider, and there exists an open path between X and Y. " + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "id": "90c8dd41", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " L\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " L\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.21333333333333326cx, -0.91cy), (-0.88cx, -0.09000000000000001cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.3807674982358589cx, -0.857697505292423cy), (0.9525658350974743cx, 0.857697505292423cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.7320508075688774mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.7843033817375872cx, -0.11901994578110102cy), (-0.88cx, -0.09000000000000001cy), (-0.8253457989366675cx, -0.17374316871320802cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9552970250331012cx, 0.7577348092426688cy), (0.9525658350974743cx, 0.857697505292423cy), (0.8904032655191203cx, 0.7793660624139958cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.7320508075688774mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.0cy), \"X\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -1.0cy), \"L\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Y\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 188, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "using Compose, Cairo, Fontconfig\n", + "\n", + "g = SimpleDiGraph(3)\n", + "add_edge!(g, 2, 1)\n", + "add_edge!(g, 2, 3)\n", + "\n", + "nodelabel = [\"X\", \"L\", \"Y\"]\n", + "\n", + "locs_x = [0, 2, 3]\n", + "locs_y = [0, -1, 1]\n", + "\n", + "nodestrokelw = [0, 0, 0]\n", + "\n", + "g = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15)\n", + "draw(PNG(\"non_collider.png\", 16cm, 16cm),g)\n", + "g" + ] + }, + { + "cell_type": "markdown", + "id": "49236ec3", + "metadata": {}, + "source": [ + "### The backdoor criterion\n", + "\n", + "One way in which estimates of causal effects may be biased is if there is an open backdoor path between the independent variable and the dependent variable. A path is a backdoor path if it has an arrow coming into (rather than out of) the independent variable." + ] + }, + { + "cell_type": "markdown", + "id": "c7c84db4", + "metadata": {}, + "source": [ + "We can condition upon a component in our graph in many ways. In this post, I will condition on a component by including it as a covariate in a linear model and by restricting our analytical population based on the component. I will signify that a component is conditioned upon by drawing a circle around the component. " + ] + }, + { + "cell_type": "markdown", + "id": "ddbe757a", + "metadata": {}, + "source": [ + "A path between two variables is blocked if it contains a non-collider that has been conditioned upon, or if it has a collider which has not been conditioned upon. (To be precise, none of the descendants of the collider can be conditioned on either for a path to be blocked)" + ] + }, + { + "cell_type": "markdown", + "id": "cc246264", + "metadata": {}, + "source": [ + "Here, a backdoor path between X and Y is open because there are only non-colliders between X and Y, and because none of these non-colliders have been conditioned upon. If we were to estimate an effect of X on Y without including any other covariate, the effect would be biased. " + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "id": "f9cef116", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " A\n", + " \n", + " \n", + " \n", + " \n", + " C\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " B\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " A\n", + " \n", + " \n", + " \n", + " \n", + " C\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " B\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8658359213500126cx, 0.2662512940083396cy), (0.1991692546833459cx, -0.2662512940083397cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9329179606750063cx, 0.1991692546833459cy), (-0.40041537265832705cx, -0.8658359213500126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.40041537265832694cx, -0.199169254683346cy), (0.9329179606750063cx, 0.8658359213500126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.33333333333333326cx, 0.18333333333333326cy), (0.33333333333333326cx, -0.18333333333333338cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.09982498575904865cx, -0.2548181740537119cy), (0.1991692546833459cx, -0.2662512940083397cy), (0.1304161973650653cx, -0.19363575084167856cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.4730309158249882cx, -0.797082864031732cy), (-0.40041537265832705cx, -0.8658359213500126cy), (-0.41184849261295486cx, -0.7664916524257154cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9214848407203785cx, 0.7664916524257154cy), (0.9329179606750063cx, 0.8658359213500126cy), (0.8603024175083452cx, 0.797082864031732cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.2991313190007664cx, -0.08936407125474254cy), (0.33333333333333326cx, -0.18333333333333338cy), (0.3675353476659001cx, -0.08936407125474252cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.33333333333333326cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.33333333333333337cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, 0.33333333333333326cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.33333333333333326cy), \"A\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.33333333333333337cy), \"C\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Y\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, -1.0cy), \"X\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, 0.33333333333333326cy), \"B\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 189, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "\n", + "g = SimpleDiGraph(5)\n", + "add_edge!(g, 1, 2)\n", + "\n", + "add_edge!(g, 2, 3)\n", + "add_edge!(g, 1, 4)\n", + "add_edge!(g, 5, 2)\n", + "nodelabel = [\"A\", \"C\", \"Y\", \"X\", \"B\"]\n", + "\n", + "locs_x = [0, 2, 3, 1, 2]\n", + "locs_y = [0, -1, 1, -2, 0]\n", + "\n", + "nodestrokelw = [0, 0, 0, 0, 0]\n", + "\n", + "\n", + "g = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15)\n", + "\n", + "draw(PNG(\"open_path.png\", 16cm, 16cm),g)\n", + "g" + ] + }, + { + "cell_type": "markdown", + "id": "5f142485", + "metadata": {}, + "source": [ + "Here, the path is closed because we conditioned on C" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "id": "94d4c09a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " A\n", + " \n", + " \n", + " \n", + " \n", + " C\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " B\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " A\n", + " \n", + " \n", + " \n", + " \n", + " C\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " B\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8658359213500126cx, 0.2662512940083396cy), (0.1991692546833459cx, -0.2662512940083397cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9329179606750063cx, 0.1991692546833459cy), (-0.40041537265832705cx, -0.8658359213500126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.40041537265832694cx, -0.199169254683346cy), (0.9329179606750063cx, 0.8658359213500126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.33333333333333326cx, 0.18333333333333326cy), (0.33333333333333326cx, -0.18333333333333338cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.09982498575904865cx, -0.2548181740537119cy), (0.1991692546833459cx, -0.2662512940083397cy), (0.1304161973650653cx, -0.19363575084167856cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.4730309158249882cx, -0.797082864031732cy), (-0.40041537265832705cx, -0.8658359213500126cy), (-0.41184849261295486cx, -0.7664916524257154cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9214848407203785cx, 0.7664916524257154cy), (0.9329179606750063cx, 0.8658359213500126cy), (0.8603024175083452cx, 0.797082864031732cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.2991313190007664cx, -0.08936407125474254cy), (0.33333333333333326cx, -0.18333333333333338cy), (0.3675353476659001cx, -0.08936407125474252cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.33333333333333326cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.33333333333333337cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, 0.33333333333333326cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.3416407864998738mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.33333333333333326cy), \"A\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.33333333333333337cy), \"C\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Y\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, -1.0cy), \"X\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, 0.33333333333333326cy), \"B\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 190, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "\n", + "g = SimpleDiGraph(5)\n", + "add_edge!(g, 1, 2)\n", + "\n", + "add_edge!(g, 2, 3)\n", + "add_edge!(g, 1, 4)\n", + "add_edge!(g, 5, 2)\n", + "nodelabel = [\"A\", \"C\", \"Y\", \"X\", \"B\"]\n", + "\n", + "locs_x = [0, 2, 3, 1, 2]\n", + "locs_y = [0, -1, 1, -2, 0]\n", + "\n", + "nodestrokelw = [0, 1, 0, 0, 0]\n", + "\n", + "\n", + "g = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15)\n", + "\n", + "draw(PNG(\"closed_path.png\", 16cm, 16cm),g)\n", + "g" + ] + }, + { + "cell_type": "markdown", + "id": "04669b0b", + "metadata": {}, + "source": [ + "### The basics of Julia\n", + "\n", + "Julia is a programming language which is designed for statisticians and data scientists. I won't attempt to explain everything about using Julia in this post, but there are a few commands that you should be familiar with:" + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "id": "00ed6065", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "y ~ 1 + z\n", + "\n", + "Coefficients:\n", + "─────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "─────────────────────────────────────────────────────────────────────────\n", + "(Intercept) 5.52486 0.107426 51.43 <1e-10 5.27714 5.77259\n", + "z 0.0261243 0.0831303 0.31 0.7614 -0.165575 0.217823\n", + "─────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 191, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using DataFrames, GLM \n", + "\n", + "x = rand(10) #creates 10 random numbers between 0 and 1\n", + "y = x .+ 5 # adds 5 to each of the random numbers that have been created. So, these numbers will be between 5 and 6.\n", + "# The . in .+ means that we are adding 5 to each element of x\n", + "# if we were adding 2 vectors together or 2 scalars together we would just use +\n", + "z = rand(Normal(0, 1), 10) #samples 10 numbers from a normal distribution with mean 0 and standard deviation 1\n", + "\n", + "\n", + "df = DataFrame(z = z, y = y) #create a dataframe with columns for z and y\n", + "lm(@formula(y ~ z), df) # fit a linear model with y as the dependent variable and z as the independent variable\n" + ] + }, + { + "cell_type": "markdown", + "id": "821bb607", + "metadata": {}, + "source": [ + "Now, we can start simulating some data. We'll start by by considering a situation which can be represented using this DAG:" + ] + }, + { + "cell_type": "code", + "execution_count": 220, + "id": "19d60076", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " CaneUse\n", + " \n", + " \n", + " \n", + " \n", + " HeartDisease\n", + " \n", + " \n", + " \n", + " \n", + " Injury\n", + " \n", + " \n", + " \n", + " \n", + " BloodPressure\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " CaneUse\n", + " \n", + " \n", + " \n", + " \n", + " HeartDisease\n", + " \n", + " \n", + " \n", + " \n", + " Injury\n", + " \n", + " \n", + " \n", + " \n", + " BloodPressure\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8595506233646433cx, -0.052668516238258745cy), (0.1928839566979766cx, -0.44733148376174126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8544786249782003cx, 0.03638034375544994cy), (0.8544786249782003cx, 0.46361965624455004cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.21333333333333337cx, -0.91cy), (0.21333333333333324cx, -0.59cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.45333333333333325cx, 0.91cy), (0.88cx, 0.59cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.09288866583745324cx, -0.4463610170084019cy), (0.1928839566979766cx, -0.44733148376174126cy), (0.116906923800866cx, -0.3823123291059679cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.771610257052115cx, 0.4076479348375131cy), (0.8544786249782003cx, 0.46361965624455004cy), (0.7550198432048135cx, 0.4740095902267189cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.1586791322700007cx, -0.6737431687132079cy), (0.21333333333333324cx, -0.59cy), (0.11763671507092044cx, -0.619019945781101cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.7843033817375872cx, 0.619019945781101cy), (0.88cx, 0.59cy), (0.8253457989366675cx, 0.6737431687132079cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.5cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.5cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, 1.0cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.5cy), \"Cane\\nUse\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 0.5cy), \"Heart\\nDisease\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, -1.0cy), \"Injury\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, 1.0cy), \"Blood\\nPressure\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 220, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "\n", + "g = SimpleDiGraph(5)\n", + "add_edge!(g, 1, 2)\n", + "add_edge!(g, 1, 3)\n", + "add_edge!(g, 4, 2)\n", + "add_edge!(g, 5, 3)\n", + "nodelabel = [\"Age\", \"Cane\\nUse\", \"Heart\\nDisease\", \"Injury\", \"Blood\\nPressure\"]\n", + "\n", + "locs_x = [0, 2, 3, 1, 2]\n", + "locs_y = [0, -1, 1, -2, 2]\n", + "\n", + "nodestrokelw = [0, 0, 0, 0, 0]\n", + "\n", + "\n", + "g = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15)\n", + "\n", + "draw(PNG(\"heart_disease_1.png\", 16cm, 16cm),g)\n", + "g" + ] + }, + { + "cell_type": "markdown", + "id": "0d171f30", + "metadata": {}, + "source": [ + "First, let's generate plausible values for age, injury, and smoking. These variables don't have any arrows going into them, so we assume that they are just generated according to a random process. Note that this simulation is deliberately simplistic and not representative of real-life data. " + ] + }, + { + "cell_type": "code", + "execution_count": 221, + "id": "199707c0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1000-element Vector{Float64}:\n", + " 95.5475455002515\n", + " 39.09850072823843\n", + " 72.61833493194055\n", + " 66.88615588110834\n", + " 97.92251564730009\n", + " 12.784685558460652\n", + " 89.81913074308488\n", + " 61.99059200438847\n", + " 50.78945063451321\n", + " 55.26094628917575\n", + " 5.714049149347988\n", + " 77.61365829929339\n", + " 88.53145108078839\n", + " ⋮\n", + " 25.822384380807495\n", + " 14.293630831848436\n", + " 54.914668706440025\n", + " 13.215324676245977\n", + " 50.57609277364288\n", + " 79.63042537988933\n", + " 54.54427785677364\n", + " 39.54023252070568\n", + " 13.723531270586875\n", + " 25.050717261766607\n", + " 18.05422979833491\n", + " 28.693898067449975" + ] + }, + "execution_count": 221, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Distributions\n", + "n = 1000\n", + "\n", + "\n", + "blood_pressure = rand(Normal(80, 10), n) # reasonable range of numbers for blood pressure\n", + "injury = rand(Bernoulli(0.1), n) # 10% of our population has a leg injury\n", + "age = rand(n) * 100 #We'll assume that our population is uniformly distributed between 0 and 100" + ] + }, + { + "cell_type": "markdown", + "id": "dedb7920", + "metadata": {}, + "source": [ + "Now, we'll generate heart disease and cane use, which will not be independent. \n", + "\n", + "For cane use, we'll assume that having an injury is like adding 40 years to your life. And, we'll say that anyone with an injury-adjusted \"age\" over 80 will use a cane. " + ] + }, + { + "cell_type": "code", + "execution_count": 222, + "id": "29121321", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1000-element BitVector:\n", + " 1\n", + " 0\n", + " 0\n", + " 0\n", + " 1\n", + " 0\n", + " 1\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 1\n", + " 1\n", + " ⋮\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0\n", + " 0" + ] + }, + "execution_count": 222, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cane_use_score = age+injury*40\n", + "cane_use= cane_use_score .> 80" + ] + }, + { + "cell_type": "code", + "execution_count": 223, + "id": "d66b2263", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1000-element BitVector:\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 0\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 0\n", + " 1\n", + " 1\n", + " ⋮\n", + " 0\n", + " 0\n", + " 1\n", + " 0\n", + " 1\n", + " 1\n", + " 1\n", + " 1\n", + " 0\n", + " 0\n", + " 0\n", + " 0" + ] + }, + "execution_count": 223, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "heart_disease_score = age+blood_pressure\n", + "heart_disease= heart_disease_score.>120" + ] + }, + { + "cell_type": "code", + "execution_count": 224, + "id": "3ff9415c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
1000×5 DataFrame
975 rows omitted
Rowblood_pressureageinjurycane_useheart_disease
Float64Float64BoolBoolBool
182.234495.5475falsetruetrue
283.606539.0985truefalsetrue
3101.95472.6183falsefalsetrue
472.485966.8862falsefalsetrue
596.834497.9225falsetruetrue
685.820212.7847falsefalsefalse
758.049589.8191falsetruetrue
883.891261.9906falsefalsetrue
979.2650.7895falsefalsetrue
1090.702455.2609falsefalsetrue
1176.70625.71405truefalsefalse
12106.05377.6137truetruetrue
1380.854588.5315falsetruetrue
98993.315125.8224falsefalsefalse
99066.471114.2936falsefalsefalse
99184.24254.9147falsefalsetrue
99282.367413.2153falsefalsefalse
99399.097650.5761falsefalsetrue
99476.316679.6304falsefalsetrue
99584.47354.5443falsefalsetrue
99681.491739.5402falsefalsetrue
99783.497313.7235falsefalsefalse
99873.874325.0507falsefalsefalse
99979.131518.0542falsefalsefalse
100086.328628.6939falsefalsefalse
" + ], + "text/latex": [ + "\\begin{tabular}{r|ccccc}\n", + "\t& blood\\_pressure & age & injury & cane\\_use & heart\\_disease\\\\\n", + "\t\\hline\n", + "\t& Float64 & Float64 & Bool & Bool & Bool\\\\\n", + "\t\\hline\n", + "\t1 & 82.2344 & 95.5475 & 0 & 1 & 1 \\\\\n", + "\t2 & 83.6065 & 39.0985 & 1 & 0 & 1 \\\\\n", + "\t3 & 101.954 & 72.6183 & 0 & 0 & 1 \\\\\n", + "\t4 & 72.4859 & 66.8862 & 0 & 0 & 1 \\\\\n", + "\t5 & 96.8344 & 97.9225 & 0 & 1 & 1 \\\\\n", + "\t6 & 85.8202 & 12.7847 & 0 & 0 & 0 \\\\\n", + "\t7 & 58.0495 & 89.8191 & 0 & 1 & 1 \\\\\n", + "\t8 & 83.8912 & 61.9906 & 0 & 0 & 1 \\\\\n", + "\t9 & 79.26 & 50.7895 & 0 & 0 & 1 \\\\\n", + "\t10 & 90.7024 & 55.2609 & 0 & 0 & 1 \\\\\n", + "\t11 & 76.7062 & 5.71405 & 1 & 0 & 0 \\\\\n", + "\t12 & 106.053 & 77.6137 & 1 & 1 & 1 \\\\\n", + "\t13 & 80.8545 & 88.5315 & 0 & 1 & 1 \\\\\n", + "\t14 & 80.2811 & 42.3351 & 0 & 0 & 1 \\\\\n", + "\t15 & 101.823 & 65.8428 & 0 & 0 & 1 \\\\\n", + "\t16 & 90.3881 & 22.9383 & 0 & 0 & 0 \\\\\n", + "\t17 & 93.3956 & 96.9699 & 0 & 1 & 1 \\\\\n", + "\t18 & 61.0411 & 28.8413 & 0 & 0 & 0 \\\\\n", + "\t19 & 80.8272 & 36.5905 & 0 & 0 & 0 \\\\\n", + "\t20 & 81.5551 & 55.2878 & 0 & 0 & 1 \\\\\n", + "\t21 & 54.7129 & 62.5551 & 1 & 1 & 0 \\\\\n", + "\t22 & 97.4039 & 35.0025 & 0 & 0 & 1 \\\\\n", + "\t23 & 60.7323 & 9.48088 & 0 & 0 & 0 \\\\\n", + "\t24 & 76.2254 & 14.0856 & 0 & 0 & 0 \\\\\n", + "\t25 & 59.1735 & 36.062 & 0 & 0 & 0 \\\\\n", + "\t26 & 67.855 & 51.02 & 0 & 0 & 0 \\\\\n", + "\t27 & 99.2721 & 21.3531 & 0 & 0 & 1 \\\\\n", + "\t28 & 78.9128 & 22.0411 & 1 & 0 & 0 \\\\\n", + "\t29 & 71.9204 & 53.0123 & 0 & 0 & 1 \\\\\n", + "\t30 & 92.8339 & 89.3526 & 1 & 1 & 1 \\\\\n", + "\t$\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m1000×5 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m blood_pressure \u001b[0m\u001b[1m age \u001b[0m\u001b[1m injury \u001b[0m\u001b[1m cane_use \u001b[0m\u001b[1m heart_disease \u001b[0m\n", + " │\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Bool \u001b[0m\u001b[90m Bool \u001b[0m\u001b[90m Bool \u001b[0m\n", + "──────┼───────────────────────────────────────────────────────────\n", + " 1 │ 82.2344 95.5475 false true true\n", + " 2 │ 83.6065 39.0985 true false true\n", + " 3 │ 101.954 72.6183 false false true\n", + " 4 │ 72.4859 66.8862 false false true\n", + " 5 │ 96.8344 97.9225 false true true\n", + " 6 │ 85.8202 12.7847 false false false\n", + " 7 │ 58.0495 89.8191 false true true\n", + " 8 │ 83.8912 61.9906 false false true\n", + " 9 │ 79.26 50.7895 false false true\n", + " 10 │ 90.7024 55.2609 false false true\n", + " 11 │ 76.7062 5.71405 true false false\n", + " ⋮ │ ⋮ ⋮ ⋮ ⋮ ⋮\n", + " 991 │ 84.242 54.9147 false false true\n", + " 992 │ 82.3674 13.2153 false false false\n", + " 993 │ 99.0976 50.5761 false false true\n", + " 994 │ 76.3166 79.6304 false false true\n", + " 995 │ 84.473 54.5443 false false true\n", + " 996 │ 81.4917 39.5402 false false true\n", + " 997 │ 83.4973 13.7235 false false false\n", + " 998 │ 73.8743 25.0507 false false false\n", + " 999 │ 79.1315 18.0542 false false false\n", + " 1000 │ 86.3286 28.6939 false false false\n", + "\u001b[36m 979 rows omitted\u001b[0m" + ] + }, + "execution_count": 224, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using DataFrames\n", + "df = DataFrame(blood_pressure = blood_pressure, age = age, injury=injury, cane_use = cane_use, heart_disease = heart_disease)" + ] + }, + { + "cell_type": "markdown", + "id": "adfc8997", + "metadata": {}, + "source": [ + "If we only include cane use in this model, we leave an open backdoor path. If we fit a logistic regression model that leaves the backdoor path open, we will have a biased estimate. \n", + "\n", + "The true effect of cane use on heart disease is zero because cane use was not used in our generating process for heart disease. Thus, if the coefficient for cane use is non-zero, we know that the estimate was biased. " + ] + }, + { + "cell_type": "code", + "execution_count": 225, + "id": "10d94d9b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{GeneralizedLinearModel{GLM.GlmResp{Vector{Float64}, Binomial{Float64}, LogitLink}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "heart_disease ~ 1 + cane_use\n", + "\n", + "Coefficients:\n", + "──────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error z Pr(>|z|) Lower 95% Upper 95%\n", + "──────────────────────────────────────────────────────────────────────────\n", + "(Intercept) -0.190157 0.073409 -2.59 0.0096 -0.334036 -0.0462781\n", + "cane_use 4.08605 0.457633 8.93 <1e-18 3.18911 4.983\n", + "──────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 225, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using GLM\n", + "unadjusted_model = glm(@formula(heart_disease ~ cane_use), df, Binomial(), LogitLink())" + ] + }, + { + "cell_type": "markdown", + "id": "46e13f53", + "metadata": {}, + "source": [ + "Now, let's close the backdoor path in this model by adjusting for age. " + ] + }, + { + "cell_type": "code", + "execution_count": 226, + "id": "b6b6a659", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " CaneUse\n", + " \n", + " \n", + " \n", + " \n", + " HeartDisease\n", + " \n", + " \n", + " \n", + " \n", + " Injury\n", + " \n", + " \n", + " \n", + " \n", + " BloodPressure\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " CaneUse\n", + " \n", + " \n", + " \n", + " \n", + " HeartDisease\n", + " \n", + " \n", + " \n", + " \n", + " Injury\n", + " \n", + " \n", + " \n", + " \n", + " BloodPressure\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8595506233646433cx, -0.052668516238258745cy), (0.1928839566979766cx, -0.44733148376174126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8544786249782003cx, 0.03638034375544994cy), (0.8544786249782003cx, 0.46361965624455004cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.21333333333333337cx, -0.91cy), (0.21333333333333324cx, -0.59cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.45333333333333325cx, 0.91cy), (0.88cx, 0.59cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.09288866583745324cx, -0.4463610170084019cy), (0.1928839566979766cx, -0.44733148376174126cy), (0.116906923800866cx, -0.3823123291059679cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.771610257052115cx, 0.4076479348375131cy), (0.8544786249782003cx, 0.46361965624455004cy), (0.7550198432048135cx, 0.4740095902267189cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.1586791322700007cx, -0.6737431687132079cy), (0.21333333333333324cx, -0.59cy), (0.11763671507092044cx, -0.619019945781101cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.7843033817375872cx, 0.619019945781101cy), (0.88cx, 0.59cy), (0.8253457989366675cx, 0.6737431687132079cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.5cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.5cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, 1.0cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.5cy), \"Cane\\nUse\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 0.5cy), \"Heart\\nDisease\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, -1.0cy), \"Injury\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, 1.0cy), \"Blood\\nPressure\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 226, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "\n", + "g = SimpleDiGraph(5)\n", + "add_edge!(g, 1, 2)\n", + "add_edge!(g, 1, 3)\n", + "add_edge!(g, 4, 2)\n", + "add_edge!(g, 5, 3)\n", + "nodelabel = [\"Age\", \"Cane\\nUse\", \"Heart\\nDisease\", \"Injury\", \"Blood\\nPressure\"]\n", + "\n", + "locs_x = [0, 2, 3, 1, 2]\n", + "locs_y = [0, -1, 1, -2, 2]\n", + "\n", + "nodestrokelw = [1, 0, 0, 0, 0]\n", + "\n", + "\n", + "g = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15)\n", + "\n", + "draw(PNG(\"heart_disease_blocked.png\", 16cm, 16cm),g)\n", + "g" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "id": "6401717e", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{GeneralizedLinearModel{GLM.GlmResp{Vector{Float64}, Binomial{Float64}, LogitLink}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "heart_disease ~ 1 + cane_use + age\n", + "\n", + "Coefficients:\n", + "──────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error z Pr(>|z|) Lower 95% Upper 95%\n", + "──────────────────────────────────────────────────────────────────────────\n", + "(Intercept) -7.9067 0.628814 -12.57 <1e-35 -9.13915 -6.67425\n", + "cane_use 0.170928 0.60365 0.28 0.7771 -1.01221 1.35406\n", + "age 0.195755 0.0151852 12.89 <1e-37 0.165993 0.225518\n", + "──────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 199, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adjusted_model = glm(@formula(heart_disease ~ cane_use + age), df, Binomial(), LogitLink())" + ] + }, + { + "cell_type": "markdown", + "id": "e2492d5c", + "metadata": {}, + "source": [ + "After adjusting for the confounder, cane use is no longer associated with heart disease. " + ] + }, + { + "cell_type": "markdown", + "id": "03fbc117", + "metadata": {}, + "source": [ + "Let's take a look at selection bias. " + ] + }, + { + "cell_type": "markdown", + "id": "e3a9f259", + "metadata": {}, + "source": [ + "Here, we'll do a study to see if there is a relationship between age and height. But, because of funding limitations, we can only recruit for our study at an amusement park. We decide to set up our station in the exit doors of a roller coaster. However, the roller coaster requires that individuals be at least 9 years old and at least 150 cm to ride the coaster. \n", + "\n", + "First, let's generate some data assuming that each year, a child grows 5 cm each year." + ] + }, + { + "cell_type": "code", + "execution_count": 200, + "id": "5cb11e25", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StudyEntry\n", + " \n", + " \n", + " \n", + " \n", + " Height\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StudyEntry\n", + " \n", + " \n", + " \n", + " \n", + " Height\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CurvePrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}}}(Compose.CurvePrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}}[Compose.CurvePrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}}((-0.8786474508437578cx, 0.5881677878438709cy), (-0.16780673104693145cx, 1.1046238014142076cy), (0.16780673104693167cx, 1.1046238014142076cy), (0.878647450843758cx, 0.588167787843871cy)), Compose.CurvePrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}}((-0.8786474508437578cx, 0.5881677878438709cy), (-0.5723152282344052cx, 0.810731175267971cy), (-0.4276847717655947cx, 0.8107311752679711cy), (-0.12135254915624209cx, 0.588167787843871cy)), Compose.CurvePrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}}((0.1213525491562421cx, 0.5881677878438709cy), (0.42768477176559483cx, 0.810731175267971cy), (0.5723152282344053cx, 0.8107311752679711cy), (0.878647450843758cx, 0.588167787843871cy))], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.7320508075688774mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.782521281249926cx, 0.6157315234255709cy), (0.878647450843758cx, 0.588167787843871cy), (0.8227281604966833cx, 0.6710715450993752cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.217478718750074cx, 0.6157315234255709cy), (-0.12135254915624209cx, 0.588167787843871cy), (-0.17727183950331676cx, 0.6710715450993752cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.782521281249926cx, 0.6157315234255709cy), (0.878647450843758cx, 0.588167787843871cy), (0.8227281604966833cx, 0.6710715450993752cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.7320508075688774mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.5cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.5cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.0cx, 0.5cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.7320508075688774mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.5cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 0.5cy), \"Study\\nEntry\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.0cx, 0.5cy), \"Height\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 200, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "\n", + "g = SimpleDiGraph(3)\n", + "add_edge!(g, 1, 2)\n", + "add_edge!(g, 3, 2)\n", + "add_edge!(g, 1, 3)\n", + "\n", + "nodelabel = [\"Age\", \"Study\\nEntry\", \"Height\"]\n", + "nodestrokelw = [0, 1, 0]\n", + "\n", + "locs_x = [-10, 10, 0]\n", + "locs_y = [1, 1, 1]\n", + "gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15,\n", + "linetype = \"curve\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 201, + "id": "03fcef01", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
2770211×4 DataFrame
2770186 rows omitted
Rowageheights1s2
Float64Float64Float64Float64
117.0541175.65520.8465257.112
216.5332160.91820.9036251.888
312.3873152.04413.9825283.161
415.9702168.93518.8487254.881
515.2372160.11424.961273.027
615.0534159.86316.2586269.309
715.2702160.11116.8619279.468
817.2811185.94828.2744287.764
915.9768160.97420.6425248.793
1014.3375151.1719.5089270.484
1117.6291170.84522.939244.799
1217.8541163.31422.9982247.668
1313.8413157.0723.0127274.365
277020013.1955164.07615.2958284.106
277020117.0431184.01725.4524266.14
277020216.2738166.03517.7408243.459
277020316.9798157.13619.0895235.644
277020413.0522156.36523.5163275.009
277020511.139155.66918.5575276.883
277020613.8318152.49919.8167260.565
277020716.9775179.2225.0271256.771
277020812.4799151.85620.8056249.859
277020916.7295168.78120.6313266.039
277021015.5101187.52924.6848283.197
277021113.9002153.95820.263250.237
" + ], + "text/latex": [ + "\\begin{tabular}{r|cccc}\n", + "\t& age & height & s1 & s2\\\\\n", + "\t\\hline\n", + "\t& Float64 & Float64 & Float64 & Float64\\\\\n", + "\t\\hline\n", + "\t1 & 17.0541 & 175.655 & 20.8465 & 257.112 \\\\\n", + "\t2 & 16.5332 & 160.918 & 20.9036 & 251.888 \\\\\n", + "\t3 & 12.3873 & 152.044 & 13.9825 & 283.161 \\\\\n", + "\t4 & 15.9702 & 168.935 & 18.8487 & 254.881 \\\\\n", + "\t5 & 15.2372 & 160.114 & 24.961 & 273.027 \\\\\n", + "\t6 & 15.0534 & 159.863 & 16.2586 & 269.309 \\\\\n", + "\t7 & 15.2702 & 160.111 & 16.8619 & 279.468 \\\\\n", + "\t8 & 17.2811 & 185.948 & 28.2744 & 287.764 \\\\\n", + "\t9 & 15.9768 & 160.974 & 20.6425 & 248.793 \\\\\n", + "\t10 & 14.3375 & 151.17 & 19.5089 & 270.484 \\\\\n", + "\t11 & 17.6291 & 170.845 & 22.939 & 244.799 \\\\\n", + "\t12 & 17.8541 & 163.314 & 22.9982 & 247.668 \\\\\n", + "\t13 & 13.8413 & 157.07 & 23.0127 & 274.365 \\\\\n", + "\t14 & 16.8805 & 158.537 & 27.6116 & 238.561 \\\\\n", + "\t15 & 14.3237 & 155.425 & 19.4712 & 267.882 \\\\\n", + "\t16 & 12.8303 & 157.926 & 19.2884 & 274.358 \\\\\n", + "\t17 & 14.2432 & 156.058 & 15.7487 & 248.267 \\\\\n", + "\t18 & 15.4292 & 164.712 & 21.6262 & 278.795 \\\\\n", + "\t19 & 14.7987 & 159.731 & 16.6391 & 260.851 \\\\\n", + "\t20 & 13.4262 & 158.536 & 20.9196 & 274.695 \\\\\n", + "\t21 & 16.621 & 163.245 & 26.5818 & 242.06 \\\\\n", + "\t22 & 15.1698 & 159.454 & 23.6835 & 278.942 \\\\\n", + "\t23 & 12.2264 & 158.878 & 15.9766 & 282.507 \\\\\n", + "\t24 & 12.4472 & 152.585 & 14.8768 & 265.015 \\\\\n", + "\t25 & 17.9078 & 166.839 & 28.2959 & 243.885 \\\\\n", + "\t26 & 16.4674 & 183.723 & 25.5146 & 258.809 \\\\\n", + "\t27 & 14.6685 & 150.471 & 16.2496 & 268.021 \\\\\n", + "\t28 & 17.977 & 170.732 & 24.5793 & 250.614 \\\\\n", + "\t29 & 13.938 & 168.055 & 17.7692 & 264.298 \\\\\n", + "\t30 & 12.98 & 155.793 & 18.7717 & 251.65 \\\\\n", + "\t$\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m2770211×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m age \u001b[0m\u001b[1m height \u001b[0m\u001b[1m s1 \u001b[0m\u001b[1m s2 \u001b[0m\n", + " │\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", + "─────────┼────────────────────────────────────\n", + " 1 │ 17.0541 175.655 20.8465 257.112\n", + " 2 │ 16.5332 160.918 20.9036 251.888\n", + " 3 │ 12.3873 152.044 13.9825 283.161\n", + " 4 │ 15.9702 168.935 18.8487 254.881\n", + " 5 │ 15.2372 160.114 24.961 273.027\n", + " 6 │ 15.0534 159.863 16.2586 269.309\n", + " 7 │ 15.2702 160.111 16.8619 279.468\n", + " 8 │ 17.2811 185.948 28.2744 287.764\n", + " 9 │ 15.9768 160.974 20.6425 248.793\n", + " 10 │ 14.3375 151.17 19.5089 270.484\n", + " 11 │ 17.6291 170.845 22.939 244.799\n", + " ⋮ │ ⋮ ⋮ ⋮ ⋮\n", + " 2770202 │ 16.2738 166.035 17.7408 243.459\n", + " 2770203 │ 16.9798 157.136 19.0895 235.644\n", + " 2770204 │ 13.0522 156.365 23.5163 275.009\n", + " 2770205 │ 11.139 155.669 18.5575 276.883\n", + " 2770206 │ 13.8318 152.499 19.8167 260.565\n", + " 2770207 │ 16.9775 179.22 25.0271 256.771\n", + " 2770208 │ 12.4799 151.856 20.8056 249.859\n", + " 2770209 │ 16.7295 168.781 20.6313 266.039\n", + " 2770210 │ 15.5101 187.529 24.6848 283.197\n", + " 2770211 │ 13.9002 153.958 20.263 250.237\n", + "\u001b[36m 2770190 rows omitted\u001b[0m" + ] + }, + "execution_count": 201, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n = 10000000\n", + "height = rand(Normal(130, 10), n) # reasonable range of numbers for blood pressure\n", + "age = rand(n) * 18 #We'll assume that only young people like going to theme parks\n", + "df = DataFrame(age = age, height = height)\n", + "\n", + "df.s1 = df.age + rand(n) * 10 .+ 1\n", + "df.s2 = df.height + rand(Normal(130, 10), n)\n", + "\n", + "df.height = df.height + df.age .*5 .- mean(df.age) .*5\n", + "\n", + "#df.selection = df.age .* 10 + df.height\n", + "\n", + "# selected_df = df[df.selection .> 150, :]\n", + "\n", + "# selected_df = df[(df.s1 .> 16) .* (df.s2 .> 300),:]\n", + "\n", + "selected_df = df[(df.age .> 9) .* (df.height .> 150),:]" + ] + }, + { + "cell_type": "markdown", + "id": "548df3e9", + "metadata": {}, + "source": [ + "Now, let's verify that the true relationship could have been recovered had no selection effects ever happened. This is what our sample would have been like if we had taken a random sample of children and asked them their ages and height. " + ] + }, + { + "cell_type": "code", + "execution_count": 202, + "id": "5fdbbd89", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StudyEntry\n", + " \n", + " \n", + " \n", + " \n", + " Height\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StudyEntry\n", + " \n", + " \n", + " \n", + " \n", + " Height\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CurvePrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}}}(Compose.CurvePrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}}[Compose.CurvePrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}}((-0.8786474508437578cx, 0.5881677878438709cy), (-0.5723152282344052cx, 0.810731175267971cy), (-0.4276847717655947cx, 0.8107311752679711cy), (-0.12135254915624209cx, 0.588167787843871cy))], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.7320508075688774mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.217478718750074cx, 0.6157315234255709cy), (-0.12135254915624209cx, 0.588167787843871cy), (-0.17727183950331676cx, 0.6710715450993752cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.7320508075688774mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.5cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.5cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.0cx, 0.5cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.7320508075688774mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.5cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 0.5cy), \"Study\\nEntry\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.0cx, 0.5cy), \"Height\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 202, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "\n", + "g = SimpleDiGraph(3)\n", + "#add_edge!(g, 1, 2)\n", + "#add_edge!(g, 3, 2)\n", + "add_edge!(g, 1, 3)\n", + "\n", + "nodelabel = [\"Age\", \"Study\\nEntry\", \"Height\"]\n", + "nodestrokelw = [0, 1, 0]\n", + "\n", + "locs_x = [-10, 10, 0]\n", + "locs_y = [1, 1, 1]\n", + "gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15,\n", + "linetype = \"curve\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 203, + "id": "d8b5d723", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "height ~ 1 + age\n", + "\n", + "Coefficients:\n", + "────────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "────────────────────────────────────────────────────────────────────────────\n", + "(Intercept) 85.0038 0.00632593 13437.36 <1e-99 84.9914 85.0161\n", + "age 4.99935 0.000608695 8213.22 <1e-99 4.99816 5.00054\n", + "────────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 203, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using GLM\n", + "model_no_selection = lm(@formula(height ~ age), df)\n" + ] + }, + { + "cell_type": "markdown", + "id": "f492a441", + "metadata": {}, + "source": [ + "And, now, we'll show that if we use data that are collected with selection effects, our estimate for how much someone grows per year of age is biased. " + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "id": "8c50e998", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "height ~ 1 + age\n", + "\n", + "Coefficients:\n", + "───────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "───────────────────────────────────────────────────────────────────────────\n", + "(Intercept) 120.835 0.0384283 3144.42 <1e-99 120.76 120.91\n", + "age 2.88792 0.0025198 1146.09 <1e-99 2.88298 2.89286\n", + "───────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 204, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using GLM\n", + "model_selection = lm(@formula(height ~ age), selected_df)" + ] + }, + { + "cell_type": "markdown", + "id": "2e909cd3", + "metadata": {}, + "source": [ + "One kind of bias that can be seen in causal inference is M-bias. In M-bias, an open backdoor path can exist despite there being no \"common cause\" of the independent and dependent variables. " + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "id": "4685329f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " ClassicalMusic\n", + " \n", + " \n", + " \n", + " \n", + " Person'sIncome\n", + " \n", + " \n", + " \n", + " \n", + " Parents'Income\n", + " \n", + " \n", + " \n", + " \n", + " Partner'sIncome\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " ClassicalMusic\n", + " \n", + " \n", + " \n", + " \n", + " Person'sIncome\n", + " \n", + " \n", + " \n", + " \n", + " Parents'Income\n", + " \n", + " \n", + " \n", + " \n", + " Partner'sIncome\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8643202713591859cx, -0.08479983040050881cy), (-0.335679728640814cx, -0.4152001695994912cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9000487923912921cx, 0.12493900951088485cy), (-0.29995120760870786cx, 0.8750609904891151cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.5000487923912921cx, -0.8750609904891151cy), (-0.29995120760870786cx, -0.6249390095108849cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.4472832035143952cx, -0.9522760010982485cy), (0.8472832035143952cx, -0.5477239989017515cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.4334925348543027cx, -0.3943998104525314cy), (-0.335679728640814cx, -0.4152001695994912cy), (-0.39723847216983466cx, -0.3363933101573826cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.33194605403912236cx, 0.7803174957156258cy), (-0.29995120760870786cx, 0.8750609904891151cy), (-0.3853606264639723cx, 0.8230491536555058cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.33194605403912236cx, -0.7196825042843742cy), (-0.29995120760870786cx, -0.6249390095108849cy), (-0.3853606264639723cx, -0.6769508463444942cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.7677930298999358cx, -0.6083978177921354cy), (0.8472832035143952cx, -0.5477239989017515cy), (0.7473898187193719cx, -0.543107542014331cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.0cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.19999999999999996cx, -0.5cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, -0.5cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.6cx, -1.0cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.19999999999999996cx, 1.0cy), 0.064w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.19999999999999996cx, -0.5cy), \"Classical\\nMusic\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, -0.5cy), \"Person's\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.6cx, -1.0cy), \"Parents'\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.19999999999999996cx, 1.0cy), \"Partner's\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 205, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "\n", + "g = SimpleDiGraph(5)\n", + "add_edge!(g, 1, 2)\n", + "add_edge!(g, 1, 5)\n", + "add_edge!(g, 4, 2)\n", + "add_edge!(g, 4, 3)\n", + "#add_edge!(g, 5, 3)\n", + "nodelabel = [\"Age\", \"Classical\\nMusic\", \"Person's\\nIncome\", \"Parents'\\nIncome\", \"Partner's\\nIncome\"]\n", + "\n", + "locs_x = [0, 2, 5, 1, 2]\n", + "locs_y = [0, -1, -1, -2, 2]\n", + "\n", + "nodestrokelw = [0, 0, 0, 0, 0]\n", + "\n", + "\n", + "p = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .16)\n", + "\n", + "draw(PNG(\"m_bias_1.png\", 16cm, 16cm),p)\n", + "p" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "id": "01ea0e03", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
1000×5 DataFrame
975 rows omitted
Rowageparents_incomeminutes_per_yearpartner_incomepersonal_income
Float64Float64Float64Float64Float64
157.065257956.11150.2172928.274050.5
236.696358573.71012.755895.049094.5
329.270228245.3635.15640494.021516.1
428.894945665.1805.637504.139297.1
542.330554445.9967.76466714.367895.7
632.852826189.2590.4257313.933760.9
751.146639883.0970.29673857.339431.7
823.632142265.4658.97539004.635678.9
954.762437756.1925.18575212.537714.4
1067.895745327.51132.2395232.356641.8
1137.904730612.1685.16949231.439317.1
1261.585138615.01002.073030.662293.5
1337.58868041.31056.2946867.262958.5
98956.603837106.7937.10578646.822053.2
99046.945721471.4684.17175357.616634.8
99163.665846000.11156.6671811.253252.4
99233.602528775.6623.78160034.626407.9
99349.77515659.88554.3571086.8-3158.59
99427.240365070.3983.10652060.865984.4
99556.849755764.61186.1478115.455957.8
99660.149554813.01149.6383982.648801.9
99720.250540179.8604.30337256.526060.2
99846.097376324.11224.2169675.784252.8
99945.92382764.51286.8768973.979150.5
100052.288738639.2909.27967615.943277.5
" + ], + "text/latex": [ + "\\begin{tabular}{r|ccccc}\n", + "\t& age & parents\\_income & minutes\\_per\\_year & partner\\_income & personal\\_income\\\\\n", + "\t\\hline\n", + "\t& Float64 & Float64 & Float64 & Float64 & Float64\\\\\n", + "\t\\hline\n", + "\t1 & 57.0652 & 57956.1 & 1150.21 & 72928.2 & 74050.5 \\\\\n", + "\t2 & 36.6963 & 58573.7 & 1012.7 & 55895.0 & 49094.5 \\\\\n", + "\t3 & 29.2702 & 28245.3 & 635.156 & 40494.0 & 21516.1 \\\\\n", + "\t4 & 28.8949 & 45665.1 & 805.6 & 37504.1 & 39297.1 \\\\\n", + "\t5 & 42.3305 & 54445.9 & 967.764 & 66714.3 & 67895.7 \\\\\n", + "\t6 & 32.8528 & 26189.2 & 590.42 & 57313.9 & 33760.9 \\\\\n", + "\t7 & 51.1466 & 39883.0 & 970.296 & 73857.3 & 39431.7 \\\\\n", + "\t8 & 23.6321 & 42265.4 & 658.975 & 39004.6 & 35678.9 \\\\\n", + "\t9 & 54.7624 & 37756.1 & 925.185 & 75212.5 & 37714.4 \\\\\n", + "\t10 & 67.8957 & 45327.5 & 1132.23 & 95232.3 & 56641.8 \\\\\n", + "\t11 & 37.9047 & 30612.1 & 685.169 & 49231.4 & 39317.1 \\\\\n", + "\t12 & 61.5851 & 38615.0 & 1002.0 & 73030.6 & 62293.5 \\\\\n", + "\t13 & 37.588 & 68041.3 & 1056.29 & 46867.2 & 62958.5 \\\\\n", + "\t14 & 39.9106 & 36941.9 & 768.525 & 61819.0 & 37024.3 \\\\\n", + "\t15 & 39.0796 & 50476.1 & 895.557 & 63498.2 & 52266.3 \\\\\n", + "\t16 & 61.9473 & 89011.6 & 1509.59 & 76416.3 & 1.07434e5 \\\\\n", + "\t17 & 62.9742 & 43696.3 & 1066.71 & 77917.5 & 58604.8 \\\\\n", + "\t18 & 50.1598 & 52814.4 & 1089.74 & 74947.9 & 52512.6 \\\\\n", + "\t19 & 35.2833 & 53951.6 & 892.349 & 58439.4 & 61274.4 \\\\\n", + "\t20 & 39.8334 & 23335.3 & 631.687 & 87091.5 & 22986.2 \\\\\n", + "\t21 & 36.0204 & 11935.2 & 539.555 & 50804.9 & 19217.8 \\\\\n", + "\t22 & 49.0041 & 51662.5 & 1006.67 & 73561.4 & 64782.7 \\\\\n", + "\t23 & 40.2478 & 20949.5 & 611.974 & 49306.5 & 13509.8 \\\\\n", + "\t24 & 66.7988 & 14477.5 & 812.763 & 80296.6 & 12211.8 \\\\\n", + "\t25 & 20.7362 & 68065.1 & 888.012 & 38465.0 & 83308.7 \\\\\n", + "\t26 & 60.5869 & 47677.5 & 1082.64 & 69199.4 & 21539.5 \\\\\n", + "\t27 & 32.5293 & 41311.8 & 738.411 & 54166.0 & 22105.3 \\\\\n", + "\t28 & 51.9043 & 68255.3 & 1201.6 & 73791.5 & 63465.7 \\\\\n", + "\t29 & 69.0734 & 21974.8 & 910.482 & 83849.2 & 20310.3 \\\\\n", + "\t30 & 39.4907 & -3092.44 & 423.983 & 64823.5 & -3867.43 \\\\\n", + "\t$\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m1000×5 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m age \u001b[0m\u001b[1m parents_income \u001b[0m\u001b[1m minutes_per_year \u001b[0m\u001b[1m partner_income \u001b[0m\u001b[1m personal_in\u001b[0m ⋯\n", + " │\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m ⋯\n", + "──────┼─────────────────────────────────────────────────────────────────────────\n", + " 1 │ 57.0652 57956.1 1150.21 72928.2 7405 ⋯\n", + " 2 │ 36.6963 58573.7 1012.7 55895.0 4909\n", + " 3 │ 29.2702 28245.3 635.156 40494.0 2151\n", + " 4 │ 28.8949 45665.1 805.6 37504.1 3929\n", + " 5 │ 42.3305 54445.9 967.764 66714.3 6789 ⋯\n", + " 6 │ 32.8528 26189.2 590.42 57313.9 3376\n", + " 7 │ 51.1466 39883.0 970.296 73857.3 3943\n", + " 8 │ 23.6321 42265.4 658.975 39004.6 3567\n", + " 9 │ 54.7624 37756.1 925.185 75212.5 3771 ⋯\n", + " 10 │ 67.8957 45327.5 1132.23 95232.3 5664\n", + " 11 │ 37.9047 30612.1 685.169 49231.4 3931\n", + " ⋮ │ ⋮ ⋮ ⋮ ⋮ ⋮ ⋱\n", + " 991 │ 63.6658 46000.1 1156.66 71811.2 5325\n", + " 992 │ 33.6025 28775.6 623.781 60034.6 2640 ⋯\n", + " 993 │ 49.7751 5659.88 554.35 71086.8 -315\n", + " 994 │ 27.2403 65070.3 983.106 52060.8 6598\n", + " 995 │ 56.8497 55764.6 1186.14 78115.4 5595\n", + " 996 │ 60.1495 54813.0 1149.63 83982.6 4880 ⋯\n", + " 997 │ 20.2505 40179.8 604.303 37256.5 2606\n", + " 998 │ 46.0973 76324.1 1224.21 69675.7 8425\n", + " 999 │ 45.923 82764.5 1286.87 68973.9 7915\n", + " 1000 │ 52.2887 38639.2 909.279 67615.9 4327 ⋯\n", + "\u001b[36m 1 column and 979 rows omitted\u001b[0m" + ] + }, + "execution_count": 206, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n = 1000\n", + "age = rand(n) .* 50 .+ 20 #We'll look at people with ages 20 to 70. \n", + "parents_income = rand(Normal(50000, 20000), n) #income is definitely not normally distributed, but we'll use it in this example\n", + "\n", + "# We'll assume everyone has some chance of being really interested in classical music\n", + "musical_interest = rand(Bernoulli(0.3), n) .* 2 \n", + "\n", + "# We'll assume that parents with higher income will always have their kids listen to more classical music \n", + "# (1 additional minute of music per 100 dollars of income) and that people who are older listen to more \n", + "# classical music (10 additional minutes per year of age)\n", + "minutes_per_year = musical_interest .* 30 + parents_income ./ 100 + age .* 10\n", + "\n", + "# We'll assume that on average, people make 1000 additional dollars per year they work. \n", + "# And, we'll assume that everyone has an average baseline pay of 20,000 per year\n", + "partner_income = rand(Normal(20000, 10000), n) + age .* 1000\n", + "\n", + "# We'll assume that a person's income is related to their parents' income, and that people vary \n", + "# from their parents' income by about $10,000 on average. \n", + "personal_income = parents_income + rand(Normal(0, 10000), n)\n", + "\n", + "\n", + "df = DataFrame(age = age, parents_income = parents_income, \n", + " minutes_per_year = minutes_per_year, partner_income = partner_income,\n", + "personal_income = personal_income)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "id": "adb2160e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "personal_income ~ 1 + partner_income\n", + "\n", + "Coefficients:\n", + "──────────────────────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "──────────────────────────────────────────────────────────────────────────────────────────\n", + "(Intercept) 54596.2 2711.84 20.13 <1e-75 49274.7 59917.8\n", + "partner_income -0.0711116 0.0401647 -1.77 0.0769 -0.149928 0.00770525\n", + "──────────────────────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 207, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using GLM\n", + "model = lm(@formula(personal_income ~ partner_income), df)" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "id": "11420154", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " ClassicalMusic\n", + " \n", + " \n", + " \n", + " \n", + " Person'sIncome\n", + " \n", + " \n", + " \n", + " \n", + " Parents'Income\n", + " \n", + " \n", + " \n", + " \n", + " Partner'sIncome\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " ClassicalMusic\n", + " \n", + " \n", + " \n", + " \n", + " Person'sIncome\n", + " \n", + " \n", + " \n", + " \n", + " Parents'Income\n", + " \n", + " \n", + " \n", + " \n", + " Partner'sIncome\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8643202713591859cx, -0.08479983040050881cy), (-0.335679728640814cx, -0.4152001695994912cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9000487923912921cx, 0.12493900951088485cy), (-0.29995120760870786cx, 0.8750609904891151cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.5000487923912921cx, -0.8750609904891151cy), (-0.29995120760870786cx, -0.6249390095108849cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.4472832035143952cx, -0.9522760010982485cy), (0.8472832035143952cx, -0.5477239989017515cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.4334925348543027cx, -0.3943998104525314cy), (-0.335679728640814cx, -0.4152001695994912cy), (-0.39723847216983466cx, -0.3363933101573826cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.33194605403912236cx, 0.7803174957156258cy), (-0.29995120760870786cx, 0.8750609904891151cy), (-0.3853606264639723cx, 0.8230491536555058cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.33194605403912236cx, -0.7196825042843742cy), (-0.29995120760870786cx, -0.6249390095108849cy), (-0.3853606264639723cx, -0.6769508463444942cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.7677930298999358cx, -0.6083978177921354cy), (0.8472832035143952cx, -0.5477239989017515cy), (0.7473898187193719cx, -0.543107542014331cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.0cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.19999999999999996cx, -0.5cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, -0.5cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.6cx, -1.0cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.19999999999999996cx, 1.0cy), 0.064w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.3416407864998738mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.19999999999999996cx, -0.5cy), \"Classical\\nMusic\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, -0.5cy), \"Person's\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.6cx, -1.0cy), \"Parents'\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.19999999999999996cx, 1.0cy), \"Partner's\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 208, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "\n", + "g = SimpleDiGraph(5)\n", + "add_edge!(g, 1, 2)\n", + "add_edge!(g, 1, 5)\n", + "add_edge!(g, 4, 2)\n", + "add_edge!(g, 4, 3)\n", + "#add_edge!(g, 5, 3)\n", + "nodelabel = [\"Age\", \"Classical\\nMusic\", \"Person's\\nIncome\", \"Parents'\\nIncome\", \"Partner's\\nIncome\"]\n", + "\n", + "locs_x = [0, 2, 5, 1, 2]\n", + "locs_y = [0, -1, -1, -2, 2]\n", + "\n", + "nodestrokelw = [0, 1, 0, 0, 0]\n", + "\n", + "\n", + "p = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .16)\n", + "\n", + "draw(PNG(\"m_bias_open_path.png\", 16cm, 16cm),p)\n", + "p" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "id": "bd0bd75d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "personal_income ~ 1 + partner_income + minutes_per_year\n", + "\n", + "Coefficients:\n", + "────────────────────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "────────────────────────────────────────────────────────────────────────────────────────\n", + "(Intercept) 7992.43 1924.05 4.15 <1e-04 4216.78 11768.1\n", + "partner_income -0.581704 0.0264102 -22.03 <1e-87 -0.633529 -0.529878\n", + "minutes_per_year 82.5458 1.90231 43.39 <1e-99 78.8128 86.2788\n", + "────────────────────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 209, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using GLM\n", + "model_conditioned = lm(@formula(personal_income ~ partner_income + minutes_per_year), df)" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "id": "7eb31fab", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " ClassicalMusic\n", + " \n", + " \n", + " \n", + " \n", + " Person'sIncome\n", + " \n", + " \n", + " \n", + " \n", + " Parents'Income\n", + " \n", + " \n", + " \n", + " \n", + " Partner'sIncome\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " ClassicalMusic\n", + " \n", + " \n", + " \n", + " \n", + " Person'sIncome\n", + " \n", + " \n", + " \n", + " \n", + " Parents'Income\n", + " \n", + " \n", + " \n", + " \n", + " Partner'sIncome\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8643202713591859cx, -0.08479983040050881cy), (-0.335679728640814cx, -0.4152001695994912cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9000487923912921cx, 0.12493900951088485cy), (-0.29995120760870786cx, 0.8750609904891151cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.5000487923912921cx, -0.8750609904891151cy), (-0.29995120760870786cx, -0.6249390095108849cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.4472832035143952cx, -0.9522760010982485cy), (0.8472832035143952cx, -0.5477239989017515cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.4334925348543027cx, -0.3943998104525314cy), (-0.335679728640814cx, -0.4152001695994912cy), (-0.39723847216983466cx, -0.3363933101573826cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.33194605403912236cx, 0.7803174957156258cy), (-0.29995120760870786cx, 0.8750609904891151cy), (-0.3853606264639723cx, 0.8230491536555058cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.33194605403912236cx, -0.7196825042843742cy), (-0.29995120760870786cx, -0.6249390095108849cy), (-0.3853606264639723cx, -0.6769508463444942cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.7677930298999358cx, -0.6083978177921354cy), (0.8472832035143952cx, -0.5477239989017515cy), (0.7473898187193719cx, -0.543107542014331cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.0cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.19999999999999996cx, -0.5cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, -0.5cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.6cx, -1.0cy), 0.064w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.19999999999999996cx, 1.0cy), 0.064w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.3416407864998738mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.3416407864998738mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.19999999999999996cx, -0.5cy), \"Classical\\nMusic\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, -0.5cy), \"Person's\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.6cx, -1.0cy), \"Parents'\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.19999999999999996cx, 1.0cy), \"Partner's\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 210, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "\n", + "g = SimpleDiGraph(5)\n", + "add_edge!(g, 1, 2)\n", + "add_edge!(g, 1, 5)\n", + "add_edge!(g, 4, 2)\n", + "add_edge!(g, 4, 3)\n", + "#add_edge!(g, 5, 3)\n", + "nodelabel = [\"Age\", \"Classical\\nMusic\", \"Person's\\nIncome\", \"Parents'\\nIncome\", \"Partner's\\nIncome\"]\n", + "\n", + "locs_x = [0, 2, 5, 1, 2]\n", + "locs_y = [0, -1, -1, -2, 2]\n", + "\n", + "nodestrokelw = [0, 1, 0, 1, 0]\n", + "\n", + "\n", + "p = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .16)\n", + "\n", + "draw(PNG(\"m_bias_2_conditions.png\", 16cm, 16cm),p)\n", + "p" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "id": "b380d5b5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "personal_income ~ 1 + partner_income + parents_income + minutes_per_year\n", + "\n", + "Coefficients:\n", + "────────────────────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "────────────────────────────────────────────────────────────────────────────────────────\n", + "(Intercept) 2709.85 1566.75 1.73 0.0840 -364.652 5784.35\n", + "partner_income -0.0433236 0.0314577 -1.38 0.1688 -0.105055 0.0184074\n", + "parents_income 0.964769 0.0415196 23.24 <1e-95 0.883293 1.04625\n", + "minutes_per_year 1.82847 3.79682 0.48 0.6302 -5.62222 9.27916\n", + "────────────────────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 211, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using GLM\n", + "model_conditioned_backdoor_blocked = lm(@formula(personal_income ~ partner_income + parents_income + minutes_per_year), df)" + ] + }, + { + "cell_type": "markdown", + "id": "ae7a6dc1", + "metadata": {}, + "source": [ + "Now, what would happen if there was an effect of partner income on personal income? (For example, maybe a high-earning partner might help get you a job at their high-paying company)" + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "id": "ea54950d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
1000×5 DataFrame
975 rows omitted
Rowageparents_incomeminutes_per_yearpartner_incomepersonal_income
Float64Float64Float64Float64Float64
157.065257956.11150.2172928.261123.6
236.696358573.71012.755895.050363.6
329.270228245.3635.15640494.0-4540.68
428.894945665.1805.637504.119192.8
542.330554445.9967.76466714.363425.0
632.852826189.2590.4257313.95268.72
751.146639883.0970.29673857.325462.2
823.632142265.4658.97539004.619147.9
954.762437756.1925.18575212.554739.8
1067.895745327.51132.2395232.361161.6
1137.904730612.1685.16949231.46281.1
1261.585138615.01002.073030.647927.1
1337.58868041.31056.2946867.261672.7
98956.603837106.7937.10578646.852037.6
99046.945721471.4684.17175357.626063.3
99163.665846000.11156.6671811.250493.9
99233.602528775.6623.78160034.621342.2
99349.77515659.88554.3571086.813644.0
99427.240365070.3983.10652060.855900.4
99556.849755764.61186.1478115.477739.2
99660.149554813.01149.6383982.668405.9
99720.250540179.8604.30337256.51557.38
99846.097376324.11224.2169675.781623.6
99945.92382764.51286.8768973.91.17377e5
100052.288738639.2909.27967615.954478.8
" + ], + "text/latex": [ + "\\begin{tabular}{r|ccccc}\n", + "\t& age & parents\\_income & minutes\\_per\\_year & partner\\_income & personal\\_income\\\\\n", + "\t\\hline\n", + "\t& Float64 & Float64 & Float64 & Float64 & Float64\\\\\n", + "\t\\hline\n", + "\t1 & 57.0652 & 57956.1 & 1150.21 & 72928.2 & 61123.6 \\\\\n", + "\t2 & 36.6963 & 58573.7 & 1012.7 & 55895.0 & 50363.6 \\\\\n", + "\t3 & 29.2702 & 28245.3 & 635.156 & 40494.0 & -4540.68 \\\\\n", + "\t4 & 28.8949 & 45665.1 & 805.6 & 37504.1 & 19192.8 \\\\\n", + "\t5 & 42.3305 & 54445.9 & 967.764 & 66714.3 & 63425.0 \\\\\n", + "\t6 & 32.8528 & 26189.2 & 590.42 & 57313.9 & 5268.72 \\\\\n", + "\t7 & 51.1466 & 39883.0 & 970.296 & 73857.3 & 25462.2 \\\\\n", + "\t8 & 23.6321 & 42265.4 & 658.975 & 39004.6 & 19147.9 \\\\\n", + "\t9 & 54.7624 & 37756.1 & 925.185 & 75212.5 & 54739.8 \\\\\n", + "\t10 & 67.8957 & 45327.5 & 1132.23 & 95232.3 & 61161.6 \\\\\n", + "\t11 & 37.9047 & 30612.1 & 685.169 & 49231.4 & 6281.1 \\\\\n", + "\t12 & 61.5851 & 38615.0 & 1002.0 & 73030.6 & 47927.1 \\\\\n", + "\t13 & 37.588 & 68041.3 & 1056.29 & 46867.2 & 61672.7 \\\\\n", + "\t14 & 39.9106 & 36941.9 & 768.525 & 61819.0 & 37359.0 \\\\\n", + "\t15 & 39.0796 & 50476.1 & 895.557 & 63498.2 & 59938.5 \\\\\n", + "\t16 & 61.9473 & 89011.6 & 1509.59 & 76416.3 & 1.14018e5 \\\\\n", + "\t17 & 62.9742 & 43696.3 & 1066.71 & 77917.5 & 41037.2 \\\\\n", + "\t18 & 50.1598 & 52814.4 & 1089.74 & 74947.9 & 62473.7 \\\\\n", + "\t19 & 35.2833 & 53951.6 & 892.349 & 58439.4 & 42858.6 \\\\\n", + "\t20 & 39.8334 & 23335.3 & 631.687 & 87091.5 & 39085.9 \\\\\n", + "\t21 & 36.0204 & 11935.2 & 539.555 & 50804.9 & 7617.54 \\\\\n", + "\t22 & 49.0041 & 51662.5 & 1006.67 & 73561.4 & 46018.9 \\\\\n", + "\t23 & 40.2478 & 20949.5 & 611.974 & 49306.5 & 2439.93 \\\\\n", + "\t24 & 66.7988 & 14477.5 & 812.763 & 80296.6 & 35541.9 \\\\\n", + "\t25 & 20.7362 & 68065.1 & 888.012 & 38465.0 & 61196.8 \\\\\n", + "\t26 & 60.5869 & 47677.5 & 1082.64 & 69199.4 & 61564.7 \\\\\n", + "\t27 & 32.5293 & 41311.8 & 738.411 & 54166.0 & 34546.5 \\\\\n", + "\t28 & 51.9043 & 68255.3 & 1201.6 & 73791.5 & 94595.1 \\\\\n", + "\t29 & 69.0734 & 21974.8 & 910.482 & 83849.2 & 50968.1 \\\\\n", + "\t30 & 39.4907 & -3092.44 & 423.983 & 64823.5 & -23298.4 \\\\\n", + "\t$\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ & $\\dots$ \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m1000×5 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m age \u001b[0m\u001b[1m parents_income \u001b[0m\u001b[1m minutes_per_year \u001b[0m\u001b[1m partner_income \u001b[0m\u001b[1m personal_in\u001b[0m ⋯\n", + " │\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m ⋯\n", + "──────┼─────────────────────────────────────────────────────────────────────────\n", + " 1 │ 57.0652 57956.1 1150.21 72928.2 61123.6 ⋯\n", + " 2 │ 36.6963 58573.7 1012.7 55895.0 50363.6\n", + " 3 │ 29.2702 28245.3 635.156 40494.0 -4540.68\n", + " 4 │ 28.8949 45665.1 805.6 37504.1 19192.8\n", + " 5 │ 42.3305 54445.9 967.764 66714.3 63425.0 ⋯\n", + " 6 │ 32.8528 26189.2 590.42 57313.9 5268.72\n", + " 7 │ 51.1466 39883.0 970.296 73857.3 25462.2\n", + " 8 │ 23.6321 42265.4 658.975 39004.6 19147.9\n", + " 9 │ 54.7624 37756.1 925.185 75212.5 54739.8 ⋯\n", + " 10 │ 67.8957 45327.5 1132.23 95232.3 61161.6\n", + " 11 │ 37.9047 30612.1 685.169 49231.4 6281.1\n", + " ⋮ │ ⋮ ⋮ ⋮ ⋮ ⋮ ⋱\n", + " 991 │ 63.6658 46000.1 1156.66 71811.2 50493.9\n", + " 992 │ 33.6025 28775.6 623.781 60034.6 21342.2 ⋯\n", + " 993 │ 49.7751 5659.88 554.35 71086.8 13644.0\n", + " 994 │ 27.2403 65070.3 983.106 52060.8 55900.4\n", + " 995 │ 56.8497 55764.6 1186.14 78115.4 77739.2\n", + " 996 │ 60.1495 54813.0 1149.63 83982.6 68405.9 ⋯\n", + " 997 │ 20.2505 40179.8 604.303 37256.5 1557.38\n", + " 998 │ 46.0973 76324.1 1224.21 69675.7 81623.6\n", + " 999 │ 45.923 82764.5 1286.87 68973.9 1.173\n", + " 1000 │ 52.2887 38639.2 909.279 67615.9 54478.8 ⋯\n", + "\u001b[36m 1 column and 979 rows omitted\u001b[0m" + ] + }, + "execution_count": 212, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "personal_income = parents_income + rand(Normal(0, 10000), n) + partner_income .- mean(partner_income)\n", + "\n", + "\n", + "df = DataFrame(age = age, parents_income = parents_income, \n", + " minutes_per_year = minutes_per_year, partner_income = partner_income,\n", + "personal_income = personal_income)" + ] + }, + { + "cell_type": "markdown", + "id": "03cdf856", + "metadata": {}, + "source": [ + "We still get the correct effect (in this case, 1) by not conditioning on the minutes of classical music per year. " + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "id": "774278ea", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "personal_income ~ 1 + partner_income\n", + "\n", + "Coefficients:\n", + "──────────────────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "──────────────────────────────────────────────────────────────────────────────────────\n", + "(Intercept) -11324.3 2806.52 -4.03 <1e-04 -16831.6 -5816.91\n", + "partner_income 0.942698 0.041567 22.68 <1e-91 0.86113 1.02427\n", + "──────────────────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 213, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using GLM\n", + "model = lm(@formula(personal_income ~ partner_income), df)" + ] + }, + { + "cell_type": "code", + "execution_count": 214, + "id": "194de1bf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "personal_income ~ 1 + partner_income + minutes_per_year\n", + "\n", + "Coefficients:\n", + "─────────────────────────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "─────────────────────────────────────────────────────────────────────────────────────────────\n", + "(Intercept) -60272.4 1934.07 -31.16 <1e-99 -64067.7 -56477.1\n", + "partner_income 0.406422 0.0265477 15.31 <1e-46 0.354326 0.458517\n", + "minutes_per_year 86.6982 1.91222 45.34 <1e-99 82.9458 90.4506\n", + "─────────────────────────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 214, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using GLM\n", + "model_conditioned = lm(@formula(personal_income ~ partner_income + minutes_per_year), df)" + ] + }, + { + "cell_type": "code", + "execution_count": 215, + "id": "06f47930", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "personal_income ~ 1 + partner_income + parents_income + minutes_per_year\n", + "\n", + "Coefficients:\n", + "────────────────────────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "────────────────────────────────────────────────────────────────────────────────────────────\n", + "(Intercept) -65722.8 1551.88 -42.35 <1e-99 -68768.1 -62677.5\n", + "partner_income 0.961906 0.0311592 30.87 <1e-99 0.90076 1.02305\n", + "parents_income 0.99542 0.0411256 24.20 <1e-99 0.914717 1.07612\n", + "minutes_per_year 3.41651 3.76079 0.91 0.3639 -3.96347 10.7965\n", + "────────────────────────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 215, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using GLM\n", + "model_conditioned_backdoor_blocked = lm(@formula(personal_income ~ partner_income + parents_income + minutes_per_year), df)" + ] + }, + { + "cell_type": "markdown", + "id": "eae9d76e", + "metadata": {}, + "source": [ + "For more information, see [here](https://ftp.cs.ucla.edu/pub/stat_ser/r493.pdf)" + ] + }, + { + "cell_type": "code", + "execution_count": 216, + "id": "8a33b498", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " A\n", + " \n", + " \n", + " \n", + " \n", + " C\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " B\n", + " \n", + " \n", + "\n", + "\n" + ], + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " A\n", + " \n", + " \n", + " \n", + " \n", + " C\n", + " \n", + " \n", + " \n", + " \n", + " Y\n", + " \n", + " \n", + " \n", + " \n", + " X\n", + " \n", + " \n", + " \n", + " \n", + " B\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8595506233646433cx, -0.052668516238258745cy), (0.1928839566979766cx, -0.44733148376174126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.9167949705662156cx, -0.12480754415067653cy), (-0.4165383627671177cx, -0.8751924558493234cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.41653836276711764cx, -0.3751924558493235cy), (0.9167949705662156cx, 0.3751924558493235cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.33333333333333326cx, -0.35cy), (0.33333333333333326cx, 0.85cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.09288866583745324cx, -0.4463610170084019cy), (0.1928839566979766cx, -0.44733148376174126cy), (0.116906923800866cx, -0.3823123291059679cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.49712092697361143cx, -0.8159771677396949cy), (-0.4165383627671177cx, -0.8751924558493234cy), (-0.4402053347888926cx, -0.7780334396165489cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8931279985444407cx, 0.278033439616549cy), (0.9167949705662156cx, 0.3751924558493235cy), (0.8362124063597218cx, 0.3159771677396949cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.3675353476659001cx, 0.7560307379214091cy), (0.33333333333333326cx, 0.85cy), (0.2991313190007664cx, 0.7560307379214092cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.3416407864998738mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 0.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.5cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 0.5cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, 1.0cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.3416407864998738mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 0.0cy), \"A\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.5cy), \"C\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 0.5cy), \"Y\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, -1.0cy), \"X\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, 1.0cy), \"B\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 216, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "\n", + "g = SimpleDiGraph(5)\n", + "add_edge!(g, 1, 2)\n", + "\n", + "add_edge!(g, 2, 3)\n", + "add_edge!(g, 1, 4)\n", + "add_edge!(g, 2, 5)\n", + "nodelabel = [\"A\", \"C\", \"Y\", \"X\", \"B\"]\n", + "\n", + "locs_x = [0, 2, 3, 1, 2]\n", + "locs_y = [0, -1, 1, -2, 2]\n", + "\n", + "nodestrokelw = [0, 1, 0, 0, 0]\n", + "\n", + "\n", + "g = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15)\n", + "\n", + "draw(PNG(\"heart_disease_1.png\", 16cm, 16cm),g)\n", + "g" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e4cc9fa", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "99e3a8be", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.8.3", + "language": "julia", + "name": "julia-1.8" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/julia_gift_exchange_simulation.ipynb b/julia_gift_exchange_simulation.ipynb new file mode 100644 index 0000000..3e78ce6 --- /dev/null +++ b/julia_gift_exchange_simulation.ipynb @@ -0,0 +1,805 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "50e67a88", + "metadata": {}, + "source": [ + "### Simulation study\n", + "\n", + "Simulation studies are used in statistics to estimate the probability of a certain event happening using pseudorandom numbers generated by a computer. Because it can be expensive and time-consuming to collect lots of real-world data on a phenomenon, statisticians sometimes use computers to create many simulated worlds and determine the frequency of an event happening in those simulated worlds. Simulation studies are used when it is difficult or impossible to analytically compute the probability of an event happening. For example, simulation is generally used to model processes happening on complex networks. \n", + "\n", + "\n", + "### Current problem: christmas gift exchange\n", + "\n", + "One of my favorite family traditions is our sibling gift draw: we each draw from a hat to choose a sibling to give a gift to. Then, on christmas, we all open gifts from each other one at a time. \n", + "\n", + "My youngest sibling will usually open the first gift. Then, whoever gave the youngest sibling the gift opens their gift, and so on. This cycle of opening gifts continues until either we have all opened our gifts, or until someone opens a gift which was given to them by the youngest sibling. If this happens, we have to choose another person to open a gift, and start another cycle of gift-opening. \n", + "\n", + "This year, something unusual happened: there were 4 \"cycles\" of gift-giving—the maximum number possible. Six of us had reciprocal gift assignments (they received a gift from the same person that they gave a gift to). This seemed unusual to me, but I wanted to know how unusual this event was. So, I set out to do a simulation study to assess how likely this was. " + ] + }, + { + "cell_type": "markdown", + "id": "7a246b16", + "metadata": {}, + "source": [ + "### Step 1: simulate a data-generating process\n", + "\n", + "In my family, gift assignments are given essentially at random. There are only two constraints: each person must give a gift to exactly one other person, and nobody can be assigned to give a gift to themselves. So, here, I'll define a function which generates a possible arrangement of gift-giving. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1866db1b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_valid_selection (generic function with 1 method)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Random\n", + "function get_valid_selection(num_participants)\n", + " selection_found = false\n", + " selection = randperm(num_participants)\n", + " while !selection_found\n", + " no_self_assignments = true\n", + " for i in 1:num_participants\n", + " if selection[i] == i ## someone got themselves\n", + " no_self_assignments = false\n", + " end\n", + " end\n", + " if no_self_assignments\n", + " selection_found = true\n", + " else\n", + " selection = randperm(num_participants)\n", + " end\n", + " end\n", + " return selection\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "cbe63fbc", + "metadata": {}, + "source": [ + "This function takes the number of family members and returns a vector saying who is assigned to give to whom. In this simulation, person 1 receives a gift from person 7, person 2 receives a gift to person 8, and so on. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9dee4090", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9-element Vector{Int64}:\n", + " 8\n", + " 7\n", + " 4\n", + " 3\n", + " 6\n", + " 1\n", + " 9\n", + " 5\n", + " 2" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "get_valid_selection(9)" + ] + }, + { + "cell_type": "markdown", + "id": "07cf676b", + "metadata": {}, + "source": [ + "### Step 2: Generate a metric from simulated data\n", + "\n", + "Now that I can simulate a family gift drawing, I need to figure out how rare my event of having 4 cycles is. To count the number of cycles, I'll define a function" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "22d8e814", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count_cycles (generic function with 1 method)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function count_cycles(selection)\n", + " num_participants = length(selection) # number of people in the drawing\n", + " given_gifts = repeat([-1], num_participants) #a vector of placeholders to record who has given a gift already\n", + " num_cycles = 1 ## we will always have at least one cycle\n", + " current_opener = 1 ## the youngest person will start with opening their gift\n", + " final_sum = sum(1:num_participants) ## our given_gifts vector will sum to this once everyone has been found\n", + " while sum(given_gifts) != final_sum\n", + " if !(current_opener in given_gifts) ## they haven't opened a gift yet, so we'll stay in the current cycle\n", + " # Add them to the opened_gifts list to mark that we have to start a new cycle if they're\n", + " # assigned to open a gift\n", + " given_gifts[current_opener] = current_opener\n", + " # Now, they open their gift, and the person who gave them the gift\n", + " # opens the next gift \n", + " current_opener = selection[current_opener] \n", + " else # They've already given a gift, so we need to start a new cycle\n", + " num_cycles = num_cycles + 1\n", + " # choose someone who hasn't opened a gift yet to open the next gift.\n", + " current_opener = findfirst(given_gifts .== -1) \n", + " # the .== means that we're comparing each element of given_gifts to -1\n", + "\n", + " end\n", + " end\n", + " return num_cycles\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "a98fb39f", + "metadata": {}, + "source": [ + "### Step 3: Estimate the probability of an event happening in the real world. \n", + "\n", + "Now, we run our simulation lots of times, and estimate the probability that we will see a given number of cycles. Here, I'm just using a for loop to run both get_valid_selection and count_cycles many times. Then, I create a frequency table to estimate the probability of getting 4 cycles. In this function, I will use the [normal approximation](https://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval#Normal_approximation_interval_or_Wald_interval) of the binomial distribution to create a 95% confidence interval around the probabilities I estimate. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "3f0da66e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "estimate_probabilities_for_printing (generic function with 1 method)" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using FreqTables, Distributions\n", + "function estimate_probabilities(num_participants, num_simulations)\n", + " num_cycles = repeat([-1], num_simulations) #create a placeholder vector for each simulation we do\n", + "\n", + " for i in 1:num_simulations\n", + " selection = get_valid_selection(num_participants)\n", + " num_cycles[i] = count_cycles(selection)\n", + " end\n", + " prop_table = prop(freqtable(num_cycles)) #create a table showing the frequency of getting given number of cycles\n", + " println(\"Results for \", num_participants, \" participants, using \", num_simulations, \" simulations\")\n", + " println(prop_table)\n", + " max_cycles = maximum(names(prop_table)[1])\n", + " z_975 = quantile(Normal(0.0, 1.0), .975)\n", + " p_hat = prop_table[max_cycles]\n", + " lower_bound = p_hat - z_975 * sqrt(p_hat * (1 - p_hat) / num_simulations)\n", + " upper_bound = p_hat + z_975 * sqrt(p_hat * (1 - p_hat) / num_simulations)\n", + " println(\"95% confidence interval for probability of getting \", max_cycles, \" cycles: [\", \n", + " round(lower_bound, digits = 4), \", \", round(upper_bound, digits = 4), \"]\")\n", + " \n", + "end\n", + "\n", + "function estimate_probabilities_for_printing(num_participants, num_simulations)\n", + " num_cycles = repeat([-1], num_simulations) #create a placeholder vector for each simulation we do\n", + "\n", + " for i in 1:num_simulations\n", + " selection = get_valid_selection(num_participants)\n", + " num_cycles[i] = count_cycles(selection)\n", + " end\n", + " prop_table = prop(freqtable(num_cycles)) #create a table showing the frequency of getting given number of cycles\n", + " #println(\"Results for \", num_participants, \" participants, using \", num_simulations, \" simulations\")\n", + " #println(prop_table)\n", + " max_cycles = maximum(names(prop_table)[1])\n", + " z_975 = quantile(Normal(0.0, 1.0), .975)\n", + " p_hat = prop_table[max_cycles]\n", + " lower_bound = p_hat - z_975 * sqrt(p_hat * (1 - p_hat) / num_simulations)\n", + " upper_bound = p_hat + z_975 * sqrt(p_hat * (1 - p_hat) / num_simulations)\n", + " #println(\"95% confidence interval for probability of getting \", max_cycles, \" cycles: [\", \n", + " # round(lower_bound, digits = 4), \", \", round(upper_bound, digits = 4), \"]\")\n", + " print(\"\\t\",round(lower_bound, digits = 4),\"\\t\",round(upper_bound, digits = 4), \"\\n\")\n", + " \n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "ec787b70", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results for 9 participants, using 1000000 simulations\n", + "4-element Named Vector{Float64}\n", + "Dim1 │ \n", + "──────┼─────────\n", + "1 │ 0.303011\n", + "2 │ 0.480495\n", + "3 │ 0.197632\n", + "4 │ 0.018862\n", + "95% confidence interval for probability of getting 4 cycles: [0.0186, 0.0191]\n" + ] + } + ], + "source": [ + "estimate_probabilities(9, 1000000)" + ] + }, + { + "cell_type": "markdown", + "id": "9591469b", + "metadata": {}, + "source": [ + "It's really quite remarkable how quickly Julia runs this simulation. I'm used to running simulations in R or Python which are a lot slower. It almost feels like Julia isn't even running the simulations. " + ] + }, + { + "cell_type": "markdown", + "id": "5ca72fb6", + "metadata": {}, + "source": [ + "### Analytical solution\n", + "\n", + "Using simulation, I have a pretty good estimate for the probability of this event happening. However, let's double-check our work using analytic techniques. \n", + "\n", + "To do this, we need to compute the following fraction:\n", + " \n", + "$\\frac{\\text{possible ways to get 4 cycles}}{\\text{possible ways gifts could be assigned}}$\n", + "\n", + "Let's start with the denominator. To find the number of different ways a gift exchange could happen, we can use [derangements](https://en.wikipedia.org/wiki/Derangement), which estimate the number of permutations of a set such that no element of the set remains in its original position. We can estimate this according to the following formula: \n", + "\n", + "$!n = n! \\sum_{i = 0}^{n}\\frac{(-1)^i}{i!}$\n", + "\n", + "And, I'll write this function to easily calculate this quantity:" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "137f5179", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_derangement (generic function with 1 method)" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function get_derangement(num_participants)\n", + "\n", + " sum = 0\n", + " for i in 0:num_participants\n", + " sum += (-1)^i / factorial(i)\n", + " end\n", + " return round(sum * factorial(num_participants))\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "10249b18", + "metadata": {}, + "source": [ + "Next, let's figure out the numerator of that fraction. \n", + "\n", + "We can think about this as choosing 2 people at random until that is no longer possible, because the maximum number of cycles for a given group of people will always involve mostly groups of 2. \n", + "\n", + "If n is even, we can think about just choosing pairs of 2 people until people run out. However, when we do this, we can end up double-counting ways to assign gift pairs because we haven't considered order. To fix this double-counting, we divide by the factorial of the number of pairs we selected. So, we can use the following formula if n is even:\n", + "\n", + "$\\frac{\\prod_{i = 1}^{n / 2}{2i \\choose 2}}{(n / 2)!}$\n", + "\n", + "We can do a similar thing if n is odd. However, in this case, the last set chosen is a set of 3, so we don't have to worry about double-counting for that set. But, we do have to consider that there are multiple ways to choose how people give others gifts in that last set of 3, so we will multiply by the derangement of 3 to account for that. So, we can use the following equation if n is odd:\n", + "\n", + "$\\frac{!3 \\prod_{i = 1}^{(n- 3) / 2}{2i \\choose 2}}{((n-3) / 2)!}$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "62092f3b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_numerator (generic function with 1 method)" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function comb(n, k) #number of ways to choose k people from a group of n people\n", + " factorial(n) / factorial(k) / factorial(n - k)\n", + "end\n", + "\n", + "function get_numerator(num_participants)\n", + " num_participants_left = num_participants\n", + " numerator = 1\n", + " num_2_pairs = 0 # what we have to divide by in the denominator\n", + " while num_participants_left > 3\n", + " numerator = numerator * comb(num_participants_left, 2)\n", + " num_participants_left = num_participants_left - 2\n", + " num_2_pairs = num_2_pairs + 1\n", + " end\n", + "\n", + " if num_participants_left == 3\n", + " numerator = numerator * get_derangement(3) / factorial(num_2_pairs)\n", + " else # in this case, we have just 2 participants left, so we have to include them as a choice of 2\n", + " num_2_pairs = num_2_pairs + 1\n", + " numerator = numerator * comb(2, 2) / factorial(num_2_pairs)\n", + " end\n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "c2588a7b", + "metadata": {}, + "source": [ + "Finally, let's put these together into a function that calculates the proportion of individuals with the maximum number of cycles for a given group size. " + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "id": "285462a3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "analytical_probability_printing (generic function with 1 method)" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function analytical_probability(num_participants)\n", + " prob = get_numerator(num_participants) / get_derangement(num_participants)\n", + " println(\"Actual probability: \", prob)\n", + "end\n", + "\n", + "function analytical_probability_printing(num_participants)\n", + " prob = get_numerator(num_participants) / get_derangement(num_participants)\n", + " print(round(prob, digits = 4))\n", + "end\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "d5146ba2", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "7b09a2c2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\t0.3333\t0.3329\t0.3348\n", + "5\t0.4545\t0.4535\t0.4555\n", + "6\t0.0566\t0.0565\t0.0574\n", + "7\t0.1133\t0.1123\t0.1136\n", + "8\t0.0071\t0.0069\t0.0072\n", + "9\t0.0189\t0.0185\t0.019\n", + "10\t0.0007\t0.0007\t0.0008\n", + "11\t0.0024\t0.0022\t0.0024\n", + "12\t0.0001\t0.0\t0.0001\n" + ] + } + ], + "source": [ + "for i in 4:12\n", + " print(i, \"\\t\")\n", + " analytical_probability_printing(i)\n", + " estimate_probabilities_for_printing(i, 1000000)\n", + " \n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "ba5c0ab1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Numerator: 3.0\n", + "Denominator: 9.0\n", + "0.3333333333333333\n" + ] + } + ], + "source": [ + "num = comb(4, 2) * comb(2, 2) / factorial(2)\n", + "den = get_derangement(4)\n", + "println(\"Numerator: \", num)\n", + "println(\"Denominator: \", den)\n", + "println(num / den)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "7d01b15f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Numerator: 20.0\n", + "Denominator: 44.0\n", + "0.45454545454545453\n" + ] + } + ], + "source": [ + "\n", + "num = comb(5, 2) * get_derangement(3) / factorial(1)\n", + "den = get_derangement(5)\n", + "println(\"Numerator: \", num)\n", + "println(\"Denominator: \", den)\n", + "println(num / den)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "aecaf89a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Numerator: 15.0\n", + "Denominator: 265.0\n", + "0.05660377358490566\n" + ] + } + ], + "source": [ + "num = comb(6, 2) * comb(4, 2) * comb(2, 2) / factorial(3)\n", + "den = get_derangement(6)\n", + "println(\"Numerator: \", num)\n", + "println(\"Denominator: \", den)\n", + "println(num / den)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "6942248c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Numerator: 210.0\n", + "Denominator: 1854.0\n", + "0.11326860841423948\n" + ] + } + ], + "source": [ + "\n", + "num = comb(7, 2) * comb(5, 2) * get_derangement(3) / factorial(2)\n", + "den = get_derangement(7)\n", + "println(\"Numerator: \", num)\n", + "println(\"Denominator: \", den)\n", + "println(num / den)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "d0426ea1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Numerator: 105.0\n", + "Denominator: 14833.0\n", + "0.0070788107597923545\n" + ] + } + ], + "source": [ + "\n", + "num = comb(8, 2) * comb(6, 2) * comb(4, 2) * comb(2, 2) / factorial(4)\n", + "den = get_derangement(8)\n", + "\n", + "println(\"Numerator: \", num)\n", + "println(\"Denominator: \", den)\n", + "println(num / den)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "a94aa413", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Numerator: 2520.0\n", + "Denominator: 133496.0\n", + "0.01887697009648229\n" + ] + } + ], + "source": [ + "num = comb(9, 2) * comb(7, 2) * comb(5, 2) * get_derangement(3) / factorial(3)\n", + "den = get_derangement(9)\n", + "println(\"Numerator: \", num)\n", + "println(\"Denominator: \", den)\n", + "println(num / den)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "35d10b88", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count_cycles (generic function with 2 methods)" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Random\n", + "function get_valid_selection(num_participants)\n", + " selection_found = false\n", + " selection = randperm(num_participants)\n", + " while !selection_found\n", + " no_self_assignments = true\n", + " for i in 1:num_participants\n", + " if selection[i] == i ## someone got themselves\n", + " no_self_assignments = false\n", + " end\n", + " end\n", + " if no_self_assignments\n", + " selection_found = true\n", + " else\n", + " selection = randperm(num_participants)\n", + " end\n", + " end\n", + " return selection\n", + "end\n", + "\n", + "function count_cycles(selection)\n", + " num_participants = length(selection)\n", + " found_members = repeat([-1], num_participants)\n", + " num_cycles = 1 ## we have to have at least one cycle\n", + " current_giver = 1 ## the first person to get a gift\n", + " final_sum = sum(1:num_participants)\n", + " while sum(found_members) != final_sum\n", + "\n", + " if !(current_giver in found_members) ## they haven't given a gift yet\n", + " found_members[current_giver] = current_giver ## Add them to the current_giver list\n", + " current_giver = selection[current_giver] ## The next person opens the gift\n", + " else # They've already given a gift, so we need to start a new cycle\n", + " num_cycles = num_cycles + 1\n", + " current_giver = findfirst(found_members .== -1)\n", + "\n", + " end\n", + " end\n", + " return num_cycles\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "11620ae8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "estimate_probabilities (generic function with 1 method)" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using FreqTables\n", + "function estimate_probabilities(num_participants, num_simulations)\n", + " num_cycles = repeat([-1], num_simulations)\n", + "\n", + " for i in 1:num_simulations\n", + " selection = get_valid_selection(num_participants)\n", + " num_cycles[i] = count_cycles(selection)\n", + " end\n", + " table = freqtable(num_cycles)\n", + " println(\"Table for \", num_participants, \" participants\")\n", + " println(prop(table))\n", + "end\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "dfe33dbc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Table for 9 participants\n", + "4-element Named Vector{Float64}\n", + "Dim1 │ \n", + "──────┼────────\n", + "1 │ 0.30412\n", + "2 │ 0.47919\n", + "3 │ 0.19751\n", + "4 │ 0.01918\n" + ] + } + ], + "source": [ + "estimate_probabilities(9, 100000)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "8b0b6b0f", + "metadata": {}, + "outputs": [ + { + "ename": "LoadError", + "evalue": "DimensionMismatch: column :name has length 1 and column :probability has length 2", + "output_type": "error", + "traceback": [ + "DimensionMismatch: column :name has length 1 and column :probability has length 2", + "", + "Stacktrace:", + " [1] DataFrame(columns::Vector{Any}, colindex::DataFrames.Index; copycols::Bool)", + " @ DataFrames ~/.julia/packages/DataFrames/dgZn3/src/dataframe/dataframe.jl:206", + " [2] DataFrame(; kwargs::Base.Pairs{Symbol, AbstractVector, Tuple{Symbol, Symbol}, NamedTuple{(:name, :probability), Tuple{Vector{Vector{Int64}}, NamedArrays.NamedVector{Float64, Vector{Float64}, Tuple{OrderedCollections.OrderedDict{Int64, Int64}}}}}})", + " @ DataFrames ~/.julia/packages/DataFrames/dgZn3/src/dataframe/dataframe.jl:326", + " [3] top-level scope", + " @ In[71]:2", + " [4] eval", + " @ ./boot.jl:368 [inlined]", + " [5] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)", + " @ Base ./loading.jl:1428" + ] + } + ], + "source": [ + "using DataFrames\n", + "DataFrame(name = names(table), probability = table)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "f4650b72", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2-element Named Vector{Float64}\n", + "Dim1 │ \n", + "──────┼─────\n", + "1 │ 0.75\n", + "2 │ 0.25\n" + ] + } + ], + "source": [ + "println(table)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34ed7628", + "metadata": {}, + "outputs": [], + "source": [ + "x x 3 4 5\n", + "x 2 x 4 5\n", + "x 2 3 x 5\n", + "x 2 3 4 x\n", + "1 x x 4 5\n", + "1 x 3 x 5\n", + "1 x 3 4 x\n", + "1 2 x x 5\n", + "1 2 x 4 x\n", + "1 2 3 x x " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.8.3", + "language": "julia", + "name": "julia-1.8" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/nonlinear_causal_simulations.Rmd b/nonlinear_causal_simulations.Rmd new file mode 100644 index 0000000..b4dc011 --- /dev/null +++ b/nonlinear_causal_simulations.Rmd @@ -0,0 +1,210 @@ +--- +title: "double_ml" +author: "Zachary Clement" +date: "`r Sys.Date()`" +output: html_document +--- + +```{r} +#remotes::install_github("DoubleML/doubleml-for-r") +``` + + + + +```{r} + +random_function <- function(c){ + slope = runif(1) + return(c*slope) +} + +random_function <- function(c){ + randnum = runif(1) + if (randnum < .25){ + return(cos(c)) + } + else if (randnum < .5){ + return(sin(c)) + } + else if (randnum < .75){ + return(c^2) + + } + else { + return(exp(c) ) +} +} + + +``` + +```{r} +generate_data <- function (n, n_confounders = 3, p_confounder = .5, effect_size = 2){ + + c0 = rnorm(n) + df = data.frame(c0 = c0) #at least one confounder + m1 = c0 + rnorm(n) + m2 = c0 + rnorm(n) + + for (i in 1:n_confounders){ + c = rnorm(n) + if (runif(1) < p_confounder){ + m1 = m1 + random_function(c) + m2 = m2 + random_function(c) + } + df[,paste0("c", as.character(i))] = c + } + + x = rnorm(n, sd = sd(m1) / 2) + m1 + + y = x * effect_size + m2 + rnorm(n, sd = sd(m2) /10) + df$x = x + df$y = y + return(df) + +} +``` + +```{r} +get_estimates <- function(n = 3000){ + df = generate_data(n) + df_doubleml = DoubleML::double_ml_data_from_data_frame(df, y_col = c("y"), d_cols = c("x")) + dml_obj = DoubleML::DoubleMLPLR$new(df_doubleml, mlr3::lrn("regr.svm"), mlr3::lrn("regr.svm")) + dml_obj$fit() + dml_df = data.frame(dml_obj$confint()) + colnames(dml_df) <- c("dml_lower", "dml_upper") + x_var = summary(lm(y ~ ., data = df))$coefficients["x",] + + linear_df = data.frame((x_var["Estimate"] + c(-1, 1) *qnorm(.975) * x_var["Std. Error"]) |> t()) + colnames(linear_df) <- c("linear_lower", "linear_upper") + + spline_mod = lm(y ~ x + splines::ns(c0) + splines::ns(c1, df = 3) + splines::ns(c2, df = 3) + splines::ns(c3, df = 3), data = df) + + x_var = summary(spline_mod)$coefficients["x",] + spline_df = data.frame((x_var["Estimate"] + c(-1, 1) * qnorm(.975) * x_var["Std. Error"]) |> t()) + colnames(spline_df) <- c("spline_lower", "spline_upper") + + output_df = cbind(spline_df, linear_df, dml_df) + return(c(output_df[1,])) + +} +``` + +```{r} +n_simulations = 30 +simulations = replicate(n_simulations, get_estimates(), simplify = TRUE) + +simulations_df = data.frame(simulations[,1]) +for (i in 2:n_simulations){ + simulations_df = rbind(simulations_df, data.frame(simulations[,i])) +} + +``` + +```{r} + +ylim_vec = c( + min(c(simulations_df$dml_lower, simulations_df$linear_lower, simulations_df$spline_lower)), + max(c(simulations_df$dml_upper, simulations_df$linear_upper, simulations_df$spline_upper)) + ) +plot(1:n_simulations, simulations_df$spline_lower, ylim = ylim_vec + ) +points(1:n_simulations, simulations_df$spline_upper) +#points(1:n_simulations, simulations_df$linear_upper, col = "blue") +#points(1:n_simulations, simulations_df$linear_lower, col = "blue") +points(1:n_simulations, simulations_df$dml_upper, col = "green") +points(1:n_simulations, simulations_df$dml_lower, col = "green") +``` + +```{r} +dml_coverage = mean(simulations_df$dml_lower < 2 & simulations_df$dml_upper > 2) +linear_coverage = mean(simulations_df$linear_lower < 2 & simulations_df$linear_upper > 2) +spline_coverage = mean(simulations_df$spline_lower < 2 & simulations_df$spline_upper > 2) +``` + + + + +```{r} +linear_df = data.frame(x_var["Estimate"] + c(-1, 1) *qnorm(.975) * x_var["Std. Error"]) +``` + + +```{r} +dml_df = data.frame(dml_obj$confint()) +colnames(dml_df) <- c("dml_lower", "dml_upper") +``` + +```{r} +dml_df +``` + + +```{r} +df = generate_data(1000) + +``` + +```{r} +#dml_obj = DoubleML::DoubleMLPLR$new(df_doubleml, mlr3::lrn("regr.xgboost"), mlr3::lrn("regr.xgboost")) + +# mlr3::lrns() to see list of learners +``` + +```{r} + + +``` + +```{r} + +``` + +```{r} + +``` + +```{r} +spline_mod = lm(y ~ x + splines::ns(c0) + splines::ns(c1) + splines::ns(c2) + splines::ns(c3), data = df) + +x_var = summary(spline_mod)$coefficients["x",] + +x_var["Estimate"] + c(-1, 1) *qnorm(.975) * x_var["Std. Error"] +``` + + + +```{r} +get_data <- function(n){ + x = rnorm(n) + y = cos(x) + rnorm(n, sd = 0.05) + return(data.frame(x = x, y=y)) +} +``` + + + +```{r} +df = get_data(500) + +task = mlr3::as_task_regr(y ~ x, data = df) + +learner = mlr3::lrn("regr.svm") + +learner$train(task) + +mlr3::lrns() +``` + +```{r} + +df = get_data(50) +task2 = mlr3::as_task_regr(y ~ x, data = df) + +preds = learner$predict(task2) + + +plot(df$x, df$y, col = "green") +points(df$x, preds$response) +``` \ No newline at end of file diff --git a/sparsity_causal_simulations.ipynb b/sparsity_causal_simulations.ipynb new file mode 100644 index 0000000..6250abb --- /dev/null +++ b/sparsity_causal_simulations.ipynb @@ -0,0 +1,1794 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "id": "03e44f3e", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "id": "1f0d15cd", + "metadata": {}, + "source": [ + "In this post, I'll introduce the econml python package and use it to compare double machine learning and doubly robust learning. I'll look at whether bootstrapping standard errors improves the coverage of confidence intervals, and I'll also look at whether sample size influences estimation accuracy. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "7f488f07", + "metadata": {}, + "source": [ + "I. Introduction to econml\n", + "\n", + "The econml package was developed by the [ALICE team](https://www.microsoft.com/en-us/research/group/alice/) at microsoft research to facilitate estimation of causal effects. This package builds upon [scikit-learn](https://scikit-learn.org/stable/) and presents several different algorithms for causal inference in one unified framework. \n", + "\n", + "One of the main reasons to use econml is its integration with scikit-learn. Because econml uses scikit-learn style estimators under the hood, it is easy to evaluate how a model would do if a different estimation style were used by simply swapping out one line in the code.\n", + "\n", + "Another big reason to use econml is that estimators defined in econml all inherit from the same base class. In practice, this means that the methods used to fit models and present treatment effects are the same, regardless of which estimator you are using. So, in this post, switching between double machine learning and doubly robust machine learning is very simple--no additional documentation reading is needed. " + ] + }, + { + "cell_type": "markdown", + "id": "a0675303", + "metadata": {}, + "source": [ + "II. Brief introduction to double machine and doubly robust learning. \n", + "\n", + "Doubly robust machine learning involves fitting two models: one model to predict the treatment X from possible confounders, and another model to predict the outcome Y from X as well as possible confounders. One of the parameters estimated in the second model is used to estimate the average treatment effect of X on Y. This method was developed by [Robins et al.](https://www.tandfonline.com/doi/pdf/10.1080/01621459.1994.10476818?needAccess=true&role=button) in 1994, and has been frequently been used under the name inverse probability weighting. For more on doubly robust machine learning, see [this](https://towardsdatascience.com/doubly-robust-estimators-for-causal-inference-in-statistical-estimation-3c00847e9db) blog post.\n", + "\n", + "Double machine learning involves fitting two models: one model to predict X from confounders and another model to predict Y from the confounders. The residuals of the two models are then used to generate estimates of the causal effect of X on Y. I wrote [this post](https://medium.com/@clementzach_38631/double-machine-learning-for-causal-inference-from-a-partially-linear-model-ada4c39914e3) on double machine learning for more of an overview. " + ] + }, + { + "cell_type": "markdown", + "id": "74adbbdd", + "metadata": {}, + "source": [ + "III. Data generation. \n", + "\n", + "For this simulation, I generated data in a similar method as my previous [blog post](https://medium.com/@clementzach_38631/causal-inference-with-high-dimensional-data-an-evaluation-of-the-double-machine-learning-algorithm-a882d2135bd5). However, I converted x to a binary variable because doubly robust learning only works with categorical variables. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5128afda", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "def generate_data(n = 400, n_confounders = 10, \n", + " n_possible_confounders = 300, \n", + " causal_effect_size = 2, \n", + " beta_c_x = None, beta_c_y = 1, \n", + " sd_x_error = None, \n", + " sd_confounders = 1):\n", + " \n", + " if beta_c_x is None:\n", + " beta_c_x = np.sqrt(1/(n_confounders + 1)) #this lets our x have a variance of 1\n", + " \n", + " if sd_x_error is None:\n", + " sd_x_error = np.sqrt(1/(n_confounders + 1)) #same as above\n", + " \n", + " zero_sequence = np.zeros(n) # a sequence of zeroes the length of our model\n", + " data_dict = dict()\n", + " x = m1 = m2 = zero_sequence\n", + " \n", + " for i in range(n_confounders): # We will have some variables that are true confounders\n", + " c = np.random.normal(size = n, scale = sd_confounders) # Create some variance in the confounder\n", + " m1 = m1 + c*beta_c_x\n", + " m2 = m2 + c*beta_c_y\n", + "\n", + " data_dict[\"c\" + str(i)] = c\n", + " \n", + " for i in range(n_confounders,n_possible_confounders): #because we are testing sparsity, the rest of the variables will have zero effect. \n", + " c = np.random.normal(size = n, scale = sd_confounders)\n", + "\n", + " data_dict[\"fc\" + str(i)] = c #label them as fake\n", + " x = ((np.random.normal(size = n, scale = sd_x_error) + m1 ) > 0) * 1 #convert to binary to make more estimation methods\n", + "\n", + "\n", + " y = x * causal_effect_size + m2 + np.random.normal(size = n, scale = np.std(m2) /10)\n", + "\n", + " data_dict[\"x\"] = x #replaces the column of zeroes we made before\n", + " data_dict[\"y\"] = y\n", + " \n", + " output_df = pd.DataFrame(data_dict)\n", + " \n", + " return output_df\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "4145b693", + "metadata": {}, + "source": [ + "Next, I defined a function to generate an estimate of the average treatment effect from a simulated dataset. As you can see, I can pass in either a LinearDRLearner or a LinearDML object to the function and use the same methods on the object to get simulated effects. \n", + "\n", + "Both methods generate confidence intervals using traditional statistical techniques (\"statsmodels\") or with bootstrapping. Here, I allow my function to conduct estimation under both techniques. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "17504b61", + "metadata": {}, + "outputs": [], + "source": [ + "from econml.dr import LinearDRLearner\n", + "from econml.dml import LinearDML\n", + "\n", + "\n", + "\n", + "estimators_to_test = {\n", + " \"dml_linear_bootstrap\": [LinearDML(), \"bootstrap\"],\n", + " \"dml_linear_statsmodels\": [LinearDML(), \"statsmodels\"],\n", + " \"dr_linear_bootstrap\": [LinearDRLearner(), \"bootstrap\"],\n", + " \"dr_linear_statsmodels\": [LinearDRLearner(), \"statsmodels\"]\n", + "}\n", + "\n", + "def get_econml_estimate(sim_df, est, inference_method = \"bootstrap\", sample_size = 0, estimator_name = \"\", alpha = 0.05):\n", + " est.fit(sim_df[\"y\"], T = sim_df[\"x\"], W=sim_df.drop([\"x\",\"y\"], axis = 1), inference = inference_method)\n", + " lb, ub = est.ate_interval(alpha=alpha) # OLS confidence intervals\n", + " point_estimate = est.ate()\n", + " return {\"lower\": lb, \"estimate\": point_estimate, \"upper\": ub, \"n\": sample_size, \"estimator_name\": estimator_name}\n", + " \n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "fd7464f0", + "metadata": {}, + "source": [ + "I'll also define a function to get effects using a standard linear model. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9d5b79a1", + "metadata": {}, + "outputs": [], + "source": [ + "import statsmodels.api as sm\n", + "def get_lm_interval(sim_df, sample_size = 0, alpha = 0.05):\n", + " y = sim_df[\"y\"]\n", + " #sim_df[\"interaction\"] = sim_df[\"moderator\"] * sim_df[\"x\"]\n", + " x = sim_df.drop(\"y\", axis = 1)\n", + " ols_model = sm.OLS(y, x)\n", + " ols_results = ols_model.fit()\n", + " results_df = pd.DataFrame(ols_results.summary(alpha = alpha).tables[1].data)\n", + " results_df.index = results_df[0]\n", + " \n", + " return {\"lower\": float(results_df.loc[\"x\",5]), \n", + " \"upper\": float(results_df.loc[\"x\",6]),\n", + " \"estimate\": float(results_df.loc[\"x\",1]),\n", + " \"n\": sample_size, \n", + " \"estimator_name\": \"standard_linear\"\n", + " }\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "fae9268e", + "metadata": {}, + "outputs": [], + "source": [ + "def get_lm_interval_small(sim_df, sample_size = 0, alpha = 0.05):\n", + " y = sim_df[\"y\"]\n", + " x = sim_df.drop([\"y\"] + [col for col in sim_df.columns if col.startswith(\"f\")], axis = 1)\n", + " ols_model = sm.OLS(y, x)\n", + " ols_results = ols_model.fit()\n", + " results_df = pd.DataFrame(ols_results.summary(alpha = alpha).tables[1].data)\n", + " results_df.index = results_df[0]\n", + " \n", + " return {\"lower\": float(results_df.loc[\"x\",5]), \n", + " \"upper\": float(results_df.loc[\"x\",6]),\n", + " \"estimate\": float(results_df.loc[\"x\",1]),\n", + " \"n\": sample_size, \n", + " \"estimator_name\": \"standard_linear_small\"\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "04bc7d6a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "400\n", + "1600\n", + "6400\n" + ] + } + ], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "import pickle\n", + "\n", + "all_estimates = []\n", + "num_reps = 50\n", + "for sample_size in [400, 1600, 6400]:\n", + " print(sample_size)\n", + " for i in range(num_reps):\n", + " sim_df = generate_data(sample_size)\n", + " for estimator_name in estimators_to_test.keys():\n", + " estimate_dict = get_econml_estimate(sim_df, \n", + " estimators_to_test[estimator_name][0], \n", + " estimators_to_test[estimator_name][1], \n", + " sample_size = sample_size,\n", + " estimator_name = estimator_name)\n", + " all_estimates.append(estimate_dict)\n", + " all_estimates.append(get_lm_interval_small(sim_df, sample_size = sample_size))\n", + " all_estimates.append(get_lm_interval(sim_df, sample_size = sample_size))\n", + " with open('simulations_4_feb.pickle', 'wb') as handle:\n", + " pickle.dump(all_estimates, handle) \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9bf3d2c9", + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "with open('all_estimates_4_feb.pickle', 'wb') as handle:\n", + " pickle.dump(all_estimates, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "81ddcbee", + "metadata": {}, + "outputs": [], + "source": [ + "all_estimates_df = pd.DataFrame(all_estimates)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "a637ba84", + "metadata": {}, + "outputs": [], + "source": [ + "all_estimates_df[\"width\"] = all_estimates_df[\"upper\"] - all_estimates_df[\"lower\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8384a4f1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lowerestimateuppernestimator_namewidth
01.7733861.9368862.100386400dml_linear_bootstrap0.326999
11.8136991.9004631.987227400dml_linear_statsmodels0.173528
2-699.627111843.4522012386.531513400dr_linear_bootstrap3086.158625
3-4117.111658745.1219115607.355481400dr_linear_statsmodels9724.467139
41.9020001.9511002.000000400standard_linear_small0.098000
51.8410001.9406002.041000400standard_linear0.200000
61.8271292.0096462.192164400dml_linear_bootstrap0.365035
71.9646292.0534122.142196400dml_linear_statsmodels0.177567
8-2318.9219072.2479792323.417865400dr_linear_bootstrap4642.339772
92.1986642.2700682.341472400dr_linear_statsmodels0.142808
\n", + "
" + ], + "text/plain": [ + " lower estimate upper n estimator_name \\\n", + "0 1.773386 1.936886 2.100386 400 dml_linear_bootstrap \n", + "1 1.813699 1.900463 1.987227 400 dml_linear_statsmodels \n", + "2 -699.627111 843.452201 2386.531513 400 dr_linear_bootstrap \n", + "3 -4117.111658 745.121911 5607.355481 400 dr_linear_statsmodels \n", + "4 1.902000 1.951100 2.000000 400 standard_linear_small \n", + "5 1.841000 1.940600 2.041000 400 standard_linear \n", + "6 1.827129 2.009646 2.192164 400 dml_linear_bootstrap \n", + "7 1.964629 2.053412 2.142196 400 dml_linear_statsmodels \n", + "8 -2318.921907 2.247979 2323.417865 400 dr_linear_bootstrap \n", + "9 2.198664 2.270068 2.341472 400 dr_linear_statsmodels \n", + "\n", + " width \n", + "0 0.326999 \n", + "1 0.173528 \n", + "2 3086.158625 \n", + "3 9724.467139 \n", + "4 0.098000 \n", + "5 0.200000 \n", + "6 0.365035 \n", + "7 0.177567 \n", + "8 4642.339772 \n", + "9 0.142808 " + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_estimates_df.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "78578a1a", + "metadata": {}, + "outputs": [], + "source": [ + "all_estimates_df.to_pickle(\"all_estimates_5_feb.pkl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "43188df6", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "all_estimates_df = pd.read_pickle(\"all_estimates_5_feb.pkl\")" + ] + }, + { + "cell_type": "markdown", + "id": "43024732", + "metadata": {}, + "source": [ + "First, let's look at whether different estimators are biased. \n", + "\n", + "The bias of an estimator d is defined as the expected value of the estimator minus the true parameter value: \n", + "\n", + "$$E(\\hat{d} - d)$$\n", + "\n", + "For an estimator to be useful, the estimator must have zero bias. If an estimator systematically delivers high or low estimates, that estimator is useless. In the presence of confounding (such as in this situation), it is especially important for the estimator to eliminate bias which originates from confounders.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "c3ce6677", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "## Bias\n", + "\n", + "def bias(x):\n", + " return np.mean(x) - 2\n", + "def mse(x):\n", + " return np.mean((np.array(x) - 2) * (np.array(x) - 2))\n", + "\n", + "def sd(x):\n", + " return np.std(x)\n", + " \n", + "bias_df = all_estimates_df.groupby([\"estimator_name\", \"n\"])[\"estimate\"].agg(\n", + " [bias, sd]\n", + ")\n", + "\n", + "bias_df[\"bias_sd\"] = np.round(bias_df[\"bias\"]).astype(str) + np.round(bias_df[\"sd\"]).astype(str)\n", + "\n", + "#" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "76c9b471", + "metadata": {}, + "outputs": [], + "source": [ + "bias_df[\"bias_sd\"] = np.round(bias_df[\"bias\"], 3).astype(str) + \" (\" + np.round(bias_df[\"sd\"]/ np.sqrt(50), 3).astype(str) + \")\"" + ] + }, + { + "cell_type": "markdown", + "id": "aad6f756", + "metadata": {}, + "source": [ + "| | A | B |\n", + "|:---|----:|----:|\n", + "| a | 1 | 1 |\n", + "| a | 2 | 2 |\n", + "| b | 3 | 3 |" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "ba45c0f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
n40016006400Name
00.017 (0.009)0.002 (0.003)0.003 (0.002)Double Machine Learning
2161.905 (108.094)-188.097 (119.696)0.048 (0.027)Doubly Robust Estimation
4-0.004 (0.008)-0.001 (0.002)0.001 (0.001)Standard Linear Model
\n", + "
" + ], + "text/plain": [ + "n 400 1600 6400 \\\n", + "0 0.017 (0.009) 0.002 (0.003) 0.003 (0.002) \n", + "2 161.905 (108.094) -188.097 (119.696) 0.048 (0.027) \n", + "4 -0.004 (0.008) -0.001 (0.002) 0.001 (0.001) \n", + "\n", + "n Name \n", + "0 Double Machine Learning \n", + "2 Doubly Robust Estimation \n", + "4 Standard Linear Model " + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bias_df = bias_df.reset_index().pivot(index = \"estimator_name\", columns = \"n\", values = \"bias_sd\").reset_index().loc[[0, 2, 4],:]\n", + "\n", + "\n", + "bias_df[\"Name\"] = [\"Double Machine Learning\", \"Doubly Robust Estimation\", \"Standard Linear Model\"]\n", + "\n", + "bias_df.drop(\"estimator_name\", axis = 1, inplace = True)\n", + "bias_df" + ] + }, + { + "cell_type": "markdown", + "id": "79978063", + "metadata": {}, + "source": [ + "Next, let's look at mean squared error, or how close estimates tend to be to the actual parameter value. An estimator with a lower mean squared error is more useful than an estimator with a higher mean squared error because it will estimate the parameter of interest with more precision. \n", + "\n", + "Mean squared error is defined as:\n", + "\n", + "$$E[(\\hat{d} - d)^2]$$\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "id": "e4510bb6", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "## mean squared error\n", + "mse_df = all_estimates_df.groupby([\"estimator_name\", \"n\"])[\"estimate\"].agg([mse]).reset_index()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "id": "b6952924", + "metadata": {}, + "outputs": [], + "source": [ + "translation_dict = {\"dml_linear_bootstrap\": \"Double Machine Learning (Bootstrap)\",\n", + " \"dml_linear_statsmodels\": \"Double Machine Learning (Bootstrap)\",\n", + " \"dr_linear_bootstrap\": \"Doubly Robust Estimation (Bootstrap)\",\n", + " \"dr_linear_statsmodels\": \"Doubly Robust Estimation (Bootstrap)\",\n", + " \"standard_linear\": \"Standard Linear Model\"\n", + " }\n", + "\n", + "translation_dict = {\"dml_linear_bootstrap\": \"Double Machine Learning\",\n", + " \"dml_linear_statsmodels\": \"Double Machine Learning\",\n", + " \"dr_linear_bootstrap\": \"Doubly Robust Estimation\",\n", + " \"dr_linear_statsmodels\": \"Doubly Robust Estimation\",\n", + " \"standard_linear\": \"Standard Linear Model\"\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "id": "94a5b294", + "metadata": {}, + "outputs": [], + "source": [ + "mse_df = mse_df.loc[mse_df[\"estimator_name\"].isin(\n", + " [\"dml_linear_statsmodels\", \"dr_linear_statsmodels\", \"standard_linear\"]),:]" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "id": "f71b5692", + "metadata": {}, + "outputs": [], + "source": [ + "mse_df[\"Estimator\"] = mse_df[\"estimator_name\"].apply(lambda x: translation_dict[x])" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "id": "f97b8a07", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "mse_df[\"MSE\"] = mse_df[\"mse\"]\n", + "\n", + "mse_df[\"Sample Size\"] = mse_df[\"n\"]\n", + "sns.barplot(data=mse_df.loc[ (mse_df[\"estimator_name\"] != \"dr_linear_statsmodels\"), :], \n", + " x=\"Estimator\", y=\"MSE\", hue=\"Sample Size\",\n", + " palette = sns.color_palette(\"Blues_r\"))\n", + "plt.title(\"Mean Squared Error of Estimators\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "id": "f874e15b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nName40016006400
0Double Machine Learning0.0028160.0006710.000133
1Doubly Robust Estimation1778149.937155376383.0853480.016019
2Standard Linear Model0.0031140.0002354.2e-05
\n", + "
" + ], + "text/plain": [ + "n Name 400 1600 6400\n", + "0 Double Machine Learning 0.002816 0.000671 0.000133\n", + "1 Doubly Robust Estimation 1778149.937155 376383.085348 0.016019\n", + "2 Standard Linear Model 0.003114 0.000235 4.2e-05" + ] + }, + "execution_count": 124, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mse_df[\"mse\"] = mse_df[\"mse\"].astype(float).round(6).astype(str)\n", + "mse_df.pivot(index = \"Name\", columns = \"n\", values = \"mse\").reset_index()" + ] + }, + { + "cell_type": "markdown", + "id": "9b06000f", + "metadata": {}, + "source": [ + "Finally, let's look at coverage probabilities. We calculated 95% confidence intervals for our estimates using both bootstrap estimation and estimation based on a known distribution. In bootstrap variance estimation, the dataset is duplicated many times by sampling with replacement and the quantiles from the distribution of these estimations are used to determine confidence intervals. In estimation based on a known distribution, statistical theory is used to determine what the variance of the estimate should be, and confidence intervals are generated from the normal or t distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "id": "8c41c8e5", + "metadata": {}, + "outputs": [], + "source": [ + "translation_dict = {\"dml_linear_bootstrap\": \"Double ML\\n (Bootstrap)\",\n", + " \"dml_linear_statsmodels\": \"Double ML\\n (Non-Bootstrap)\",\n", + " \"dr_linear_bootstrap\": \"Doubly Robust\\n(Bootstrap)\",\n", + " \"dr_linear_statsmodels\": \"Doubly Robust\\n(Non-Bootstrap)\",\n", + " \"standard_linear\": \"Standard Linear\\nModel\"\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "id": "267b5177", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "## coverage\n", + "\n", + "all_estimates_df[\"covered\"] = (all_estimates_df[\"upper\"] > 2) & (all_estimates_df[\"lower\"] < 2)\n", + "coverage_df = all_estimates_df.groupby([\"estimator_name\", \"n\"])[\"covered\"].agg(\"mean\").reset_index()\n", + "\n", + "coverage_df = coverage_df.loc[coverage_df[\"estimator_name\"] != \"standard_linear_small\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "id": "656b9b78", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
estimator_namencovered
0dml_linear_bootstrap4000.98
1dml_linear_bootstrap16000.96
2dml_linear_bootstrap64001.00
3dml_linear_statsmodels4000.90
4dml_linear_statsmodels16000.88
5dml_linear_statsmodels64000.96
6dr_linear_bootstrap4000.98
7dr_linear_bootstrap16000.96
8dr_linear_bootstrap64001.00
9dr_linear_statsmodels4000.64
10dr_linear_statsmodels16000.66
11dr_linear_statsmodels64000.62
12standard_linear4000.92
13standard_linear16000.96
14standard_linear64000.96
\n", + "
" + ], + "text/plain": [ + " estimator_name n covered\n", + "0 dml_linear_bootstrap 400 0.98\n", + "1 dml_linear_bootstrap 1600 0.96\n", + "2 dml_linear_bootstrap 6400 1.00\n", + "3 dml_linear_statsmodels 400 0.90\n", + "4 dml_linear_statsmodels 1600 0.88\n", + "5 dml_linear_statsmodels 6400 0.96\n", + "6 dr_linear_bootstrap 400 0.98\n", + "7 dr_linear_bootstrap 1600 0.96\n", + "8 dr_linear_bootstrap 6400 1.00\n", + "9 dr_linear_statsmodels 400 0.64\n", + "10 dr_linear_statsmodels 1600 0.66\n", + "11 dr_linear_statsmodels 6400 0.62\n", + "12 standard_linear 400 0.92\n", + "13 standard_linear 1600 0.96\n", + "14 standard_linear 6400 0.96" + ] + }, + "execution_count": 145, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "coverage_df" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "id": "99ca067f", + "metadata": {}, + "outputs": [], + "source": [ + "coverage_df[\"Estimator\"] = coverage_df[\"estimator_name\"].apply(lambda x: translation_dict[x])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4c44fc62", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 147, + "id": "879e0046", + "metadata": {}, + "outputs": [], + "source": [ + "coverage_df[\"Sample Size\"] = coverage_df[\"n\"]\n", + "\n", + "coverage_df[\"Coverage Probability\"] = coverage_df[\"covered\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "id": "b04ca322", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['ArtistList',\n", + " '_AxesBase__clear',\n", + " '_PROPERTIES_EXCLUDED_FROM_SET',\n", + " '__class__',\n", + " '__delattr__',\n", + " '__dict__',\n", + " '__dir__',\n", + " '__doc__',\n", + " '__eq__',\n", + " '__format__',\n", + " '__ge__',\n", + " '__getattribute__',\n", + " '__getstate__',\n", + " '__gt__',\n", + " '__hash__',\n", + " '__init__',\n", + " '__init_subclass__',\n", + " '__le__',\n", + " '__lt__',\n", + " '__module__',\n", + " '__ne__',\n", + " '__new__',\n", + " '__reduce__',\n", + " '__reduce_ex__',\n", + " '__repr__',\n", + " '__setattr__',\n", + " '__setstate__',\n", + " '__sizeof__',\n", + " '__str__',\n", + " '__subclasshook__',\n", + " '__weakref__',\n", + " '_add_text',\n", + " '_adjustable',\n", + " '_agg_filter',\n", + " '_alias_map',\n", + " '_alpha',\n", + " '_anchor',\n", + " '_animated',\n", + " '_aspect',\n", + " '_autotitlepos',\n", + " '_axes',\n", + " '_axes_class',\n", + " '_axes_locator',\n", + " '_axis_map',\n", + " '_axis_names',\n", + " '_axisbelow',\n", + " '_box_aspect',\n", + " '_callbacks',\n", + " '_check_no_units',\n", + " '_children',\n", + " '_clipon',\n", + " '_clippath',\n", + " '_cm_set',\n", + " '_colorbars',\n", + " '_convert_dx',\n", + " '_current_image',\n", + " '_default_contains',\n", + " '_deprecate_noninstance',\n", + " '_errorevery_to_mask',\n", + " '_facecolor',\n", + " '_fill_between_x_or_y',\n", + " '_frameon',\n", + " '_fully_clipped_to_axes',\n", + " '_gci',\n", + " '_gen_axes_patch',\n", + " '_gen_axes_spines',\n", + " '_get_aspect_ratio',\n", + " '_get_lines',\n", + " '_get_pan_points',\n", + " '_get_patches_for_fill',\n", + " '_get_view',\n", + " '_gid',\n", + " '_gridOn',\n", + " '_in_layout',\n", + " '_init_axis',\n", + " '_internal_update',\n", + " '_label',\n", + " '_label_outer_xaxis',\n", + " '_label_outer_yaxis',\n", + " '_left_title',\n", + " '_make_twin_axes',\n", + " '_mouseover',\n", + " '_mouseover_set',\n", + " '_navigate',\n", + " '_navigate_mode',\n", + " '_originalPosition',\n", + " '_parse_scatter_color_args',\n", + " '_path_effects',\n", + " '_pcolor_grid_deprecation_helper',\n", + " '_pcolorargs',\n", + " '_picker',\n", + " '_position',\n", + " '_prepare_view_from_bbox',\n", + " '_process_unit_info',\n", + " '_projection_init',\n", + " '_quiver_units',\n", + " '_rasterization_zorder',\n", + " '_rasterized',\n", + " '_remove_legend',\n", + " '_remove_method',\n", + " '_request_autoscale_view',\n", + " '_right_title',\n", + " '_sci',\n", + " '_set_alpha_for_array',\n", + " '_set_artist_props',\n", + " '_set_gc_clip',\n", + " '_set_lim_and_transforms',\n", + " '_set_position',\n", + " '_set_title_offset_trans',\n", + " '_set_view',\n", + " '_set_view_from_bbox',\n", + " '_shared_axes',\n", + " '_sharex',\n", + " '_sharey',\n", + " '_sketch',\n", + " '_snap',\n", + " '_stale',\n", + " '_stale_viewlims',\n", + " '_sticky_edges',\n", + " '_subclass_uses_cla',\n", + " '_subplotspec',\n", + " '_tight',\n", + " '_transform',\n", + " '_transformSet',\n", + " '_twinned_axes',\n", + " '_unit_change_handler',\n", + " '_unstale_viewLim',\n", + " '_update_image_limits',\n", + " '_update_line_limits',\n", + " '_update_patch_limits',\n", + " '_update_props',\n", + " '_update_set_signature_and_docstring',\n", + " '_update_title_position',\n", + " '_update_transScale',\n", + " '_url',\n", + " '_use_sticky_edges',\n", + " '_validate_converted_limits',\n", + " '_viewLim',\n", + " '_visible',\n", + " '_xaxis_transform',\n", + " '_xmargin',\n", + " '_yaxis_transform',\n", + " '_ymargin',\n", + " 'acorr',\n", + " 'add_artist',\n", + " 'add_callback',\n", + " 'add_child_axes',\n", + " 'add_collection',\n", + " 'add_container',\n", + " 'add_image',\n", + " 'add_line',\n", + " 'add_patch',\n", + " 'add_table',\n", + " 'angle_spectrum',\n", + " 'annotate',\n", + " 'apply_aspect',\n", + " 'arrow',\n", + " 'artists',\n", + " 'autoscale',\n", + " 'autoscale_view',\n", + " 'axes',\n", + " 'axhline',\n", + " 'axhspan',\n", + " 'axis',\n", + " 'axison',\n", + " 'axline',\n", + " 'axvline',\n", + " 'axvspan',\n", + " 'bar',\n", + " 'bar_label',\n", + " 'barbs',\n", + " 'barh',\n", + " 'bbox',\n", + " 'boxplot',\n", + " 'broken_barh',\n", + " 'bxp',\n", + " 'callbacks',\n", + " 'can_pan',\n", + " 'can_zoom',\n", + " 'child_axes',\n", + " 'cla',\n", + " 'clabel',\n", + " 'clear',\n", + " 'clipbox',\n", + " 'cohere',\n", + " 'collections',\n", + " 'containers',\n", + " 'contains',\n", + " 'contains_point',\n", + " 'contour',\n", + " 'contourf',\n", + " 'convert_xunits',\n", + " 'convert_yunits',\n", + " 'csd',\n", + " 'dataLim',\n", + " 'drag_pan',\n", + " 'draw',\n", + " 'draw_artist',\n", + " 'end_pan',\n", + " 'errorbar',\n", + " 'eventplot',\n", + " 'figure',\n", + " 'fill',\n", + " 'fill_between',\n", + " 'fill_betweenx',\n", + " 'findobj',\n", + " 'fmt_xdata',\n", + " 'fmt_ydata',\n", + " 'format_coord',\n", + " 'format_cursor_data',\n", + " 'format_xdata',\n", + " 'format_ydata',\n", + " 'get_adjustable',\n", + " 'get_agg_filter',\n", + " 'get_alpha',\n", + " 'get_anchor',\n", + " 'get_animated',\n", + " 'get_aspect',\n", + " 'get_autoscale_on',\n", + " 'get_autoscalex_on',\n", + " 'get_autoscaley_on',\n", + " 'get_axes_locator',\n", + " 'get_axisbelow',\n", + " 'get_box_aspect',\n", + " 'get_children',\n", + " 'get_clip_box',\n", + " 'get_clip_on',\n", + " 'get_clip_path',\n", + " 'get_cursor_data',\n", + " 'get_data_ratio',\n", + " 'get_default_bbox_extra_artists',\n", + " 'get_facecolor',\n", + " 'get_fc',\n", + " 'get_figure',\n", + " 'get_frame_on',\n", + " 'get_gid',\n", + " 'get_gridspec',\n", + " 'get_images',\n", + " 'get_in_layout',\n", + " 'get_label',\n", + " 'get_legend',\n", + " 'get_legend_handles_labels',\n", + " 'get_lines',\n", + " 'get_mouseover',\n", + " 'get_navigate',\n", + " 'get_navigate_mode',\n", + " 'get_path_effects',\n", + " 'get_picker',\n", + " 'get_position',\n", + " 'get_rasterization_zorder',\n", + " 'get_rasterized',\n", + " 'get_renderer_cache',\n", + " 'get_shared_x_axes',\n", + " 'get_shared_y_axes',\n", + " 'get_sketch_params',\n", + " 'get_snap',\n", + " 'get_subplotspec',\n", + " 'get_tightbbox',\n", + " 'get_title',\n", + " 'get_transform',\n", + " 'get_transformed_clip_path_and_affine',\n", + " 'get_url',\n", + " 'get_visible',\n", + " 'get_window_extent',\n", + " 'get_xaxis',\n", + " 'get_xaxis_text1_transform',\n", + " 'get_xaxis_text2_transform',\n", + " 'get_xaxis_transform',\n", + " 'get_xbound',\n", + " 'get_xgridlines',\n", + " 'get_xlabel',\n", + " 'get_xlim',\n", + " 'get_xmajorticklabels',\n", + " 'get_xminorticklabels',\n", + " 'get_xscale',\n", + " 'get_xticklabels',\n", + " 'get_xticklines',\n", + " 'get_xticks',\n", + " 'get_yaxis',\n", + " 'get_yaxis_text1_transform',\n", + " 'get_yaxis_text2_transform',\n", + " 'get_yaxis_transform',\n", + " 'get_ybound',\n", + " 'get_ygridlines',\n", + " 'get_ylabel',\n", + " 'get_ylim',\n", + " 'get_ymajorticklabels',\n", + " 'get_yminorticklabels',\n", + " 'get_yscale',\n", + " 'get_yticklabels',\n", + " 'get_yticklines',\n", + " 'get_yticks',\n", + " 'get_zorder',\n", + " 'grid',\n", + " 'has_data',\n", + " 'have_units',\n", + " 'hexbin',\n", + " 'hist',\n", + " 'hist2d',\n", + " 'hlines',\n", + " 'ignore_existing_data_limits',\n", + " 'images',\n", + " 'imshow',\n", + " 'in_axes',\n", + " 'indicate_inset',\n", + " 'indicate_inset_zoom',\n", + " 'inset_axes',\n", + " 'invert_xaxis',\n", + " 'invert_yaxis',\n", + " 'is_transform_set',\n", + " 'label_outer',\n", + " 'legend',\n", + " 'legend_',\n", + " 'lines',\n", + " 'locator_params',\n", + " 'loglog',\n", + " 'magnitude_spectrum',\n", + " 'margins',\n", + " 'matshow',\n", + " 'minorticks_off',\n", + " 'minorticks_on',\n", + " 'mouseover',\n", + " 'name',\n", + " 'patch',\n", + " 'patches',\n", + " 'pchanged',\n", + " 'pcolor',\n", + " 'pcolorfast',\n", + " 'pcolormesh',\n", + " 'phase_spectrum',\n", + " 'pick',\n", + " 'pickable',\n", + " 'pie',\n", + " 'plot',\n", + " 'plot_date',\n", + " 'properties',\n", + " 'psd',\n", + " 'quiver',\n", + " 'quiverkey',\n", + " 'redraw_in_frame',\n", + " 'relim',\n", + " 'remove',\n", + " 'remove_callback',\n", + " 'reset_position',\n", + " 'scatter',\n", + " 'secondary_xaxis',\n", + " 'secondary_yaxis',\n", + " 'semilogx',\n", + " 'semilogy',\n", + " 'set',\n", + " 'set_adjustable',\n", + " 'set_agg_filter',\n", + " 'set_alpha',\n", + " 'set_anchor',\n", + " 'set_animated',\n", + " 'set_aspect',\n", + " 'set_autoscale_on',\n", + " 'set_autoscalex_on',\n", + " 'set_autoscaley_on',\n", + " 'set_axes_locator',\n", + " 'set_axis_off',\n", + " 'set_axis_on',\n", + " 'set_axisbelow',\n", + " 'set_box_aspect',\n", + " 'set_clip_box',\n", + " 'set_clip_on',\n", + " 'set_clip_path',\n", + " 'set_facecolor',\n", + " 'set_fc',\n", + " 'set_figure',\n", + " 'set_frame_on',\n", + " 'set_gid',\n", + " 'set_in_layout',\n", + " 'set_label',\n", + " 'set_mouseover',\n", + " 'set_navigate',\n", + " 'set_navigate_mode',\n", + " 'set_path_effects',\n", + " 'set_picker',\n", + " 'set_position',\n", + " 'set_prop_cycle',\n", + " 'set_rasterization_zorder',\n", + " 'set_rasterized',\n", + " 'set_sketch_params',\n", + " 'set_snap',\n", + " 'set_subplotspec',\n", + " 'set_title',\n", + " 'set_transform',\n", + " 'set_url',\n", + " 'set_visible',\n", + " 'set_xbound',\n", + " 'set_xlabel',\n", + " 'set_xlim',\n", + " 'set_xmargin',\n", + " 'set_xscale',\n", + " 'set_xticklabels',\n", + " 'set_xticks',\n", + " 'set_ybound',\n", + " 'set_ylabel',\n", + " 'set_ylim',\n", + " 'set_ymargin',\n", + " 'set_yscale',\n", + " 'set_yticklabels',\n", + " 'set_yticks',\n", + " 'set_zorder',\n", + " 'sharex',\n", + " 'sharey',\n", + " 'specgram',\n", + " 'spines',\n", + " 'spy',\n", + " 'stackplot',\n", + " 'stairs',\n", + " 'stale',\n", + " 'stale_callback',\n", + " 'start_pan',\n", + " 'stem',\n", + " 'step',\n", + " 'sticky_edges',\n", + " 'streamplot',\n", + " 'table',\n", + " 'tables',\n", + " 'text',\n", + " 'texts',\n", + " 'tick_params',\n", + " 'ticklabel_format',\n", + " 'title',\n", + " 'titleOffsetTrans',\n", + " 'transAxes',\n", + " 'transData',\n", + " 'transLimits',\n", + " 'transScale',\n", + " 'tricontour',\n", + " 'tricontourf',\n", + " 'tripcolor',\n", + " 'triplot',\n", + " 'twinx',\n", + " 'twiny',\n", + " 'update',\n", + " 'update_datalim',\n", + " 'update_from',\n", + " 'use_sticky_edges',\n", + " 'viewLim',\n", + " 'violin',\n", + " 'violinplot',\n", + " 'vlines',\n", + " 'xaxis',\n", + " 'xaxis_date',\n", + " 'xaxis_inverted',\n", + " 'xcorr',\n", + " 'yaxis',\n", + " 'yaxis_date',\n", + " 'yaxis_inverted',\n", + " 'zorder']" + ] + }, + "execution_count": 154, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dir(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "id": "bf022ebb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(0, 0, 'Double ML\\n (Bootstrap)'),\n", + " Text(1, 0, 'Double ML\\n (Non-Bootstrap)'),\n", + " Text(2, 0, 'Doubly Robust\\n(Bootstrap)'),\n", + " Text(3, 0, 'Doubly Robust\\n(Non-Bootstrap)'),\n", + " Text(4, 0, 'Standard Linear\\nModel')]" + ] + }, + "execution_count": 156, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ax.get_xticklabels()" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "id": "94ecee10", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "matplotlib.rcParams['figure.figsize'] = [8, 5]\n", + "\n", + "ax = sns.barplot(data=coverage_df, \n", + " x=\"Estimator\", y=\"Coverage Probability\", hue=\"Sample Size\",\n", + " palette = sns.color_palette(\"Blues_r\"))\n", + "\n", + "plt.legend(loc='lower left')\n", + "plt.title(\"Coverage Probabilities of Various Estimators\")\n", + "#ax.set_xticklabels(ax rotation=0, fontsize=8)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "193c17db", + "metadata": {}, + "source": [ + "To summarize, here are my main conclusions from this simulation: \n", + "\n", + "1. econml is a great package for causal inference \n", + "2. Bootstrapping can be used to generate accurate coverage probabilities even when traditional statistical estimation fails\n", + "3. Double Machine Learning out-performs doubly robust estimation in conditions of sparsity and low sample size" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "27fd682a", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import binom" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "8b5b7a25", + "metadata": {}, + "outputs": [], + "source": [ + "observed_list = []\n", + "prob_list = []\n", + "for num_observed in range(30, 51):\n", + " observed_list.append(num_observed)\n", + " if num_observed < 0.95 * 50:\n", + " \n", + " prob_list.append(binom.cdf(num_observed, 50, .95))\n", + " \n", + " else:\n", + " prob_list.append(1 - binom.cdf(num_observed -1, 50, .95))" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "988809a5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
probsobserved
01.668198e-1230
12.058903e-1131
22.340397e-1032
32.446165e-0933
42.346135e-0834
52.059933e-0735
61.651038e-0636
71.203974e-0537
87.956627e-0538
94.743368e-0439
102.537013e-0340
111.209576e-0241
125.101349e-0242
131.885832e-0143
146.044188e-0144
151.657869e+0045
163.833473e+0046
177.351470e+0047
188.648530e+0048
194.470908e+0049
201.231120e+0050
\n", + "
" + ], + "text/plain": [ + " probs observed\n", + "0 1.668198e-12 30\n", + "1 2.058903e-11 31\n", + "2 2.340397e-10 32\n", + "3 2.446165e-09 33\n", + "4 2.346135e-08 34\n", + "5 2.059933e-07 35\n", + "6 1.651038e-06 36\n", + "7 1.203974e-05 37\n", + "8 7.956627e-05 38\n", + "9 4.743368e-04 39\n", + "10 2.537013e-03 40\n", + "11 1.209576e-02 41\n", + "12 5.101349e-02 42\n", + "13 1.885832e-01 43\n", + "14 6.044188e-01 44\n", + "15 1.657869e+00 45\n", + "16 3.833473e+00 46\n", + "17 7.351470e+00 47\n", + "18 8.648530e+00 48\n", + "19 4.470908e+00 49\n", + "20 1.231120e+00 50" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame({\"probs\": np.array(prob_list) * 16, \"observed\": observed_list})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3373fa3a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dml_env", + "language": "python", + "name": "dml_env" + }, + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}