{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BA model and scale-free networks\n",
    "\n",
    "<div style=\"display: flex; align-items: center;\">\n",
    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/yy/netsci-course/blob/master/docs/m05-scalefree/lab05.ipynb\">\n",
    "        <img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" style=\"vertical-align: -8px; margin-right: 10px;\" />\n",
    "        Open this notebook in Google Colab\n",
    "    </a>\n",
    "</div>\n",
    "\n",
    "\n",
    "<div style=\"display: flex; align-items: center;\">\n",
    "    <a href=\"https://raw.githubusercontent.com/yy/netsci-course/master/docs/m05-scalefree/lab05.ipynb\" download>\n",
    "        <img src=\"http://yyahn.com/netsci-course/images/download_icon.png\" style=\"vertical-align: -8px; margin-right: 10px;\" />\n",
    "        Download this notebook (File -> Save As)\n",
    "    </a>\n",
    "</div>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "XtLwnyz-Ys9j"
   },
   "source": [
    "## Implement BA algorithm\n",
    "\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. 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": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5]\n"
     ]
    }
   ],
   "source": [
    "import random \n",
    "\n",
    "node_list = [0,1,2,3,4,5]\n",
    "print(random.sample(node_list, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": 4,
   "metadata": {
    "id": "GQZErbFjYs9p"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0], [2], [0], [5], [0], [0], [0], [0], [0], [0]]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "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. "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "putSesFfYs9r"
   },
   "source": [
    "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": 5,
   "metadata": {
    "id": "qQEsSvShYs9s"
   },
   "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",
    "np.random.choice?"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "2_3vrd5FYs9s"
   },
   "source": [
    "It accepts `p` parameter and you can specifies the probability of each item in the list! So instead of creating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wlCS5F9oYs9t"
   },
   "outputs": [],
   "source": [
    "alist = [1,1,1,1,1,1,2,2,2,3,3]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "R8Mne9h1Ys9t"
   },
   "source": [
    "You can do the following. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 165,
     "status": "ok",
     "timestamp": 1644860506513,
     "user": {
      "displayName": "Shubham Singh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
      "userId": "12193469281340462671"
     },
     "user_tz": 300
    },
    "id": "AKsBZeY8Ys9u",
    "outputId": "9c6e807d-967e-4727-f6bd-5c81a325e7ef",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.5454545454545454, 0.2727272727272727, 0.18181818181818182]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nodes = [1,2,3]\n",
    "degrees = [6,3,2]\n",
    "sum_degrees = sum(degrees)\n",
    "node_probs = [degree*1.0/sum_degrees for node, degree in zip(nodes,degrees)] \n",
    "node_probs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do more efficiently with numpy."
   ]
  },
  {
   "cell_type": "code",
   "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/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1644860506514,
     "user": {
      "displayName": "Shubham Singh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
      "userId": "12193469281340462671"
     },
     "user_tz": 300
    },
    "id": "F4u8bSHEYs9u",
    "outputId": "3586ad0d-4b86-4eff-89ac-733a12afb4b6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 1, 1, 2, 1, 1, 2, 1, 1, 1]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[np.random.choice(nodes, p=node_probs) for i in range(10)]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "rvmljTQ6Ys9v"
   },
   "source": [
    "We can also sample multiple nodes at once (without replacement) from the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 3,
     "status": "ok",
     "timestamp": 1644860506514,
     "user": {
      "displayName": "Shubham Singh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
      "userId": "12193469281340462671"
     },
     "user_tz": 300
    },
    "id": "FGqHQ5duYs9v",
    "outputId": "13da7c37-ad5d-4f45-c7ed-d456e36ea9a5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.choice(nodes, 2, replace=False, p=node_probs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "8lFnaZpkkS9Z"
   },
   "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",
    "**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": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 662,
     "status": "ok",
     "timestamp": 1644860507174,
     "user": {
      "displayName": "Shubham Singh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
      "userId": "12193469281340462671"
     },
     "user_tz": 300
    },
    "id": "JbgsmrAcj72N",
    "outputId": "66fb5ee1-07cb-4d8b-d3d0-565ced1c0a82"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "EdgeView([(0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# YOUR SOLUTION HERE"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "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. \n",
    "\n",
    "**Q: Can you implement the BA algorithm?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "vClsd6d9Ys9w"
   },
   "outputs": [],
   "source": [
    "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",
    "    # 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        "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "_Jbyx4JyYs9w"
   },
   "source": [
    "## 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": 29,
   "metadata": {
    "id": "_-DFRrhyYs9w"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.9999513483458435"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# YOUR SOLUTION HERE"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "cO3K1xxWYs9x"
   },
   "source": [
    "**Q: Calculate (and print) the average clustering coefficient of the graph.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 191,
     "status": "ok",
     "timestamp": 1644860510434,
     "user": {
      "displayName": "Shubham Singh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
      "userId": "12193469281340462671"
     },
     "user_tz": 300
    },
    "id": "1GitJsGdYs9x",
    "outputId": "874011c9-3b25-4d11-bc6d-95dcb505e62a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03201703547323779"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# YOUR SOLUTION HERE"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "6YIsMN0zYs9x"
   },
   "source": [
    "The [cumulative distribution function (CDF) and complementary cumulative distribution function (CCDF)](https://en.wikipedia.org/wiki/Cumulative_distribution_function) are among the most direct ways to identify a power-law-like distribution. Plot the **CCDF** of the graph's degree distribution. \n",
    "\n",
    "First, **CDF** for a discrete distribution is defined as the following:\n",
    "\n",
    "$$ F_X(x) = P(X \\le x) = \\sum_{x' \\le x} P(x') $$\n",
    "\n",
    "CCDF is it's reverse and is defined as following:\n",
    "\n",
    "$$\\bar F_X(x) = P(X > x) = \\sum_{x' > x} P(x') = 1 - F_X(x).$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 300
    },
    "executionInfo": {
     "elapsed": 1752,
     "status": "ok",
     "timestamp": 1644860512182,
     "user": {
      "displayName": "Shubham Singh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
      "userId": "12193469281340462671"
     },
     "user_tz": 300
    },
    "id": "pu3WfD26Ys9y",
    "outputId": "0c42ba86-bc14-42f4-dced-7d2768b31cd9"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def CCDF(degrees):\n",
    "    # YOUR SOLUTION HERE\n",
    "    pass\n",
    "\n",
    "\n",
    "# YOUR SOLUTION HERE\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "fhJSPdWfYs9y"
   },
   "source": [
    "## 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": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of nodes: 1000\n",
      "number of edges: 6972\n"
     ]
    }
   ],
   "source": [
    "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": 63,
   "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"
   },
   "outputs": [
    {
     "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q: calculate the average path length in both graphs.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average shortest path length of G_BA: 2.73567967967968\n",
      "Average shortest path length of G_random: 2.8836036036036035\n"
     ]
    }
   ],
   "source": [
    "# YOUR SOLUTION HERE\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "_jpoPTy6Ys9z"
   },
   "source": [
    "Now plot the CCDF (for BA and ER) of the degree distribution of the random graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 300
    },
    "executionInfo": {
     "elapsed": 730,
     "status": "ok",
     "timestamp": 1644860550564,
     "user": {
      "displayName": "Shubham Singh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
      "userId": "12193469281340462671"
     },
     "user_tz": 300
    },
    "id": "0h5dCNw3Ys9z",
    "outputId": "5f2e5a1b-9439-4655-c894-0d48de2cbddc"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# YOUR SOLUTION HERE\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "7O9-iutHYs9z"
   },
   "source": [
    "## Preferential attachment without using the degree\n",
    "\n",
    "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": 68,
   "metadata": {
    "id": "CEY9rPiRYs90"
   },
   "outputs": [],
   "source": [
    "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": 81,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 300
    },
    "executionInfo": {
     "elapsed": 1171,
     "status": "ok",
     "timestamp": 1644860914153,
     "user": {
      "displayName": "Shubham Singh",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GijoisQnjqkyk4XuiiLVRYCgmYcq1Gu2z5e_-09=s64",
      "userId": "12193469281340462671"
     },
     "user_tz": 300
    },
    "id": "DGA0dWpppzHA",
    "outputId": "f9a3c1f7-2151-446e-9d5f-d0b3d3656d95"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G = barabasi_albert_graph_without_knowing_degrees(5000, m0=7, m=4)\n",
    "\n",
    "# YOUR SOLUTION HERE\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}