triangle_counting_analysis.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Bader-Research/triangle-counting/blob/main/triangle_counting_analysis.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b_Bn3soDu0Ja"
      },
      "source": [
        "## Generate Graph"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lThJVPAY8zBD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5c895767-7f87-40b6-d9cc-5f5efc5c8d4f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting snap-stanford\n",
            "  Downloading snap_stanford-6.0.0-cp37-cp37m-manylinux1_x86_64.whl (11.6 MB)\n",
            "\u001b[K     |████████████████████████████████| 11.6 MB 5.0 MB/s \n",
            "\u001b[?25hInstalling collected packages: snap-stanford\n",
            "Successfully installed snap-stanford-6.0.0\n"
          ]
        }
      ],
      "source": [
        "!pip install snap-stanford"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "enUJ97Eq9BiI"
      },
      "outputs": [],
      "source": [
        "sig_size = 5\n",
        "\n",
        "class Edge:\n",
        "  def __init__(self, src, dst):\n",
        "\n",
        "    self.src = src                                      # Source of Edge (Node)\n",
        "    self.dst = dst                                      # Destination of Edge (Node)\n",
        "    self.type = 'Tree'                                  # Type of Edge\n",
        "\n",
        "class Node:\n",
        "  def __init__(self, label, degree):\n",
        "    self.dist = -1                                      # distance from root\n",
        "    self.visited = False                                # if the node has been visited (for BFS)\n",
        "    self.label = label                                  # label for the node (int)\n",
        "    self.degree = degree                                # degree (# of connections)\n",
        "    self.weight = 'light'                               # describes the weight of the node (light or heavy) based on the degree - light by default\n",
        "\n",
        "class Graph:\n",
        "  def __init__(self, v):\n",
        "    self.vertices = v                                   # number of total vertices\n",
        "    self.adj = {}                                       # adjacency dictionary for the graph (key = each node & value = a list of it's neighbors)\n",
        "    for i in range(v):\n",
        "      self.adj[i] = []                                  # every value per key is an empty list (will contain the labels of neighbor nodes)\n",
        "    self.edgeList = []                                  # list of total edges in graph\n",
        "    self.root = 0                                       # root node's label is automatically 0\n",
        "    self.sig_size = sig_size                            # size of signature agreement (to be set after threshold is calculated)\n",
        "    self.node_list = {}                                 # dictionary of all nodes (key = label of node & value = address to the actual node in memory)\n",
        "    lst = list(range(0, v))\n",
        "    self.node_list = dict.fromkeys(lst)\n",
        "    for i in range(v):\n",
        "      self.node_list[i] = Node(i, 0)                    # make the value (actual node) for every key (node's label)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q79nNZ7v81BM"
      },
      "outputs": [],
      "source": [
        "# This is the code section to generate a directed RMAT graph and transcribe it to\n",
        "# dictionary type undirected graph. It then runs BFS, classifies the edges, and\n",
        "# returns the number of cross edges\n",
        "import snap\n",
        "\n",
        "SCALE = 20\n",
        "q = pow(2,SCALE)                                      # number of vertices (n) = 2^scale\n",
        "# (DAB) Why the constant 1.184... in the value computation of m?\n",
        "# (DAB) And then m is reset later. Why?\n",
        "m = round(1.18438720703125 * 16 * q)                  # number of edges (m) = 16 * n\n",
        "\n",
        "Rnd = snap.TRnd()\n",
        "RMAT = snap.GenRMat(q, m, .57, .19, .19, Rnd)           # Generate the Graph\n",
        "                                                        # a = 0.57, b = 0.19, c = 0.19, d = 1 - (a+b+c)\n",
        "\n",
        "m = 16 * q\n",
        "\n",
        "g = Graph(q)                                            # initialize the graph"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fvwBz_ob83rN"
      },
      "outputs": [],
      "source": [
        "tempEdgeList=[]\n",
        "numOfEdgesNeeded = 0\n",
        "edgeCount = 0\n",
        "for EI in RMAT.Edges():                                # for every edge in the RMAT list of edges\n",
        "  if edgeCount < m:\n",
        "    n = EI.GetSrcNId()                                   # n = source node\n",
        "    k = EI.GetDstNId()                                   # k = destination node\n",
        "    numOfEdgesNeeded += 1\n",
        "    if n not in g.adj[k]:\n",
        "      tempEdgeList.append(str(n) + \" \" + str(k))\n",
        "      #if(n < k):\n",
        "      g.adj[n].append(k)\n",
        "      #if(k < n):\n",
        "      g.adj[k].append(n)\n",
        "      edgeCount += 1\n",
        "  else: break\n",
        "edgeSet = set(tempEdgeList)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(edgeCount)\n",
        "print(m)\n",
        "print(numOfEdgesNeeded)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PK2XDdzVVmkR",
        "outputId": "9b1895f6-0c4a-4d7c-b9c7-51cc338700dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16777216\n",
            "16777216\n",
            "17338318\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "366owzKau7Bv"
      },
      "source": [
        "## Heavy & Light Nodes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AaqiJc4ebyUe"
      },
      "outputs": [],
      "source": [
        "# Calculate the standard deviation and mean.\n",
        "mean = 0                                            # For a Graph500 RMAT, the average vertex degree is 32. But, I am assuming that graphs can still have a mean slightly below or above.\n",
        "SD = 0\n",
        "summationMean = 0\n",
        "summationSD = 0\n",
        "for adjList in g.adj.values():                      #for each node\n",
        "  summationMean += len(adjList)                       #add the length of its adjacency list to summationMean\n",
        "mean = summationMean / g.vertices                   #divide summationMean by the total amount of vertices to find the average degree\n",
        "for adjList in g.adj.values():                      #for each node\n",
        "  summationSD += pow((len(adjList) - mean), 2)        #add (length of its adjacency list - mean)^2 to summationSD\n",
        "SD = pow((summationSD / (g.vertices - 1)), 0.5)      #set SD to  √(summationSD divided by total number of vertices)\n",
        "SD = round(SD)                                       #round SD to ensure it is an integer\n",
        "mean = round(mean)                                   #round mean to ensure it is an integer\n",
        "g.sig_size = pow(mean + (2 * SD), 2)                 #set sig size to (mean + 2*SD)^2\n",
        "threshold = mean + (2 * SD);                         #set threshold to mean + 2*SD"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tH2FIPIU7hc_"
      },
      "outputs": [],
      "source": [
        "for node_label in g.adj:                             #for each node in the graph\n",
        "  deg = len(g.adj[node_label])                        #set deg to the length of the node's adjacency list\n",
        "  g.node_list[node_label].degree = deg                #update the node's degree in g.node_list (the dictionary with node objects)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "clrTNjTkAQ44"
      },
      "outputs": [],
      "source": [
        "lst = list(range(0, g.vertices))\n",
        "nodes = dict.fromkeys(lst)\n",
        "\n",
        "heavyCount = 0;\n",
        "for index in g.node_list.keys():                     #for each node object in g.node_list\n",
        "\n",
        "  if (g.node_list[index].degree > threshold):        #if its degree is bigger than the treshold\n",
        "    g.node_list[index].weight = 'heavy'                 #set its weight as heavy\n",
        "    heavyCount += 1                                     #increment heavyCount\n",
        "\n",
        "lightCount = g.vertices - heavyCount                 #Light node count is all vertices - the number of heavy vertices\n",
        "\n",
        "g.sig_size = threshold                               #set the graph's signature size as the treshold"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tYByI7Ef8xVV"
      },
      "outputs": [],
      "source": [
        "for index in g.node_list:                            # for each node\n",
        "  node = g.node_list[index]\n",
        "  lst = list(range(0, g.sig_size))                    #create a list the size of the signature\n",
        "  node.sig = dict.fromkeys(lst)                       #set the node's signature as the empty list in the form of a dictionary\n",
        "  for i in node.sig.keys():                           #for each key in node's signature\n",
        "    node.sig[i] = []                                    #set the key's value as a list so it can be appended later"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6_ptL-Uou-XL"
      },
      "source": [
        "## BFS"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UV67a5gO-MxW"
      },
      "outputs": [],
      "source": [
        "def BFS(g):\n",
        "    print(g.sig_size)                                   # double checks that the graph's signature size is correct\n",
        "    numCross = 0                                        # Number of cross edges\n",
        "\n",
        "    g.node_list[g.root].visited = True                  # root has been visited\n",
        "    g.node_list[g.root].dist = 0                        # root's distance starts at 0\n",
        "    queue = []                                          # initializes the queue\n",
        "    queue.append(g.root)                                # root node is the first node in the queue\n",
        "\n",
        "    while queue:                                        # Creating loop to visit each node\n",
        "        s = queue.pop(0)                                # s is the value at the beginning of the queue\n",
        "\n",
        "        for neighbor in g.adj[s]:                       # goes through each neighbor of s\n",
        "\n",
        "          #signature as dict\n",
        "          if(neighbor <= s):                                       #modified neighbors - only add neighbors with a smaller label\n",
        "            key = hash(neighbor) % g.sig_size                      #hash the node and % by the size of signature agreement\n",
        "            g.node_list[s].sig[key].append(neighbor)               #add the node to the list of nodes (the value) for the hashed key\n",
        "\n",
        "          edge = Edge(s, neighbor)                                 # creates an edge with a given neighbor and s\n",
        "\n",
        "          if g.node_list[neighbor].visited == False:               # as long as the neighbor has not been visited\n",
        "            g.node_list[neighbor].dist = g.node_list[s].dist + 1 # neighbor's dist = s's dist + 1\n",
        "            g.node_list[neighbor].visited = True                 # neighbor is marked as visited\n",
        "            queue.append(neighbor)                               # neighbor is added to the queue\n",
        "\n",
        "          else:\n",
        "            if g.node_list[neighbor].dist == g.node_list[s].dist: # checks if the neighbor's and s's distance are equal (aka a cross edge)\n",
        "              edge.type = \"Cross\"                                 # mark as cross edge\n",
        "              numCross+=1                                         # numCross counter is incremented by 1\n",
        "\n",
        "          if (str(neighbor) + \" \" + str(s)) not in edgeSet:\n",
        "            g.edgeList.append(edge)                                 # edge is added to our edge list\n",
        "\n",
        "    cross_edges = numCross/2                                        # cross_edges = final cross edge count\n",
        "    total_edges = len(g.edgeList)                                 # total_edges = final edge count\n",
        "    print(\"Number of Cross Edges:\", cross_edges)                  # prints # of cross edges\n",
        "    print(\"% of Cross Edges:\", (cross_edges / total_edges)*100)   # prints % of cross edges over total edges"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P8O7bw5y0jHD",
        "outputId": "bc04a7c7-b2a1-4571-d952-755865533fc8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "Number of Cross Edges: 6845.0\n",
            "% of Cross Edges: 64.36900507805153\n"
          ]
        }
      ],
      "source": [
        "BFS(g)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YDQpboCQxrww",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3dc26285-930a-4bdd-def0-3cffac84af4e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16384\n"
          ]
        }
      ],
      "source": [
        "light_edges = 0\n",
        "heavy_edges = 0\n",
        "light_and_heavy_edges = 0\n",
        "\n",
        "print(len(g.edgeList))\n",
        "\n",
        "for edge in g.edgeList:\n",
        "  if edge.type == 'Cross':                                                            # if the edge is a cross edge\n",
        "    n = edge.src                                                                      # n = source node\n",
        "    k = edge.dst                                                                      # k = destination node\n",
        "    if g.node_list[n].weight == 'light' and g.node_list[k].weight == 'light':         # if n and k are both light nodes --> then it's a light edge\n",
        "      light_edges += 1\n",
        "    elif g.node_list[n].weight == 'heavy' and g.node_list[k].weight == 'heavy':       # if n and k are both heavy nodes --> then it's a heavy edge\n",
        "      heavy_edges += 1\n",
        "    elif g.node_list[n].weight == 'heavy' and g.node_list[k].weight == 'light':       # if n is heavy and k is light --> then it's a light & heavy edge\n",
        "      light_and_heavy_edges += 1\n",
        "    elif g.node_list[n].weight == 'light' and g.node_list[k].weight == 'heavy':       # if n is light and k is heavy --> then it's a light & heavy edge\n",
        "      light_and_heavy_edges += 1\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Modified Neighborhood List"
      ],
      "metadata": {
        "id": "SQKtaUUtkDH2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for key in g.adj:\n",
        "  for node_label in list(g.adj[key]):\n",
        "    if(node_label < key):\n",
        "      g.adj[key].remove(node_label)"
      ],
      "metadata": {
        "id": "lcUyG0y2ic_p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "count_list = [0, 0, 0]\n",
        "cost_list = [0, 0, 0]\n",
        "\n",
        "for edge in g.edgeList:\n",
        "  if(edge.type == 'Cross'):\n",
        "    a = edge.src\n",
        "    b = edge.dst\n",
        "    length_a = len(g.adj[a])\n",
        "    length_b = len(g.adj[b])\n",
        "    m1 = length_a * SCALE                               #sending |A| * logn bits\n",
        "    m2 = length_b * SCALE                               #sending |B| * logn bits\n",
        "    m3 = q                                              #sending n bits (for the bit vector)\n",
        "\n",
        "   min_list = [m1, m2, m3]\n",
        "\n",
        "    min_value = min(min_list)\n",
        "    cost_list[min_list.index(min_value)] += min_value\n",
        "    for index, val in enumerate(min_list):              #if two methods have the same cost --> we are incrementing both counters\n",
        "      if(val == min_value):\n",
        "        count_list[index]+=1\n",
        "\n",
        "print(count_list)\n",
        "print(cost_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qh49s3b6dPc_",
        "outputId": "74bc08f9-3bbf-4c23-b656-92a2d959e77b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1366, 7004, 578]\n",
            "[468420, 1352880, 591872]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(q, m)\n",
        "s = cost_list[0] + cost_list[1]\n",
        "print(s)\n",
        "print(s / (0.65 * m * q))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        },
        "id": "loDrB6WQGuWr",
        "outputId": "31e6e564-8204-4c89-832e-f336dc33dc4f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-49ee99e55f2c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mq\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mm\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      2\u001b[0m \u001b[0ms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcost_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mcost_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0.65\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mm\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mq\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[0;31mNameError\u001b[0m: name 'q' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k6bA4MuWu_3D"
      },
      "source": [
        "## Counting Triangles"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iE7syENMA1yK"
      },
      "outputs": [],
      "source": [
        "def triangle_count(graph):\n",
        "  tc = 0                                                              # triangle count = 0\n",
        "  for edge in graph.edgeList:\n",
        "\n",
        "    if(edge.src.degree > edge.dst.degree):                            # if src_node degree > dst_node degree\n",
        "      low = edge.dst                                                  # low_degree_node = dst\n",
        "      high = edge.src                                                 # high_degree_node = src\n",
        "\n",
        "    else:                                                             # if src_node degree < dst_node degree\n",
        "      low = edge.src                                                  # low_degree_node = src\n",
        "      high = edge.dst                                                 # high_degree_node = dst\n",
        "\n",
        "    if(edge.label == 'Cross'):                                       # traverse through cross edges when counting triangles\n",
        "      for key in high.sig:                                           # iterate through the high_degree_node signature to compare with low degree (sending high_degree_node's signature to low_degree_node)\n",
        "\n",
        "        if(len(high.sig[key]) > 0 and (len(low.sig[key] > 0))):        # checks for a signature agreement for a particular index\n",
        "            for node in low.sig[key]:                                # for each node in k.low.sig's list of values\n",
        "                if node in high.sig[key]:                            # if that node appears in k.high.sig's list of values\n",
        "                  tc += 1                                            # increment triangle count by 1\n",
        "\n",
        "  print(tc)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jzr1dYVWvBuQ"
      },
      "source": [
        "## Counting Collisions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UMJbpHgJlcD1"
      },
      "outputs": [],
      "source": [
        "def collision_count(graph):\n",
        "  collision_node = 0\n",
        "  collisions = 0\n",
        "  for node in graph.node_list.values():                                     # for every node in the graph's node list (each value in the dictionary)\n",
        "    flag = False\n",
        "    for key in node.sig.keys():                                             # for every key in the node's signature\n",
        "      num_collisions = len(node.sig[key])\n",
        "      if(num_collisions > 1):                                                # if the array of values per key in the signature has more than 1 neighbor --> there is a collision\n",
        "        collisions = collisions + num_collisions                             # increase collisions by the length of the bucket\n",
        "        flag = True\n",
        "    if (flag == True):\n",
        "        collision_node += 1\n",
        "  print(\"Number of Collisions: \", collisions)\n",
        "  print(\"Number of nodes that has collisions\", collision_node)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Counting Number of Nodes With Degree Greater than Sqrt(n)"
      ],
      "metadata": {
        "id": "S3DssWxs4_u-"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "81yETpj_YRjI"
      },
      "outputs": [],
      "source": [
        "def sqrtNVertices(graph):\n",
        "  vertices = 0\n",
        "  sqrtN = pow(n,0.5)\n",
        "  for node in graph.adj:                                                    # for every node in the graph (each key value in the adjacency list)\n",
        "    if(graph.node_list[node].degree >= sqrtN):                              # if the node's degree is greater than the square root of the number of vertices\n",
        "      vertices += 1\n",
        "  percent = vertices / graph.vertices\n",
        "  print(\"Percentage of vertices > sqrt(n): \", percent * 100)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Print Statistics"
      ],
      "metadata": {
        "id": "fW_-oOv35JMw"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vc8y3ik1ZMLn",
        "outputId": "58d02278-d6fe-4d94-a4b6-617d11f28022"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Scale 10 Graph ( 1024 Nodes and  16384 Edges)\n",
            "\n",
            "Number of Collisions:  0\n",
            "Number of nodes that has collisions 0\n",
            "Percentage of vertices > sqrt(n):  18.06640625\n",
            "Heavy Nodes: 41 ( 4.00390625 %) - Nodes with degree higher than 102\n",
            "Light Nodes: 983  - Nodes with degree lower than 102\n",
            "\n",
            "\n",
            "Threshold: 102\n",
            "Standard Deviation: 43\n",
            "Mean: 16\n",
            "\n",
            "\n",
            "Total Cross Edges in the graph: 8915\n",
            "Light Edges: 3847 ( 43.151991026360065 %) - Edges that have light nodes as both endpoints\n",
            "Heavy Edges: 578 ( 6.483454851374089 %) - Edges that have heavy nodes as both endpoints\n",
            "Light & Heavy Edges: 4490 ( 50.364554122265844 %)  - Edges that have 1 light and 1 heavy node as its endpoints\n"
          ]
        }
      ],
      "source": [
        "print(\"Scale\",SCALE, \"Graph (\", q, \"Nodes and \", m, \"Edges)\\n\" )\n",
        "collision_count(g)\n",
        "sqrtNVertices(g)\n",
        "\n",
        "print(\"Heavy Nodes:\", heavyCount, \"(\",(heavyCount/g.vertices)*100, \"%) - Nodes with degree higher than\", threshold)\n",
        "print(\"Light Nodes:\", lightCount, \" - Nodes with degree lower than\", threshold)\n",
        "print(\"\\n\")\n",
        "\n",
        "print(\"Threshold:\", threshold)\n",
        "print(\"Standard Deviation:\", SD)\n",
        "print(\"Mean:\", mean)\n",
        "print(\"\\n\")\n",
        "\n",
        "total = light_edges + heavy_edges + light_and_heavy_edges\n",
        "print(\"Total Cross Edges in the graph:\", total)\n",
        "print(\"Light Edges:\", light_edges, \"(\", light_edges*100/total, \"%) - Edges that have light nodes as both endpoints\")\n",
        "print(\"Heavy Edges:\", heavy_edges, \"(\", heavy_edges*100/total, \"%) - Edges that have heavy nodes as both endpoints\" )\n",
        "print(\"Light & Heavy Edges:\", light_and_heavy_edges, \"(\", light_and_heavy_edges*100/total, \"%)  - Edges that have 1 light and 1 heavy node as its endpoints\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qfodDtU-TOEk"
      },
      "source": [
        "##Statistics"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![2a3a006f1ab81063b794875e4aa853f1.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "LcHBSPlf2k_w"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![a3a5ba1325587a82ed43084b20acf66a.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "pjifeLCU2q3U"
      }
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "fW_-oOv35JMw",
        "qfodDtU-TOEk"
      ],
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}