2_evaluation_for_paper.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy import stats\n",
    "from collections import defaultdict\n",
    "import random\n",
    "import copy\n",
    "import math\n",
    "from scipy.optimize import linprog\n",
    "import time\n",
    "from collections import Counter\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "mpl.rcParams.update({'font.size': 14})\n",
    "# mpl.rc('text', usetex = False)\n",
    "mpl.rc('font', family = 'serif')\n",
    "import networkx as nx\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Load input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines = 500000\n",
    "random.seed(10)\n",
    "dataset = 'russian'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load episode set $E$ with the users that retweeted each original tweet in the trace. \n",
    "\n",
    "Each episode $E_{s}$ includes the users that retweeted s, ordered chronologically, as they appear in the trace. The first user in each episode is the user that originally tweeted the tweet, and is denoted by $r_{s}$. Subsequent users in $E_{s}$ are users that retweeted s, either directly from user $r_{s}$ or from another user that appears in Es before them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "D = pickle.load(open(\"./Extracted/\"+dataset+\"/D\"+ str(lines) + \".p\", \"rb\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "E = pickle.load(open(\"./Extracted/\"+dataset+\"/E\"+ str(lines) + \".p\", \"rb\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "for tweet in E:\n",
    "    E[tweet] = list(dict.fromkeys(E[tweet]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the set of original tweets denoted by $S$. \n",
    "\n",
    "The set of original tweets is denoted by $S$, where $S$ = S is the total number of original tweets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "S = pickle.load(open(\"./Extracted/\"+dataset+\"/S\"+ str(lines) + \".p\", \"rb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load $U$ set xith unique users"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# U = pickle.load(open(\"./Extracted/U\"+ str(lines) + \".p\", \"rb\"))\n",
    "# U = list(U)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load $M_{ij}$ variables that count number of episodes where the ordered pair (i,j) appears"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = pickle.load(open(\"./Extracted/\"+dataset+\"/M_d\"+ str(lines) + \".p\", \"rb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load $Q_{ij}$ results for the ordered pair (i,j) derived from the consrained algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "Q = pickle.load(open(\"./Extracted/\"+dataset+\"/results/Q_constrained_\"+ str(lines) + \".p\", \"rb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load $s_{ij}$ derived from the consrained algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = pickle.load(open(\"./Extracted/\"+dataset+\"/results/s_constrained_\"+ str(lines) + \".p\", \"rb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load $k_{ij}$ derived from Saito"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# k = pickle.load(open(\"./Extracted/\"+dataset+\"/results/k_saito_\"+ str(lines) + \".p\", \"rb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load $Q_{ij}$ derived from Newman's"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q_newman = pickle.load(open(\"./Extracted/\"+dataset+\"/Q_newman_\"+ str(lines) + \".p\", \"rb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Necessary functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flatten(obj):\n",
    "    if type(obj) == list:\n",
    "        return [l for L in obj for l in L]\n",
    "    if type(obj) == dict:\n",
    "        return [l for i in obj for l in obj[i].values()]\n",
    "    if type(obj) == defaultdict:\n",
    "        return [l for i in obj for l in obj[i].values()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_serpent_graph(U,D):\n",
    "    G = nx.DiGraph()\n",
    "    G.add_nodes_from(U)\n",
    "    for tweet in D:\n",
    "        for time in D[tweet]:\n",
    "            ind = list(D[tweet].keys()).index(time)\n",
    "            if ind+1==len(D[tweet]): break\n",
    "            next_time = list(D[tweet].keys())[ind+1]\n",
    "            for u1 in D[tweet][time]:\n",
    "                for u2 in D[tweet][next_time]:\n",
    "                    G.add_edge(u1,u2)\n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_saito_graph(U,k):\n",
    "    G = nx.DiGraph()\n",
    "    G.add_nodes_from(U)\n",
    "\n",
    "    for i in k:\n",
    "        for j in k[i]:\n",
    "            if k[i][j] > 0.5:\n",
    "                G.add_edge(i,j)\n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_star_graph(U,E):\n",
    "    G = nx.DiGraph()\n",
    "    G.add_nodes_from(U)\n",
    "    for s in E:\n",
    "        for j in E[s][1:]:\n",
    "            G.add_edge(E[s][0],j)\n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_our_graph(U,Q):\n",
    "    G = nx.DiGraph()\n",
    "    G.add_nodes_from(U)\n",
    "    for i in Q:\n",
    "        for j in Q[i]:\n",
    "            if Q[i][j] > 0.5:\n",
    "                G.add_edge(i,j)\n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_newman_graph(U,Q):\n",
    "    G = nx.DiGraph()\n",
    "    G.add_nodes_from(U)\n",
    "\n",
    "    for i in Q:\n",
    "        for j in Q[i]:\n",
    "            if Q[i][j] > 0.5:\n",
    "                G.add_edge(i,j)\n",
    "    return G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wedge_metric(graph):\n",
    "    numerator = 0\n",
    "    denominator = 0\n",
    "\n",
    "    for i in graph.nodes:\n",
    "        leaders = set(graph.predecessors(i))\n",
    "        followers = set(graph.successors(i))\n",
    "        friends = leaders.intersection(followers)\n",
    "        if len(leaders) + len(followers) < 2:\n",
    "            continue\n",
    "        if leaders==followers and len(leaders)==1:\n",
    "            continue\n",
    "        L = len(leaders)\n",
    "        F = len(followers)\n",
    "        LintF = len(friends)\n",
    "        numerator += L*F - LintF\n",
    "        denominator += (L+F)**2 - L - F - 2*LintF\n",
    "\n",
    "    if denominator != 0:\n",
    "        result = 2 * numerator / denominator\n",
    "    else:\n",
    "        result = 0\n",
    "        \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f_check(E, Q):\n",
    "    '''\n",
    "    Function that checks feasibility of results\n",
    "\n",
    "    '''\n",
    "    retweets = 0 # minimum existing edges\n",
    "    infeasible_episodes = 0 \n",
    "    total_feasible_edges = []\n",
    "    total_inf = 0 \n",
    "    for s in E:\n",
    "        feasible_edges = 0 \n",
    "        for j in E[s]:\n",
    "            indx = E[s].index(j)\n",
    "            if indx!=0:\n",
    "                u_before = E[s][:indx]\n",
    "                for i in u_before: \n",
    "                    if i in Q and j in Q[i] and Q[i][j] > 0.5:\n",
    "                        feasible_edges +=1\n",
    "                        total_feasible_edges.append((i,j))\n",
    "\n",
    "        infeasible = (len(E[s]) - 1) - feasible_edges\n",
    "        if infeasible > 0:\n",
    "#             print('Tweet', s, 'retweeted by', len(E[s])-1, 'users in total. But, we only found:', feasible_edges, 'feasible edges, so the infeasible ones are:', infeasible)            \n",
    "            total_inf+=infeasible\n",
    "            infeasible_episodes+=1\n",
    "            \n",
    "        retweets += len(E[s])-1\n",
    "        total_feasible_edges = list(set(total_feasible_edges))\n",
    "        \n",
    "    return infeasible_episodes\n",
    "        \n",
    "#     print('Total feasbile edges:', len(total_feasible_edges), 'Number of retweets', retweets)\n",
    "#     print('Total infeasible edges:', total_inf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def longest_path(E, U, Q, k, graph_type):\n",
    "    max_l = 0\n",
    "    max_path = 0\n",
    "    \n",
    "    if graph_type=='ours' or graph_type=='newman':    \n",
    "        for s in E:\n",
    "            G = nx.DiGraph()\n",
    "            G.add_nodes_from(U)\n",
    "            for j in E[s][1:]:\n",
    "                    indx = E[s].index(j)\n",
    "                    u_before = E[s][:indx]\n",
    "                    for i in u_before: \n",
    "                            if j in Q[i] and Q[i][j] > 0.5:\n",
    "                                G.add_edge(i,j)\n",
    "\n",
    "            if len(nx.dag_longest_path(G))>max_l: \n",
    "                max_l = len(nx.dag_longest_path(G))\n",
    "                max_path = nx.dag_longest_path(G)\n",
    "                \n",
    "    if graph_type=='star':\n",
    "        for s in E:\n",
    "            G = nx.DiGraph()\n",
    "            G.add_nodes_from(U)\n",
    "            for j in E[s][1:]:\n",
    "                G.add_edge(E[s][0],j)\n",
    "\n",
    "            if len(nx.dag_longest_path(G))>max_l: \n",
    "                max_l = len(nx.dag_longest_path(G))\n",
    "                max_path = nx.dag_longest_path(G)\n",
    "                \n",
    "    if graph_type=='saito':    \n",
    "        for s in E:\n",
    "            G = nx.DiGraph()\n",
    "            G.add_nodes_from(U)\n",
    "            for j in E[s][1:]:\n",
    "                    indx = E[s].index(j)\n",
    "                    u_before = E[s][:indx]\n",
    "                    for i in u_before: \n",
    "                            if j in k[i] and k[i][j] > 0.5:\n",
    "                                G.add_edge(i,j)\n",
    "\n",
    "            if len(nx.dag_longest_path(G))>max_l: \n",
    "                max_l = len(nx.dag_longest_path(G))\n",
    "                max_path = nx.dag_longest_path(G)\n",
    "                \n",
    "    return max_l, max_path   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_tweetgraph(s, E, S, Q, k, pos, graph_type):\n",
    "        \n",
    "        G = nx.DiGraph()\n",
    "        \n",
    "        if graph_type=='ours' or graph_type=='newman':\n",
    "            t = 0\n",
    "            for j in E[s][1:]:\n",
    "                G.add_node(j)\n",
    "                indx = E[s].index(j)\n",
    "                u_before = E[s][:indx]\n",
    "                for i in u_before: \n",
    "                        G.add_node(i)\n",
    "                        if j in Q[i] and Q[i][j] > 0.5:\n",
    "                            G.add_edge(i,j, label=f'{t}')\n",
    "                            t+=1\n",
    "                            \n",
    "        elif graph_type=='star':\n",
    "            \n",
    "            G.add_node(E[s][0])\n",
    "            for j in E[s][1:]:\n",
    "                    G.add_edge(E[s][0],j)\n",
    "                    G.add_node(j)\n",
    "                    \n",
    "        elif graph_type=='saito':\n",
    "            t = 0\n",
    "            for j in E[s][1:]:\n",
    "                G.add_node(j)\n",
    "                indx = E[s].index(j)\n",
    "                u_before = E[s][:indx]\n",
    "                for i in u_before: \n",
    "                        G.add_node(i)\n",
    "                        if j in k[i] and k[i][j] > 0.5:\n",
    "                            G.add_edge(i,j, label=f'{t}')\n",
    "                            t+=1\n",
    "                            \n",
    "        elif graph_type=='serpent':\n",
    "            for time in D[s]:\n",
    "                ind = list(D[tweet].keys()).index(time)\n",
    "                if ind+1==len(D[tweet]): break\n",
    "                next_time = list(D[tweet].keys())[ind+1]\n",
    "                for u1 in D[tweet][time]:\n",
    "                    for u2 in D[tweet][next_time]:\n",
    "                        G.add_edge(u1,u2)\n",
    "\n",
    "        # print('- Edges:', G.edges)\n",
    "        color_map = []\n",
    "        cmap = plt.get_cmap('Greens')\n",
    "\n",
    "        for node in G:\n",
    "            if node == S[tweet]:\n",
    "                color_map.append('green')\n",
    "            else:\n",
    "                color_map.append('yellow')\n",
    "        \n",
    "        pos = nx.spring_layout(G)        \n",
    "        nx.draw_networkx_nodes(G, pos, node_color = color_map, cmap=plt.get_cmap('jet'), node_size = 300)\n",
    "        nx.draw_networkx_edges(G, pos, edge_color='r', arrows=True)\n",
    "        nx.draw_networkx_labels(G, pos, font_size=8)\n",
    "        if graph_type=='ours' or graph_type=='saito':\n",
    "            nx.draw_networkx_edge_labels(G, pos, font_size=8)\n",
    "        plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Statistics\n",
    "\n",
    "## 1. number of infeasible episodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-Total number of episodes: 111\n",
      "-Total infeasible episodes in our graph: 0\n",
      "-Total infeasible episodes in Saitos graph: 42\n",
      "-Total infeasible episodes in Newmans graph: 111\n"
     ]
    }
   ],
   "source": [
    "print('-Total number of episodes:', len(E))\n",
    "inf_ep = f_check(E, Q)\n",
    "print('-Total infeasible episodes in our graph:', inf_ep)\n",
    "inf_ep = f_check(E, k)\n",
    "print('-Total infeasible episodes in Saitos graph:', inf_ep)\n",
    "inf_ep = f_check(E, Q_newman)\n",
    "print('-Total infeasible episodes in Newmans graph:', inf_ep)\n",
    "\n",
    "df['']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = dict()\n",
    "data['Graph Type'] = ['Ours','Saito','Star','Serpent', 'Newman']\n",
    "\n",
    "# df = pd.DataFrame(data, columns= ['Graph Type', 'Infeasible Episodes', 'Number of Edges'])\n",
    "# df.to_csv (r'C:\\Users\\Ron\\Desktop\\export_dataframe.csv', index = False, header=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Expected number of edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create graphs\n",
    "G_star = create_star_graph(U,E)\n",
    "G_ours = create_our_graph(U,Q)\n",
    "G_saito = create_saito_graph(U,k)\n",
    "G_newman = create_newman_graph(U,Q_newman)\n",
    "G_serpent = create_serpent_graph(U,D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "edges_ours = len(G_ours.edges())\n",
    "edges_saito = len(G_saito.edges())\n",
    "edges_star = len(G_star.edges())\n",
    "edges_serpent = len(G_serpent.edges())\n",
    "edges_newman = len(G_newman.edges())\n",
    "\n",
    "data['Number of edges'] = [edges_ours, edges_saito, edges_star, edges_serpent, edges_newman]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #OURS\n",
    "\n",
    "# exp_edges = sum(Q[i][j] for i in Q for j in Q[i])\n",
    "# print('- Expected number of edges in our graph:', exp_edges, 'out of', len(U)*(len(U)-1), 'possible ones')\n",
    "\n",
    "# #SAITO\n",
    "\n",
    "# probs = np.histogram(flatten(k))[1]\n",
    "# probs = probs[1:]\n",
    "# nbs = np.histogram(flatten(k))[0]\n",
    "# lena = len(probs)\n",
    "# exp_edges = sum(probs[i]*nbs[i] for i in range(0,lena))\n",
    "# print('- Expected number of edges in Saitos graph:', exp_edges, 'out of', len(U)*(len(U)-1), 'possible ones')\n",
    "\n",
    "# #NEWMAN\n",
    "\n",
    "# exp_edges = sum(Q_newman[i][j] for i in Q_newman for j in Q_newman[i])\n",
    "# print('- Expected number of edges in Newmans graph:', exp_edges, 'out of', len(U)*(len(U)-1), 'possible ones')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # plot k\n",
    "# fig, ax = plt.subplots()\n",
    "# ax.hist(flatten(k), facecolor='yellow', edgecolor='red')\n",
    "# # ax.set_yscale('log')\n",
    "# plt.xlabel(\"k_ij distribution\")\n",
    "# plt.ylabel(\"Number of edges\")\n",
    "# plt.show()\n",
    "# plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# degree_sequence = list(G_ours.out_degree())\n",
    "\n",
    "# # plot k\n",
    "# fig, ax = plt.subplots()\n",
    "# ax.hist(np.array(degree_sequence)[:,1], facecolor='yellow', edgecolor='red')\n",
    "# # ax.set_yscale('log')\n",
    "# plt.xlabel(\"k_ij distribution\")\n",
    "# plt.ylabel(\"Number of edges\")\n",
    "# plt.show()\n",
    "# plt.close()\n",
    "# plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Average out degree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "av_ours = sum(d[1] for d in G_ours.out_degree())/float(len(G_ours))\n",
    "av_saito = sum(d[1] for d in G_saito.out_degree())/float(len(G_saito))\n",
    "av_star = sum(d[1] for d in G_star.out_degree())/float(len(G_star))\n",
    "av_serpent = sum(d[1] for d in G_serpent.out_degree())/float(len(G_serpent))\n",
    "av_newman = sum(d[1] for d in G_newman.out_degree())/float(len(G_newman))\n",
    "\n",
    "data['Average out degree'] = [av_ours, av_saito, av_star, av_serpent, av_newman]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum degree of Our graph: 9\n",
      "Maximum degree of Saito graph: 25\n",
      "Maximum degree of Star graph : 71\n",
      "Maximum degree of Serpent graph: 25\n",
      "Maximum degree of Newman's graph: 9\n"
     ]
    }
   ],
   "source": [
    "degree_sequence = list(G_ours.out_degree())\n",
    "max_degree_our = max(np.array(degree_sequence)[:,1])\n",
    "print(\"Maximum degree of Our graph: \" + str(max_degree))\n",
    "\n",
    "degree_sequence = list(G_saito.out_degree())\n",
    "max_degree_saito = max(np.array(degree_sequence)[:,1])\n",
    "print(\"Maximum degree of Saito graph: \" + str(max_degree))\n",
    "\n",
    "\n",
    "degree_sequence = list(G_star.out_degree())\n",
    "max_degree_saito = max(np.array(degree_sequence)[:,1])\n",
    "print(\"Maximum degree of Star graph : \" + str(max_degree))\n",
    "\n",
    "degree_sequence = list(G_serpent.out_degree())\n",
    "max_degree_serpent = max(np.array(degree_sequence)[:,1])\n",
    "print(\"Maximum degree of Serpent graph: \" + str(max_degree))\n",
    "\n",
    "\n",
    "degree_sequence = list(G_newman.out_degree())\n",
    "max_degree_newmans = max(np.array(degree_sequence)[:,1])\n",
    "print(\"Maximum degree of Newman's graph: \" + str(max_degree))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min degree of Our graph: 9\n",
      "Min degree of Saito graph: 11\n",
      "Min degree of Star graph : 9\n",
      "Min degree of Serpent graph: 25\n",
      "Min degree of Newman's graph: 71\n"
     ]
    }
   ],
   "source": [
    "degree_sequence = list(G_ours.in_degree())\n",
    "max_degree = max(np.array(degree_sequence)[:,1])\n",
    "print(\"Min degree of Our graph: \" + str(max_degree))\n",
    "\n",
    "degree_sequence = list(G_saito.in_degree())\n",
    "max_degree = max(np.array(degree_sequence)[:,1])\n",
    "print(\"Min degree of Saito graph: \" + str(max_degree))\n",
    "\n",
    "degree_sequence = list(G_star.in_degree())\n",
    "max_degree = max(np.array(degree_sequence)[:,1])\n",
    "print(\"Min degree of Star graph : \" + str(max_degree))\n",
    "\n",
    "degree_sequence = list(G_serpent.in_degree())\n",
    "max_degree = max(np.array(degree_sequence)[:,1])\n",
    "print(\"Min degree of Serpent graph: \" + str(max_degree))\n",
    "\n",
    "degree_sequence = list(G_newman.in_degree())\n",
    "max_degree = max(np.array(degree_sequence)[:,1])\n",
    "print(\"Min degree of Newman's graph: \" + str(max_degree))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "def degree_histogram_directed(G, in_degree=False, out_degree=False):\n",
    "    \"\"\"Return a list of the frequency of each degree value.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    G : Networkx graph\n",
    "       A graph\n",
    "    in_degree : bool\n",
    "    out_degree : bool\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    hist : list\n",
    "       A list of frequencies of degrees.\n",
    "       The degree values are the index in the list.\n",
    "\n",
    "    Notes\n",
    "    -----\n",
    "    Note: the bins are width one, hence len(list) can be large\n",
    "    (Order(number_of_edges))\n",
    "    \"\"\"\n",
    "    nodes = G.nodes()\n",
    "    if in_degree:\n",
    "        in_degree = dict(G.in_degree())\n",
    "        degseq=[in_degree.get(k,0) for k in nodes]\n",
    "    elif out_degree:\n",
    "        out_degree = dict(G.out_degree())\n",
    "        degseq=[out_degree.get(k,0) for k in nodes]\n",
    "    else:\n",
    "        degseq=[v for k, v in G.degree()]\n",
    "    dmax=max(degseq)+1\n",
    "    freq= [ 0 for d in range(dmax) ]\n",
    "    for d in degseq:\n",
    "        freq[d] += 1\n",
    "    return freq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "in_degree_freq = degree_histogram_directed(G_ours, in_degree=True)\n",
    "out_degree_freq = degree_histogram_directed(G_ours, out_degree=True)\n",
    "in_degrees = range(len(in_degree_freq))\n",
    "out_degrees = range(len(out_degree_freq))\n",
    "plt.figure(figsize=(12, 8)) \n",
    "plt.plot(range(len(in_degree_freq)), in_degree_freq, 'go-', label='in-degree') \n",
    "plt.plot(range(len(out_degree_freq)), out_degree_freq, 'bo-', label='out-degree')\n",
    "plt.xlabel('Degree')\n",
    "plt.ylabel('Frequency')\n",
    "\n",
    "in_degree_freq = degree_histogram_directed(G_saito, in_degree=True)\n",
    "out_degree_freq = degree_histogram_directed(G_saito, out_degree=True)\n",
    "in_degrees = range(len(in_degree_freq))\n",
    "out_degrees = range(len(out_degree_freq))\n",
    "\n",
    "in_degree_freq = degree_histogram_directed(G_star, in_degree=True)\n",
    "out_degree_freq = degree_histogram_directed(G_star, out_degree=True)\n",
    "in_degrees = range(len(in_degree_freq))\n",
    "out_degrees = range(len(out_degree_freq))\n",
    "\n",
    "in_degree_freq = degree_histogram_directed(G_newman, in_degree=True)\n",
    "out_degree_freq = degree_histogram_directed(G_newman, out_degree=True)\n",
    "in_degrees = range(len(in_degree_freq))\n",
    "out_degrees = range(len(out_degree_freq))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def plot_degree_dist(G, graph_type):\n",
    "#     degrees = [G.degree(n) for n in G.nodes()]\n",
    "#     counts, bins, bars = plt.hist(degrees, density=True)\n",
    "#     print(counts, bins)\n",
    "#     print(sum(counts))\n",
    "#     exp_edges = sum(counts[i]*bins[i] for i in range(0,len(counts)))\n",
    "#     print('- Expected number of edges in Newmans graph:', exp_edges)\n",
    "#     plt.hist(degrees, density=True)\n",
    "#     plt.title('degree distribution plot (P(deg=k), k=0,1,…) for graph_type graph')\n",
    "#     plt.show()\n",
    "\n",
    "# plot_degree_dist(G_ours, 'Our')\n",
    "# plot_degree_dist(G_saito, 'Saito')\n",
    "# plot_degree_dist(G_star, 'Star')\n",
    "# plot_degree_dist(G_newman, 'Newman')\n",
    "# plot_degree_dist(G_serpent, 'Serpent')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Graph diameter\n",
    "\n",
    "The maximum among all the distances between a vertex to all other vertices is considered as the diameter of the Graph G."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Diameter for strongly connected components of Ours\n",
      "Strongly connected component with diameter: 1\n",
      "- Diameter for strongly connected components of Saito\n",
      "- Diameter for strongly connected components of Star\n",
      "Strongly connected component with diameter: 1\n",
      "- Diameter for strongly connected components of Serpent\n",
      "Strongly connected component with diameter: 4\n",
      "Strongly connected component with diameter: 44\n",
      "Strongly connected component with diameter: 4\n",
      "Strongly connected component with diameter: 1\n",
      "- Diameter for strongly connected components of Newman\n",
      "Strongly connected component with diameter: 1\n"
     ]
    }
   ],
   "source": [
    "def diameter_scc(G, graph_type):\n",
    "    print('- Diameter for strongly connected components of', graph_type)\n",
    "    for C in nx.strongly_connected_components(G):\n",
    "        C = G.subgraph(C)\n",
    "        if len(C)>1: # skip one nodes\n",
    "            print('Strongly connected component with diameter:', nx.diameter(C)) # maximum eccentricity\n",
    "\n",
    "diameter_scc(G_ours, 'Ours')\n",
    "diameter_scc(G_saito, 'Saito')\n",
    "diameter_scc(G_star, 'Star')\n",
    "diameter_scc(G_serpent, 'Serpent')\n",
    "diameter_scc(G_newman, 'Newman')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Wedge metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Wedge metric for our graph: 0.423692636072572\n",
      "- Wedge metric for the star graph: 0.008169934640522876\n",
      "- Wedge metric for the Saito graph: 0.3199285075960679\n",
      "- Wedge metric for the Serpent graph: 0.31484671029968997\n",
      "- Wedge metric for the Newman graph: 0.009416877942774357\n"
     ]
    }
   ],
   "source": [
    "print('- Wedge metric for our graph:', wedge_metric(G_ours))\n",
    "print('- Wedge metric for the star graph:', wedge_metric(G_star))\n",
    "print('- Wedge metric for the Saito graph:', wedge_metric(G_saito))\n",
    "print('- Wedge metric for the Serpent graph:', wedge_metric(G_serpent))\n",
    "print('- Wedge metric for the Newman graph:', wedge_metric(G_newman))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Cumulative degree distribution plots (P(deg>k), k=0,1,…)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cumulative degree distribution plot (P(deg>k), k=0,1,…) for Our Graph\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cumulative degree distribution plot (P(deg>k), k=0,1,…) for Saito Graph\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cumulative degree distribution plot (P(deg>k), k=0,1,…) for Star Graph\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cumulative degree distribution plot (P(deg>k), k=0,1,…) for Newman Graph\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEACAYAAAC08h1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAEVhJREFUeJzt3X+sX3V9x/Hny4KtLYoyrpTN1dolblh/bVwQN/kxAZsBYnAzMZLF/SCdERNRy2adGqagoDMSDdExExnZGNNMM1JnGpCVYv2xtvirNpsTBBUp1hAcP0oVfe+P72Fevt7bnnvvt3zL/TwfSXPy/ZzP537f96R5fc/9nHM+31QVkqR2PGHcBUiSHlsGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4Jakxh4y7gOkceeSRtXLlynGXIUmPG9u3b/9RVU306XtQBv/KlSvZtm3buMuQpMeNJHf07etUjyQ1xuCXpMYY/JLUGINfkhrTO/iTPDHJpUkeTrKyR/+nJLkqydYktyS5LMlBeTFZklrSK/i7oL8JOBpY1PNnXwUsqqrjgBOAE4F3zbpCSdJI9T3jPwz4Y+DjfToneS5wDvA+gKr6CXA5cEGSw+ZQpyRpRHoFf1XtqKpvz+LnngY8BOyY0rYVeBLwkln8HEnSiB2oi7urgLvr0V/ou2vKPknSmByoi63LgL1DbY+8XjrdgCRrgbUAK1asmPMbr3zrZ+Y8dj5uv/TMsbyvJM3WgTrjfwBYPNT2yOsHpxtQVVdW1WRVTU5M9FpuQpI0Bwcq+G8Dnp4kU9qWd9tbD9B7SpJ6OFDBfz2DC7mrp7RNAnuALQfoPSVJPYwk+JNcnGRHkiUAVfVN4NPAhd3+Q4E3ApdX1f2jeE9J0tz0fYDriUk2MbgXH+DaJJ+a0mUJg4u2U6d2/qQbuxX4MvAF4J3zrFeSNE+97urpHsA6ZR/71wHrhtr+F3jtfIqTJI2ei7RJUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDWmd/AnOTvJ1iSbk2xJMrmf/icn+XySm5N8KclVSY6Yf8mSpPnoFfxJjgWuAV5bVScB7wU2Jlk+Q/+nAhuAa6vqROB3gcOAvxtJ1ZKkOet7xr8e2FhVOwGqagNwN3D+DP1/g0HQf67r/3PgRuBl86pWkjRvfYP/NGDbUNtW4PQZ+n8T+C/gNQBJlgKvZPBhIUkao/0Gfzcvfzhw19CuXcCq6cZU1UPAqcBLk9wB/AB4HvD6eVUrSZq3Pmf8y7rt3qH2vcDS6QYkeTJwPXAzsBL4NeAS4M6Z3iTJ2iTbkmzbvXt3j7IkSXPRJ/gf6LaLh9oXAw/OMObPGfw1cFENPAB8Hbipu/D7S6rqyqqarKrJiYmJHmVJkuZiv8FfVfcA9wLDd/AsB26dYdizgV3dlM8jvgNMACfPoU5J0oj0vbh7AzB83/5k1z6dO4GJJIumtB3dbWf6K0GS9BjoG/yXAmuSHAOQ5AwGQX5F9/riJDuSLOn6/3P3s1/f7V8EvBn4HvDF0ZUvSZqtQ/p0qqrtSc4Frk6yB1gErKmqXV2XJQwu9Kbrf1uSNcAlSV7d7b+zG3P/qH8JSVJ/vYIfoKquA66bYd86YN1Q283ASfOqTpI0ci7SJkmNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUmN7Bn+TsJFuTbE6yJclkjzGvS3JTN+a2JB+fX7mSpPk6pE+nJMcC1wDHV9XOJGcBG5OsrqpdM4z5K+AlwMuqam+SFwDXj6pwSdLc9D3jXw9srKqdAFW1AbgbOH+6zkl+BbgIeEtV7e3GfA34o/kWLEman77BfxqwbahtK3D6DP3PAH5cVd+a2lhVm2dXniRp1PYb/EmOAA4H7hratQtYNcOw5wE/SHJekv9I8oUkH00yMb9yJUnz1eeMf1m33TvUvhdYOsOYpwHPBU5m8FfBycBTgU1JDp1DnZKkEekT/A9028VD7YuBB2cY8zPgUOCiqnq4qn4KvBN4DrBmugFJ1ibZlmTb7t27e5QlSZqL/QZ/Vd0D3AssH9q1HLh1hmHfH9oC3NFtnzXD+1xZVZNVNTkx4YyQJB0ofS/u3gAM37c/2bVP56Zue/SUtqO67Xd7vqck6QDoG/yXAmuSHAOQ5AwGoX5F9/riJDuSLAGoqpuBLcCbpvyMNwHfAjaOqHZJ0hz0eoCrqrYnORe4OskeYBGwZsrDW0sYXOjNlGHnAB9OcguwB7gTOL2qHhpZ9ZKkWesV/ABVdR1w3Qz71gHrhtp2A6+eV3WSpJFzkTZJaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUmN7Bn+TsJFuTbE6yJclkz3HLktyeZNOcq5QkjcwhfTolORa4Bji+qnYmOQvYmGR1Ve3az/B3AYfPs05J0oj0PeNfD2ysqp0AVbUBuBs4f1+Dkvw2cBxw3XyKlCSNTt/gPw3YNtS2FTh9pgFJngBcweDDoeZUnSRp5PYb/EmOYDBVc9fQrl3Aqn0MfQNwc1V9Y+7lSZJGrc8c/7Juu3eofS+wdLoBSZ4BnAec0LeQJGuBtQArVqzoO0ySNEt9pnoe6LaLh9oXAw/OMOZDwPqqmmn/L6mqK6tqsqomJyYm+g6TJM3Sfs/4q+qeJPcCy4d2LQduHe6f5MnAC4ELk1zYNf8WsKS7pfOLVbV+XlVLkuas1+2cwA3A8H37k8CnhjtW1X0Mzf0nuQpYWVWnzL5ESdIo9b2r51JgTZJjAJKcARzN4K4dklycZEeSJQemTEnSqPQ646+q7UnOBa5OsgdYBKyZ8vDWEgYXejN1XJIXApfz6Kme91fVZ0ZUvyRplvpO9VBV1zHDg1hVtQ5YN037V4FT5lqcJGn0XKRNkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxvYM/ydlJtibZnGRLksl99D0qyXuSfD7JpiRfSbI+ySGjKVuSNFe9gjjJscA1wPFVtTPJWcDGJKuratc0Q14FrAFOqar7kvw6cAvwJOCdI6pdkjQHfc/41wMbq2onQFVtAO4Gzp+h/w+B91fVfV3/7wGfAM6dX7mSpPnqG/ynAduG2rYCp0/Xuao+UVXXDjXvARbPrjxJ0qjtN/iTHAEcDtw1tGsXsGoW7/ViBmf9kqQx6jPHv6zb7h1q3wss7fMmSU4DVgBn7qPPWmAtwIoVK/r8WEnSHPSZ6nmg2w5P0ywGHtzf4CTPBD4CnF1V987Ur6qurKrJqpqcmJjoUZYkaS72G/xVdQ9wL7B8aNdy4NZ9jU1yFPBvwHlV9ZW5FilJGp2+F3dvAIbv25/s2qeV5GnABmB9Vd3Uta2dS5GSpNHpG/yXAmuSHAOQ5AzgaOCK7vXFSXYkWdK9Pgz4LIMPht1JJrsHvv5i1L+AJGl2ej3AVVXbk5wLXJ1kD7AIWDPl4a0lDC70pnv9RuBF3b+3jrZkSdJ89F6yoaquq6rjquqkqvq9qto6Zd+6qlpVVXu615dUVab7dyB+CUlSfy7SJkmNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMb2+c1f7t/Ktnxnbe99+6Zlje29Jjz+e8UtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY3pHfxJzk6yNcnmJFuSTO6n/1OSXNWNuSXJZUlcG0iSxqxXECc5FrgGOL6qdiY5C9iYZHVV7Zph2FXAA1V1XJInApuAdwFvm3/ZmmpcC8S5OJz0+NT3jH89sLGqdgJU1QbgbuD86ToneS5wDvC+rv9PgMuBC5IcNt+iJUlz1zf4TwO2DbVtBU7fR/+HgB1D/Z8EvGQ2BUqSRmu/Uz1JjgAOB+4a2rUL+IMZhq0C7q6qGur/yD4tAOP8DoJxcXpLC0GfOf5l3XbvUPteYOk+xkzXn5nGJFkLrO1e3p/kv3vUNp0jgR/NcexC47F4tHkfj1w2okoODv7/+IWFcCye2bdjn+B/oNsuHmpfDDy4jzHT9WemMVV1JXBlj3r2Kcm2qtrnHUet8Fg8msfj0Twev9DasdjvHH9V3QPcCywf2rUcuHWGYbcBT0+Sof7sY4wk6THQ9+LuDcDwp+Fk1z6d6xlcyF091H8PsGU2BUqSRqtv8F8KrElyDECSM4CjgSu61xcn2ZFkCUBVfRP4NHBht/9Q4I3A5VV1/2h/hV8y7+miBcRj8Wgej0fzePxCU8cij77xZh8dk7OBdzA4a18EXFBVW7t9fwu8ElhdVXu6tqcAHwae0/W/AXhbVT086l9CktRf7+CXJC0MC2aRttmuJbRQJTkryb8n+VySLyX5bJLnj7uug0GSNySpJKeMu5ZxSvLMJP+S5MYk30iyPcnvj7uucUiyOMkHk3w1yU1JvpzknHHXdaAtiOCfspbQa6vqJOC9DNYSGr4TqQVXAf9YVadW1QnA14DPJTlqvGWNV5Jfpbvm1LIkRwI3Ah+pqpcCz2dwF97qfQ5cuN4OvAI4sapOBl4HXJvkBeMt68BaEMHPLNcSWuA2V9U1U15/gMHDKS8bUz0Hiw8D7xl3EQeBvwS+XFWbALqn698CbBhnUWP0QmBrVd0HUFVfAX4MvHSsVR1gCyX4Z7uW0IJVVa8catrTbYcfqGtGkpcDPwU2jruWg8AfApunNlTVd6vq9vGUM3b/CpyY5BkASdYAEwxOHBesx/36+HNcS6glL2awYN514y5kHJIsAy4B1tDwhx/8/7FYBSxK8k/ASgZP0l9ZVZ8cZ23jUlVXJVkK7EhyF/Bs4JPAJ8Zb2YH1uA9+5raWUBO6J6ffAby9qn447nrG5N3AR6vqriQrx1zLuD21214MnFpVtyQ5HrgpyaFDU4RNSHIeg+8Imayqb3c3QpwG/Hy8lR1YC2GqZy5rCbXiPcAdVfWBcRcyDkl+B3gR8NFx13KQ+Fm33VBVtwBU1X8yeNjyzWOraky6E6P3AX9fVd8GqKqvA2ezwL8w6nEf/HNcS2jBS3IBg4fn/nTctYzRmQyWDrkxySbg2q798iSbkvzm2Cobj90M/hL+/lD7HcCzHvtyxm4CeBpw+1D7dxhcC1mwFsJUD8y8ltCnxlDL2HV/vp4BvLyqHk6yClhVVTOtrbQgVdW7GUz1ANBN9XyHwVPnm8ZT1fhU1c+SbGGw3MpURwHfHUNJ4/YjBh+Ew8fjaBb4bMHj/oy/s8+1hFqS5NXAXzO4oPm87kG20/GbzzRwGfCKJM+CwcNcDL4m9UNjrWoMqurnwD8Af9bdJPLI9OCpLPCLuwtmyYZ9rSXUkiQ/Zfq/5P6mqi56jMs5aCS5HDiBwZz/14D/qapXjbeq8UjyGmAdg7PaQ4CPVdXHxlvVeHR39FzE4ILug8CTGXwYfLAWSjhOY8EEvySpn4Uy1SNJ6sngl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXm/wBe5zTpvWWUBwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cumulative degree distribution plot (P(deg>k), k=0,1,…) for Serpent Graph\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_degree_dist(G, graph_type):\n",
    "    degrees = [G.out_degree(n) for n in G.nodes()]\n",
    "#     plt.xlim(0,250)\n",
    "    plt.hist(degrees, cumulative=-1, density=True)\n",
    "    print('Cumulative degree distribution plot (P(deg>k), k=0,1,…) for', graph_type, 'Graph')\n",
    "#     plt.title('Cumulative degree distribution plot (P(deg>k), k=0,1,…) for graph_type graph')\n",
    "    plt.show()\n",
    "\n",
    "plot_degree_dist(G_ours, 'Our')\n",
    "plot_degree_dist(G_saito, 'Saito')\n",
    "plot_degree_dist(G_star, 'Star')\n",
    "plot_degree_dist(G_newman, 'Newman')\n",
    "plot_degree_dist(G_serpent, 'Serpent')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Mean length of shortest-path from i to j (for any i and j)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Average shortest path for strongly connected components of Ours\n",
      "Strongly connected component with average shortest path: 1.0\n",
      "- Average shortest path for strongly connected components of Saito\n",
      "- Average shortest path for strongly connected components of Star\n",
      "Strongly connected component with average shortest path: 1.0\n",
      "- Average shortest path for strongly connected components of Serpent\n",
      "Strongly connected component with average shortest path: 2.5\n",
      "Strongly connected component with average shortest path: 15.191586538461538\n",
      "Strongly connected component with average shortest path: 2.5\n",
      "Strongly connected component with average shortest path: 1.0\n",
      "- Average shortest path for strongly connected components of Newman\n",
      "Strongly connected component with average shortest path: 1.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Done'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def avg_sh_path(G, graph_type):\n",
    "    print('- Average shortest path for strongly connected components of', graph_type)\n",
    "    for C in nx.strongly_connected_components(G):\n",
    "        C = G.subgraph(C)\n",
    "        if len(C)>1: # skip one nodes\n",
    "            print('Strongly connected component with average shortest path:', nx.average_shortest_path_length(C))\n",
    "    return('Done')\n",
    "\n",
    "avg_sh_path(G_ours, 'Ours')\n",
    "avg_sh_path(G_saito, 'Saito')\n",
    "avg_sh_path(G_star, 'Star')\n",
    "avg_sh_path(G_serpent, 'Serpent')\n",
    "avg_sh_path(G_newman, 'Newman')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [],
   "source": [
    "# G = nx.Graph([(1, 2), (3, 4)])\n",
    "# for C in (G.subgraph(c).copy() for c in nx.connected_components(G)):\n",
    "#     print(C.nodes())\n",
    "#     print(nx.average_shortest_path_length(C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Is there a clustering coefficient for directed graphs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Weakly connected components are those that are connected when you consider the undirected version of the graph (replace every directed edge with an undirected one). \n",
    "- Strongly connected components are those components where every pair of nodes is reachable from each other (has a path)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Average shortest path for strongly connected components of Ours\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.0034724259028071315\n",
      "Strongly connected component, with average clustering coefficient: 0.5\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "- Average shortest path for strongly connected components of Saito\n",
      "- Average shortest path for strongly connected components of Newman\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "- Average shortest path for strongly connected components of Star\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.18828479899549044\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.6666666666666666\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "- Average shortest path for strongly connected components of Serpent\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.0\n",
      "Strongly connected component, with average clustering coefficient: 0.006530220631757855\n",
      "Strongly connected component, with average clustering coefficient: 0.07611622986979792\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Done'"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def avg_sh_path(G, graph_type):\n",
    "    print('- Average shortest path for strongly connected components of', graph_type)\n",
    "    for C in nx.strongly_connected_components(G):\n",
    "        C = G.subgraph(C)\n",
    "        if len(C)>1: # skip one nodes\n",
    "            print('Strongly connected component, with average clustering coefficient:', nx.average_clustering(C))\n",
    "    return('Done')\n",
    "\n",
    "avg_sh_path(G_ours, 'Ours')\n",
    "avg_sh_path(G_saito, 'Saito')\n",
    "avg_sh_path(G_star, 'Star')\n",
    "avg_sh_path(G_serpent, 'Serpent')\n",
    "avg_sh_path(G_newman, 'Newman')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare [a.] Our graph VS [b.] Saito. x-axis is the threshold sigma>t. And y-axis the percentage of nodes in our graph that have >t threshold over the Saito nodes with >t threshold (we should see for large t that the percentage is higher...)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "0.1\n",
      "0.2\n",
      "0.3\n",
      "0.4\n",
      "0.5\n",
      "0.6\n",
      "0.7\n",
      "0.8\n",
      "0.9\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "our_plot = dict()\n",
    "for thr in range(0, 11):\n",
    "    thr = thr/10\n",
    "    print(thr)\n",
    "    total_edges = 0 \n",
    "    edges = 0 \n",
    "    for i in k:\n",
    "        for j in k[i]:\n",
    "            if k[i][j]==thr and s[i][j]>=thr: \n",
    "                edges+=1\n",
    "            total_edges+=1\n",
    "    our_plot[thr] = edges/total_edges\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0.0: 0.0,\n",
       " 0.1: 0.003768646951059932,\n",
       " 0.2: 0.011148913896885632,\n",
       " 0.3: 0.0,\n",
       " 0.4: 0.0002093692750588851,\n",
       " 0.5: 0.027532059670243393,\n",
       " 0.6: 0.0,\n",
       " 0.7: 0.0,\n",
       " 0.8: 5.234231876472128e-05,\n",
       " 0.9: 0.0,\n",
       " 1.0: 0.055901596440722325}"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "our_plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 11 artists>"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "labels, values = zip(*our_plot.items())\n",
    "plt.bar(labels, values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Also, we will need a plot to show the role of trace size: plot the metrics 2., 3., 5., 6, 8, 9, as a function of the trace length - for T=1,000, 10,000, 50,000, 100,000, 200,000, 500,000, 1M, 1.5M etc…"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [],
   "source": [
    "# max(nx.weakly_connected_components(G_ours), key=len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for C in nx.weakly_connected_components(G_ours):\n",
    "#     print(nx.shortest_path_length(C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [],
   "source": [
    "# max_scc = max(nx.strongly_connected_components(G_ours), key=len)\n",
    "# print('Length of maximum strongly connected component in our graph', len(max_scc))\n",
    "# max_scc = max(nx.strongly_connected_components(G_saito), key=len)\n",
    "# print('Length of maximum strongly connected component in Saitos graph', len(max_scc))\n",
    "# max_scc = max(nx.strongly_connected_components(G_star), key=len)\n",
    "# print('Length of maximum strongly connected component in Star graph', len(max_scc))\n",
    "# max_scc = max(nx.strongly_connected_components(G_serpent), key=len)\n",
    "# print('Length of maximum strongly connected component in Serpent graph', len(max_scc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print('Max strongly connected components', max(nx.strongly_connected_components(G_ours), key=len))\n",
    "# print('Max strongly connected components', max(nx.strongly_connected_components(G_star), key=len))\n",
    "# print('Max strongly connected components', max(nx.strongly_connected_components(G_saito), key=len))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# print('Strongly connected components in our graph')\n",
    "# [print('our') for c in sorted(nx.strongly_connected_components(G_ours), key=len, reverse=True) if len(c)>3108]\n",
    "\n",
    "# print('Strongly connected components in Star graph')\n",
    "# [print('star') for c in sorted(nx.strongly_connected_components(G_star), key=len, reverse=True) if len(c)>6]\n",
    "\n",
    "# print('Strongly connected components in Saito graph')\n",
    "# [print('saito') for c in sorted(nx.strongly_connected_components(G_saito), key=len, reverse=True) if len(c)>9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'E' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-f139c0272113>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtweet\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m956219412377407488\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'- Episode:'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mE\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtweet\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# pos = nx.spring_layout(G_ours)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mpos\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'E' is not defined"
     ]
    }
   ],
   "source": [
    "tweet = 956219412377407488\n",
    "print('- Episode:', E[tweet])\n",
    "\n",
    "# pos = nx.spring_layout(G_ours)\n",
    "pos = 0 \n",
    "plot1 = plt.figure(1)\n",
    "plot_tweetgraph(tweet, E, S, Q, k, pos, 'ours')\n",
    "plot2 = plt.figure(2)\n",
    "plot_tweetgraph(tweet, E, S, Q, k, pos, 'star')\n",
    "plot2 = plt.figure(3)\n",
    "plot_tweetgraph(tweet, E, S, Q, k, pos, 'saito')\n",
    "plt.show()\n",
    "plot_tweetgraph(tweet, E, S, Q_newman, k, pos, 'newman')\n",
    "plt.show()\n",
    "plot_tweetgraph(tweet, E, S, Q, k, pos, 'serpent')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame({'name': ['Raphael', 'Donatello'],\n",
    "                   'mask': ['red', 'purple'],\n",
    "                   'weapon': ['sai', 'bo staff']})\n",
    "df.to_csv (r'./export_dataframe.csv', index = False, header=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Get the list of the degrees\n",
    "# degree_sequence = list(G_ours.out_degree())\n",
    "\n",
    "# nb_nodes = len(G_ours.nodes())\n",
    "# nb_arr = len(G_ours.edges())\n",
    "\n",
    "# avg_degree = np.mean(np.array(degree_sequence)[:,1])\n",
    "# # med_degree = np.median(np.array(degree_sequence)[:,1])\n",
    "\n",
    "# max_degree = max(np.array(degree_sequence)[:,1])\n",
    "# min_degree = np.min(np.array(degree_sequence)[:,1])\n",
    "\n",
    "# # esp_degree = (n-1)*p\n",
    "\n",
    "# print(\"Number of nodes : \" + str(nb_nodes))\n",
    "# print(\"Number of edges : \" + str(nb_arr))\n",
    "\n",
    "# print(\"Maximum degree : \" + str(max_degree))\n",
    "# print(\"Minimum degree : \" + str(min_degree))\n",
    "\n",
    "# print(\"Average degree : \" + str(avg_degree))\n",
    "# # print(\"Expected degree : \" + str(esp_degree))\n",
    "# # print(\"Median degree : \" + str(med_degree))"
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}