Module 2 - Random Networks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "290a7077",
   "metadata": {},
   "source": [
    "# MODULE 2 - RANDOM NETWORKS\n",
    "\n",
    "Enrico Borriello, CAS 522 Dynamical Systems, ASU Fall C 2023\n",
    "\n",
    "Latest update: Oct 2023"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c6f548c",
   "metadata": {},
   "source": [
    "# Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2c63f32",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random as rn\n",
    "from pyvis.network import Network"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80e0ae13",
   "metadata": {},
   "source": [
    "**NumPy** is the default Python library for matrix oprations. **Random** contains useful functions to generate pseudo-random numbers. **PyVis** is a user-friendly library for the visualization of small-size networks.\n",
    "\n",
    "The abbreviations we have defined for numpy and random are useful when using functions from those libraries. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c74cc645",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean([1,4,-2,6])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cc1b7ee",
   "metadata": {},
   "source": [
    "as opposed to the longer syntax 'numpy.mean([1,4,-2,6])' that we would use if we just imported numpy with 'import numpy'.\n",
    "\n",
    "'np.mean( )' is a function that evaluates the average of the list of numbers we provide as input."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aa06258",
   "metadata": {},
   "source": [
    "# Matrices\n",
    "A numpy matrix can be defined as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49aca0d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1,2],[0,-1]])\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d35114a",
   "metadata": {},
   "source": [
    "**Numpy** also contains functions to automatically generate matrices of given shapes and with specific characteristics without the need to manually assign all the entries. For example, a 6x6 matrix with all the entries equal to zero can be defined as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a4b34a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 6\n",
    "A = np.zeros((N,N), dtype=int)\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26500cd8",
   "metadata": {},
   "source": [
    "We can select the i-th row of matrix A by typing A[i]. Remeber that python numbering starts from zero. Therefore the first row of A is A[0], the second row is A[1], etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7596f676",
   "metadata": {},
   "outputs": [],
   "source": [
    "A[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "062e2dfa",
   "metadata": {},
   "source": [
    "We can select element j of column i of matrix A by typing A[i][j]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "229c4c9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "A[2][3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f4a21b6",
   "metadata": {},
   "source": [
    "We can achieve the same result with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f216004c",
   "metadata": {},
   "outputs": [],
   "source": [
    "A[2,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d174e480",
   "metadata": {},
   "source": [
    "Additionally, we can retrieve all the elements of a given row/column replacing its index with ':'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "061cee46",
   "metadata": {},
   "outputs": [],
   "source": [
    "A[2,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4321a66",
   "metadata": {},
   "outputs": [],
   "source": [
    "A[:,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "037229aa",
   "metadata": {},
   "source": [
    "We can change the value of an entry of a matrix by just reassigning its value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ae1c5c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "A[2,3] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09cdb0b8",
   "metadata": {},
   "source": [
    "We can check the result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a6d96d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6559ae0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "A[2,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdc7f1b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "A[:,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abf6a400",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d9c4a76",
   "metadata": {},
   "source": [
    "We can use a **for** loop to iterate one or more operations: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3ea5d26",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in [0,1,2,3]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "691ebc77",
   "metadata": {},
   "source": [
    "Notice that the instruction that we want to perform begins with an indentation. \n",
    "\n",
    "There is a more compact way to refer to a range of consecutive integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0809a266",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c1386d2",
   "metadata": {},
   "source": [
    "Notice that the numbering starts at zero and ends at 4-1 = 3. Therfore, with range(4), we refer to 4 consecutive integers, the first one being zero.\n",
    "\n",
    "Here's another example, showing that we can perform more than one instruction per step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e1f6423",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    x = 2*i\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "348d91e4",
   "metadata": {},
   "source": [
    "(The four basic operations in Python are '+', '-', '*', '/'.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "408208f9",
   "metadata": {},
   "source": [
    "The **for** loop can also be used to easily generate lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "159e0c99",
   "metadata": {},
   "outputs": [],
   "source": [
    "[2*i for i in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85b892b2",
   "metadata": {},
   "source": [
    "Here's an example not involving numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b718d9be",
   "metadata": {},
   "outputs": [],
   "source": [
    "[character for character in 'word']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "211694b5",
   "metadata": {},
   "source": [
    "(We won't need it, but if you're wondering about the previous output, python sees words as lists of charaters.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f365b34",
   "metadata": {},
   "source": [
    "### Nested loops\n",
    "\n",
    "It is possible to have a for loop as an instruction inside another for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a98328a",
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 3\n",
    "for i in range(N):\n",
    "    for j in range(N):\n",
    "        print(i*j)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "679cebb3",
   "metadata": {},
   "source": [
    "# If condition\n",
    "It is possible to perform an instructio only if a certain condition is met. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "215ec2ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "if rn.random() < 0.6:\n",
    "    print('random number less than 0.6')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bd7af93",
   "metadata": {},
   "source": [
    "Execute the previous command several times. It will print an output only about 60% of times. The reason is that 'rn.random( )' generates a random number between zero and 1. Therefore, it will be less than 1 only 60% of times.\n",
    "\n",
    "Common conditions that can be used with 'if' are:\n",
    "\n",
    "'<' less than\n",
    "\n",
    "'>' greater than\n",
    "\n",
    "'==' equal to\n",
    "\n",
    "'!=' not equal to"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e57ef9c3",
   "metadata": {},
   "source": [
    "It is possible to have an if condition nested within a for loop: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9af4ae0",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = 0.5\n",
    "for i in range(10):\n",
    "    x = rn.random() \n",
    "    if x < p:\n",
    "        print(i,x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0572ab0",
   "metadata": {},
   "source": [
    "(Notice that 'print( )' can have more than one input.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07088f41",
   "metadata": {},
   "source": [
    "Notice that, if the condition is not satisfied, the instructions are not executed, and the xcecution leaves the if statement. Sometimes, it could be useful to provide an alternative set of instructions for when the conditon is not satisfied. This is done using 'if' and 'else' (not nested):"
   ]
  },
  {
   "cell_type": "raw",
   "id": "7f4c8bbf",
   "metadata": {},
   "source": [
    "if condition == True:\n",
    "    instructions 1\n",
    "    else:\n",
    "        instructions 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8a7fc29",
   "metadata": {},
   "source": [
    "In our previous example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72fd96d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "if rn.random() < 0.6:\n",
    "    print('random number less than 0.6')\n",
    "else:\n",
    "    print('random number greater than 0.6')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49a3c3df",
   "metadata": {},
   "source": [
    "# Functions\n",
    "'print( )', 'np.random( )', 'np.mean( )' etc. are **functions**. We can easily define new, custom functions as in the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5eea42be",
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    return x*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "744c58ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "square(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e95bcaf8",
   "metadata": {},
   "source": [
    "A function can have any number of inputs. It can also contain any number of intermediate instructions between 'def' and 'return'. For example, here's a function that calculates the volume of a cylinder of radius r and height h:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff4aec3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cylinder_volume(r,h):\n",
    "    base_area = np.pi*r*r \n",
    "    # np.pi = 3.14... \n",
    "    # everything following # in a line is not executed by python, \n",
    "    # and can be used to add comments to the code\n",
    "    volume = base_area*h\n",
    "    return volume"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79a425bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "cylinder_volume(2,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b0cc001",
   "metadata": {},
   "source": [
    "A function can contain loops and if conditions, nested or not."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26fb4fcc",
   "metadata": {},
   "source": [
    "## QUESTION 1\n",
    "Using what you've learned so far, define a python function that generates the adjacency matrix of a random (Erdos-Renyi) graph with *N* nodes and probability *p*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab4fd7b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ER_adj_matrix(N,p):\n",
    "    ...\n",
    "    return ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa54006a",
   "metadata": {},
   "source": [
    "Once you're done, chose values of *p* and *N*, and use the following code to visualize your network:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e173f62",
   "metadata": {},
   "outputs": [],
   "source": [
    "N = ... # Don't choose N too large, because of the limitations of PyVis\n",
    "p = ...\n",
    "A = ER_adj_matrix(N,p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c6bc6a1",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "g = Network(notebook = True,directed=False)\n",
    "for i in range(len(A)):\n",
    "    g.add_node(i,size=10,color='black')\n",
    "for i in range(len(A)):\n",
    "    for j in range(i):\n",
    "        if A[i][j] == 1:\n",
    "            g.add_edge(i, j)\n",
    "g.show(\"network.html\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7877a8bf",
   "metadata": {},
   "source": [
    "## QUESTION 2\n",
    "\n",
    "Define a python function that calculates the average clustering coefficient *C* of a random network with adjacency matrix *A* as defined in the previous question. Test your function by changing the inputs *N* and *p*. Can you verify that your function produces the intended results?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff9848f4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}