From e31d40b83c3678dbb0a361aa83f15fe63cc074c0 Mon Sep 17 00:00:00 2001
From: YY Ahn <yongyeol@gmail.com>
Date: Sun, 4 Feb 2024 21:51:36 -0500
Subject: [PATCH] lab5 update

---
 docs/m05-scalefree/lab05.ipynb | 576 +++++++++++++++++----------------
 1 file changed, 304 insertions(+), 272 deletions(-)

diff --git a/docs/m05-scalefree/lab05.ipynb b/docs/m05-scalefree/lab05.ipynb
index 6ae1739..410ac1e 100644
--- a/docs/m05-scalefree/lab05.ipynb
+++ b/docs/m05-scalefree/lab05.ipynb
@@ -30,71 +30,75 @@
     "id": "XtLwnyz-Ys9j"
    },
    "source": [
+    "## Implement BA algorithm\n",
     "\n",
-    "## 1. Implement BA algorithm\n",
-    "For this assignment you will be implementing the BA algorithm from the reading (see [Barabasi Ch 5.3](http://barabasi.com/networksciencebook/)). Create a function that takes `n` the number of nodes for the graph, and `m0` the initial number of nodes, as arguments and returns a networkx graph with a scale-free degree distribution.\n",
+    "For this assignment you will be implementing the BA algorithm from the reading (see [Barabasi Ch 5.3](http://barabasi.com/networksciencebook/)). Create a function that takes `n`, the number of nodes for the graph, and `m0` the initial number of nodes, as arguments and returns a networkx graph with a power-law degree distribution.\n",
     "\n",
-    "The first step is figuring out how to do \"preferential attachment\" based on the degree of existing nodes. A brute-force way to do this is creating a huge list with duplicated items. Say, node 1's degree is 6, node 2's degree is 3, and node 3's degree is 2. (This is not a 'graphical' sequence. But for the sake of simplicity let's just assume that.) Then, we can create the following list to *preferentially sample* nodes from the network. "
+    "The first step is figuring out how to do \"preferential attachment\" based on the degree of existing nodes. In other words, a node with degree 10 should be 10 times more likely to get a new edge than a node with degree 1 and 5 times more likely than a node with degree 2. How can we do this? \n",
+    "\n",
+    "If we just sample from a list containing all nodes, the probability of choosing a node is same for all nodes. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "GQZErbFjYs9p"
-   },
-   "outputs": [],
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[5]\n"
+     ]
+    }
+   ],
    "source": [
-    "alist = [1,1,1,1,1,1,2,2,2,3,3]"
+    "import random \n",
+    "\n",
+    "node_list = [0,1,2,3,4,5]\n",
+    "print(random.sample(node_list, 1))"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
-   "metadata": {
-    "id": "wCe87EqOYs9q"
-   },
+   "metadata": {},
    "source": [
-    "1 is repeated 6 times, 2 is repeated 3 times, and so on. Now if we randomly sample from this list, we will be three times more like to sample node 1 than node 3!"
+    "Can we make a list where node 0 is 7 times more likely to be chosen than node 1?\n",
+    "\n",
+    "A simple way to do this is to simply repeat the node 0 seven times in the list. Then, when we sample a node from the list, we are 7 times more likely to choose node 0 than node 1."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "executionInfo": {
-     "elapsed": 7,
-     "status": "ok",
-     "timestamp": 1644860506350,
-     "user": {
-      "displayName": "Shubham Singh",
-      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
-      "userId": "12193469281340462671"
-     },
-     "user_tz": 300
-    },
-    "id": "GASQfT4lYs9r",
-    "outputId": "014d84a6-e275-4ebc-ba9a-1cc7b3ae01ee"
+    "id": "GQZErbFjYs9p"
    },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[3]"
+       "[[0], [2], [0], [5], [0], [0], [0], [0], [0], [0]]"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "import random\n",
-    "\n",
-    "random.sample(alist, 1)"
+    "node_list = [0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5]\n",
+    "[random.sample(node_list, 1) for i in range(10)]"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "wCe87EqOYs9q"
+   },
+   "source": [
+    "In other words, if we simply repeat each node $i$ in the list $k_i$ (degree of node $i$), then the probability of choosing node $i$ is proportional to $k_i$. As you can imagine, this is not the most efficient way to do this, but it's a start. "
    ]
   },
   {
@@ -104,18 +108,114 @@
     "id": "putSesFfYs9r"
    },
    "source": [
-    "So, if you can maintain this list for your network, you can implement preferential attachment. Simply update this list whenever you add an edge! \n",
-    "\n",
     "A more space-efficient way is using `numpy`'s sampling method. If you run the following cell, the documentation for the [`np.random.choice`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.random.choice.html) function will appear. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {
     "id": "qQEsSvShYs9s"
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[0;31mDocstring:\u001b[0m\n",
+      "choice(a, size=None, replace=True, p=None)\n",
+      "\n",
+      "Generates a random sample from a given 1-D array\n",
+      "\n",
+      ".. versionadded:: 1.7.0\n",
+      "\n",
+      ".. note::\n",
+      "    New code should use the `~numpy.random.Generator.choice`\n",
+      "    method of a `~numpy.random.Generator` instance instead;\n",
+      "    please see the :ref:`random-quick-start`.\n",
+      "\n",
+      "Parameters\n",
+      "----------\n",
+      "a : 1-D array-like or int\n",
+      "    If an ndarray, a random sample is generated from its elements.\n",
+      "    If an int, the random sample is generated as if it were ``np.arange(a)``\n",
+      "size : int or tuple of ints, optional\n",
+      "    Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
+      "    ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
+      "    single value is returned.\n",
+      "replace : boolean, optional\n",
+      "    Whether the sample is with or without replacement. Default is True,\n",
+      "    meaning that a value of ``a`` can be selected multiple times.\n",
+      "p : 1-D array-like, optional\n",
+      "    The probabilities associated with each entry in a.\n",
+      "    If not given, the sample assumes a uniform distribution over all\n",
+      "    entries in ``a``.\n",
+      "\n",
+      "Returns\n",
+      "-------\n",
+      "samples : single item or ndarray\n",
+      "    The generated random samples\n",
+      "\n",
+      "Raises\n",
+      "------\n",
+      "ValueError\n",
+      "    If a is an int and less than zero, if a or p are not 1-dimensional,\n",
+      "    if a is an array-like of size 0, if p is not a vector of\n",
+      "    probabilities, if a and p have different lengths, or if\n",
+      "    replace=False and the sample size is greater than the population\n",
+      "    size\n",
+      "\n",
+      "See Also\n",
+      "--------\n",
+      "randint, shuffle, permutation\n",
+      "random.Generator.choice: which should be used in new code\n",
+      "\n",
+      "Notes\n",
+      "-----\n",
+      "Setting user-specified probabilities through ``p`` uses a more general but less\n",
+      "efficient sampler than the default. The general sampler produces a different sample\n",
+      "than the optimized sampler even if each element of ``p`` is 1 / len(a).\n",
+      "\n",
+      "Sampling random rows from a 2-D array is not possible with this function,\n",
+      "but is possible with `Generator.choice` through its ``axis`` keyword.\n",
+      "\n",
+      "Examples\n",
+      "--------\n",
+      "Generate a uniform random sample from np.arange(5) of size 3:\n",
+      "\n",
+      ">>> np.random.choice(5, 3)\n",
+      "array([0, 3, 4]) # random\n",
+      ">>> #This is equivalent to np.random.randint(0,5,3)\n",
+      "\n",
+      "Generate a non-uniform random sample from np.arange(5) of size 3:\n",
+      "\n",
+      ">>> np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])\n",
+      "array([3, 3, 0]) # random\n",
+      "\n",
+      "Generate a uniform random sample from np.arange(5) of size 3 without\n",
+      "replacement:\n",
+      "\n",
+      ">>> np.random.choice(5, 3, replace=False)\n",
+      "array([3,1,0]) # random\n",
+      ">>> #This is equivalent to np.random.permutation(np.arange(5))[:3]\n",
+      "\n",
+      "Generate a non-uniform random sample from np.arange(5) of size\n",
+      "3 without replacement:\n",
+      "\n",
+      ">>> np.random.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])\n",
+      "array([2, 3, 0]) # random\n",
+      "\n",
+      "Any of the above can be repeated with an arbitrary array-like\n",
+      "instead of just integers. For instance:\n",
+      "\n",
+      ">>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']\n",
+      ">>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])\n",
+      "array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], # random\n",
+      "      dtype='<U11')\n",
+      "\u001b[0;31mType:\u001b[0m      builtin_function_or_method"
+     ]
+    }
+   ],
    "source": [
     "import numpy as np\n",
     "\n",
@@ -150,12 +250,12 @@
     "id": "R8Mne9h1Ys9t"
    },
    "source": [
-    "You can do"
+    "You can do the following. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
@@ -182,7 +282,7 @@
        "[0.5454545454545454, 0.2727272727272727, 0.18181818181818182]"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -195,9 +295,45 @@
     "node_probs"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can do more efficiently with numpy."
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.54545455, 0.27272727, 0.18181818])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# using numpy to calculate the probabilities of each node more efficiently\n",
+    "node_probs = np.array(degrees) / np.sum(degrees)\n",
+    "node_probs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we can sample from the list with corresponding probability. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
@@ -220,16 +356,16 @@
     {
      "data": {
       "text/plain": [
-       "1"
+       "[3, 1, 1, 2, 1, 1, 2, 1, 1, 1]"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "np.random.choice(nodes, p=node_probs)"
+    "[np.random.choice(nodes, p=node_probs) for i in range(10)]"
    ]
   },
   {
@@ -239,12 +375,12 @@
     "id": "rvmljTQ6Ys9v"
    },
    "source": [
-    "or sample two nodes from the list. "
+    "We can also sample multiple nodes at once (without replacement) from the list. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
@@ -267,10 +403,10 @@
     {
      "data": {
       "text/plain": [
-       "array([3, 2])"
+       "array([2, 3])"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -288,12 +424,12 @@
    "source": [
     "Ok, now the sampling can be done. How about the initial graph with `m0` nodes? `networkx` has a convenient function for that: https://networkx.org/documentation/stable/reference/generated/networkx.generators.classic.complete_graph.html \n",
     "\n",
-    "Can you create a complete graph with 5 nodes and then check the edges to make sure you have the right graph? "
+    "**Q: Can you create a complete graph with 5 nodes and then check the edges to make sure you have the right graph?**"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
@@ -319,7 +455,7 @@
        "EdgeView([(0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)])"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -335,32 +471,37 @@
     "id": "4xeLpD43Ys9v"
    },
    "source": [
-    "Now you're ready to implement the BA algorithm! Create a fully-connected network with `m0` nodes. Then in each step, sample `m` nodes from the existing node pool. Add a new node and connect it to the chosen `m` nodes. "
+    "Now you're ready to implement the BA algorithm! Create a fully-connected network with `m0` nodes. Then in each step, sample `m` nodes from the existing node pool. Add a new node and connect it to the chosen `m` nodes. \n",
+    "\n",
+    "**Q: Can you implement the BA algorithm?**"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "metadata": {
     "id": "vClsd6d9Ys9w"
    },
    "outputs": [],
    "source": [
-    "def barabasi_albert_graph(n, m0, m=1):\n",
+    "def barabasi_albert_graph(n, m0=5, m=2):\n",
     "    \"\"\"Create a BA network with n nodes, where each new node connects to \n",
     "    m existing nodes according to the preferential attachment rule. The initial\n",
     "    network is a clique (fully-connected network) with m0 nodes. \n",
     "    \"\"\"\n",
     "    # Initial network of m_o nodes (a complete graph)\n",
+    "    # YOUR SOLUTION HERE\n",
     "\n",
+    "    # Prepare a degree list and node probability list. Use numpy arrays for more efficient calculations.\n",
     "    # YOUR SOLUTION HERE\n",
     "\n",
     "    # Until network has n nodes, \n",
-    "    # 1. preferentially sample m nodes from the network,\n",
+    "    # 1. *preferentially* sample m nodes from the network,\n",
     "    # 2. create a new node, \n",
     "    # 3. and connect the new node to the m selected nodes. \n",
     "\n",
     "    # YOUR SOLUTION HERE\n",
+    "\n",
     "    return G        "
    ]
   },
@@ -371,17 +512,29 @@
     "id": "_Jbyx4JyYs9w"
    },
    "source": [
-    "## 2. BA graph analysis\n",
-    "Test your algorithm by creating a graph with `N = 1200` and `m0 = 7`. Calculate (and print) the average shortest path length of the graph:"
+    "## BA graph analysis\n",
+    "\n",
+    "**Q: Test your algorithm by creating a graph with $n = 1200$, $m_0 = 7$, and $m=2$. Calculate (and print) the average shortest path length of the graph:**"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 29,
    "metadata": {
     "id": "_-DFRrhyYs9w"
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3.9999513483458435"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "# YOUR SOLUTION HERE"
    ]
@@ -393,12 +546,12 @@
     "id": "cO3K1xxWYs9x"
    },
    "source": [
-    "Calculate (and print) the average clustering coefficient of the graph. (Note: You may need to try values of m > 1)"
+    "**Q: Calculate (and print) the average clustering coefficient of the graph.**"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 31,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
@@ -419,11 +572,14 @@
    },
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0.039526110720144475\n"
-     ]
+     "data": {
+      "text/plain": [
+       "0.03201703547323779"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -450,7 +606,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 61,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/",
@@ -473,31 +629,24 @@
    "outputs": [
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f3ab9f3edd0>]"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "execution_count": 12,
      "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
      "output_type": "display_data"
     }
    ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "\n",
-    "# YOUR SOLUTION HERE"
+    "def CCDF(degrees):\n",
+    "    # YOUR SOLUTION HERE\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "# YOUR SOLUTION HERE\n"
    ]
   },
   {
@@ -507,59 +656,42 @@
     "id": "fhJSPdWfYs9y"
    },
    "source": [
-    "## 3. BA and ER comparison\n",
+    "## BA and ER comparison\n",
     "\n",
     "Now let's compare the scale-free and random graphs. Create a random graph with the same number of nodes and about the same number of edges, then calculate the average shortest path length of that graph:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "executionInfo": {
-     "elapsed": 22799,
-     "status": "ok",
-     "timestamp": 1644860534979,
-     "user": {
-      "displayName": "Shubham Singh",
-      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
-      "userId": "12193469281340462671"
-     },
-     "user_tz": 300
-    },
-    "id": "3w7sjPKnYs9y",
-    "outputId": "8e8b5e7b-882b-4454-e861-37c47c37f300"
-   },
+   "execution_count": 62,
+   "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "3.5471823742007227"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "number of nodes: 1000\n",
+      "number of edges: 6972\n"
+     ]
     }
    ],
    "source": [
-    "# YOUR SOLUTION HERE"
+    "G_BA = barabasi_albert_graph(1000, m0=7, m=7)\n",
+    "print(\"number of nodes:\", G_BA.number_of_nodes())\n",
+    "print(\"number of edges:\", G_BA.number_of_edges())"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 63,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "executionInfo": {
-     "elapsed": 14732,
+     "elapsed": 22799,
      "status": "ok",
-     "timestamp": 1644860549692,
+     "timestamp": 1644860534979,
      "user": {
       "displayName": "Shubham Singh",
       "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
@@ -567,68 +699,48 @@
      },
      "user_tz": 300
     },
-    "id": "7tHIwwHVpo7T",
-    "outputId": "357cd73d-8c1a-421d-e191-40766df98e1d"
+    "id": "3w7sjPKnYs9y",
+    "outputId": "8e8b5e7b-882b-4454-e861-37c47c37f300"
    },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "4.153923118904018"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "number of nodes: 1000\n",
+      "number of edges: 6972\n"
+     ]
     }
    ],
    "source": [
+    "# you can use nx.gnm_random_graph(n, m) to create a random graph with n nodes and m edges.\n",
+    "\n",
     "# YOUR SOLUTION HERE"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
-   "metadata": {
-    "id": "ppknthUJYs9z"
-   },
+   "metadata": {},
    "source": [
-    "Calculate (and print) the average clustering coefficient of the graph:"
+    "**Q: calculate the average path length in both graphs.**"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "executionInfo": {
-     "elapsed": 15,
-     "status": "ok",
-     "timestamp": 1644860549840,
-     "user": {
-      "displayName": "Shubham Singh",
-      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
-      "userId": "12193469281340462671"
-     },
-     "user_tz": 300
-    },
-    "id": "MHuwwy7pYs9z",
-    "outputId": "0afa0787-e6dc-4748-d5a2-ff8a53778805"
-   },
+   "execution_count": 64,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.029275119458150905\n",
-      "0.00488252488252488\n"
+      "Average shortest path length of G_BA: 2.73567967967968\n",
+      "Average shortest path length of G_random: 2.8836036036036035\n"
      ]
     }
    ],
    "source": [
-    "# YOUR SOLUTION HERE"
+    "# YOUR SOLUTION HERE\n"
    ]
   },
   {
@@ -643,7 +755,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 67,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/",
@@ -666,99 +778,17 @@
    "outputs": [
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f3ab9dd0290>]"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "execution_count": 16,
      "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEKCAYAAAAMzhLIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3TU5b3v8fd3ZjK5JxCSIJJAwCBKsaIE71VR69ZWNlZpvbT1tFWoPVX33p5e7Gl7uvZuu213bavW22G31mMvqLWXDYqL2gq6FVSCIIggN0HCxVyAQEKuM8/5YwYIgUxIMpPfzOTzWmtWZp7fZb5hZfis5/f8nmfMOYeIiEhPfF4XICIiyU1BISIiMSkoREQkJgWFiIjEpKAQEZGYFBQiIhJTwOsCEqG4uNhVVFR4XYaISEpZsWJFvXOupHt7WgZFRUUF1dXVXpchIpJSzGzb8dp16UlERGJSUIiISEwKChERiUlBISIiMSX9YLaZ5QKPAO3AEufc7zwuSURkSPGkR2Fmj5tZrZm90639KjN7z8w2mdk90ebrgGedc7OBfxz0YkVEhjivLj09AVzVtcHM/MDDwNXAJOAmM5sElAHbo7uFElnUWx/s5Y0tDYl8CxGRlONJUDjnXgH2dGs+B9jknNvinGsHngJmAjVEwgJi1Gtmc8ys2syq6+rq+lXXA3/byL+/sL5fx4qIpKtkGswezZGeA0QCYjTwJ+B6M3sUWNDTwc65uc65KudcVUnJMRMLRUSkn5J+MNs51wx80es6RESGqmTqUewAyru8Lou2nTAzm2FmcxsbG+NamIjIUJZMQbEcmGBm48wsCNwIzO/LCZxzC5xzcwoLCxNSoIjIUOTV7bHzgGXARDOrMbNbnXOdwB3AImAd8Ixzbq0X9YmIyBGejFE4527qoX0hsHCQyxERkRiS6dLTgGmMQkQk/tIqKDRGISISf2kVFCIiEn9pFRS69CQiEn9pFRS69CQiEn9pFRQiIhJ/Sb+Ex2Br6wixraEZwzCLtPl8hgFmHG43AAOfHdp29D6Rbce2m0FmwIcdOrmISJJTUHSRGfCxfvcBLvnJkoS+z5WTRjL3lqqEvoeISLykVVCY2QxgRmVlZb+O/+41k7hq8kk4Bw5wzuEAHISjzyPbXORn17bo83D0OV32jbRFnv9l5Q62NjTH5fcVERkMaRUUzrkFwIKqqqrZ/Tm+vCiH8qKcOFd1tDU1jWyua0roe4iIxJMGs0VEJCYFhYiIxKSgEBGRmNIqKDQzW0Qk/tIqKDQzW0Qk/tIqKEREJP7S6vbYVLG7sZV7/rgaM8MXnd3t90Vmbfu6tPl8R54f2tcfbT+0b35WgM9UlZPhV+aLSGIoKAbZtIoiVn6wj5fW1x6enBd2kUl5YReZyBcKu8PPw1229+TUkflMqygavF9CRIYUBcUg+9JF4/jSReP6daxzLhoikQB5fUsDX/j1cjpDMVJERGSA0up6Rbrf9WRmBPw+ggEfWRl+MgN+r0sSkSEgrYJCdz2JiMRfWgWFiIjEn4JCRERiUlCIiEhMCgoREYlJt8emgfqmNnY1tuCPTszzH5qo57OjJ/B12aavYhWRE6WgSGHBQKRDeOe8lX0+9tDM7tL8TP529yXkZupPQUSOL63+dxjoV6Gmminlw3j0s2dzoLWT0KEZ3NEJeYdmdx+a1R0Ku+iEvSOzvdfu3M9L62vZe7BdQSEiPUqr/x0G+lWoqcbvM64+Y1S/j3+mejsvra+NY0Uiko40mC0iIjEpKEREJCYFhYiIxKSgEBGRmBQUQjgcWcJcROR40uquJ+kbf3TS3cU/WQxAwBeZkHf4p993+LXPjIA/0h70+/jmVacx/bRSL8sXkUGioBjCrpg0km9/4nRaOkJ0hh2hcDjyM+Sir91R7eHo64VrdvH6lgYFhcgQoaAYwgqzM5h98fg+H3fad19IQDUikqw0RiEiIjGlVVCk+1ehioh4Ia2CQl+FKiISf2kVFCIiEn8KChERiUl3PUm/tHWGOdDaEf0ipCPzL/SFSCLpR0EhfZbh8/HE0q08sXTrMdvMIhP5fD7DHw2QEXlB5n/1IgpzMga/WBEZMAWF9NkjnzubDR82EQ47Qi4yMe/QI3zodfRLlDbVNrH4vTpqD7QqKERSlIJC+uxjE0r42ISSE9r3udU7WfxeXYIrEpFE0mC2iIjEpKAQEZGYFBQiIhKTxihkUDz40iZG5AYjS5j7I7fSBny+yE9/5GdW0M/MKSdTkKVBb5FkoqCQhKoszaO8KJvXNtXTGQoTCjs6utwl1Z3fjJvPHeNBpSLSEwWFJNRpJxXw39+47Ljbut5eW7u/jYt/spjOcHiQKxSR3igoxDM+n+HDyPBDbqbf63JEpAcazBYRkZiSvkdhZuOBbwOFzrlZXtcjieGLrhH1/efe5SeL3iPo95Hh95ERMDL8PoJ+HwF/5Pu6vzq9kstPH+lxxSJDR0KDwsweB64Bap1zk7u0XwU8APiBXzrnftTTOZxzW4BbzezZRNYq3hqeG+TfZn6Emr0tdITCkUenoyMUpj0UpjMUef7KxjpeWl+roBAZRInuUTwBPAQ8eajBzPzAw8DHgRpguZnNJxIa93Y7/kvOudoE1yhJ4pbzK3rdp+oHLya+EBE5SkKDwjn3iplVdGs+B9gU7SlgZk8BM51z9xLpfYiISBLxYjB7NLC9y+uaaNtxmdkIM3sMOMvMvhVjvzlmVm1m1XV1WoRORCRekn4w2znXANx+AvvNBeYCVFVVHTuTS0RE+sWLoNgBlHd5XRZtEzkhyzY38K0/rSYz4Ccz4Is8MvyHf54xupAp5cO8LlMkbXgRFMuBCWY2jkhA3AjcHI8Tm9kMYEZlZWU8TidJ6LLTSlm2pYG/r6ultSNEW2eYts6jZ3OPHZHDy1+f7lGFIukn0bfHzgMuBYrNrAb4nnPuV2Z2B7CIyJ1Ojzvn1sbj/ZxzC4AFVVVVs+NxPkk+/zHrzGPanHO0hyKB8e0/v8OKrXs8qEwkfSX6rqebemhfCCxM5HvL0GFm0ctQfrICWmxAJN6SfjC7L3TpSQAOdoSY//ZOsjP8kUfwyM+8zAAl+ZlelyiSUtIqKHTpSUoLMtl3sIO75q3scZ/7b5jCtWf1eEe2iHSTVkEh8rUrJ3LzuWNpaQ9FHh0hDrZ30toRYt/BDu750xo+3N/qdZkiKUVBIWnFzBg9LPu42w62d3LPn9bw5vt7yMkMkJfpJycYIC8zQE7QT2F2BuOKc7HoAoUiEpFWQaExCokl6Pcxelg2f19fy9/XH38JsQdunMLMKbosJdJVWgWFxigkloDfx6vfnE5LR4imtk6a20I0t3XS3NbJhwfauGveSvY2t3tdpkjSSaugEOmNmZETDJATDED+kXYFhEjPdNO5iIjElFY9Co1RyED9edVOtjYcpCArQEF2BgVZGRRkB/jIyYWUF+V4XZ6IJ8y59FtotaqqylVXV3tdhqSQzlCY256sZlNtE/tbOjjQ1knXj0ZlaR5/u/sS7woUGQRmtsI5V9W9Pa16FCL9FfD7eOKL5xx+HQ47mto72d/Swb8ueJd3d+73sDoRbykoRI7D57PIZaesDAqzM7wuR8RTCgqRE1DX1MacJ6spyg0yPDdIUU6QotwgZ5YXUlma3/sJRFJYWgWFBrMlET55xii27znItoaDrNy+j73N7XSGjwxgPD3nPIrzMynOzaQgO6CZ3ZJ2NJgt0kfOOZraOvnmH1ezcM3uo7Zl+I2SvEx+eN0ZTJ9Y6lGFIv2jwWyRODEz8rMyePDGs7jzsiYamtqpb2qLPtp57OXNrPpgn4JC0oaCQqSfAn4fp48qOKb9sZc3s/dgO3ua2xmek6FLUZLyFBQicZYT9PPksm08uWwbQb+P0oJMTirIYtbUMm48Z4zX5Yn0WcygMLN/d8797+jzjzvnXhycskRS1/N3fYx1u/azu7GVDw+08mFjKy9vqOPp6u0KCklJMQezzewt59zZ3Z8nqy53Pc3euHGj1+WIHPY/Hn+TpZvrmVCaz+jh2Ywelk3Z8GwunVhKZWme1+WJAENkMFvLjEuyuuOySsqLstmxt4VtDc0s3VRPc3uIJe/V8dvbzvW6PJGYeguKUjO7G7Auzw9zzv0sYZWJpJFpFUVMqyg6/No5xw1zX6c9FPawKpET01tQ/CdHVu3v+lxEBsDM8BmE028ak6ShmEHhnPvXwSpEZCiqb2rj1Y31jCvJZVRBFj6fbqWV5NPrGIWZTQfuAE6LNq0DHnLOLUlgXSJpb2xRLq9v2cPnfvUGAFkZPsYX5/HDT03mrDHDPa5O5Ijebo/9JPAQ8G/RhwFnA4+b2R3OuYWJL1EkPf3o+jO4+8pT2VLXzJb6JjZ+2MQTS7fyxvt7FBSSVHrrUXwduNY593aXtlVmVg38AlBQiPSTmTGyIIuRBVmcf8oIWtpDPLF0q9dliRyjt6A4qVtIAOCcW21mIxNUU79p9VhJB4vW7sZvxumjCjhtVD7FeZlelyRDXG9B0dzPbZ7QPApJZVkZPq47azSvba7nhwvXHW6/sHIEv7vtPA8rk6Gut6A4xczmH6fdgPEJqEdkyDIzfnbDFAAamtp4b/cBfvHSJtbqa1jFY70FxcwY2+6LZyEicsSIvEwuqMxk0drdrNnRyK7GFkYVZntdlgxRvQXFu0CJc+7dro1mNgmoS1hVIgJAUW4mTW2dnH/vS4wsyGRK+TDOHz+CW86v0JwLGTS9BcUvgEeO0z4C+A5wc9wrEpHD7riskotPLWbV9n2s2r6P/1q1k0VrPyTk4IZp5eRlptVybZKkels9tvp4KwlGt73jnJucsMoGQF+FKulqdc0+Zj26jPZQGJ/B5NGFXFhZzD9dPoGsDL/X5UmK6+/qsbHWdsoYWEki0lcfLRvGyv/zcVZ+sI83329g8Xt1PLpkM2XDs7n+7DKFhSREbz2K54GHu8/ANrOrgbucc1cnuL5+UY9ChopNtQe45hev0toRJhjwcU5FEf8w+SQ+f95Yr0uTFNRTj6K3oJgAPA8sBVZEm6uA84FrnHMbElDrgCkoZCg52N7JG+/v4dWN9fz13d1s39PCW9/9OEW5Qa9LkxTT30tPDvgSMAE4NB7xMpElx0NxrVBE+iUnGGD6xFKmTyylojiX7/7lHfa3dCgoJG56C4r7gW85537dtdHMzohum5GowkSk73KiYxSX3reE0vxMJozMY0JpPpWleVSW5nHqyHwFiPRZb0Ex0jm3pnujc26NmVUkpKIB0FpPMtTNnHIyRXlBNuw+wMbaJjbWNvGH6u00t0cuAPgM5s0+j3PHj/C4UkklvQXFsBjbkm6aqNZ6kqEu4Pcdvgx1iHOOXY2tvLqpnm88u5rd+1s9rFBSka+X7dVmdsx/umZ2G0cGt0UkiZkZJw/LZurYyHdc1B1oI9ZNLCLd9daj+Gfgz2b2WY6+6ykIfCqRhYlIfBXlBCnICvCD59fx7Ioabj53DNeeNZqCLE2Jkthi3h57eKfI16EeuutprXPupYRWNUC6PVbk+JraOpm/aie/f3Mb7+zYT07Qz6ypZXzhggrGl+R5XZ54rF/zKFKVgkKkd6tr9vH/lm5jwds7aQ+FOW98ERNK8ykbnk3Z8Jzoz2yKcoOYaQHCoUBBISLHVXegjd+/8QF/fXc3NXtbaGzpOGp7doafsuHZlBcdCY+y4TmMK85l4sh8rWKbRhQUInJC9rd2sGNvCzV7W6jZe5DteyI/D73e39p5eN+S/EymTyzhstNKuWhCiVazTXH9nZktIkNMQVYGBaMyOH1UwXG3N7ZEguTdXftZ/F4tL7yzm2eqa8jwG9MqirjtY+O47LSRg1y1JJJ6FCIyIB2hMCu27WXx+khofLDnIDOnnMz3ZnxEs8BTjC49iUjCtXeGeWTJJh5evInivEwWf+1SLX2eQnoKit4m3ImInLBgwMc/X3Eq3/nkJHY1ttLQ3O51SRIHGqMQkbgryI7813LD/13GRZXFXFBZzAWnjKA4L9PjyqQ/FBQiEndXTx7F/pZOXt1Uz/NrdvHU8u0AnHZSPhecUsyFlSOoqiiiMFuzwlOBxihEJKE6Q2HW7tzPa5vrWbqpgeVb99DWGcYMJo7MZ+rY4VRVDKdqbBFlw7M1uc9DKTuYbWbXAp8ECoBfOef+2tsxCgqR5NXaEWLlB/uo3rqH5dv2snLbXg60ReZmlOZnUlUxnKljizinoojJowsUHIPIk6Aws8eBa4Ba59zkLu1XAQ8AfuCXzrkfncC5hgP3Oedu7W1fBYVI6giFHRs+PED11j1Ub9tL9da97NjXAsBDN5/FNR892eMKhw6vJtw9ATwEPNmlED/wMPBxoAZYbmbziYTGvd2O/5Jzrjb6/DvR40Qkjfh9xumjCjh9VAGfP78CgHW79nP1A//N3oMdsQ+WQZHQoHDOvXKcb8I7B9jknNsCYGZPATOdc/cS6X0cxSL9zh8BLzjn3kpkvSKSHEryI3dHNTS1eVyJgDfzKEYD27u8rom29eRO4Apglpnd3tNOZjbHzKrNrLquri4+lYqIJ0bkBrmwcgQPL97Ess0NXpcz5CX9hDvn3IPOuanOududc4/F2G+uc67KOVdVUlIymCWKSJyZGY98dipjR+Ty5d9Us6WuyeuShjQvgmIHUN7ldVm0TUTksMLsDH79hWnsb+1k/ts7vS5nSPMiKJYDE8xsnJkFgRuB+fE4sZnNMLO5jY2N8TidiHisvCgHMwiHk/s2/nSX0KAws3nAMmCimdWY2a3OuU7gDmARsA54xjm3Nh7v55xb4JybU1hYGI/TiUiSWFXTSO3+Vq/LGLISfdfTTT20LwQWJvK9RSQ93HLeWH77xgdc9B+LuXFaObdfcgonD8v2uqwhJelnZveFmc0AZlRWVs7euHGj1+WISJxsa2jm0SWbeXZFDWYwa2o5//PSUygvyvG6tLSSskt49IdmZoukp5q9B3ns5c08s7yGkHPceVkl/3T5BC3zESf6PgoRSXllw3P4wbVn8Mo3pnPNR0dx/9828r+eeZv2zrDXpaU1LTMuIinnpMIs7r9hCqeU5PGzFzewq7GVxz43lcIcLVueCGnVo9DtsSJDh5lx1+UT+PkNZ1K9bQ/XP7aUxhatDZUIaRUUuj1WZOj51Fll/PyGKWyqbaJ66x6vy0lLaRUUIjI0jS3KBSAN781JCgoKERGJKa2CQmMUIkNbZ1h3PyVCWgWFxihEhqZxJbnkZQZYtPZDr0tJS2kVFCIyNOVlBpg1tYznVu+k9oDWhIo3BYWIpIVbzh9LR8gx743tve8sfaIJdyKSFsaX5HHxqSX85vWt5GcFGFeSy/jiXMqG5+D3aYmPgUirtZ60KKDI0LZi217mPFlNQ3P74bag38eYETmMK44Ex7jiXMaX5DGuOJfivKDWiepCiwKKyJDgnKOhuZ3365t5v66ZLfXNvF/fxPv1zWytP0h76MidUfmZkZ5HJETyDvdCKoojg+NDTU9BMfT+JUQkrZkZxXmZFOdlMq2i6KhtobBj576WSHjURcJjS30z1Vv3Mv/tnUdN2BtZkMm44lzGFed16YnkUl6UQ4Z/aA3vKihEZMjw+4zyohzKi3K45NSSo7a1doTY1nCQ9+ub2FzXHOmR1DezaO1u9nS5lOX3GWOKcqIhEgmPQz2SkQWZaXkpS0EhIgJkZfiZeFI+E0/KP2bbvoPt0V7IkQDZUt/M0s31tHYcuZSVE/RTMSISHmeWDeOLF1YQSIPeh4JCRKQXw3KCnD0myNljhh/VHg47du9vPRwckSBpYnVNI8+t3sWIvCDXnV3mUdXxk1ZB0eWuJ69LEZEhwOczTh6WzcnDsrmwsvhwu3OO6fct4anl29MiKFK/T9SFlvAQkWRgZny6qpw339/Dlromr8sZsLQKChGRZDFrahl+n/FMdY3XpQyYgkJEJAFGFmQxfWIJf3yrho5Qaq9qq6AQEUmQG6aNoe5AG4vX13pdyoAoKEREEmT6xBJGFmTywN830tYZ8rqcflNQiIgkSMDv4/szJ7N2535++tcNXpfTbwoKEZEEuvIjJ/G588Yw95UtvLKhzuty+iWtgkJfhSoiyejbn5jEhNI87n7mbeqb2rwup8/SKig0j0JEklF20M+DN53F/tYOvvHsalJt1e60CgoRkWR1+qgCvnX1aby0vpYnl23zupw+UVCIiAySL1xQwaUTS/jhwnWs373f63JOmIJCRGSQmBn3ffpMCrIyuGveSlraU+OWWQWFiMggKs7L5KefOZMNHzZx5f0v88KaXUk/ZqGgEBEZZJecWsJvbz2X7Aw/X/ndW9ww93Xe2ZG8d2sqKEREPHDRhGIW3vUxfnDtZDbVNjHjoVf5+h/epnZ/q9elHUNBISLikYDfx+fOG8vir13KbReN4y+rdnDpfUt46KWNtHYkz/iFgkJExGOF2Rl8+5OTePFfLuGiymLu++sGLv/pyyx4e2dSjF8oKEREkkRFcS5zb6ni97PPpSA7gzvnrWTWY8tYtX2fp3UpKEREkswFpxTz3J0X8ePrz2Bbw0Guffg17n56FbsaWzypx5KhWxMvXb4ze/bGjRu9LkdEZMAOtHbwyJLN/OrV9/EZ3H7JKXz54lPIDvrj/l5mtsI5V3VMezoFxSFVVVWuurra6zJEROJm+56D/OiF9Ty/ZhejCrP4xlUTmXnmaHw+i9t79BQUuvQkIpICyotyePizZ/PMl8+nOC+Tf3n6bT716FJWbNub8PdWUIiIpJBzxhXxX1+9kPs+fSa79rVw/aNLuWveSnbsS9z4hYJCRCTF+HzGrKllLP7apdx1WSWL1u7mip++zPY9BxPzfgk5q4iIJFxuZoC7r5zIr784jZaOEBs+PJCQ91FQiIikuNL8TACaE7QarYJCRCTF5QQDABxs60zI+RUUIiIpLvdQUKhHISIix3No8t3BdvUoRETkOIIBHxl+0xiFiIj0LCcY0BiFiIj0LCfo1xiFiIj0TEEhIiIx5WYGaNZgtoiI9CQ7Ywj3KMzsdDN7zMyeNbOveF2PiEgyys0MpObtsWb2uJnVmtk73dqvMrP3zGyTmd0T6xzOuXXOuduBzwAXJrJeEZFUlRP0c7AtNXsUTwBXdW0wMz/wMHA1MAm4ycwmmdkZZvZct0dp9Jh/BJ4HFia4XhGRlJQT9CdsjCKQkLNGOedeMbOKbs3nAJucc1sAzOwpYKZz7l7gmh7OMx+Yb2bPA78/3j5mNgeYAzBmzJi41C8ikipygoGEjVEkNCh6MBrY3uV1DXBuTzub2aXAdUAmMXoUzrm5wFyIfBVqPAoVEUkVuZmRwWznHGbx+3pU8CYo+sQ5twRY4nEZIiJJLScYIBR2tHWGycrwx/XcXtz1tAMo7/K6LNo2YGY2w8zmNjY2xuN0IiIpIye6MGBLAi4/eREUy4EJZjbOzILAjcD8eJzYObfAOTensLAwHqcTEUkZh5YaT8SAdqJvj50HLAMmmlmNmd3qnOsE7gAWAeuAZ5xzaxNZh4hIuhueG2RMUQ6dofgP0Zpz6TPua2YzgBmVlZWzN27c6HU5IiIpxcxWOOequrcn/czsvtClJxGR+EuroBARkfhTUIiISExpFRS6PVZEJP7SKig0RiEiEn9pFRQiIhJ/CgoREYkprYJCYxQiIvGXVhPuDjGzOmBbPw8vBBKdNPF+j4Gcr7/H9uW4eO9bDNSf4PnSwWD8TZ6owaolnu8z0HP15/i+HnOi+yf68zHWOVdyTKtzTo8uD2Buqr3HQM7X32P7cly89wWqvfr78OIxGH+TyVZLPN9noOfqz/F9PeZE9/fq85FWl57iZEEKvsdAztffY/tyXKL2HSqS6d9ksGqJ5/sM9Fz9Ob6vx5zo/p78LaTlpSdJb2ZW7Y6zHo2IJObzoR6FpKK5XhcgksTi/vlQj0JERGJSj0JERGJSUIiISEwKChERiUlBISnPzMab2a/M7FmvaxFJNmZ2rZn9p5k9bWZX9uccCgpJSmb2uJnVmtk73dqvMrP3zGyTmd0D4Jzb4py71ZtKRQZfHz8ff3HOzQZuB27oz/spKCRZPQFc1bXBzPzAw8DVwCTgJjObNPiliXjuCfr++fhOdHufKSgkKTnnXgH2dGs+B9gU7UG0A08BMwe9OBGP9eXzYRE/Bl5wzr3Vn/dTUEgqGQ1s7/K6BhhtZiPM7DHgLDP7ljeliXjuuJ8P4E7gCmCWmd3enxMHBl6biLeccw1Err+KSDfOuQeBBwdyDvUoJJXsAMq7vC6LtolIAj8fCgpJJcuBCWY2zsyCwI3AfI9rEkkWCft8KCgkKZnZPGAZMNHMaszsVudcJ3AHsAhYBzzjnFvrZZ0iXhjsz4cWBRQRkZjUoxARkZgUFCIiEpOCQkREYlJQiIhITAoKERGJSUEhIiIxaQkPkRNkZiFgDZABdAJPAj93zoU9LUwkwRQUIieuxTk3BcDMSoHfAwXA9wZ6YjPzO+dCAz2PSCLo0pNIPzjnaoE5wB3RZZz9ZvYTM1tuZqvN7MsAZuYzs0fMbL2ZvWhmC81sVnTbVjP7sZm9BXzazK40s2Vm9paZ/cHM8qL7TTWzl81shZktMrNRnv3iMiQpKET6yTm3BfADpcCtQKNzbhowDZhtZuOA64AKIl8k83ng/G6naXDOnQ38jcgXy1wRfV0N3G1mGcAvgFnOuanA48APE/27iXSlS08i8XEl8NFDvQWgEJgAXAT8ITqOsdvMFnc77unoz/OIhMlrZgYQJLqWDzAZeDHa7gd2JfD3EDmGgkKkn8xsPBACagED7nTOLeq2zyd6OU3zoV2BF51zN3U7/gxgrXOue09EZNDo0pNIP5hZCfAY8JCLrKy5CPhK9FIRZnaqmeUCrwHXR8cqRgKX9nDK14ELzawyenyumZ0KvAeUmNn50fYMM/tIIn83ke7UoxA5cdlmtoojt8f+BvhZdNsviYxFvGWRa0R1wLXAH4HLgXeJfE3lW0Bj9xM75+rM7AvAPDPLjDZ/xzm3IXo560EzKyTymb0f0PLqMmi0zLhIgplZnnOuycxGAG8CFzrndntdl8iJUo9CJPGeM7NhRAaov6+QkFSjHoWIiMSkwWwREYlJQSEiIjEpKGwicpgAAAAbSURBVEREJCYFhYiIxKSgEBGRmBQUIiIS0/8HmKhqZbNhYZEAAAAASUVORK5CYII=",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
      "output_type": "display_data"
     }
    ],
    "source": [
-    "# YOUR SOLUTION HERE"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 300
-    },
-    "executionInfo": {
-     "elapsed": 590,
-     "status": "ok",
-     "timestamp": 1644860551152,
-     "user": {
-      "displayName": "Shubham Singh",
-      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
-      "userId": "12193469281340462671"
-     },
-     "user_tz": 300
-    },
-    "id": "_TeeOmehptT5",
-    "outputId": "6bd517eb-a008-48bd-e9fa-a67c7fc3b6c4"
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f3ab93ea550>]"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# YOUR SOLUTION HERE"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "BhUtqvbyYs9z"
-   },
-   "source": [
-    "How do the average shortest path lengths, average clustering coefficients, and degree distributions between the graphs compare?"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "adQWWn7yYs9z"
-   },
-   "source": [
-    "(use this markdown cell for your response)"
+    "# YOUR SOLUTION HERE\n"
    ]
   },
   {
@@ -768,26 +798,48 @@
     "id": "7O9-iutHYs9z"
    },
    "source": [
-    "## 4. Preferential attachment without using the degree\n",
+    "## Preferential attachment without using the degree\n",
     "\n",
-    "As you know from the discussion and videos, it is possible to achieve the linear preferential attachment without calculating the degree by using the friendship paradox. Implement this version and see whether you can get a power-law degree distribution.  "
+    "As you know from the discussion and videos, it is possible to achieve the preferential attachment without calculating the degree by using the friendship paradox. Implement this version and see whether you can get a power-law degree distribution.  "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 68,
    "metadata": {
     "id": "CEY9rPiRYs90"
    },
    "outputs": [],
    "source": [
-    "def barabasi_albert_graph_alt(n, m0=2, m=1):\n",
-    "    # YOUR SOLUTION HERE"
+    "def barabasi_albert_graph_without_knowing_degrees(n, m0=5, m=2):\n",
+    "    \"\"\"Create a BA network with n nodes, where each new node connects to \n",
+    "    m existing nodes according to the preferential attachment rule. The initial\n",
+    "    network is a clique (fully-connected network) with m0 nodes. \n",
+    "\n",
+    "    This function does not use the degree list and node probability list.\n",
+    "    \"\"\"\n",
+    "    # Create the initial network with m_o nodes (a complete graph)\n",
+    "    # YOUR SOLUTION HERE\n",
+    "\n",
+    "    # now we add new nodes and grow the network by preferential attachment. \n",
+    "    while(len(G.nodes()) < n):\n",
+    "        # how would you do the preferential attachment without knowing the degree of the nodes?\n",
+    "        new_node = len(G.nodes())\n",
+    "        # YOUR SOLUTION HERE\n",
+    "        \n",
+    "    return G            "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Q: build a network using this function and plot its CCDF to see if it has a power-law degree distribution.**"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 81,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/",
@@ -810,40 +862,20 @@
    "outputs": [
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f3ab8d5f710>]"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "execution_count": 21,
      "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
      "output_type": "display_data"
     }
    ],
    "source": [
-    "# generate the network and show the CCDF\n",
-    "# YOUR SOLUTION HERE"
+    "G = barabasi_albert_graph_without_knowing_degrees(5000, m0=7, m=4)\n",
+    "\n",
+    "# YOUR SOLUTION HERE\n"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "-yrbmZx0F_He"
-   },
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -865,7 +897,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,