{
 "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": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\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": 2,
   "metadata": {
    "id": "GQZErbFjYs9p"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0], [0], [0], [0], [0], [4], [0], [0], [4], [2]]"
      ]
     },
     "execution_count": 2,
     "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": 3,
   "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": 4,
   "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": 5,
   "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": 5,
     "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": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.54545455, 0.27272727, 0.18181818])"
      ]
     },
     "execution_count": 6,
     "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": 7,
   "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, 3, 1, 1, 2, 2, 3, 1, 1]"
      ]
     },
     "execution_count": 7,
     "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": 8,
   "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, 1])"
      ]
     },
     "execution_count": 8,
     "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": 9,
   "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": 9,
     "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": 10,
   "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": 11,
   "metadata": {
    "id": "_-DFRrhyYs9w"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.019531554072839"
      ]
     },
     "execution_count": 11,
     "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": 12,
   "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.02681342349673337"
      ]
     },
     "execution_count": 12,
     "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": 13,
   "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": 14,
   "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": 15,
   "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": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average shortest path length of G_BA: 2.731253253253253\n",
      "Average shortest path length of G_random: 2.8844964964964963\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": 17,
   "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": 18,
   "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": 19,
   "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": ".venv",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}