_Reachability_labels_for_version_control_graphs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Graphs in Python\n",
    "\n",
    "* [Network Chart - The Python Graph Gallery](https://python-graph-gallery.com/network-chart/)\n",
    "  * [NetworkX library](https://networkx.github.io/documentation/stable/index.html) -- data structures for graphs\n",
    "    (or networks) along with graph algorithms, generators, and drawing tools\n",
    "  * [Graph Tool library](https://graph-tool.skewed.de/) -- the core data structures and algorithms\n",
    "    are implemented in C++  \n",
    "    drawing in Jupyter described e.g. in <https://gist.github.com/jg-you/2ce69ffccf6f3ed17c09e5d7b2695f1c>\n",
    "\n",
    "* [Snap.py](http://snap.stanford.edu/snappy/index.html) is a Python interface for SNAP\n",
    "  (Stanford Network Analysis Platform). [SNAP](http://snap.stanford.edu/snap/) is a general purpose,\n",
    "  high performance system in C++ for analysis and manipulation of large networks.\n",
    "  \n",
    "* [python-graph](https://github.com/Shoobx/python-graph) (???)\n",
    "\n",
    "* [NetworKit](https://github.com/kit-parco/networkit) is a growing open-source toolkit for large-scale network analysis. <https://networkit.github.io>\n",
    "  * High-performance algorithms are written in C++ and exposed to Python via the Cython toolchain\n",
    "  * [NetworKit UserGuide](https://github.com/kit-parco/networkit/blob/Dev/notebooks/User-Guide.ipynb)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Label + Graph algorithms**\n",
    "\n",
    "----\n",
    "\n",
    "FELINE index\n",
    "\n",
    "\"Reachability Queries in Very Large Graphs: A **F**ast R**e**fined On**line** Search Approach\" (2014)  \n",
    "<http://openprocedings.org/EDBT/2014/paper_166.pdf>\n",
    "\n",
    "----\n",
    "\n",
    "min-post spanning-tree interval labeling (description)\n",
    "\n",
    "\"GRAIL: Scalable Reachability Index for Large Graphs\" (2010)  \n",
    "<https://www.researchgate.net/publication/220538786_GRAIL_Scalable_reachability_index_for_large_graphs>\n",
    "\n",
    "----\n",
    "\n",
    "other pruning mechanisms with min-post / pre-max DFS spanning-tree interval labeling\n",
    "\n",
    "\"PReaCH: A Fast Lightweight Reachability Index using Pruning and Contraction Hierarchies\" (2014)  \n",
    "<https://arxiv.org/abs/1404.4465>\n",
    "\n",
    "----\n",
    "min-post spanning-tree intervals (exact and inexact)\n",
    "\n",
    "\"FERRARI: Flexible and efficient reachability range assignment for graph indexing\" (2013)\n",
    "<http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.365.2894&rep=rep1&type=pdf>\n",
    "\n",
    "----\n",
    "\n",
    "independent permutations (IP) labelling, a variant of probabilistic reachable vertices set containment labeling\n",
    "\n",
    "H. Wei, J. X. Yu, C. Lu, and R. Jin. \"Reachability querying: An independent permutation labeling approach.\" PVLDB, 7(12):1191-1202 (2014)\n",
    "<http://www1.se.cuhk.edu.hk/~lucan/paper/vldb14-reachability.pdf>\n",
    "<http://www1.se.cuhk.edu.hk/~lucan/paper/vldbj17-reachability.pdf>\n",
    "\n",
    "Bloom filter labeling (BFL), a variant of probabilistic reachable vertices set containment labeling\n",
    "\n",
    "\"Reachability Querying: Can It Be Even Faster?\" (2016)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Building wheel for gputil (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
      "Gen RAM Free: 12.8 GB | I Proc size 113.6 MB (RSS)\n"
     ]
    }
   ],
   "source": [
    "# memory footprint support libraries/code\n",
    "# https://stackoverflow.com/questions/48750199/google-colaboratory-misleading-information-about-its-gpu-only-5-ram-available\n",
    "!ln -sf /opt/bin/nvidia-smi /usr/bin/nvidia-smi\n",
    "!pip install -q gputil\n",
    "!pip install -q psutil\n",
    "!pip install -q humanize\n",
    "import psutil\n",
    "import humanize\n",
    "import os\n",
    "#import GPUtil as GPU\n",
    "#GPUs = GPU.getGPUs()\n",
    "# XXX: only one GPU on Colab and isn’t guaranteed\n",
    "#gpu = GPUs[0]\n",
    "def printm():\n",
    "  process = psutil.Process(os.getpid())\n",
    "  print(\"Gen RAM Free: {0:s} | I Proc size {1:s} (RSS)\".format(\n",
    "      humanize.naturalsize( psutil.virtual_memory().available ), \n",
    "      humanize.naturalsize( process.memory_info().rss )))\n",
    "  #print(\"GPU RAM Free: {0:.0f}MB | Used: {1:.0f}MB | Util {2:3.0f}% | Total {3:.0f}MB\".format(gpu.memoryFree, gpu.memoryUsed, gpu.memoryUtil*100, gpu.memoryTotal))\n",
    "  \n",
    "printm()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Table of contents**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">>[FELINE index: NetworkX and matplotlib visualization](#scrollTo=YfZ3QVnv3XpN)\n",
    "\n",
    ">>>[Crown DAG know as $S_3^0$ graph](#scrollTo=UcFgrrGRWozd)\n",
    "\n",
    ">>>[Small DAG (example in Figure 2)](#scrollTo=uWUbIuPRW4Ze)\n",
    "\n",
    ">>>[Didactic example of search space reduction](#scrollTo=Obk2giojprpS)\n",
    "\n",
    ">>>[Optimizations: Level Filter (negative-cut)](#scrollTo=_87BlZdX6tBl)\n",
    "\n",
    ">>>[Optimizations: min-post interval (positive-cut filter)](#scrollTo=_rP8JdufWvCd)\n",
    "\n",
    ">>>[Optimization: min-post / pre-max DFS interval (positive-cut and negative-cut)](#scrollTo=WA1mc9PNOmZe)\n",
    "\n",
    ">>>[Optimization: Reachability Contraction Hierarchies (from PReaCH)](#scrollTo=jRCySqjWg4wg)\n",
    "\n",
    ">>[Algorithms](#scrollTo=5dI9rZ92OFXg)\n",
    "\n",
    ">>>[Starter / preliminary algorithms](#scrollTo=VugXLha7SrZQ)\n",
    "\n",
    ">>>>[Tips / heads](#scrollTo=TzISTJktS6jt)\n",
    "\n",
    ">>>>[Spanning tree / spanning forest](#scrollTo=2ZxiafIZWayY)\n",
    "\n",
    ">>>>[Reach of the node](#scrollTo=Q8vaDlTD0TSe)\n",
    "\n",
    ">>>[Optimizations algorithms](#scrollTo=fOamYN7y3ZG5)\n",
    "\n",
    ">>>>[Levels](#scrollTo=ewJDfAE-3jQo)\n",
    "\n",
    ">>>>[Min-post intervals](#scrollTo=kVCGZQcS3nFi)\n",
    "\n",
    ">>>>[DFS spanning-tree extra data](#scrollTo=1tsblSSZlYkg)\n",
    "\n",
    ">>>[FELINE-index algorithms](#scrollTo=iFR7yqyJ71TN)\n",
    "\n",
    ">>>>[Calculating FELINE index](#scrollTo=Wl2yteSU78UO)\n",
    "\n",
    ">>>>[Quality of FELINE index (and comparison with paper's version)](#scrollTo=6tp3wTcP7Wcq)\n",
    "\n",
    ">>>>[Reachability queries with FELINE index](#scrollTo=cSNGubgZ8Eyc)\n",
    "\n",
    ">>>>[Reachability query stats for sample](#scrollTo=9Lw6Cg4CaFti)\n",
    "\n",
    ">>>>[Weak dominance drawing (and related drawing algorithms)](#scrollTo=OcdSmPxh8Q2_)\n",
    "\n",
    ">>>>[TODO: Reverse FELINE index](#scrollTo=NHjQ0g7_IaVl)\n",
    "\n",
    ">>[Version control graphs](#scrollTo=Nga1c33bMlWN)\n",
    "\n",
    ">>>[git.git commit graph](#scrollTo=Wn715kAEhcoo)\n",
    "\n",
    ">>>>[Draw fragment of git.git commit graph](#scrollTo=4U33EFnMq7qI)\n",
    "\n",
    ">>>>[Draw fragment of larger part of git.git commit graph](#scrollTo=Wt7Gz8hpu7eR)\n",
    "\n",
    ">>>>[Full git.git commit graph and its properties](#scrollTo=4GULcY75vTbn)\n",
    "\n",
    ">>>>[Finding paths / checking reachability between two commits](#scrollTo=7zdcHrIF16am)\n",
    "\n",
    ">>>>[N^2 connectivity on [random sample of] commit graph nodes](#scrollTo=T2UuQefM4E57)\n",
    "\n",
    ">>>[Linux kernel commit graph](#scrollTo=mK2BzqFKETax)\n",
    "\n",
    ">>>>[Full linux kernel commit graph and its properties](#scrollTo=bMdzTWdb2KLw)\n",
    "\n",
    ">>>>[Finding paths / checking reachability between two commits](#scrollTo=YiRqzbSBmFg7)\n",
    "\n",
    ">>>>[N^2 connectivity on random sample of commits / nodes](#scrollTo=am1Tt5VxmV2E)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FELINE index: NetworkX and matplotlib visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading package lists... Done\n",
      "Building dependency tree       \n",
      "Reading state information... Done\n",
      "dirmngr is already the newest version (2.2.4-1ubuntu1.3).\n",
      "0 upgraded, 0 newly installed, 0 to remove and 14 not upgraded.\n",
      "Executing: /tmp/apt-key-gpghome.KkNxkwLndM/gpg.1.sh --keyserver pgp.skewed.de --recv-key 612DEFB798507F25\n",
      "gpg: keyserver receive failed: No data\n",
      "Get:1 http://security.ubuntu.com/ubuntu bionic-security InRelease [88.7 kB]\n",
      "Ign:2 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  InRelease\n",
      "Get:3 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease [3,626 B]\n",
      "Ign:4 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease\n",
      "Get:5 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease [15.9 kB]\n",
      "Hit:6 http://archive.ubuntu.com/ubuntu bionic InRelease\n",
      "Get:7 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Release [697 B]\n",
      "Hit:8 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release\n",
      "Get:9 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Release.gpg [836 B]\n",
      "Get:10 http://archive.ubuntu.com/ubuntu bionic-updates InRelease [88.7 kB]\n",
      "Ign:11 http://downloads.skewed.de/apt/artful artful InRelease\n",
      "Get:12 http://security.ubuntu.com/ubuntu bionic-security/main amd64 Packages [1,781 kB]\n",
      "Err:13 http://downloads.skewed.de/apt/artful artful Release\n",
      "  404  Not Found [IP: 49.12.93.194 80]\n",
      "Hit:14 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n",
      "Get:15 http://security.ubuntu.com/ubuntu bionic-security/universe amd64 Packages [1,365 kB]\n",
      "Get:16 http://archive.ubuntu.com/ubuntu bionic-backports InRelease [74.6 kB]\n",
      "Ign:18 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Packages\n",
      "Get:18 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Packages [442 kB]\n",
      "Get:19 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic/main Sources [1,689 kB]\n",
      "Get:20 http://archive.ubuntu.com/ubuntu bionic-updates/multiverse amd64 Packages [54.3 kB]\n",
      "Get:21 http://archive.ubuntu.com/ubuntu bionic-updates/universe amd64 Packages [2,130 kB]\n",
      "Get:22 http://archive.ubuntu.com/ubuntu bionic-updates/restricted amd64 Packages [252 kB]\n",
      "Get:23 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic/main amd64 Packages [865 kB]\n",
      "Get:24 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 Packages [2,209 kB]\n",
      "Reading package lists...\n",
      "E: The repository 'http://downloads.skewed.de/apt/artful artful Release' does not have a Release file.\n",
      "Reading package lists... Done\n",
      "Building dependency tree       \n",
      "Reading state information... Done\n",
      "E: Unable to locate package python-graph-tool\n"
     ]
    }
   ],
   "source": [
    "#@title Installing packages: graph-tool (commented-out)\n",
    "!apt-get install dirmngr --install-recommends\n",
    "!echo \"deb http://downloads.skewed.de/apt/artful artful universe\" >/etc/apt/sources.list.d/graph-tool.list\n",
    "!echo \"deb-src http://downloads.skewed.de/apt/artful artful universe\" >>/etc/apt/sources.list.d/graph-tool.list\n",
    "!apt-key adv --keyserver pgp.skewed.de --recv-key 612DEFB798507F25\n",
    "!apt-get -q update\n",
    "!apt-get install python-graph-tool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'networkx' from '/usr/local/lib/python3.6/dist-packages/networkx/__init__.py'>"
      ]
     },
     "execution_count": null,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title Imports for graphs (NetworkX and matplotlib)\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "#import graph_tool.all as gt\n",
    "nx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See <https://networkx.github.io/documentation/stable/auto_examples/index.html> for examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'pandas' from '/usr/local/lib/python3.6/dist-packages/pandas/__init__.py'>"
      ]
     },
     "execution_count": null,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title Imports SciPy modules\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Crown DAG know as $S_3^0$ graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<networkx.classes.digraph.DiGraph at 0x7febc5e59da0>"
      ]
     },
     "execution_count": null,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title Create a crown DAG known as $S_3^0$ graph\n",
    "DG=nx.DiGraph()\n",
    "DG.add_nodes_from([1,2,3,4,'u','v'])\n",
    "DG.add_edges_from([(1,2),(3,4),(1,'v'),(3,'v'),('u',2),('u',4)])\n",
    "DG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3RV5cHn8d8+t9yQEAKCIQiEQYt9VYzYN5WrjRVLdeGIRCzS1hp8Zwbeib4LLXQ5M31l1YJVgbG4fCvY5bLUUFLsjC68Zk1BVFQIoKPlBeSaILeQm+Hc954/aJgEss/Z55x9efZ+fp+1XKuk52x2yJPnyZPv3ucomqZpICIikoTP6RMgIiKyExc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSChc+IiKSSsDpEyCxJJIqmtvCiCZU5AV8KC8pQMDPn4/IXTiOKRUufIS27hg27DiGhqZmHGntRtDvg09RoGoa4kkVo0qLcE9lOebeNBKDCkNOny5RvziOyShF0zTN6ZMgZ8QSKlY37sPabYegKEAkruo+Nj/og6YBtZPHoK76KoQC/OmZxMBxTJniwieplvYw5q3djpOdEYRTTBQXKwj6MGxgPtbXVmHEoAILz5AoPY5jygYXPgm1tIdx52+3oeNcHMksvvx+RUFxYRCvL5rMSYMcw3FM2eI+XzKxhIp5a7dnPVkAQFLT0HEujvvXbkc8afynbCKzcBxTLrjwSWZ14z6c7IxkPVn0SGoaTnRGsbpxv0lnRmQcxzHlggufRNq6Y1i77VBGLSSVcDyJF98/iPZzMVOOR2QExzHligufRDbsOAZFMfeYinL+uER24TimXHHhk0hDU3PKS707tjfg9GtP9vnY2Xf/DWff/Tfd50TiKhp2Npt2jkTppBvHAHBk+R2Itx2/8Oczb6xE29ZXdB/PcSwXLnySSCRVHGntTvmYovFTEf5qJ9ToOQCApiZxbu82FF0zLeXzDrd2I8GLA8gGRsZxtjiO5cGFTxLNbWEE07xkU6D4coSGj8W5fR8BACJHPoMSzEPeiG+lfF7Q70NzW9i0cyXSY2QcZ4vjWB5c+CQRTajwGQgjRddMQ/fftgIAur/ckna3BwA+RUE0wZ+UyXpGx3E2OI7lwYVPEnkBH1QDl34Xfmsyokc/R6LzDM7t+whF10xP+xxV05DHl34iGxgdx0owD1o8euHPye62tM/hOJYHv8qSKC8pMHSTrr+wGHlXXovWzasQKB6G4JCRaZ8TT6ooL+ErX5D1jI7j0OUV6P5yCzQ1ifDBnYge+79pn8NxLA8ufJII+H0YVVpk6LFF10xD5PBuFH07/a85AWB0aRHf8oVsYXQcl9z6EMIHPsGxVXPR/cVfUTCuKu1zOI7lwbclksg9leVY1bgv7aXgA/7hexjwD98zdMz8oA9zbiw34/SIDDEyjvOuGIey2ucNH5PjWC788UYic28aCbNfklzTgJqJ6X8dSmQWjmPKFRc+iQwqDKF28hgUBM35shcE/VgwpYJv6km24jimXHHhk0xd9VUYNjAf/hwvCfcrCoYPzENd9TiTzozIOI5jygUXPsmEAj6sr61CcWEw60mj533M/lBbZdnNxESp9IzjfL8KLZnM6hhaMonCgMZxLCF+tSUTi8Xw3PJ/xYMjTmPk4IKMf11UEPTjMl8Utyt7MPwy/mqInBM+04KWdf+MRMcJBJTMbjwPIIlExwmc+eNjCEQ7LTpDEhUXPknEYjH87ne/w4gRI7BixQo8urAW7zw8DT+bNAZ5AR/y0yyABUEf8gI+PDh5DD5bXoNfP/4oxo4di/r6eiSz/ImbKFuRSAQ1NTXo+Pow/rH1PfzTtHEZjeOHpo3D2H9/FSe++hL3338/x7BkFE0z+/ooEs0f//hHLF26FEePHr3wsauvvhp79+4FALSfi2HDjmNo2NmMw63dCPp98CkKVE1DPKlidGkR5txYjpqJIzGoMITS0lKcPXv2wrHGjx+PZ599FrfffrvtnxvJadGiRVizZg0qKirQ1NSE4uLijMfx8ePHMWHCBJw+fRrLli3D448/7vSnRTbhwudx4XAYRUVFuPjL/Mgjj+DZZ5+95PGJpIrmtjCiCRV5AR/KSwouual3zpw5aGho6POxoUOH4tSpU+Z/AkQX2bhxI2pqahAKhfDhhx/ixhtvvOQxRsYxALzzzju4/fbboSgKGhsbMX36dBs+A3Iaf9XpcQUFBXjqqaegXHQhy/XXX9/v4wN+H0YPKcLVwy/D6CH9v5LFxc8NBAL9LqJEZjtw4AAefPBBAMAzzzzT76IHGBvHAHDbbbfhF7/4BVRVxX333YeTJ09adu4kDi58EigvL79kx6e38Blx3XXX9flzMpnEqFGjsj4ekRE9Xa+rqwuzZ8/GwoULTTnuL3/5S0ydOhUnTpxg75MEf9Xpcfv370dlZSW++eYbLF++HJ988gk6Ozvx5ptvIhDI7hXrOjs7UV1djeuuuw7FxcVYuXIlysrKsHv3bgwdOtTkz4DovP66nlnY++TChc/DIpEIqqqqsGfPHsyZMwcbNmy45FeeuUokEpg+fTo++OADzJgxA5s3b4bPx18kkLmMdL1csffJgzOUhz3yyCPYs2cPxo4dixdffNH0RQ843/fq6+tRWlqKt99+GytWrDD97yC5Ge16uWLvkwd3fB5VX1+P++67D6FQCB999BEqKyst/fvefPNNzJw5Ez6fD3/9618xZcoUS/8+kkMkEsHNN9+MXbt2Yfbs2di4caMlP8D1SCQSqK6uxtatW3Hrrbfirbfegt/vt+zvI2dwx+dB+/fvx4IFCwAAK1eutHzRA4Af/OAHWLJkCVRVxdy5c3H69GnL/07yvsWLF2PXrl2oqKjAunXrLF30gPO/wXj11VcxdOhQvPfee/j1r39t6d9HzuCOz2Ps6Hp62PvITHZ0PT3sfd7GWclj7Oh6etj7yCx2dT097H3exh2fh9jd9fSw91Eu7O56etj7vIs7Po9wouvpYe+jXNjd9fSw93kXd3we4GTX08PeR9lwsuvpYe/zHs5EHuBk19PD3keZcrrr6WHv8x7u+FxOlK6nh72PjBCl6+lh7/MW7vhcTKSup4e9j4wQpevpYe/zFu74XErErqeHvY9SEbHr6WHv8wbOPi4lYtfTw95HekTtenrY+7yBOz4XEr3r6WHvo95E73p62Pvcjzs+l3FD19PD3ke9id719LD3uR93fC7ipq6nh72PAHd1PT3sfe7FGcdF3NT19LD3kdu6nh72Pvfijs8l3Nr19LD3ycmtXU8Pe587ccfnAm7uenrY++Tk1q6nh73PnbjjE5wXup4e9j65eKHr6WHvcxfOMoLzQtfTw94nD690PT3sfe7CHZ/AvNb19LD3eZvXup4e9j734I5PUF7senrY+7zNa11PD3ufe3DHJyAvdz097H3e5OWup4e9T3ycWQTk5a6nh73Pe7ze9fSw94mPOz7ByNL19LD3eYMsXU8Pe5/YuOMTiExdTw97nzfI0vX0sPeJjTs+QcjY9fSw97mbjF1PD3ufmDibCELGrqeHvc+9ZO16etj7xMQdnwBk73p62PvcRfaup4e9Tzzc8TmMXU8fe5+7yN719LD3iYc7Pgex66XH3ucO7HrpsfeJgzOIg9j10mPvEx+7njHsfeLgjs8h7HqZYe8TE7teZtj7xMAdnwPY9TLH3icmdr3MsPeJgTs+m7HrZY+9Tyzsetlj73MWZw2bsetlj71PHOx6uWHvcxZ3fDZi1zMHe5+z2PXMwd7nHO74bMKuZx72Pmex65mDvc853PHZgF3PfOx9zmDXMx97n/04U9iAXc987H32Y9ezBnuf/bjjsxi7nrXY++zBrmct9j57ccdnof379+Ohhx4CwK5nFfY+e7DrWYu9z17c8VmEXc8+7H3WYtezD3ufPTg7WKR311u7di0XPQux91mHXc9e7H324I7PAr273vbt23HDDTc4fUpSYO8zF7ueM9j7rMcdn8l636+3atUqLno2Yu8zF7ueM9j7rMcdn4l6d72amhrU19dzsrAZe5852PWcx95nHc4IJuL9es5j78sdu54Y2Puswx2fSdj1xMLelx12PbGw91mDOz4TsOuJh70vO+x6YmHvswZ3fDli1xMXe19m2PXExd5nLs4COWLXExd7n3HsemJj7zMXd3w5YNdzB/a+1Nj13IG9zzzc8WWJXc892PtSY9dzB/Y+83DHlwV2Pfdh7+sfu577sPfljt/5WWDXcx/2vkux67kTe1/uuOPLELueu7H3nceu527sfbnhji8D7Hrux953Hrueu7H35YY7PoPY9bxD9t7Hrucd7H3Zkee7PUfset4hc+9j1/MW9r7scMdnALueN8nW+9j1vIm9L3Pc8aXBruddsvU+dj1vYu/LHHd8KbDreZ8svY9dz/vY+4zz3ne4idj1vE+G3seuJwf2PuO449PBricXr/Y+dj25sPcZwx1fP9j15OPV3seuJxf2PmO447sIu568vNb72PXkxd6Xmnu/qy3CricvL/U+dj25sfelxh1fL+x6BLi/97HrEcDelwp3fH/Hrkc93N772PUIYO9LhTs+sOvRpdza+9j16GLsfZcS/zvZBux6dDE39j52PeoPe9+lpN/xsetRKm7pfex6lAp7X19S7/jY9Sgdt/Q+dj1Khb2vL2l3fOx6ZJTovY9dj4xi7ztPnO9em7HrkVEi9z52PcoEe995Uu742PUoG6L1PnY9ygZ7n4Q7PnY9ypZovY9dj7LB3ifZjo9dj3IlSu9j16Ncydz7pNrxsetRrkTofex6ZAaZe580Oz52PTKTU72PXY/MJGvvk2LHx65HZnOq97HrkZlk7X2e3/Gx65FV7O597HpkFdl6n+d3fOx6ZBU7ex+7HllJtt7n6R0fux7Zwerex65Hduiv9+3ZswfDhw9HWVmZ06dnLs2j9u3bpw0YMEADoD3//PNOnw553JIlSzQAWllZmXbq1ClTj71w4UINgFZRUaG1t7ebemyi3lpaWrShQ4dqALSqqioNgHbDDTc4fVqm8+SOj12P7GZV72PXI7u9/PLL+OlPf3rhz4qioKurC0VFRc6dlMk82fjY9chuVvQ+dj2y26FDh1BXV9fnY5qm4YsvvnDojKzhuYWvvr4eL7zwAkKhEDZu3IiBAwc6fUokifLycrzyyisAgMcffxzvv/9+1seKRCKoqalBV1cXZs+ejYULF5p1mkS6wuEwIpHIJR/fvXu3A2djHVctfImkisNnuvHvJ7pw+Ew3Ekm1z//P+/XIaWbd38f79cgJ11xzDfbu3YsFCxYgEAhc+Pj69ev7fXy6OVlUwje+tu4YNuw4hoamZhxp7UbQ74NPUaBqGuJJFaNKi3BPZTnuuu5y3H7LFHY9clyuvY9dj0Rw+PBhLFy4EJs3b8asWbPwl7/8BYDxOXnuTSMxqDDk8GfRP2EXvlhCxerGfVi77RAUBYjE9X+SyA/6EI8ncPbDjRh8/GPs2vkpf8VJjmpubsaECRPQ2tqKJ598EkuXLjX0vAMHDqCyshJdXV147rnnsGjRIovPlCi1eDyOYDCY8ZysaUDt5DGoq74KoYBYv1wUcuFraQ9j3trtONkZQTjFP+7FlGQcw4sL0LBwKkYMKrDwDInSy/T+Pt6vR6LKdk4uCPowbGA+1tdWCTUni7UM4/w/8J2/3YZjZ8MZ/QMDgOYP4lR3Enf+dhta2sMWnSGRMZn2PnY9ElEuc3I4ruLY2bBwc7JQO75YQsVtq7bg2Nkwkjmcll9RcOXgArzzyDQE/cKt7SQRo72PXY9E5NU52fkz6GV14z6c7Izk9A8MAElNw4nOKFY37jfpzIiyY+T+Pt6vR6Ly6pwszI6vrTuGquWNiCb630p37nwd3Z83Inb6MIrGT8OQOx5Je8y8gA8fL60W9soikode72PXI1Glm5N7i59twfF1i1D0rUkYcudi3ceJMicLs+PbsOMYUn2/BwaUovjmezHguu8bPqainD8ukdP0eh+7Hokq3Zzc29l3XkDeFePSPk6UOVmYha+hqTnl5bGFV9+Mwqu+C1+B8dsUInEVDTubzTg9opwtW7YMkyZNwvHjxzF//nxs2LABa9asQSgUwp/+9CcUFxc7fYpEF6Sbk3t0f7kFvvwi5I+6Pu1jRZmThVj4EkkVR1q7LTn24Vb3vJoAedvFve8nP/kJAHY9Eo/ROVmNnkP7++tR8r1aw8cWYU4WYuFrbgtbdqVP0O9Dc5s4l9GS3MrLy7Fu3ToAQDQaxdSpU/k6nCQco3Ny+9ZXMOD62xAYOMTwsUWYk4VY+KIJFT6L2oZPUQzFWSK7vPvuuxf+9759+3DmzBkHz4boUkbm5NjJg4gc2YOBN83K6NgizMmB9A+xXl7AB9Wii0tVTUOeYC+XQ/LauHHjha43fvx47NmzB/Pnzzft/fuIzGBkTo4c/RyJjpNofv4BAIAWiwCaiq/P1OGKB1brPk+EOVmIha+8pADxNL/z1dQk0POfpkJLxACfH4rPn/J58aSK8hJxXiqH5HXx/Xp33XUXJkyYcOH+PqOv50lkNSNz8oAJM1A0fuqFP3d+sgmJjpMYPCP1r+5FmJOF+BEz4PdhVGnqd/ft+KAeR5++G53bG9D9xf/B0afvRscH9WmPPbq0CAEBXimA5Nbf++uZ+f59RGYyMif7gvnwDyi58J8SzIcSCMFfmPrqZBHmZGFuYH9hy1dY1bjP0OWzRuUHffiXW6/CQ1PHmnZMomwsWrQIa9asQUVFBZqamvrcurB06VIsX74cZWVl2L17N4YOHergmRKd5+U5WZit0NybRsLsJVjTgJqJI809KFGGene9/u7Xu/j+PlXlxVjkPC/PycIsfIMKQ6idPAYFQXNOqSDox4IpFY6/NA7JzcjrcBp5PU8iu3l5ThZm4QOAuuqrMGxgPvw53trgVxQMH5iHuur0L6FDZJX+up4e9j4SkVfnZKEWvlDAh/W1VSguDGb9D61ARXFhEH+orRLi7S9IXpm+Dmem799HZDUz5mS/ogg3J4txFr2MGFSA1xdNxsjBBRlvsdVYBLGzX+N/VOUL9W6/JJ90XU8Pex+J5NSpU3ji5w9j+fRBWc3JBUE/rhx8fk4XaU4W5qrOi8USKlY37sPabYegKEh5ZVFB0AdVAypih/DW0/8V5WVXYNeuXRgyxPjL6BCZ5cCBA6isrERXVxeee+45LFq0KKPnNzc3Y8KECWhtbcWTTz7J+/vIdm1tbVi1ahWWL1+OWCyGa6+9Fjuadmc8Jy+YUoG66nHC7PR6CLvw9Wg/F8OGHcfQsLMZh1u7EfT74FMUqJqGeFLF6NIizLmxHDUTR6IoqGDatGn46KOPMHPmTLz++ut8NQyylVnvr6f3/n1EVkomk/jVr36FZ555Bp2dnRc+XltbixdffBFAZnOyCBey9EtzkXgiqR06/Y229+tO7dDpb7R4InnJY44cOaINHjxYA6CtWLHCgbMkmS1cuFADoFVUVGjt7e05HWvJkiUaAK2srEw7deqUSWdIpO+9997TAFzy35///Od+H29kThaR8Du+bLzxxhu488474ff7sWXLFkyaNMnpUyIJbNy4ETU1NQiFQvjwww9zfquhRCKB6dOn44MPPsCMGTP4ep5kuVgshnnz5qGhoaHPxw8cOICxY73zQiCe/C6644478OijjyKZTGLu3Ll89XuynJH79TLF+/vIbqFQCGVlZX0+VlRUhDFjxjh0RhZxestplVgspn33u9/VAGgzZ87Ukkl3bMHJfcLhsHbDDTdoALTZs2drqqqaevzNmzdrADSfz6dt3brV1GMT9bZp0yYNgBYMBrWXX35ZmzhxorZ48WKnT8t0nl34NI29j+xhZtfTw95HVjt48KBWXFysAdBWrVrl9OlYypONrzf2PrKS2V1PD3sfWSkWi2Hy5Mn49NNPcdddd2HTpk1ZXY3sFp7/zmHvI6tY0fX0sPeRlR577DF8+umnGD16NF566SVPL3qAC+7jM0M8Huf9fWQqs+7XyxTv7yOzvfbaa7j77rsRDAaxbds2fOc733H6lCwnxewfDAZRX1+PwYMHY/PmzXj66aedPiVyuUxfh9MsfD1PMtOhQ4fwwAMPAAB+85vfSLHoAZLs+Hqw95EZ7Op6etj7yAyydb3epPpuYe+jXNnZ9fSw95EZZOt6vUm14wPY+yh7TnU9Pex9lC0Zu15v0s347H2ULae6nh72PsqGrF2vN+l2fD3Y+ygTTnc9Pex9lAmZu15v0n6HsPeRUSJ0PT3sfZQJmbteb9Lu+AD2PkpPtK6nh72P0pG96/Um9SzP3kfpiNb19LD3USrsen1JvePrwd5H/RG16+lh76P+sOtdit8VYO+jS4nc9fSw91F/2PUuxR3f37H3UQ+3dD097H3Ug12vf5zZ/469j3q4pevpYe8jgF0vFe74LsLeJze3dT097H1yY9dLjd8JF2Hvk9dXX33luq6nh71Pbux6qXHH1w/2PvlEo1HcfPPNaGpqcmXX08PeJx92vfQ4m/eDvU8+ixcvRlNTk2u7nh72Prn07npPPfUUFz0d3PGlwN4nh4aGBsyZM8f1XU8Pe58cene9WbNm4bXXXvPMD3Bm4+hPgb3P+7zU9fSw98mhp+uNGjUKv//977nopcAdXxrsfd7l1a6nh73Pu9j1MsMZPA32Pu/yatfTw97nTex6meOOzyD2Pm/xetfTw97nLex62eGIN4i9zztk6Hp62Pu8hV0vO9zxZYC9z/1k63p62Pvcj10ve5y1M8De536ydT097H3uxq6XG+74ssDe506ydj097H3uxK6XO47yLLD3uY/MXU8Pe587sevljju+LLH3uQe7Xmrsfe7BrmcOztRZYu9zD3a91Nj73IFdzzzc8eWIvU9s7HrGsPeJjV3PXBzZOWLvExe7nnHsfWJj1zMXd3wmYO8TD7tedtj7xMOuZz7OziZg7xMPu1522PvEwq5nDe74TMTeJwZ2vdyw94mBXc86HM0mYu9zHrte7tj7xMCuZx3u+EzG3uccdj1zsfc5h13PWpyRTcbe5xx2PXOx9zmDXc963PFZhL3PXux61mDvsxe7nj04gi3Su/fde++97H0WYtezDnufvdj17MEdn4XY+6zHrmcP9j7rsevZh7Owhdj7rMeuZw/2Pmv17norVqzgomcx7vhswN5nDXY9e7H3WYNdz34ctTbg/X3mY9ezH3ufNdj17Mcdn03Y+8zDrucs9j7zsOs5gzOvTdj7zMOu5yz2PnPwfj3ncMdnM/a+3LDriYG9Lzfses7iSLUZe1/22PXEwd6XG3Y9Z3HH5wD2vsyx64lp8+bN+OEPf8jelwF2PedxtnUAe1/m2PXENHPmTPz85z9n7zOIXU8M3PE5iL3PGHY9scXjcdxyyy3sfWmw64mDo9NB7H3pseuJLxgM4tVXX2XvS4NdTxzc8TmMvU8fu567sPfp27RpE2bPns2uJwjOsA5j79PHrucu7H39O3jwIH72s58BYNcTBXd8gmDv64tdz53Y+/qKRqOYPHkyduzYwa4nEHlHpGDY+/4/dj33Yu/r67HHHsOOHTvY9QTDHZ9A2PvY9byCvY9dT2RyzaqCY+9j1/MK2Xsfu57YuOMTkKy9j13PW2Ttfex64vP+KHQhGXsfu573yNr72PXExx2foGTqfex63iZT72PXcwdvzqQeIFPvY9fzNll6H7uee3DHJziv9z52PTl4vfex67mLd0aeR3m597HrycPrvY9dz12443MBL/Y+dj05ebH3seu5j7tnT0l4sfex68nJa72PXc+duONzEa/0PnY9uXml97HruZf7RpvEvND72PXIK72PXc+9uONzGTf3PnY96s3NvY9dz93cMWPSBW7ufex61Jtbex+7nvtxx+dSbut97HrUH7f1PnY9bxB3hFFKbup97Hqkx229j13PG7jjczE39D52PTLCDb2PXc87xJolKSNu6H3semSE6L2PXc9buOPzAFF7H7seZULU3seu5z3OjyrKmYi9j12PMiVq72PX8x7u+DxCpN7Hrke5EKn3set5E3d8HiFS72PXo1yI0vvY9byLOz6Pcbr3seuRGZzufex63sYdn8c42fvY9cgsTvc+dj1v447Pg5zofex6ZAUneh+7nvdxx+dBTvQ+dj2ygt29j11PDtzxeZhdvY9dj6xkV+9j15MHd3we1l/vO3r0KL744oucj71z506cOnWKXY8sZ1fvY9eTB3d8Hte791177bU4cOAANE1DS0sLBg8enNUx9+7di/Hjx6OkpAQlJSU4ePAgux5Zzsrex64nF+74PC4YDGLdunUIhUL4/PPPEQ6HEYlEsGvXrqyPuX37dgBAW1sbDh48iOLiYrzwwgtc9MhSVvU+dj35cOHzuHg8jh/96EeIxWJ9Pv7ZZ59lfcw9e/b0+XNHRwd+/OMfZ308IqOWLVuGSZMm4fjx45g/fz5UVc3peNFoFPfeey86Ojowa9Ys1NXVmXSmJDIufBJobW295GMff/xx1sfr77kivD4oeZ/ZvY9dT05sfBJob2/H6tWrsXLlSnR0dAAASkpKcPbs2Usem0iqaG4LI5pQkRfwobykAAF/35+PgsEgEokEAGDYsGFYsmQJHnroIRQWFlr/yRAhfe8zMo7Z9eTFhU8i7e3teOKJJ7Bq1SpcccUVaGlpAQC0dcewYccxNDQ140hrN4J+H3yKAlXTEE+qGFVahHsqyzH3ppEYVBjCgAEDEI1G8cQTT6Curo4LHjliyZIlWLFiBcrKyrB7924ECosNj+OzJ5pRWVmJjo4OrFy5Eg8//LDTnw7ZiAufhOLxOPx+PxIqsLpxH9ZuOwRFASJx/V6SH/RB04DayWOwcFoFQgEfAoGAjWdN1NeF+/s++hi3/PNv0HLZ1YbH8aATO/HJS/+KWXf+kPfrSYgLn6Ra2sOYt3Y7TnZGEE4xUVysIOjDsIH5WF9bhRGDCiw8Q6L0dvztIO773YdAQTHimvFLFgJQ4aBFJgMAAAScSURBVIt24i911bhm1HALz5BExIVPQi3tYdz5223oOBdHMosvv19RUFwYxOuLJnPxI8dwHFO2eFWnZGIJFfPWbs96sgCApKah41wc96/djngyt8vJibLBcUy54MInmdWN+3CyM5L1ZNEjqWk40RnF6sb9Jp0ZkXEcx5QL/qpTIm3dMVQtb0Q00f9Pt1oijtZ3nkfk8G6okW8QGDQcJdN+goKxE3WPmRfw4eOl1RhUGLLqtIn6SDeOe5x5/WlEDu+BGo/AX1SCgVWzcdn1M/p9LMexXLjjk8iGHceQ6uI1TU0icNkQDP/Rcox8ZAMGTZ2P0/9rBRLtJ3Wfoyjnj0tkl3TjuMfAqjkY8Z9fwpX/shGX3/Pf0L71FURPHOj3sRzHcuHCJ5GGpuaUl3r7QvkYNGUeAoOGQVF8KPwP30GgeJjuZAGcv3S8YWezFadL1K9047hHaOgoKIHg3/+kQIGCRNvX/T6W41guvBFLEomkiiOt3Rk9J9ndhvjZFoSGXpnycYdbu5FIqpe8MgaR2TIdx61vP4/uzxuhJaIIDRub8tf2HMfy4MIniea2MIJ+H+LJpKHHa8kEzvzvpzHg2moES0emfGzQ70NzWxijhxSZcapEujIdx6Uz/gsGf/+fEG3Zi8jRz6H4g7qP5TiWB3+0kUQ0ocJn8NUpNE3FmTeeAfwBDP7+f0r7eJ+ipL3QgMgMmYzjHorPj/yR30ay6wy6dm3WfRzHsTy48EkiL+CDauACXk3T0Lr5fyLZ3Y6h//EXUPzpfymgahryAhxKZD2j47hfqqrb+ACOY5nwqyyJ8pICQzfpnn17DeKtx3D5Pf8dvmCeoWPHkyrKS/jKF2Q9o+M42d2O7i+3QI2FoalJhA/uRPfftiB/9ATd53Acy4ONTxIBvw+jSotw4NQ3uo9JdJzCN7vfAvxBND83/8LHB9++EAO+fYvu80aXFvGCALKFkXEMAFAUdO16E61vPw9oKgLFl6OkegEKx/2j7lM4juXBhU8i91SWY1XjPt1LwQPFl2PUkjcyOmZ+0Ic5N5abcXpEhqQbxwDgLyzG8HnLDR+T41gu/PFGInNvGgmzX6dH04Caiamv+iQyE8cx5YoLn0QGFYZQO3kMCoLmfNkLgn4smFLBl3kiW3EcU6648EmmrvoqDBuYD3+Ob7zpVxQMH5iHuupxJp0ZkXEcx5QLLnySCQV8WF9bheLCYNaTRs/7mP2htgpBXgxADuA4plzw3Rkklf07sPsxfGAe/sB3YCcBcBxTNrjwSSyWULG6cR/WbjsERUHKq+QKgj6oGrBgSgXqqsfxJ2QSBscxZYoLH6H9XAwbdhxDw85mHG7tRtDvg09RoGoa4kkVo0uLMOfGctRMHMkLAEhYHMdkFBc+6iORVNHcFkY0oSIv4EN5SQFv6iXX4TimVLjwERGRVPgjEBERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSYULHxERSeX/AaiumQ9GyhDdAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#@title Draw the $S_3^0$ graph using [automatic] shell layout\n",
    "nx.draw_shell(DG,with_labels=True,node_size=500,width=2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#@title Draw the $S_3^0$ graph using weak dominance drawing\n",
    "from matplotlib.patches import Rectangle, FancyArrowPatch\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(Rectangle((2,2), 5, 5, facecolor=\"lightgrey\",alpha=0.5))\n",
    "ax.add_patch(\n",
    "    FancyArrowPatch((2,2),(5,5),\n",
    "                    shrinkA=15,shrinkB=15,\n",
    "                    arrowstyle='fancy',mutation_scale=18,\n",
    "                    linestyle='dashed',hatch='\\\\',color='orange')\n",
    ")\n",
    "\n",
    "plt.grid(True)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('$S_3^0$ graph')\n",
    "plt.xlim(xmin=0,xmax=7)\n",
    "plt.ylim(ymin=0,ymax=7)\n",
    "\n",
    "DG.pos={1:(1,4),2:(3,6),'u':(2,2),3:(4,1),4:(6,3),'v':(5,5)}\n",
    "nx.draw_networkx(DG,pos=DG.pos,\n",
    "                 node_size=500,width=2.0,label='$S_3^0$ graph')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above figure is an example of exception between $u$ and $v$.  The shaded part is dominance region of $u$.  The orange arrow is *falsely-implied path* or a *false-positive*; node $v$ lies in shaded region, but there is no path from $u$ to $v$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Small DAG (example in Figure 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<networkx.classes.digraph.DiGraph at 0x7febc30ae9b0>"
      ]
     },
     "execution_count": null,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title Create a small DAG\n",
    "sd=nx.DiGraph()\n",
    "sd.add_nodes_from([chr(c) for c in range(ord('a'),ord('h')+1)])\n",
    "sd.add_edges_from([('a','c'),('a','d'),('a','e'),('b','f'),('b','g'),('c','h'),('e','h'),('f','h')])\n",
    "sd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeVhUZfsH8O8cthncd1RUUlJAVFJBwQVFBfO1UrOyzNK09M3Mcq/cM5dMM8vKcmkxW/1lmtYArrgjuAGSKyoCKpsgzMAw5/79wevJUdnPzJlh7s91cVU+h+fcms/c3Oc8i4qICIwxxpidEJQOgDHGGLMkTnyMMcbsCic+xhhjdoUTH2OMMbvCiY8xxphd4cTHGGPMrnDiY4wxZlc48THGGLMrnPgYY4zZFU58jDHG7AonPsYYY3aFEx9jjDG7womPMcaYXeHExxhjzK5w4mOMMWZXOPExxhizK5z4GGOM2RVOfIwxxuwKJz7GGGN2xVHpABizN6JYBL0+CaKohyCooVZ7QBB4KDJmKTzaGLMAgyEDqakbkJa2ETrdRahUTlCpHEBkBFEhNBpPuLmNQdOmY+HkVF/pcBmr1lREREoHwVh1JYqFSEpagOTklQBUEEVdidcKggYAwd19Cjw85kEQnC0WJ2P2hBMfY2ai11/FqVP9UVBwHaKYX+7vEwRXuLg0R6dOkVCrW5oxQsbsEyc+xsxAr7+KmJiuMBgyARgr0YMDnJzqo0uX45z8GJMZz+pkTGaiWIhTp/pXIekBgBEGQyZOneoPUTTIGR5jdo8TH2MyS0pagIKC66h80rvLiIKC60hKWiBHWIyx/+FHnYzJyGDIwOHD7hBFvWx9CoIagYHXebYnYzLhio8xGaWmbgCgkrlXFVJT18vcJ2P2iys+xmR07JgP8vPPlnrNuXPA8uXA9etAQACgUgHu7sDYsSV/j6urDwIC4mWOljH7xBUfYzIRxSLodBdLvcZgAObOBcLCgG3bgJAQ4MCBsvvW6S5AFItkipQx+8aJjzGZ6PVJUKmcSr0mIQEwGoGnnwYcHYHevQEvr7L7VqmcoNcnyRMoY3aOEx9jMhFFPVQqh1KvycgAGjYsfrx5V+PGZfetUjnIOmGGMXvGiY8xmQiCGkSlL2GoXx9ITwfufbN+82bZfRMZIQjqKkbIGAM48TEmG7XaA0SlLzZv3x4QBOD334sfeR44ACQmlt03kQFqtYc8gTJm5zjxMSYTQXCERtOm1GucnICFC4GdO4HBg4HISCAwsPjXS6PRePLRRYzJhBMfYzJycxvzv1MWStauHbBuHfDXX8D8+cCtW0CjRiVfLwgauLmNkTdQxuwYJz7GZNS06VgApS+NPXkSyMwsftT599/ApUvF6/lKRmja9BU5w2TMrvGzE8Zk5ORUH+7uU5CcvKrEo4iuXSt+3KnTAc2aFVd9DRo8vD9BcIW7+9u8XRljMuKdWxiTmSgWIjraFzrdJVRto2oHaDSt4e8fD0Eo4yUgY6zc+FEnYzITBGd06hT5vyqt9HV9JSs+j69Tp0hOeozJjCs+xsyET2BnzDpxxceYGaSnp6NPn2fx0ktGNGv2JgRBXeZsT0FwhSCo4e7+Nvz94znpMWYmXPExJiNRFPHNN9/g7bffRk5ODgAgOTkZjRtrkJq6Hmlp30CnuwCVygkqlQOIjCAyQKPxhJvbGDRt+gpPZGHMzDjxMSaTy5cv46WXXsKBe45bUKlUMBgMcHD4912fKBZBr0+CKOohCGqo1R68OJ0xC+LRxphMFi1aZJL0AKBRo0YmSQ8o3uHF1dXTkqExxu7B7/gYk8n06dPhdd8ZQ25ubgpFwxgrCSc+xmTSrl07KdE5OhY/TGnevLmSITHGHoIfdTImk02bNmHv3r1o0KABIiMj8cMPP2D48OFKh8UYuw9PbmFMBhkZGfDy8kJ6ejo2btyI0aNHKx0SY6wE/KiTMRnMnDkT6enpCA4Oxssvv6x0OIyxUnDFx1gVRUVFoXfv3nBycsLp06cfmODCGLMuXPExVgWFhYWYMGECgOKqj5MeY9aPEx9jVbBixQokJCSgTZs2ePfdd5UOhzFWDvyok7FKunTpEtq3bw+9Xo/w8HAMGDBA6ZAYY+XAyxkUxFtX2S4iwsSJE6HX6/HCCy9w0mNl4vFuPbjiszCDIQOpqRuQlrYROt3F+zYrLrxns+KxvFmxFfvll1/w3HPPoW7dukhMTESTJk2UDolZIR7v1okTn4WIYiGSkhYgOXklABVEUVfitcXH1xDc3afAw2MeBMHZYnGyst2+fRteXl5IS0vDl19+ifHjxysdErMyPN6tGyc+C+ADSauXN954A2vWrEFgYCAOHDgAQeA5YuxfPN6tHyc+M9PrryImpisMhkwAxkr04AAnp/ro0uU4DwYrcOzYMXTv3h2CICA2NhYdO3ZUOiRmRXi82wb+UdWMRLEQp071r8IgAAAjDIZMnDrVH6JokDM8VkFFRUUYP348iAhTpkzhpMdM8Hi3HZz4zCgpaQEKCq7jYYNgxAggJqa8PRlRUHAdSUkL5AyPVdCnn36KkydPolWrVpg3b57S4TArU9p4v9fVq8C4ccCgQcCWLQ+7gse7uXHiMxODIQPJySsr9Iy/NKKYj+TkFf/7aZJZ2rVr1zBnzhwAwGeffYYaNWooHBGzJhUZ7z/9BDz2GLBzJ/D00w+/hse7eXHiM5PU1A0AVDL3qkJq6voHfjU9PR27d++GKIoy34/d9eabbyIvLw/Dhg3D4MGDlQ6HWZmKjPcbNwAPj/Jc+fDxzqqOE5+ZpKVtLHUKMwBcuACMHQsMHgwsWAAUFpbepyjqkJb2jfTf6enpeOedd+Dh4YF+/frhjz/+kCFydr9t27Zh69atqFmzJj755BOlw2FWqDzjHQCmTAFOngQ++QR4/HHg2rWSr71/vDP58LYBZiCKRdDpLpZ53d69wLJlgLMzMGkS8PffwJNPlv49Ot0FpKVdx+uvT8LOnTtRUFAgte3cuRM6XdmDj5WfXq/H9OnTAQBDhw7F/v37FY6IWR8jmjU7X64rV64E3noLGDAA+M9/yr5ep7sAUSziHV5kxn+aZqDXJ0GlcgJR6SXcsGFAw4bF/x4YWFwBlkWlcsJ//zsUW7dGP9C2bt06rFu3rjIhs3L4/vvv8f333ysdBrMyzZoB69YBGo38fatUTtDrk+Dq6il/53aME58ZiKIeKpVDmdfVv2eHIrUayMgou2+VygFjx47Cvn0XkJWVZdIWEBCANm3aVDRcVoKsrCxotVoQEcLCwlC/Pm8pxR5Ur142HB13ASjjXUUlqFQOEEW97P3aO058ZiAIahBVdh1P6YiMCAl5HLduvY5169Zh6dKlSEpKAgCMGzcOr776qlnua2+MRiN69OgBIsKkSZOwevVqpUNiVio//wKOH/eDKMqf+IiMEAS17P3aO058ZqBWe4DIPItPiQwIDByCf/65YPJ+DwBatGhhlnvao6+++gpHjx5Fs2bNsGjRIqXDYVbM3ONdrfYwS9/2jGd1moEgOEKjMc8jR7W6NU6fjn8g6QmCgMLCQp7cIoPU1FS88847AIBPPvkEtWvXVjgiZs3MOd41Gk+e2GIGvFenmVy9uhxJSfPKNcW5vARBAw+PhTh+vDVefPHFhyY5tVqN3r17IywsDGFhYfDx8YFKJfd6wuptxIgR+PnnnzFo0CD8+eef/OfHymTO8d6y5TTZ+mTFOPGZicGQicOHm8v6YloQ1AgMvA4np/qIi4vDwIEDcf36dQBAnz59kJOTg9jYWJPvad68OUJDQxEWFob+/fujQYMGssVTHWm1WgwcOBAajQYJCQnwKN9KY2bnzD3embw48ZnRpUvvITl5lSzblgmCK9zd30br1v++b7p27RoGDhyIc+fOIS4uDu3atcPNmzcRERGB8PBwhIeHIy0tTbpepVKha9euUjXYrVs3ODk5VTm26kKn08HX1xeXLl3CsmXLMGPGDKVDYlbo4MGDOHLkCJKSknD+/HlER0ejoKAAe/eOQn7+d2Yb70w+nPjMSBQLER3tC53uEiq/WzsAOECjaQ1//3gIgmmiKiwsxK1bt9C8efMHvouIcPr0aYSHh0Or1SIqKgqF92wPU7t2bYSEhCAsLAyhoaFo3bp1FWK0fe+99x4WL16MDh06ICYmhn8oYA+4desWmjRpgod9bB46tB+CMNas453JgxOfmVnT+Vx5eXnYv38/tFottFotEhMTTdo9PT2lJNi3b1/UqlWrSvezJQkJCfDz84PBYMDBgwcRFBSkdEjMComiiK5du+LEiRMmv/7000/jt99+s6rxzkrGic8CrPVE5qtXr0rVYGRkJLKzs6U2JycnBAUFSe8HH3vssWp70rgoiujTpw+ioqLw2muvYe3atUqHxKyUVqvFyy+/jBs3bki/VqtWLZw7dw5ubm4ArHe8s39x4rMQUSxEUtICJCevBKAqdfaXILgCEPHHH2ps3GjETz/9htDQULPGZzQaER0dLVWDR48eNTntoVGjRhgwYABCQ0MRGhqKpk2bmjUeS9qwYQPGjh2Lxo0bIzExEfXq1VM6JGZlbt++jWnTpklbAjZv3lyaWLZ06VLMnDnT5PrKjHd396nw8JjHjzctgBOfhRkMmUhNXY+0tG+g012ASuUElcoBREYQGaDReMLNbQyaNn0FNWq4wWAoXhj70ksvYfny5WjcuLFF4szOzsauXbukRHj16lWT9o4dO0rVYM+ePaFW2+buErdu3YKXlxcyMzOxadMmjBw5UumQmJXRarUYN24ckpOT4ezsjIULF2Ly5Ml45plnkJOTA61WW+Lf/4qMd569aTmc+BQkikXQ65MginoIghpqtYfJYlVPT09cvPjvKQ/16tXD+vXrMXToUIvGSUQ4d+4ctFotwsPDsWfPHuTn//sIR6PRIDg4WJot6uXlZTNr30aPHo1vv/0W/fv3R3h4uM3Ezczv/irP398f33zzDXx8fCrVX1njnVkOJz4rFhoaioiICJNfCwwMxKFDhxSKqFhBQQEOHjwoJcKTJ0+atLdo0UKqBvv162e1mzvv3bsXffv2hYuLC86cOYNHH31U6ZCYlXhYlTd16lQ4OnKiqhaIWa1Ro0YRAOmrdevWFB8fr3RYD0hNTaXvvvuOXnzxRWrcuLFJzIIgULdu3Wju3Ll04MABMhgMSodLRER6vZ7atWtHAGjBggVKh8OsRHZ2No0bN076++vv72+VY45VDSc+KzZ79mwCQBqNhgBQ/fr16datW0qHVSqj0UixsbG0dOlS6tu3Lzk5OZkkwjp16tCwYcNo7dq1dPnyZcXiXLhwIQGgdu3akV6vVywOZj3+/vtvcnd3JwDk7OxMS5cutZof1Ji8OPFZsfT0dFqzZg2lpKRQv379CACNHj1a6bAqJDc3l7Zv306TJk2itm3bmiRBANS2bVuaNGkSbd++nXJzcy0S07lz58jFxYUA0O7duy1yT2a9uMqzP/yOz0acO3cOHTp0QGFhIfbu3Yvg4GClQ6qUpKQkae3grl27cPv2banNyckJPXv2lN4PdurUSfa1g0SE0NBQREZG4qWXXsK3334ra//MtvC7PPvEic+GLFiwAPPnz4eXlxdOnjwJFxcXpUOqkqKiIhw7dkxaMhEdHW2ydrBx48YYMGCAtJtMkyZNqnzPzZs3Y+TIkahfvz4SExPRqFGjKvfJbI/cMzaZbeHEZ0MKCgrQsWNHnDt3Du+//z5mz56tdEiyyszMNFk7mJycbNLu5+cnVYM9evSocOLPysqCl5cXbt68iXXr1mHs2LFyhs9sBFd5jBOfjdmzZw9CQkLg4uKCuLg4eHp6Kh2SWRAREhMTpSUTe/fuNTl/0NXVFX369JHWDrZt27bMNXgTJkzA2rVr0bNnT+zbt6/absHGHo6rPHYXJz4b9NJLL+H777/HgAEDoNVq7WLRtV6vx4EDB6T3g6dPnzZpb9Wqlcnawbp165q0Hz58GEFBQXB0dMTJkyfRvn17S4bPFMZVHrsXJz4bdPPmTXh5eSErKwubN2/G888/r3RIFpeamiqdORgeHo709HSpTRAEdOvWTaoG/fz8EBAQgDNnzuCdd97B4sWLFYycWRJXeexhOPHZqPXr12PcuHFo0qQJEhMTH6hw7Ikoijhx4oRUDR48eBBFRUVSu0ajgU6nQ8OGDXHgwAG0a9dOwWiZpXCVx0rCic9GiaKI4OBgHDhwABMmTMAXX3yhdEhWIzc3F3v37oVWq8WOHTuQlJRk0u7l5SVVg71790aNGjWUCZSZBVd5rCyc+GxYfHw8/Pz8YDQacejQIXTv3l3pkKwKEeGJJ57Ajh070KVLF7Ro0QK7du1Cbm6udI2zszN69eolLZno2LGjXbwzra64ymPlwYnPxr377rtYsmQJOnbsiOPHj8PJic/yumvLli0YPnw4ateujcTERDRt2hQGgwFHjx6VlkwcP34c9w4BNzc3ae3ggAEDLHYMFKsarvJYRXDis3H5+fnw9fXF5cuXsXz5ckybNk3pkKxCTk4OvL29kZKSgjVr1uD1119/6HUZGRmIjIyUEmFKSopJe+fOnaXZokFBQXB2drZE+KwCuMpjFcWJrxr4+++/8fjjj8PV1RUJCQlo1aqV0iEpbvLkyVi9ejUCAgJw6NAhODg4lPk9RISEhAQpCe7fvx96vV5qr1GjBvr27Su9H/T09OTHogriKo9VFie+auK5557DL7/8gsGDB2Pbtm12/YEcExODgIAAqFQqHD9+HH5+fpXqR6fTISoqSlpEHxcXZ9Lu4eEhJcGQkBDUqVNHjvBZOXCVx6qCE181kZqaCi8vL+Tk5GDLli0YNmyY0iEpwmg0olu3boiJicGUKVOwYsUK2fq+fv26tG4wIiICGRkZUpuDgwO6d+8uJcIuXbqUq8pkFcNVHpMDJ75qZM2aNXjjjTfQvHlznD17FrVq1VI6JItbvXo1Jk+ejBYtWiAhIQE1a9Y0y32MRiNiY2OltYOHDx82WTtYv3599O/fX5ot6u7ubpY47AlXeUwunPiqEaPRiMDAQERHR2Py5MlYtWqV0iFZ1PXr1+Ht7Y3c3Fxs3boVTz31lMXunZOTgz179kjvBy9dumTS7uPjIyXB4OBgaDQai8Vm67jKY3LjxFfNnDhxAl27dgUAREdHo3PnzgpHZDnDhw/Hli1b8NRTT2Hr1q2KxnLx4kUpCe7evRt37tyR2lxcXNC7d28pEfr6+tr1O9nScJXHzIETXzU0ZcoUfPzxx+jatSuOHDliF++aduzYgcGDB6NGjRo4e/YsWrRooXRIksLCQhw5ckRKhLGxsSZrB5s1a4bQ0FCEhoZiwIABaNiwoYLRWgeu8pg5ceKrhu7cuQNvb28kJydj9erVmDRpktIhmVVeXh7at2+PK1euYMWKFZgyZYrSIZXq1q1b0trB8PBwpKamSm0qlQpdunSR1g4GBgba3aYEXOUxc+PEV01t3boVQ4cORa1atXD27Fk0b95c6ZDMZubMmfjwww/h5+eH6Ohom/qAJCLExcVJ1WBUVBQKCgqk9lq1aiEkJERKhG3atFEwWvPiKo9ZCie+auypp57Ctm3bMHz4cPz6669Kh2MWZ86cQefOnWE0GnHkyBEEBAQoHVKV5OfnY//+/VI1mJCQYNLepk0bKQn27dsXtWvXVihSeXGVxyyJE181dvXqVfj4+CAvLw87duzAoEGDlA5JVqIoomfPnjh8+DBef/11rFmzRumQZHft2jWTtYNZWVlSm6OjIwIDA6W1g507d7a5U+W5ymNK4MRXza1YsQLTpk2Dh4cH4uPj4erqqnRIsvnqq68wfvx4uLm5ITExsdrvnGI0GnH8+HGpGjxy5AiMRqPU3qBBA2mD7dDQUDRr1kzBaMvGVR5TCie+aq6oqAhdu3bFqVOnMHPmTCxdulTpkGRx48YNeHl5ITs7Gz/99BOee+45pUOyuOzsbOzevVtaRH//uYO+vr5SEuzduzfUarUygd6HqzymNE58duDo0aMIDAyEg4MDTpw4AV9fX6VDqrIXX3wRP/zwA8LCwvDXX3/Z/To4IsL58+elJLhnzx7k5eVJ7Wq1GsHBwdL7QR8fH0X+zLjKY9aAE5+dmDhxIj7//HMEBQUhKirK5t4F3SsyMhIDBgyAWq1GfHw8WrdurXRIVqewsBCHDh2SZoueOHHCpN3d3V1aO9i/f380aNDArPFwlcesCSc+O3H79m14eXkhLS0NX331FV599VWlQ6oUvV6Pjh074vz581i8eDHeeecdpUOyCTdv3kRERIT0fvDGjRtSm0qlgr+/v1QNduvWTda1g1zlMWvDic+O/PzzzxgxYgTq1auHxMREmzxdfN68eVi4cCF8fHxw4sQJPhi2EogIp0+flpJgVFQUCgsLpfbatWsjJCREmi36yCOPVOo+XOUxa8WJz44QER5//HFotVq8+OKL+P7775UOqUISExPRsWNHGAwGREVFoWfPnkqHVC3k5eVh3759UiJMTEw0aX/00UdN1g6W58QLrvKYNePEZ2cuXbqE9u3bQ6/XIzIyEv369VM6pHIhIvTt2xf79u3D2LFjpSqCye/KlSvS2sHIyEhkZ2dLbU5OTggKCpKqQT8/P5P3xVzlMVvAic8OLV68GO+99x4effRRnD592mqmuZfm22+/xejRo9GwYUMkJiaafTIGK1ZUVITo6GhptujRo0chiqLU3qhRI2ntoKOjI2bOnMlVHrN6nPjsUGFhIR577DEkJCRg7ty5WLBggdIhlSojIwNeXl5IT0/Ht99+i5deeknpkOxWVlYWdu3aJSXCq1evPnCNm5sbFi1ahJEjR9rED1XM/nDis1NRUVHo3bs3nJ2dcfr0abRr107pkEo0duxYbNiwAX379sWuXbvsfs2etSAirF+/HtOmTcPt27cfaNdoNOjTp4/0ftDLy4v/3zGrwInPjt1NKH369MHu3but8kPJlhK0PXnYu7yvvvoKmZmZ0trBU6dOmXxPixYtpJ1k+vfvj3r16ikROmOc+OyZtT9CLCwshJ+fH86ePWsTj2TtRXlnbKalpZmsHbx165bUJggCAgICpGowICCA3wUyi+HEZ+esedKILU7Cqc6qMmNTFEWcOnVKqgYPHjwIg8EgtdepUwf9+vWTZou2atXKbL8Pxjjx2TkiQkhICPbu3WtVywQuXrwIX19f6PV6REREoH///kqHZNfkXpd3584d7N27V6oGz507Z9Letm1bKQn26dMHNWrUkOO3wRgATnwMpgvD9+/fj169eikaz70L7UeOHIlNmzYpGo89s9S6vMuXL0szRXft2oWcnBypzcnJCT179pQSYceOHW16r1mmPE58DAAwd+5cvP/++1axFdjdrdXq1q2LxMRENGnSRLFY7JlSu68UFRXh6NGjUjV47Ngx3Psx1aRJE2nt4IABA/jvB6swTnwMQPHmzx06dMCFCxcU3fw5Ozsb3t7eSEtLw9q1a/Haa68pEoc9s7bdVzIzMxEZGSlVhMnJySbtfn5+UjUYFBQEFxcXReJktoMTH5NYw3E/1en4JFtk7XtsEhHOnj0rVYP79u2DTqeT2mvUqIE+ffpIyybatm1rlct0mLI48TETI0eOxObNmzFw4EDs3LnToh8ax44dQ/fu3eHg4IDY2Fh06NDBYve2d9ZW5ZWXXq9HVFSUVA2eOXPGpL1Vq1bSkol+/fqhbt26CkXKrAknPmbixo0b8PLyQnZ2Nn7++Wc8++yzFrlvUVER/P39cfLkScyYMQPLli2zyH2Z9Vd5FZGSkiKtHYyIiEB6errU5uDggG7dukmJ0N/fHw4ODgpGy5TCiY894KuvvsL48ePh5uaGxMRE1KlTx+z3XLlyJaZOnQoPDw/ExcXx9HULsNUqr7xEUcSJEyektYOHDh1CUVGR1F63bl30799fej/YokULBaNllsSJjz1AFEX06tULhw4dwsSJE/HZZ5+Z9X5Xr16Fj48P8vLysGPHDgwaNMis92PVq8orr5ycHGntoFarxcWLF03avby8pCQYHBwMV1dXhSJl5saJjz3UmTNn0LlzZxiNRhw5cgQBAQFmu9eQIUPwxx9/YPjw4fj111/Ndh9W/au8irh48aL0bnD37t3Izc2V2pydndGrVy8pEXbo0IEnyVQjnPhYiWbOnIkPP/wQfn5+iI6ONks18Mcff2DIkCGoVasWEhMT0axZM9nvwYrZY5VXXgaDAUeOHJGqwZiYGJO1g25ubtK7wf79+6Nx48YKRsuqihMfK1FeXh7at2+PK1euYOXKlXj77bdl7T83Nxc+Pj5ITk7G6tWrMWnSJFn7Z8W4yqu49PR0REZGSssmUlJSTNo7d+4sLZkICgpSdMMHVnGc+FipduzYgcGDB6NGjRpISEhAy5YtZet7ypQp+Pjjj9G1a1ccOXKEZ9iZAVd5VUdEiI+PN1k7WFBQILXXrFkTffv2lRKhp6cnPxa1cpz4WJmGDx+OLVu24KmnnsLWrVtl6fPkyZPo0qULACA6OhqdO3eWpV9WjKs889HpdNi/f7+UCOPj403aH3nkESkJhoSEWGRWNKsYTnysTNevX4e3tzdyc3OxdetWPPXUU1Xqz2g0IjAwENHR0Zg8eTJWrVolU6QM4CrP0pKTkxEeHo7w8HBEREQgMzNTanNwcED37t2lSTJdunThJxtWgBMfK5fVq1dj8uTJaNGiBRISElCzZs1K97VmzRq88cYbaN68Oc6ePYtatWrJGKn94ipPeUajETExMdJs0cOHD8NoNErt9evXl9YOhoaGwt3dXcFo7RcnPlYuRqMR3bp1Q0xMDKZMmYIVK1ZUqp+UlBR4e3sjJycHW7ZswbBhw2SO1D5xlWedbt++jT179kizRS9fvmzS7uPjI1WDvXv3hkajUShS+8KJj5VbTEwMAgICoFKpcPz4cfj5+VW4j+eeew6//PILBg8ejG3btvEkgCriKs92EBEuXLhgsnYwLy9PandxcUHv3r2lRNi+fXseH2bCiY9VyOTJk7F69WoEBATg0KFDFXpf8ffff+Pxxx+Hq6srEhIS0KpVKzNGWv1xlWfbCgsLcfjwYakajI2NNWlv1qyZydrBhrKR808AACAASURBVA0bKhRp9WNTiU8Ui6DXJ0EU9RAENdRqDwgCD3JLysnJgbe3N1JSUrBmzRq8/vrr5fq+/Px8+Pr64vLly/jwww8xffp0M0dafXGVVz3dunVL2mA7PDwcaWlpUptKpUKXLl2kd4OBgYFwcnJSMNpitvqZbPWJz2DIQGrqBqSlbYROdxEqlRNUKgcQGUFUCI3GE25uY9C06Vg4OdVXOly7sGXLFgwfPhy1a9dGYmIimjZtWub3vPvuu1iyZAk6dOiAmJgYqxi0toirPPtARDhz5oxUDUZFRaGwsFBqr1WrFkJCQqSKsE2bNhaLrTp8Jltt4hPFQiQlLUBy8koAKoiirsRrBUEDgODuPgUeHvMgCLyLgjkREZ544gns2LEDzz33HH766adSr4+Pj4efnx+MRiMOHjyIwMBAC0VafXCVZ9/y8/Oxb98+qRo8e/asSXubNm1M1g6aY6Z0dfpMtsrEp9dfxalT/VFQcB2imF/u7xMEV7i4NEenTpFQq+XbYYQ9KCkpCT4+PtDpdPj7778RFhb20OtEUURwcDAOHDiA8ePH48svv7RwpLaPqzx2v6tXr0qTZCIjI5GdnS21OTo6IigoSKoGO3fuDEEQqnS/6vaZbHWJT6+/ipiYrjAYMgEYy7z+QQ5wcqqPLl2OW9UfdHX04YcfYubMmWjdujXi4uIeOhV7/fr1GDduHBo3bozExETUq1dPgUhtE1d5rDyMRiOio6OlavDIkSMQRVFqb9CgAQYMGCBVhBXdCL46fiZbVeITxUJER/tCp7uEyv0B3+UAjaY1/P3jIQj8LslcDAYDunTpgjNnzuDdd9/FBx98YNJ+69YteHl5ITMzEz/88ANeeOEFhSK1PVzlscrKzs7Grl27pIrwypUrJu2+vr7SkolevXpBrVaX2Fd1/Uy2qsR36dJ7SE5eVaFSuiSC4Ap397fRuvUiGSJjJTl8+DB69OgBR0dHnDx50qQaefnll/Hdd99hwIAB0Gq1vCapHLjKY3IiIpw7d05Kgnv27EF+/r+fr2q1GsHBwVI16OPjYzJOq+tnstUkPoMhA4cPu0MU9bL1KQhqBAZet9qZRdXFhAkTsHbtWvTq1Qt79+6FIAjYs2cPQkJC4OLigri4OHh6eiodptXjKo+ZW0FBAQ4ePCglwpMnT5q0u7u7IzQ09H9f3XDmjHe1/Ey2msR39epyJCXNK3WmUEUJggYeHgvQsiWvGTOnrKwseHl54ebNm1i/fj1GjhyJjh074ty5c3j//fcxe/ZspUO0alzlMSUUFRXh1KlTOHv2rPR+8ObNm1L7zJmtMGjQzWr5mVy1qT4ySkvbWOYf8ObNwMiRwKBBwOjRQFRU6X2Kog5pad/IFiN7uHr16uHjjz8GAEyfPh1z587FuXPn4OXlxQvVy6DVauHr64t169bB2dkZS5cuxaFDhzjpMbN7++230bVrV/zwww+YOHEiUlNTceLECSxduhShoaHo1SuvzM/k9HRg7lxgyBDg+eeBLVtKv6e1fCZbRcUnikWIiqoBosJSr9u7F/D1BerXL/735cuBTZuABg1K+y4n1KwZBZWKHxeZExFh4sSJOHbsGARBgCiKWLt2rXTmHjN1584drFq1Sjrf0MfHB/Pnz0fr1q0VjozZi7feegsHDhyQ/jsoKAizZs3CE088Ua7PZFEEJkwAevQAXngBuHULmDYNeOstICCg5PuqVM7o1StP0R1erCLx5edfwPHjfhDFvLIvvse4ccWVX8+eJV+j0xVfl5JStRgZY8webN++HSEhXmV+JickAAsWAD///O+v/fADkJwMzJxZcv+CUANdu56Eq6ty7/2togwSRT1UqrI3O9ZqgV9/Be5uYafTAbdvl/49KpUAP792cHPj4z7MLSMjQ5o67ezsDB8fnyovnK1OjEYjkpOTkZGRAQBwdXVFq1at+CgapogLFy4gJyfH5Nfq1KmDDh06QBRzy/xMvnGj+FHn4MH//pooAh07ln5flcpB1gkzlWEViU8Q1CAqfY1IWhqwYkXxl48P4OBQXMmVxdVVg19/3aboTxf2IDMzE15eXgAANzc3pKWlYejQoZg7d67CkVmHuzM2MzIyeMYmswpPPPEE/vzzTwBAp06dMG/ePDz11FMQBAH5+RfK/Exu3Bho2rT4dVNFEBkhCCWvHbQEq/hxXK32AJGh1Gv0//sBoU6d4n/+9Rdw35mOD1VQkIcRIybj008/xblz52AFT3arpVmzZuHWrVvo3bs3Nm/eDABYvHgxzp8/r3Bkyrp9+zZeffVVDBw4EMnJyfD398eJEycwc+ZMTnpMUePGjcPjjz+O//u//0NsbCyGDh0qPaEpz2eylxfg6gr8+CNQUAAYjcWfyYmJpd+XyAC12kOm30XlWMU7PgA4dswH+flnS71m3Tpg2zZApQJCQ4Fz54r/+Z//lPw9ly8Dr7zy7397eHhIe9j169cPde5mUlZpBw8eRM+ePeHk5IRTp07B29sbo0ePxrfffot+/fohIiLCLhev87o8ZsvK85mcng588QVw4gRgMAAtWgBjxwKlzWlzdfVBQEC8zNFWjNUkPnOt46tffxqOH28NrVaLiIgI6f0KADg4OKBbt27S9j1du3at0MGqrHjbss6dOyMuLg7vvfceFi0q3pUhPT0d7dq1Q2ZmJjZt2oSRI0cqHKnl8Lo8Vh2Yb231QrRsOU22PivDahKfwZCJw4eby/zS0xk9eqRKuwSIoojY2FhpseahQ4dQVFQkXV2vXj30799f2r6nRYsWMsZSPS1btgyzZs1CmzZtcObMGZOJGhs2bMDYsWPtaoNqrvJYdWGOz2TeueUh5NwXTqcDfvsNaNx4FubNm/fQjVhzcnKwZ88eKRFevHjRpN3b21uqBnv37g1XV9cqx1WdXL58Ge3bt4dOp4NWq0VoaKhJOxEhODgYUVFReO2117B27VqFIjU/rvJYdcR7dVqAnDuB37lTC0OHZqOoqHhx8MaNGxFQ2qpKABcvXpSS4O7du5Gbmyu1ubi4oFevXlI12KFDB7t8b3UXEWHw4MHYuXMnRowYgR9//PGh1yUkJMDPzw8GgwEHDx5EUFCQhSM1P67yWHXFpzNYiJxnP504cR2jR4/GuXPnIAgCZsyYUWL1dz+DwYDDhw9Lm7nGxMSYzAht2rSpNEmmf//+aNSoUSVitV2//fYbnnnmGdSpUweJiYlwc3Mr8dr33nsPixcvhq+vL2JjY+HkpPxffDlwlcfsAZ/HZyFynvar0+kwd+5crFixAkRU7urvfunp6YiMjIRWq4VWq0VqaqrUplKp0LlzZ6kaDAwMhLOzc4X6tyU5OTnw9vZGSkoKPv/8c/z3v/8t9XqdTgdfX19cunQJy5Ytw4wZMywUqflwlcfsCZ/AbiGiWIikpAVITl4JQFXqzCJBcAUgwt19Kjw85j20lD58+HClq7/7ERHi4uKkanD//v0oKCiQ2mvWrImQkBCpIqxuR/K8+eab+PTTT9GtWzccOnSoXLuzaLVaDBw4EBqNBgkJCfDw8DB/oGbAVR6zV3J/JivJahPfXQZDJlJT1yMt7RvodBegUjlBpXIAkRFEBmg0nnBzG4OmTV8pc6aQXNXf/fLz8xEVFSVVgwkJCSbtrVu3lpJgSEgIateuXaX7Ken48eMICAiAIAiIiYlBp06dyv29zz//PH766Sf85z//wfbt223uHSlXeYzJ+5msGLIhRqOB8vLOU27uGcrLO09Go6FS/Rw6dIjatm1LAEgQBJo1axbpdDrZ4rx27RqtX7+enn32WapXrx4BkL4cHR2pV69e9P7779OxY8eoqKhItvuam8FgoM6dOxMAmjZtWoW/PzU1lerUqUMA6LfffjNDhOaRnZ1N48aNk/4f+vv7U3x8vNJhMaY4uT6TLc2mEp+c8vPzadq0aaRSqQgA+fj40NGjR2W/T1FRER09epQWLlxIPXr0IAcHB5NE2KBBA3ruuedow4YNlJycLPv95bRq1SoCQC1btqQ7d+5Uqo/PP/+cAFCzZs3o9u3bMkcov7///pvc3d0JADk7O9PSpUvJYLCNwc0Yezi7TXx3mbv6u192djb93//9H40fP548PDxMkiAAat++PU2ZMoW0Wi3l5+ebLY6KunbtGtWsWZMA0LZt2yrdj9FopG7duhEAevPNN2WMUF5c5TFWfdl94iOyXPV3P1EU6dy5c/Tpp5/S4MGDqUaNGiZJUK1WU2hoKK1YsYLOnDlDoiiaPaaSDBs2jADQ0KFDq9zXyZMnycHBgQRBoOPHj8sQnby4ymOseuPEdw9LV3/3KygooD179tCsWbOkd2n3fjVv3pzGjBlDP/74I6Wnp1ssrm3bthEAqlmzJl27dk2WPqdOnUoAqHPnzlaTVLjKY8w+cOK7j1LV38PcuHGDNm3aRC+99BK5ubmZJEGVSkX+/v40e/Zs2r9/PxUWFpolhjt37lDLli0JAH388cey9Zubm0stWrQgALRq1SrZ+q0srvIYsx+c+EqgdPV3P1EU6eTJk/Thhx9Sv379yNnZ2SQR1q5dm4YMGUKff/45Xbx4Ubb7Tps2jQDQY489Jnsi+OOPP2SvJCuKqzzG7A8nvlJYU/V3vzt37tCOHTto8uTJ5OXl9cBjUU9PT3r99dfpjz/+oJycnErd4+67OJVKRceOHZP5d1BsyJAhBICGDRtmlv5Lw1UeY/aJE185WFv19zBXrlyhr7/+moYPH05169Z9YO1g79696YMPPqDjx4+T0Wgssz+j0Ujdu3cnAPTGG2+YLe6rV69Ks0W3b99utvvci6s8xuwbJ75ysubq734Gg4EOHz5M8+fPp8DAQBIEwSQRNmzYkJ5//nn65ptvKCUl5aF9fPHFFwSAmjZtStnZ2WaNd+XKlVVeH1heXOUxxjjxVZAtVH/3y8zMpN9++41effVVaaLKvV8dOnSgadOmUUREBOl0OpMdVn755Rezx2cwGMjPz48A0PTp081yD67yGGN3ceKrBFuq/u4niiIlJibSJ598QoMGDSJXV1eTJKjRaKhp06YEgHr16lWux6JyOHr0KKlUKnJwcKBTp07J2jdXeYyxe3HiqwJbrP7up9fradeuXTRjxgzq1KnTA9Wgu7s7jR07ln7++WfKyMgwaywTJ04kANS9e3dZEi5XeYyxh+HEV0W2XP3dLz8/X9pGzc/Pjxo1amSSBAVBoG7dutGcOXPowIEDsldN2dnZUrX55ZdfVqkvrvIYYyXhxCeT6lD9zZ49W9ovtLCwkIxGI8XGxtKSJUuob9++5OTkZJII69SpQ8OGDaMvv/ySLl++LEsMP//8MwGgunXrUlpaWoW/n6s8xlhZOPHJyJarv4SEBCmxHThw4KHX5Obm0vbt22nSpElSkr/3q23btvTGG2/Q9u3bKTc3t1JxiKJIAwcOJAD0wgsvVOh7ucpjjJUHJz4zsLXqTxRFCg4OJgA0bty4cn/f5cuX6csvv6Rhw4ZJs0Dvfjk5OVGfPn1oyZIlFBsbW6F3dhcvXiS1Wk0AKDw8vMzrucpjjFUEJz4zsaXqb+PGjQSAGjVqVOkJLAaDgQ4cOEBz586lbt26PbB2sHHjxjRy5Ej67rvvyvUIc8mSJdIONKX90MBVHmOsojjxmZm1V3+3bt2iBg0aEAD6/vvvZes3IyODfvnlFxo7dqyUmO796tSpE82YMYN27dpFer3+ge8vLCyk9u3bEwCaM2fOA+1c5THGKosTnwVYc/U3ZswYAkD9+vUz23l/oihSfHw8ffzxxzRw4EDSaDQmSdDV1ZUGDRpEn3zyCZ09e1aK48CBA9Jj07Nnz0r9cZXHGKsKTnwWZG3V3759+6Tk8c8//1jsvjqdjiIiImjatGnUoUOHB6rBli1b0quvvkq//vorjRo1igBQcHAwZWVlcZXHGKsyFRERmMXodDrMnTsXK1asABHBx8cHGzduREBAgEXjKCwshJ+fH86ePYv58+dj3rx5Fr3/vVJSUhAREQGtVouIiAikp6dLbSqVCg4ODigqKkKtWrWQm5sLZ2dnLFy4EFOnToWjo6NicTPGbBMnPoUcPnwYo0ePxrlz5yAIAmbMmIF58+ZBrVZb5P4ffPABZs+ejbZt2+L06dNwcXGxyH3LIooiTpw4Aa1WC61Wi4MHD8JoNErtgiCgX79+eOaZZxAWFoaWLVsqGC1jzBZx4lOQUtXfhQsX4Ovri4KCAuzevRt9+/Y16/0qS6vVYuzYsbh+/XqJ13h5eSE0NBRhYWEIDg5GjRo1LBghY8wmKfeUld1lyXd/oijSgAEDCACNGjXKLPeoqofN2Pzzzz+lU+fffvttGjJkCNWqVcvk3aCzszOFhITQsmXL6OTJk2abrMMYs22c+KyEpWZ+bt68mQBQvXr16MaNG7L3X1WlzdicN28eASBvb28qKCigwsJC2r9/P82ePZv8/f2lP7u7X02aNKFRo0bRpk2brPL3yhhTBic+K2PO6i8rK4uaNGlCAOjrr7+WpU+53L59u8wZmzqdjh599FECQIsWLXqgj1u3btFPP/1EY8aMoWbNmj0wW/Sxxx6jWbNm0Z49e6igoMBSvzXGmJXhxGeFzFX9TZgwgQBQjx49LHbOXnlotVpq0aKFVOUtWbKkxHV5u3btIgCkVqvpwoULJfYpiiLFxcXRihUrKDQ0VNoC7e5XjRo1aPDgwfTpp5/SP//8w49FGbMjnPismJzV3+HDh0mlUpGjoyPFxcXJHGnlPKzKK09sL774IgGg0NDQcies/Px80mq1NGXKFGlHmHu/PDw8aPz48bRlyxbKzs6u6m+NMWbFOPFZOTmqv8LCQurYsSMBoFmzZpkp0oqpSJV3vxs3blC9evUIAP3444+Vun9ycjJt2LCBnnvuOapfv75JEnRwcKAePXrQwoUL6ciRI1RUVFSpezDGrBMnPhtRlepv+fLlBIAeeeQRysvLM3OkpatslXe/r776SprAkpWVVaWYioqK6NixY/T+++9Tz549ycHBwSQR1q9fn5599llat24dXbt2rUr3YowpjxOfDalM9ZeUlESurq4EgHbu3GmhSB+uKlXe/YxGI/Xo0YMA0H//+19Z47x9+zb9/vvvNGHCBHrkkUceeCzq4+NDb731Fv3111+K/yDBGKs4Tnw2qLzVnyiK9MQTTxAAeuaZZxSItJhcVd79zpw5Q46OjqRSqejIkSMyRPpw58+fp88++4yefPJJqlmzpkkSdHFxof79+9Py5cvp9OnTPEmGMRvAic9Glaf6+7//+z8CQLVr16br168rEqecVd7DzJw5UzrmyBInNBQUFNDevXvpnXfeoS5dujxQDTZt2pRefvll2rx5M928edPs8TDGKo4Tn40rqfrLycmh5s2bEwD69NNPLR6Xuaq8++Xl5ZGHhwcBoI8++kj2/sty8+ZN+uGHH+jll18mNzc3kySoUqmoS5cu9O6779K+fft47SBjVoITXzXwsOpvxIgRBIC6du1q8VmJ5q7y7rdz507pXL8rV66Y7T5lEUWRTp06RcuXL6f+/fuTi4uLSSKsWbMmPfnkk7RmzRo6f/68YnEyZu94k+pq5N4TH4DiI30OHTqE7t27W+T+OTk5mDp1KtatWwcA8Pf3x8aNG9G+fXuz3/vZZ5/Fr7/+iieffBJ//PGH2e9XHvn5+di/f7900sTZs2dN2lu3bo2wsDCEhoYiJCQEtWvXVihSxuwLJ75q5s6dO/D09MSNGzcAwGInPoSHh2PcuHG4du0anJ2dsWDBAkybNs1i5+WlpKTA29sbOTk5+P333zFkyBCL3Lcirl27hvDwcGi1WkRGRiIrK0tqc3R0RGBgoJQIu3TpAkEQFIyWsWpM2YKTye3TTz8lANS4cWPy9PQ0+4kPlnqXVx53f+/u7u6Uk5OjSAzlVVRUREeOHKEFCxZQUFDQA2sHGzRoQCNGjKANGzZQcnKy0uEyVq1w4qtGrl+/Lh3V8/vvv5v9xAdLv8srS1FREXXt2lU6usiWZGVl0ZYtW+i1116jVq1aPTBb1NfXl6ZMmUJarZby8/OVDpcxm8aJrxp55plnCAA9+eSTJr8u94kP1lTl3S8mJoYEQSBBECg2NlbpcCpFFEX6559/aPXq1fSf//xH2oDg7pdaraawsDBasWIFxcXF8dpBxiqIE181sWPHDunUgYfNbJSr+rO2Ku9h3nrrLcVmtJqDXq+n3bt308yZM+mxxx57oBps3rw5jRkzhn766SdKT09XOlzGrB4nvmqgImvZKlv9WXOVd7+cnBzpMFsl1jCaW1paGn3//fc0atQo6XzFu18qlYr8/f1p9uzZFBUVRYWFhUqHy5jV4cRXDVR095KKVn+2UOXd7+6uNbVq1VJs1xpLMBqNdOLECVq2bBmFhISQs7OzSSKsXbs2DRkyhL744gu6ePGi0uEyZhU48dm4quxXWVb1Z0tV3v2sZZ9SS7tz5w7t2LGD3nzzTWrXrt0Dj0U9PT1p4sSJ9Mcff1j9zFfGzIUTnw0zGo0UFBRUpRMKSqr+bLHKu581nUyhlKSkJPrqq6/o6aefpjp16pgkQScnJwoODqYPPviAjh8/TkajUelwGbMIXsBuw77++mu89tprcHNzw9mzZ1G3bt1K93X/ri93WXL3FXP46KOPMH36dHh4eCA+Ph6urq5Kh6SYoqIiREdHSzvJHDt2DKIoSu2NGjXCgAEDEBoaitDQUDRt2lTBaBkzH058NurmzZvw8vJCVlYWfvzxR4wYMaLKfW7fvh0jR45Ebm4uAKBx48b4/fffERQUVOW+lWIwGNC1a1ecPn0as2bNwpIlS5QOyWpkZWVh165dUiK8du2aSXvHjh0RGhqKsLAw9OzZE2q1WqFIGZMXJz4bNWrUKGzatAmhoaH4+++/oVKpKt3X/Xtsent7Iz8/H1euXIEgCJgxYwbmzZtnsx98R44cQVBQEBwcHHDixAn4+voqHZLVISL8888/UhLcu3cvdDqd1K7RaBAcHIywsDCEhYXBy8urSn/nGFOUgo9ZWSVFRkZKC5kvXLhQpb5Kepdn7l1fLG3ChAkEgHr06MHvsspBr9dTZGQkTZ8+nTp16vTAJJkWLVrQ2LFj6ZdffqHMzEylw2WsQjjx2RidTkePPvooAaBFixZVup/yztiUe9cXpWRlZUlr3r7++mulw7E5KSkp9O2339LIkSOpUaNGJklQEATq1q0bzZ07lw4ePGhzk6CY/eHEZ2PmzZtHAMjb27vSB5tWdMZmdan+Nm/eTACoXr16dOPGDaXDsVlGo5FiYmJo8eLF1KdPH3JycjJJhHXq1KFhw4bR2rVr6fLly0qHy9gDOPHZkMTERGmB8r59+yr8/VVdl2fr1Z8oijRgwAACQKNGjVI6nGojJyeHtm3bRm+88Yb0NOLer7Zt29KkSZPozz//pNzcXKXDZYwTn60QRZFCQkIIAI0ZM6bC3y/Xujxbr/4uXLhAarWaANCuXbuUDqdaunTpEn355Zc0dOhQql279gNrB/v27UtLly6l2NhYft/KFMGJz0Z89913BIAaNmxYoY2IzbX7ii1Xf4sWLZIqEb1er3Q41VphYSEdOHCA5syZQwEBAdIPTHe/GjduTCNHjqTvvvuO0tLSlA6X2QlOfDYgIyNDmlDwzTfflPv7zL37iq1WfwUFBeTt7U0AaP78+UqHY1cyMjLo559/pldeeYWaN2/+wGNRPz8/mjFjBu3atYt/KGFmw4nPBtyt2Pr06VOus9csvcemLVZ/+/btk34g+Oeff5QOxy6Jokjx8fG0cuVKGjhwoPQI+u6Xq6srDRo0iD755BNKTEzkcweZbDjxWbmoqCjp3cjZs2fLvF6pPTZtsfobM2YMAaCQkBD+ULUCOp2OwsPDaerUqdShQ4cHqsFWrVrRq6++Sr/99htlZWUpHS6zYZz4rFhBQQG1b9+eANCcOXNKvdZaTlKwperv1q1b1KBBAwJA33//vdLhsPtcv36dNm7cSM8//zw1bNjwgbWDgYGBNH/+fDp8+HC1OHCYWQ4nPiu2ePFi6SiZ0pKHtZ2kYEvV38aNGwkANWrUiDIyMpQOh5XAaDRSdHQ0ffDBB9S7d29ydHQ0SYR169al4cOH09dff01XrlxROlxm5TjxKchoNFBe3nnKzT1DeXnnyWj8N1ldvHhReucRERHx0O+3liqvJLZQ/YmiSMHBwQSAxo0bp3Q4rJxu375NW7dupddff53atGnzwGNRLy8vmjx5Mu3cuZPu3LmjdLhEVPp4Z5bFm1RbmMGQgdTUDUhL2wid7iJUKieoVA4gMoKoEBqNJ9zcxuCtt7T4/fddeOGFF/DDDz880E94eDjGjRuHa9euwdnZGQsWLMC0adPg6OiowO+qZDqdDnPnzsWKFStARPDx8cHGjRsREBCgdGiSxMREdOzYEQaDAVFRUejZs6fSIbEKunjxIsLDw6HVarF7927phBEAcHZ2Rq9evRAWFobQ0FB07NjRYhtsl3e8N206Fk5O9S0SE+PTGSxGFAuRlLQAyckrAaggiroSr1WpNNDrddi2zQVz5pyHm1sLqe3+kxRs5by8e8/7s8YTH+bMmYNFixahffv2iI2NhbOzs9IhsUoyGAw4cuSIdNJETEwM7v2Yc3Nzk84cHDBgABo3bix7DBUZ74KgAUBwd58CD495EAT+u2dunPgsQK+/ilOn+qOg4DpEMb8C36mGRtMCnTpFQq1uaTNVXkmsufrT6XTo0KEDLl68iCVLlmDWrFlKh8Rkkp6ejsjISGi1WoSHhyMlJcWkvXPnztK5g0FBQVX+oaey410QXOHi0lwa78x8OPGZmV5/FTExXWEwZAIwVqIHBzg61sOvv/bH6tU/AbCdKq8k1lr9RUREIDQ0FBqNBvHx8XjkkUcUjYfJj4gQHx8vVYP79+9HQUGB1F6zZk307dtXSoSenp4mj0UjIyMRHR2N467j/wAADCpJREFUKVOmwMXF5YH+5RjvTk710aXLcU5+ZsSJz4xEsRDR0b7Q6S6hcoPgbj8qXL9OGD/eCXPnLrSpKq8k1lr9vfDCC/jxxx/x+OOPY8eOHXzYajWn0+mwf/9+qRqMj483aX/kkUekJNi3b1+0b98eKSkpCAkJwe+//47atWtL18o13gEHaDSt4e8fD0FwqkI/rCSc+Mzo0qX3kJy86qGPO0aMAKZPB7p0KV9fBoMD6tQZi4CAtTJHqSxrq/7S0tLg5eWF27dv45dffsEzzzyjSBxMGcnJyQgPD0d4eDgiIiKQmZkptQmCAFEUpf/28/PDX3/9BTc3NwClj/eHWboUaNQIGDv2wTZBcIW7+9to3XpR1X5D7KEEpQOorgyGDCQnr6zgO72SOTkZodd/979HKNVHYGAgTp48iWnTpoGIsHTpUnTp0gXHjh1TJB43NzcsXboUADB58mTcvn1bkTiYMtzd3fHKK6/gp59+ws2bN3H06FG8//776NmzJ+6vEU6ePAlPT0+cOHFC9vEuivlITl5R7ca7teDEZyapqRsAyP2YTIXU1PUy96k8jUaD5cuX4+DBg2jbti0SEhIQGBiId955B3q93uLxvPbaa+jevTtSU1Mxe/Zsi9+fWQcHBwcEBARg9uzZiIqKQnBw8APX5OXlYdWqVTzebQwnPjNJS9tY6hRmAEhMBEaPBp54Ali2DCgsLL1PUdQhLe0b2WK0NtZS/QmCgLVr18LBwQFr1qxBdHS0Re/PrFPh/waoi4sL/P398fzzz2Py5MlYs2ZNucb7+fPAa68BgwYBCxbweFcSJz4zEMUi6HQXy7wuMhL48EPghx+Aa9eA778vu2+d7gJEsUiGKK2TtVR/HTt2xNtvvw0iwvjx41FUVH3/zFn5/Pnnn4iLi0Nubi6OHTuGzZs3Y9WqVXB1VZc53g0GYM4cYMAAYNs2oE8fYP/+su9Z3ce7UjjxmYFenwSVquzZWEOHAo0bA7VrAy++COzeXXbfKpUT9Pqkqgdp5ayh+ps/fz5atmyJEydO4LPPPrPYfZl1qlevHtq3bw8nJ9OxXZ7xnpAAFBUBw4cDjo5AcDDg5VX2Pe1lvFsaJz4zEEU9VCqHMq9r1Ojff2/SBEhPL7tvlcoBomj5915KKK36u3ftlbnUqFEDa9asAVC8s0tycrLZ78lsT3nGe0YG0LAhcO/qmCZNyu7bnsa7JXHiMwNBUIOo7HU8t279++83bxYPjLIQGSEI1rHNl6U8rPrr3LmzRd69DR48GMOGDcOdO3fw5ptvmv1+zPaUZ7zXr1/8g+29E0Nv3Ci7b3sc75bAic8M1GoPEBnKvG7r1uLkl5MDbNpU/Ny/LEQGqNUeVY7R1jys+uvevbtFqr9PPvkENWvWxO+//47t27eb9V7M9pRnvLdvDzg4AFu2FD/y3L+/eHJbWex1vJsbJz4zEARHaDRtyryuX7/iRewvvAA0awaMGlV23xqNJwTBtndtqYq71d/UqVMtVv25u7tj0aLihcRvvPEG7ty5Y7Z7MdtTnvHu5AQsXAhotcCTTwJ79gC9epXdt72Pd3PhnVvM5OrV5UhKmlfmFOeKEAQNPDwWomXLabL1acsOHTqEMWPGmOz6Mn/+/IfuoVhVRqMRAQEBiI2NxdSpU/HRRx/Jfg9mu3i82xZOfGZiMGTi8OHmsr6YFgQ1AgOv87ld99DpdJgzZw5Wrlwp7fn5zTffwN/fX/Z7HT9+HN26dYNKpUJMTAw6deok+z2YbeLxblv4UaeZODnVh7v7FAiCqyz9Fe/dN5UHwX00Gg0++ugjHDhwwOzv/rp27YqJEyfCaDRi/PjxMBqrshExq054vNsWrvjMiHdrtyxLVH85OTnw9vZGSkoKPv/8c/z3v/+VrW9m23i82w6u+MxIEJzRqVPk/35qK3td38MVn8/VqVMkD4IyWKL6q127Nj755BMAwDvvvIO0tDRZ+mW2j8e77eDEZ2ZqdUt06XIcGk3rCj8GEQRXaDSt+VDKCgoKCjLrzM+nn34agwYNwu3bt/H222/L0ierHni82wZ+1GkholiIpKQFSE5eCUBV6uyv4gEjwt19Kjw85vFPflVgrpmfSUlJ8PHxgU6ng1arRWhoqEwRs+qAx7t148RnYQZDJlJT1yMt7RvodBegUjlBpXIAkRFEBmg0nnBzG4OmTV/hF9syMde7v2XLlmHWrFlo3bo14uLioNFoZIqYVRc83q0TJz4FiWIR9PokiKIegqCGWu3Bi1XNSO7qz2AwoHPnzoiLi8N7770nLXJn7GF4vFsPTnzMrshd/R06dAg9evSAk5MTTp06BW9vb5kjZozJjSe3MLsi98zPoKAgvPrqqzAYDJgwYQL450jGrB9XfMxuyVX9ZWZmwsvLC7du3cKGDRswZswYM0XMGJMDJz5m9+R497dp0yaMGjUKDRo0QGJiIhqW54wpxpgi+FEns3tyrPsbOXIk+vXrh4yMDEyfPt2M0TLGqoorPsbuUZXq7/z58+jQoQMKCgqwd+9eBAcHWyBixlhFccXH2D2qUv09+uijePfddwEAEyZMMPsBuYyxyuHEx9h9qjLzc+bMmWjXrh0SExOxfPlyC0XMGKsIftTJWCkqM/Nzz549CAkJgYuLC+Li4uDp6WnBiBljZeGKj7H/b+9uXqO64jCOP/dOk8xklYQQHTrImIpMpBIQFSSbJtSFXZiVIEEC1SzMShrdSBfSLsyiWLpwJaRtFsFF/4EsBMEupGoQFZNINEyGhIQEAwGZeyeTObeL2BD7MuMkZ6xwvp/dXM45nFk987tzXsqoVP1FUaTR0VE9evRoq093d7f6+/tVKBQ0ODjI3j7gI0PFB7ynf6v+ent7NTw8rNbWVs3MzKipqUmStLKyokwmo9XVVY2Njamvr29rHI6uAv5fBB9Qpe0rP7cbGhrSjRs3tj6PjIxoYGBAbW1tmpr6Q2/e/KalpV8UBK/+dljx+rbDii9wWDFQYwQfsAP5fF4dHR3K5XJbz2KxmCYnJ3Xw4EFJkjFGJ09+of37f9e5cw3yfb/C9TQJSZFSqaG319PU1/prAE4i+IAdGB8f16lTp/7xvKOjQ5OTk5KkMMzp8eMeFQoLksL3Htv3G9XQ8Kk6O+9wISlQAyxuAXYgk8moq6tLzc3N7zyfnp6WMUZhmNPExFEVCllVE3qSZExeQTCriYmjCsNc5Q4AqkLFB+zS2tqa5ubmdO/ePaVSKZ0+/ZUePvxcQTArqbSLkWNKJNp17NhzbuUGLCL4AMtmZ7/V/PxPMia/67F8v1Gp1Ddqb+eSW8AWgg+wqFh8rfv3UzKmuteb5fh+XCdOLLDaE7CE//gAixYXf5bkWR7V0+LiiOUxAXdR8QEWPXhwSPn8VMV2y8vSzZvS06dSFEk9PdKlS//dvrHxkI4ff25xpoC7OC4CsMSYDQXBq4rtSiXp6lXpyBHp9m0pFpNevCjfJwheypgNTngBLOBVJ2BJGGbleZVXX05PS69fSxcvSomEVF8vHT5cvo/n1SkMs3YmCjiO4AMsMSaU58Uqtltelvbs2az03pfnxawumAFcRvABlvh+XFFUed9eW9tm+JWq2OIXRSX5fnwXswPwF4IPsCQeTyuKihXbZTJSS4t065YUBNL6uvTsWfk+UVRUPJ62M1HAcQQfYInvf6JE4rOK7WIx6fp1aWFBOntWOnNGunu3fJ9E4gALWwBL2M4AWJTL/aBs9lrZWxiq5fsJpdPfa9++K9bGBFxGxQdYlExekGT7t2SkZPK85TEBdxF8gEV1dS1KpYbk+41Wxts8q/Myx5UBFvGqE7DMmHVuZwA+YlR8gGW+X6/Ozjtvq7QqNuu9I6a6uhZ1dt4h9ADLqPiAGgnDnJ48+VKFwkJVVxRxAztQWwQfUEPGrCub/U7z8z9K8squ9tz8X9AolbqsdPoalR5QIwQf8AEUi6taXBzR0tKvCoKX8rw6eV5MUVRSFBWVSBzQ3r1fK5k8z0IWoMYIPuADM2ZDYZiVMaF8P654PM3mdOADIvgAAE5hVScAwCkEHwDAKQQfAMApBB8AwCkEHwDAKQQfAMApBB8AwCkEHwDAKQQfAMApBB8AwCkEHwDAKQQfAMApBB8AwCkEHwDAKQQfAMApBB8AwCkEHwDAKQQfAMApfwLRNMbLrZTLSAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#@title Draw a small DAG using [automatic] shell layout\n",
    "nx.draw_shell(sd,with_labels=True,node_size=500,width=2.0,node_color='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#@title Draw a small DAG, as in Figure 2 (levels-based)\n",
    "limits = plt.axis('off')\n",
    "nx.draw_networkx(sd,\n",
    "                 pos={'a':(2,3),'b':(4.5,3),'c':(1,2),'d':(2,2),'e':(3,2),'f':(4,2),'g':(5,2),'h':(3,1)},\n",
    "                 node_size=500,width=2.0,node_color='y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The drawing of a small DAG: the DAG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>e</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>f</th>\n",
       "      <td>6</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>g</th>\n",
       "      <td>8</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>h</th>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   X  Y\n",
       "a  1  4\n",
       "b  5  1\n",
       "c  2  7\n",
       "d  3  6\n",
       "e  4  5\n",
       "f  6  3\n",
       "g  8  2\n",
       "h  7  8"
      ]
     },
     "execution_count": null,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title Small DAG index as DataFrame\n",
    "sd.x=np.array([1,5,2,3,4,6,8,7])\n",
    "sd.y=np.array([4,1,7,6,5,3,2,8])\n",
    "sd.idx=pd.DataFrame({'X':sd.x,'Y':sd.y},index=sorted(sd.nodes.keys()))\n",
    "sd.idx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The drawing od a small DAG: the related index, where each row represents the coordinate of a vertex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': (1, 4),\n",
       " 'b': (5, 1),\n",
       " 'c': (2, 7),\n",
       " 'd': (3, 6),\n",
       " 'e': (4, 5),\n",
       " 'f': (6, 3),\n",
       " 'g': (8, 2),\n",
       " 'h': (7, 8)}"
      ]
     },
     "execution_count": null,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title Small DAG index as dict\n",
    "#{key: (x,y) for key in sd.idx.index for (x,y) in sd.idx.loc[key].values}\n",
    "sd.pos={}\n",
    "for key in sd.idx.index:\n",
    "  (x,y)=sd.idx.loc[key].values\n",
    "  sd.pos[key]=(x,y)\n",
    "\n",
    "sd.pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1 4\n",
      "b 5 1\n",
      "c 2 7\n",
      "e 4 5\n",
      "f 6 3\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#@title Draw small DAG using weak dominance drawing\n",
    "from matplotlib.patches import Rectangle\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(Rectangle(sd.pos['a'], 8, 5, facecolor=\"lightgrey\",alpha=0.4))\n",
    "\n",
    "for node in sd.nodes:\n",
    "  if sd.out_degree(node) == 0:\n",
    "    continue\n",
    "  (vx,vy)=sd.pos[node]\n",
    "  print(node,vx,vy)\n",
    "  plt.axhline(xmin=vx/9.0,y=vy,color='0.5', ls=':')\n",
    "  plt.axvline(x=vx,ymin=vy/9.0,color='0.7', ls=':')\n",
    "\n",
    "plt.grid(True)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Small DAG: example of dominance regions')\n",
    "plt.xlim(xmin=0,xmax=9)\n",
    "plt.ylim(ymin=0,ymax=9)\n",
    "\n",
    "nx.draw_networkx(sd,pos=sd.pos,\n",
    "                 node_size=500,width=2.0,node_color='y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of dominance regions for the drawing of a small DAG (Figure 3)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Didactic example of search space reduction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<networkx.classes.digraph.DiGraph at 0x7febc2fa8828>"
      ]
     },
     "execution_count": null,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title Create a didactic example of a DAG (a tree)\n",
    "de=nx.DiGraph()\n",
    "de.add_nodes_from([chr(c) for c in range(ord('a'),ord('i')+1)])\n",
    "de.add_edges_from([('a','b'),('a','c'),('a','d'),\n",
    "                   ('b','e'),('b','f'),\n",
    "                   ('c','g'),\n",
    "                   ('d','h'),('d','i')])\n",
    "de"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'e', 'f', 'c', 'g', 'd', 'h', 'i']\n",
      "['a', 'd', 'i', 'h', 'c', 'g', 'b', 'f', 'e']\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#@title Draw a didactic example of a DAG, as in Figure 6 (levels-based)\n",
    "from matplotlib.patches import Rectangle\n",
    "from matplotlib.lines import Line2D\n",
    "\n",
    "plt.axis('off')\n",
    "de.tree={\n",
    "  'a':(3,3),\n",
    "  'b':(1.5,2),'c':(3,2),'d':(4.5,2),\n",
    "  'e':(1,1),'f':(2,1),'g':(3,1),'h':(4,1),'i':(5,1)\n",
    "}\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(Rectangle((2.5,0.5), 1, 3, facecolor=\"grey\",alpha=0.3))\n",
    "ax.add_line(Line2D([2.5,2.5], [0.5,3.5],lw=5., alpha=0.3))\n",
    "ax.add_line(Line2D([3.5,3.5], [0.5,3.5],lw=5., alpha=0.3))\n",
    "\n",
    "nx.draw_networkx(de,\n",
    "                 pos=de.tree,\n",
    "                 node_size=500,width=2.0,node_color='c')\n",
    "\n",
    "o1=list('abefcgdhi')\n",
    "o2=list('adihcgbfe')\n",
    "print(o1)\n",
    "print(o2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This figure shows a didactic example of a DAG and its two topological orderings obtatined by Algorithm 1 in FELINE-index paper. Given a query $r(a,g)$, all vertices after $g$ in first and second table are discarded, This strategy reduces the search space to only vertices $a$, $c$ and $g$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': (0, 0),\n",
       " 'b': (1, 6),\n",
       " 'c': (4, 4),\n",
       " 'd': (6, 1),\n",
       " 'e': (2, 8),\n",
       " 'f': (3, 7),\n",
       " 'g': (5, 5),\n",
       " 'h': (7, 3),\n",
       " 'i': (8, 2)}"
      ]
     },
     "execution_count": null,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "de.pos={v: (x,0) for (x,v) in enumerate(o1)}\n",
    "for (y,v) in enumerate(o2):\n",
    "  de.pos[v]=(de.pos[v][0],y)\n",
    "de.pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#@title Draw a didactic example of a DAG using weak dominance drawing\n",
    "from matplotlib.patches import Rectangle\n",
    "from matplotlib.lines import Line2D\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(Rectangle(de.pos['a'],\n",
    "                       de.pos['g'][0] - de.pos['a'][0],\n",
    "                       de.pos['g'][1] - de.pos['a'][1],\n",
    "                       facecolor=\"grey\",alpha=0.35))\n",
    "ax.add_line(Line2D([de.pos['g'][0],de.pos['g'][0]],\n",
    "                   [de.pos['g'][1],de.pos['a'][1]],\n",
    "                   lw=5., alpha=0.3))\n",
    "ax.add_line(Line2D([de.pos['g'][0],de.pos['a'][0]],\n",
    "                   [de.pos['g'][1],de.pos['g'][1]],\n",
    "                   lw=5., alpha=0.3))\n",
    "\n",
    "  \n",
    "plt.axvline(x=de.pos['a'][1],color='0.5', ls=':')\n",
    "plt.axhline(y=de.pos['a'][0],color='0.5', ls=':')\n",
    "\n",
    "plt.grid(True)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Didactic example of a DAG: search space of FELINE')\n",
    "plt.xlim(xmin=-1,xmax=9)\n",
    "plt.ylim(ymin=-1,ymax=9)\n",
    "\n",
    "nx.draw_networkx(de,pos=de.pos,\n",
    "                 node_size=500,width=2.0,node_color='c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pruning behavior of FELINE (see Figure 7)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax=plt.gca()\n",
    "ax.add_patch(Rectangle(de.pos['a'],\n",
    "                       de.pos['g'][0] - de.pos['a'][0],\n",
    "                       9 - de.pos['a'][1],\n",
    "                       facecolor=\"grey\",alpha=0.35))\n",
    "ax.add_line(Line2D([de.pos['g'][0],de.pos['g'][0]],\n",
    "                   [0,9],\n",
    "                   lw=5., alpha=0.3))\n",
    "#ax.add_line(Line2D([de.pos['g'][0],de.pos['a'][0]],\n",
    "#                   [de.pos['g'][1],de.pos['g'][1]],\n",
    "#                   lw=5., alpha=0.3))\n",
    "\n",
    "  \n",
    "plt.axvline(x=de.pos['a'][1],color='0.5', ls=':')\n",
    "plt.axhline(y=de.pos['a'][0],color='0.5', ls=':')\n",
    "\n",
    "plt.grid(True)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Didactic example of a DAG: search space of FERRARI\\n(topological ordering x)')\n",
    "plt.xlim(xmin=-1,xmax=9)\n",
    "plt.ylim(ymin=-1,ymax=9)\n",
    "\n",
    "nx.draw_networkx(de,pos=de.pos,\n",
    "                 node_size=500,width=2.0,node_color='c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimizations: Level Filter (negative-cut)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **level** of a vertex $v$ (denoted as $l_v$) can be defined as its depth: if $v$ has no immediate predecessors, then $l_v = 0$, otherwise it is maximum of levels of its immediate predecessors plus one: $l_v = \\max\\limits_{u\\colon (v,u)\\in E}(l_u)+1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<networkx.classes.digraph.DiGraph at 0x7febc303c940>"
      ]
     },
     "execution_count": null,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title Create an example for level-filter\n",
    "lf=nx.DiGraph()\n",
    "lf.add_nodes_from([chr(c) for c in range(ord('a'),ord('i')+1)])\n",
    "lf.add_edges_from([('a','c'),('a','d'),('a','e'),\n",
    "                   ('b','f'),\n",
    "                   ('d','g'),\n",
    "                   ('e','h'),\n",
    "                   ('f','g'),('f','i')])\n",
    "lf.lvl={\n",
    "    'g':0,'h':0,'i':0,\n",
    "    'c':1,'d':1,'e':1,'f':1,\n",
    "    'a':2,'b':2\n",
    "}\n",
    "lf.fel={\n",
    "    'a':(1,4),'b':(6,1),'c':(2,9),'d':(3,7),'e':(4,5),\n",
    "    'f':(7,2),'g':(8,8),'h':(5,6),'i':(9,3),\n",
    "}\n",
    "lf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-8ddf52e2eb54>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     12\u001b[0m                  \u001b[0mnode_color\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlvl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGreens\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m                  \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m                  node_size=500,width=2.0)\n\u001b[0m\u001b[1;32m     15\u001b[0m labels=nx.draw_networkx_labels(lf,\n\u001b[1;32m     16\u001b[0m                                \u001b[0mpos\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m0.21\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m0.04\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtree\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\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;32m/usr/local/lib/python3.6/dist-packages/networkx/drawing/nx_pylab.py\u001b[0m in \u001b[0;36mdraw_networkx\u001b[0;34m(G, pos, arrows, with_labels, **kwds)\u001b[0m\n\u001b[1;32m    324\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mvalid_kwds\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m]\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[1;32m    325\u001b[0m         \u001b[0minvalid_args\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\", \"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mkwds\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mvalid_kwds\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;32m--> 326\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Received invalid argument(s): {invalid_args}\"\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    327\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    328\u001b[0m     \u001b[0mnode_kwds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mv\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mvalid_node_kwds\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: Received invalid argument(s): nodes"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADKUlEQVR4nO3UMQEAIAzAMMC/5+GiHCQKenXPzAKgcV4HAPzEdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIGS6ACHTBQiZLkDIdAFCpgsQMl2AkOkChEwXIHQBcjcEy3+fc28AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#@title Draw an example DAG for levels-filter, as in Figure 9 (levels-based)\n",
    "plt.axis('off')\n",
    "lf.tree={\n",
    "  'a':(2,2),'b':(4,2),\n",
    "  'c':(1,1),'d':(2,1),'e':(3,1),'f':(4,1),\n",
    "  'g':(2,0),'h':(3,0),'i':(4,0)\n",
    "}\n",
    "plt.ylabel('level')\n",
    "nx.draw_networkx(lf,\n",
    "                 pos=lf.tree,\n",
    "                 nodes=lf.lvl.keys(),\n",
    "                 node_color=list(lf.lvl.values()),cmap=plt.cm.Greens,\n",
    "                 vmin=-2,vmax=5,\n",
    "                 node_size=500,width=2.0)\n",
    "labels=nx.draw_networkx_labels(lf,\n",
    "                               pos={k: (v[0]+0.21,v[1]-0.04) for (k,v) in lf.tree.items()},\n",
    "                               labels=lf.fel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw an example DAG for levels-filter, corrected (levels-based)\n",
    "plt.axis('off')\n",
    "lf.lvl['c']=0\n",
    "lf.tree['c']=(1,0)\n",
    "plt.ylabel('level')\n",
    "nx.draw_networkx(lf,\n",
    "                 pos=lf.tree,\n",
    "                 nodes=lf.lvl.keys(),\n",
    "                 node_color=list(lf.lvl.values()),cmap=plt.cm.Greens,\n",
    "                 vmin=-2,vmax=5,\n",
    "                 node_size=500,width=2.0)\n",
    "labels=nx.draw_networkx_labels(lf,\n",
    "                               pos={k: (v[0]+0.21,v[1]-0.04) \n",
    "                                    for (k,v) in lf.tree.items()},\n",
    "                               labels=lf.fel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example where the vertex $h$ does not reach $g$, but there is false-implied path between them ($g$ is in domination area of $h$, because $(5,6) \\preceq (8,8)$). However, $g$ and $h$ are in the same level, and the ***level filter*** prune the search.  The numbers represents the coordinates attributed by FELINE. The vertical height and the color represents level of vertex."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw an example DAG for levels-filter, using weak dominance drawing\n",
    "from matplotlib.patches import Rectangle, FancyArrowPatch\n",
    "from matplotlib.lines import Line2D\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(Rectangle(lf.fel['h'],\n",
    "                       #lf.fel['g'][0] - lf.fel['h'][0],\n",
    "                       #lf.fel['g'][1] - lf.fel['h'][1],\n",
    "                       10 - lf.fel['h'][0],\n",
    "                       10 - lf.fel['h'][1],\n",
    "                       facecolor=\"grey\",alpha=0.35))\n",
    "\n",
    "ax.add_patch(\n",
    "    FancyArrowPatch(lf.fel['h'],lf.fel['g'],\n",
    "                    shrinkA=15,shrinkB=15,\n",
    "                    arrowstyle='fancy',mutation_scale=18,\n",
    "                    linestyle='dashed',hatch='\\\\',color='orange')\n",
    ")\n",
    "  \n",
    "#plt.axvline(x=lf.fel['h'][0],color='0.4', ls=':')\n",
    "#plt.axhline(y=lf.fel['h'][1],color='0.4', ls=':')\n",
    "\n",
    "plt.grid(True)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Example of false-implied path pruned by level filter')\n",
    "plt.xlim(xmin=0,xmax=10)\n",
    "plt.ylim(ymin=0,ymax=10)\n",
    "\n",
    "nx.draw_networkx(lf,pos=lf.fel,\n",
    "                 node_size=500,width=2.0,\n",
    "                 nodes=lf.lvl.keys(),\n",
    "                 node_color=list(lf.lvl.values()),cmap=plt.cm.Greens,\n",
    "                 vmin=-2,vmax=5)\n",
    "labels=nx.draw_networkx_labels(lf,\n",
    "                               pos={k: (v[0]-0.60,v[1]+0.35) for (k,v) in lf.fel.items()},\n",
    "                               labels={k:'$l_'+str(k)+'='+str(l)+'$'\n",
    "                                       for (k,l) in lf.lvl.items()})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example where the vertex $h$ does not reach $g$, but there is false-implied path (orange) between them ($g$ is in domination area of $h$, shown as the gray area). However, $g$ and $h$ are in the same level: $l_g = l_h = 0$, and the ***level filter*** prune the search.  The labels and the color represents level of vertex."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Could not get toolkit for 3D visualization does not work, unfortunately.\n",
    "# https://networkx.github.io/documentation/latest/auto_examples/3d_drawing/mayavi2_spring.html\n",
    "#!apt-get -qq install -y vtk python-vtk\n",
    "#!pip install -q vtk\n",
    "#!pip install -q PyVTK\n",
    "#!pip install -q mayavi\n",
    "#from mayavi import mlab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimizations: _min-post_ interval (positive-cut filter)\n",
    "\n",
    "This strategy utilizes a *spanning-tree* of a DAG (or rather a spanning-forest or [arborescence](https://en.wikipedia.org/wiki/Arborescence_%28graph_theory%29)), for example a depth-first search or breadth-first search tree.\n",
    "\n",
    "The *min-post* strategy is used by GRAIL (Graph Reachability indexing via rAndomized Interval Labeling) online search approach.  *Min-post* strategy creates a unique interval $I_u = [s_u, e_u]$ for each vertex $u$, where $s_u$ and $e_u$ denote the start and the end of the interval.  The ending value $e_u$ is defined as $e_u = post(u)$, that is the post-order value of vertex $u$.  The starting value $s_u$ is defined as $e_u$ if $u$ is a leaf, and $s_u = \\min\\{s_x| x \\in children(u)\\}$ if $u$ is not a leaf.\n",
    "\n",
    "In other words, interval labeling (*min-post* strategy) labels each node $u$ with a range $I_u = [s_u, e_u]$, where $e_u$ denotes the rank of the node $u$ in a post-order traversal of the tree, where the ranks are assumed to begin at 1, and all the children of a node are assumed to be ordered and fixed for that traversal. Further, $s_u$ denotes the lowest rank for any node $x$ in the subtree rooted at $u$ (i.e., including $u$).\n",
    "\n",
    "For these paths restricted to tree edges, reachability can be guaranteed (only positive queries).  Thus, if $I_v \\subseteq I_u$, we can conclude that $u$ reaches $v$. However, we can state nothing about non-tree edges. Interval takes linear time and space for constructing the index, and provides constant time querying.\n",
    "\n",
    "See: *\"[GRAIL: Scalable reachability index for large graphs](https://www.researchgate.net/profile/Mohammed_Zaki4/publication/220538786_GRAIL_Scalable_reachability_index_for_large_graphs/links/542970020cf238c6ea7f2eed/GRAIL-Scalable-reachability-index-for-large-graphs.pdf)\"* (PDF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw a small DAG and its spanning-tree, as in Figure 8\n",
    "from copy import deepcopy\n",
    "\n",
    "plt.axis('off')\n",
    "plt.title('Small DAG with the spanning tree overlay and min-post intervals')\n",
    "sd.tree={\n",
    "  'a':(2,3),'b':(4.5,3),\n",
    "  'c':(1,2),'d':(2,2),'e':(3,2),'f':(4,2),'g':(5,2),\n",
    "  'h':(3,1)\n",
    "}\n",
    "nx.draw_networkx(sd,\n",
    "                 pos=sd.tree,\n",
    "                 node_size=500,width=8.0,\n",
    "                 edge_color='#aaaaaa',node_color='y')\n",
    "edges=nx.draw_networkx_edges(sd,\n",
    "                             pos=sd.tree,\n",
    "                             edgelist=[\n",
    "                               ('a','c'),('a','d'),('a','e'),\n",
    "                               ('e','h'),\n",
    "                               ('b','f'),('b','g')\n",
    "                             ],\n",
    "                             node_size=500,width=2.0,\n",
    "                             arrowstyle='->')\n",
    "\n",
    "sd.lpos=deepcopy(sd.tree)\n",
    "for v in list('abh'):\n",
    "  sd.lpos[v] = (sd.lpos[v][0]+0.30,sd.lpos[v][1])\n",
    "for v in list('cdfg'):\n",
    "  sd.lpos[v] = (sd.lpos[v][0]+0.05,sd.lpos[v][1]-0.2)\n",
    "for v in list('e'):\n",
    "  sd.lpos[v] = (sd.lpos[v][0]+0.25,sd.lpos[v][1]+0.1)\n",
    "sd.mpi={\n",
    "    'a':(1,5),'b':(7,9),\n",
    "    'c':(1,1),'d':(2,2),'e':(3,4),'f':(7,7),'g':(8,8),\n",
    "    'h':(3,3),\n",
    "}\n",
    "sd.mpi_labels={\n",
    "  v:('[%d,%d]'%(i[0],i[1]))\n",
    "  for (v,i) in sd.mpi.items()\n",
    "}\n",
    "\n",
    "labels=nx.draw_networkx_labels(sd,\n",
    "                               pos=sd.lpos,\n",
    "                               labels=sd.mpi_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Min-post indexing for a spanning tree extracted from the small DAG of Figure 2.  Each vertex is labeled with its *min-post* interval. Original edges of the DAG are marked in light gray.\n",
    "\n",
    "For instance, consider the vertex $h$ of above figure.  We can conclude that the query $r(a,h)$ will return true, without search, because $[3,3] \\subseteq  [1,5]$.  However, we can say nothing about the query $r(b,h)$, because there is no tree edge connecting the two vertices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plt.axis('off')\n",
    "plt.title('Small DAG with the spanning tree overlay and min-post intervals\\n'+\n",
    "          'drawn using spanning tree position and levels')\n",
    "sd.lvl = {\n",
    "    'h': 0, 'g': 0, 'd': 0,\n",
    "    'c': 1, 'e': 1, 'f': 1,\n",
    "    'a': 2, 'b': 2,\n",
    "}\n",
    "sd.mpilvl={\n",
    "  v: (sd.mpi[v][1],sd.lvl[v]) for v in sd\n",
    "}\n",
    "plt.xlabel('spanning-tree post-order $\\phi(v)$')\n",
    "plt.ylabel('node level $L(v)$')\n",
    "\n",
    "ax=plt.gca()\n",
    "for v in sd:\n",
    "  if sd.mpi[v][0] == sd.mpi[v][1]:\n",
    "    continue\n",
    "  ax.add_line(Line2D([sd.mpi[v][0],sd.mpi[v][1]],\n",
    "                     [sd.lvl[v],sd.lvl[v]],\n",
    "                     lw=5., alpha=0.3))\n",
    "  \n",
    "nx.draw_networkx(sd,\n",
    "                 pos=sd.mpilvl,\n",
    "                 node_size=500,width=8.0,\n",
    "                 edge_color='#aaaaaa',node_color='y')\n",
    "edges=nx.draw_networkx_edges(sd,\n",
    "                             pos=sd.mpilvl,\n",
    "                             edgelist=[\n",
    "                               ('a','c'),('a','d'),('a','e'),\n",
    "                               ('e','h'),\n",
    "                               ('b','f'),('b','g')\n",
    "                             ],\n",
    "                             node_size=500,width=2.0,\n",
    "                             arrowstyle='->')\n",
    "\n",
    "labels=nx.draw_networkx_labels(sd,\n",
    "                               pos={u:(x+0.5,y-0.08) for (u,(x,y)) in sd.mpilvl.items()},\n",
    "                               labels=sd.mpi_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimization: min-post / pre-max DFS interval (positive-cut and negative-cut)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Create an example from PReaCH { form-width: \"30%\" }\n",
    "ch=nx.DiGraph()\n",
    "ch.add_edges_from([('a','e'),\n",
    "                   ('b','e'),('b','f'),('b','g'),\n",
    "                   ('c','h'),('c','i'),\n",
    "                   ('d','i'),\n",
    "                  \n",
    "                   ('e','j'),\n",
    "                   ('f','o'),('f','k'),\n",
    "                   ('g','l'),\n",
    "                   ('h','l'),\n",
    "                   ('i','m'),('i','n'),\n",
    "                   \n",
    "                   ('j','o'),('j','p'),\n",
    "                   ('k','p'),\n",
    "                   ('l','q'),\n",
    "                   ('m','q'),\n",
    "                  ])\n",
    "ch.lvl={\n",
    "    'o':0,'p':0,'q':0,'n':0,\n",
    "    'j':1,'k':1,'l':1,'m':1,'i':1,\n",
    "    'e':2,'f':2,'g':2,'h':2,'d':2,\n",
    "    'a':3,'b':3,'c':3,\n",
    "}\n",
    "ch.pos={\n",
    "    'a':(0,0),'b':(1,0),          'c':(3,0),'d':(4,0),\n",
    "    'e':(0,1),'f':(1,1),'g':(2,1),'h':(3,1),'i':(4,1),\n",
    "    'j':(0,2),'k':(1,2),'l':(2,2),'m':(3,2),'n':(4,2),\n",
    "    'o':(0,3),'p':(1,3),          'q':(3,3),          \n",
    "}\n",
    "\n",
    "plt.axis(\"off\")\n",
    "plt.title('Example graph from PReaCH paper '+\n",
    "          '(Figures 1 and 2)')\n",
    "nx.draw_networkx(ch,pos=ch.pos,\n",
    "                 node_size=500,width=2.0,node_color='m')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Section 3.3 \"*Pruning Based on DFS Numbering*\" in the PReaCH paper.**\n",
    "\n",
    "Let $\\phi(v)$ denote the DFS number of node $v$ and $\\hat{\\phi}(v)$ the largest DFS number of a node\n",
    "in the subtree of the DFS tree rooted at $v$. The properties of DFS ensure that the nodes in\n",
    "$\\text{range}(v) := \\phi(v)..\\hat{\\phi}(v)$ are all reachable from $v$ (they form the subtree of the DFS tree which\n",
    "is rooted at $v$) and that no nodes with DFS number exceeding $\\hat{\\phi}(v)$ is reachable from $v$.\n",
    "\n",
    "Let $u \\to v$ denote that $r(u,v)$ is true, and $u \\nrightarrow v$ that $r(u,v)$ is false.\n",
    "\n",
    "\n",
    "*   $\\forall v,t \\in V \\colon\\ t \\in \\text{range}(v) \\implies v \\to t$  \n",
    "    (positive-cut)\n",
    "*   $\\forall v,t \\in V \\colon\\ \\phi(t) > \\hat{\\phi}(v) \\implies v \\nrightarrow t$  \n",
    "    (negative-cut)\n",
    "\n",
    "Let's define node $w = p_{\\text{tree}}(v)$ as the node that has $v \\to w$ and $w \\notin \\text{range}(v)$\n",
    "which maximizes $\\lvert\\text{range}(w)\\rvert$.  Then, if $p_{\\text{tree}}(v)$ exists\n",
    "\n",
    "*   $\\forall v,t \\in V \\colon\\ p_{\\text{tree}}(v) \\neq \\bot \\land t \\in \\text{range}(p_{\\text{tree}}(v)) \\implies v \\to t$  \n",
    "    (positive-cut)\n",
    "    \n",
    "For any $v \\in V$, let $\\phi_{\\text{min}}(v)$ denote the smallest DFS number of a node reachable from $v$ (including $v$). Then\n",
    "\n",
    "*   $\\forall v,t \\in V \\colon\\ \\phi(t) < \\phi_{\\text{min}}(v) \\implies v \\nrightarrow t$  \n",
    "    (negative-cut)\n",
    "    \n",
    "We can also define $\\phi_{\\text{gap}}(v)$ in such way that\n",
    "\n",
    "*   $\\forall v,t \\in V \\colon\\ \\phi_{\\text{gap}}(v) < \\phi(t) < \\phi(v) \\implies v \\nrightarrow t$  \n",
    "    (negative-cut)\n",
    "    \n",
    "All those values: $\\phi(v), \\hat{\\phi}(v), p_{\\text{tree}}(v), \\phi_{\\text{min}}(v), \\phi_{\\text{gap}}(v)$ can be done while computing the DFS numbering."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**On choosing the DFS spanning-tree from PReaCH paper**\n",
    "\n",
    "There are many ways to define a DFS ordering: We are free to choose the order in\n",
    "which we scan the nodes for starting recursive exploration and we can choose the order in\n",
    "which we inspect edges leaving a node being explored.\n",
    "\n",
    "One heuristics that seems to be useful: Make sure that most nodes are in a small number of trees because this leads to large positive intervals. It therefore makes sense to only uses sources of the graph as tree roots.\n",
    "\n",
    "In addition, one can order the sources by the number of nodes reached from them during the search for topological levels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimization: Reachability Contraction Hierarchies (from PReaCH)\n",
    "\n",
    "In general, a _Reachability Contraction Hierarchy_ (RCH) can be defined based on any numbering\n",
    "order : $V \\mapsto 1..n$. We successively contract nodes with increasing $\\text{order}(v)$. Contracting\n",
    "node $v$ means removing it from the graph and possibly inserting new edges such that the\n",
    "reachability relation in the new graph is the same as in the previous graph, i.e., if the graph\n",
    "contains a path $\\langle u, v, w \\rangle$ and after removing $v$, $u$ would no longer be reachable from $v$, we\n",
    "have to insert a new *shortcut edge* $(u,w)$. The query algorithm \n",
    "(a variant of the bidirectional BFS) does not use the contracted\n",
    "versions of the graph but only the ordering and the shortcuts.\n",
    "\n",
    "One can exploit the fact that any DAG contains source nodes (with in-degree zero) and\n",
    "sink nodes (with out-degree zero). Contracting such a node $v$ never requires the insertion of\n",
    "shortcuts because shortcuts always bridge paths of the form $\\langle u, v, w \\rangle$ but such paths cannot\n",
    "exist because $v$ either lacks incoming or outcoming edges. Hence from now on we restrict the\n",
    "considered orderings such that they only contract source or sink nodes. This implies a huge\n",
    "simplification and acceleration of preprocessing compared to general RCHs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ch.labels = {\n",
    "    'a':  1, 'b': 11, 'c':  7, 'd':  2,\n",
    "    'e': 14, 'f': 13, 'g': 12, 'h':  9, 'i': 17,\n",
    "    'j': 15, 'k':  8, 'l': 16, 'm': 10, 'n':  3,\n",
    "    'o':  4, 'p':  5, 'q':  6,\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Figure 1 from PReaCH paper, with contraction hierarchy { form-width: \"30%\" }\n",
    "interpolation = \"bicubic\" #@param [\"none\", \"nearest\", \"bilinear\", \"bicubic\", \"spline16\", \"spline36\", \"hanning\", \"hamming\", \"hermite\", \"kaiser\", \"quadric\", \"catrom\", \"gaussian\", \"bessel\", \"mitchell\", \"sinc\", \"lanczos\"]\n",
    "#fig = plt.gcf()\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches(10, 8)\n",
    "plt.axis(\"off\")\n",
    "plt.title('Example graph from PReaCH paper '+\n",
    "          '(Figure 1)')\n",
    "oxy=np.full((4,5),np.nan)\n",
    "for n in ch.labels:\n",
    "  oxy[ch.pos[n][1],ch.pos[n][0]] = ch.labels[n]\n",
    "oxy[np.isnan(oxy)] = 0\n",
    "plt.imshow(oxy,\n",
    "           origin='lower',\n",
    "           # https://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.imshow.html\n",
    "           # https://matplotlib.org/gallery/images_contours_and_fields/interpolation_methods.html\n",
    "           interpolation=interpolation,\n",
    "           #cmap=plt.cm.Purples,\n",
    "           cmap=plt.cm.terrain,\n",
    "           #vmin=-8,vmax=len(ch)*2,\n",
    "           alpha=0.4)\n",
    "nx.draw_networkx(ch,pos=ch.pos,\n",
    "                 edges=ch.edges(),\n",
    "                 edge_color=['g' if ch.labels[u] < ch.labels[v] else 'b'\n",
    "                             for (u,v) in ch.edges()],\n",
    "                 node_size=400,width=2.0,\n",
    "                 #node_color='#C8A2C8'\n",
    "                 node_color=[ch.labels[n] for n in ch.nodes()],\n",
    "                 cmap=plt.cm.Purples,\n",
    "                 vmin=-8,vmax=len(ch)*2)\n",
    "nx.draw_networkx_nodes(ch,pos=ch.pos,\n",
    "                       nodelist=['e','q'],\n",
    "                       node_color=['#dd4444','#ff0044'],\n",
    "                       node_size=500,width=2.0)\n",
    "nx.draw_networkx_edges(ch,pos=ch.pos,\n",
    "                       edgelist=[('e','j'),('l','q'),('m','q'),('i','m')],\n",
    "                       edge_color=['g','b','b','b'],\n",
    "                       width=8.0,alpha=0.5)\n",
    "nx.draw_networkx_labels(ch,\n",
    "                        pos={u:(x+0.18,y-0.02) for (u,(x,y)) in ch.pos.items()},\n",
    "                        labels=ch.labels,\n",
    "                        font_size=15,font_weight='bold')\n",
    "nx.draw_networkx_labels(ch,\n",
    "                        pos={u:(x-0.16,y+0.03) for (u,(x,y)) in ch.pos.items()},\n",
    "                        labels={'e': '$s$', 'q': '$t$'},\n",
    "                        font_size=15,font_color='r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Figure 1** in PReaCH paper:\n",
    "\n",
    "Example RCH. Edges in the forward search space are \\[light\\] green and those in the\n",
    "backward search space are \\[dark\\] blue. The search spaces for a query from $s$ to $t$ are ~~circled~~ bolded.\n",
    "Node labels specify the node ordering.\n",
    "\n",
    "Forward search can only consider edges in ascending order of contraction hierarchy; backward search can only consider reverse edges in ascending order (edges in descending order)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algorithms\n",
    "\n",
    "This section includes Python implementations of algorithms for calculating:\n",
    "\n",
    "* node level (also known as generation number)\n",
    "* spanning forest (arborescence)\n",
    "* min-post intervals for spanning tree / spanning forest\n",
    "* topological sort\n",
    "* FELINE index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Starter / preliminary algorithms\n",
    "\n",
    "Those are needed to begin work on other algorithms, or draw graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def order_to_pos { form-width: \"30%\" }\n",
    "# define helper function for calculating FELINE index with Algorithm 1\n",
    "def order_to_pos(list,start=0):\n",
    "  \"\"\"Turn sorted list into dict values are position on list\n",
    "  \n",
    "  Given sorted list of values [x_0, x_1, x_2,...,x_n] return a dictionary,\n",
    "  where keys are elements the list and values are their original positions\n",
    "  in the sort order given by the list: {x_0: 0, x_1: 1,..., x_n: n}.\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  list\n",
    "      Sorted list of [hashable] elements, e.g. nodes in a graph.\n",
    "      \n",
    "  start : number\n",
    "      Staring number (ffor first position on list).\n",
    "      \n",
    "  Returns:\n",
    "  --------\n",
    "  dict\n",
    "      Dictionary where keys are elements and values their positions on list.\n",
    "  \"\"\"\n",
    "  return {\n",
    "    elem: pos\n",
    "    for (pos,elem) in enumerate(list,start=start)\n",
    "  }\n",
    "\n",
    "# test order_to_pos() helper function\n",
    "order_to_pos(list('abcdefgh'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "order_to_pos(list('12345'),start=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tips / heads\n",
    "\n",
    "Find all nodes with no in-nodes (tips / heads in version control terminology).\n",
    "\n",
    "Note that \"tips\" or \"heads\" in commit graph (in version control) are \"roots\" or \"sources\" of the graph;  \n",
    "and that \"roots\" in commit graph (parentless commits) are \"leaves\" or \"sinks\" of the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def find_heads(G)\n",
    "def find_heads(G):\n",
    "  \"\"\"Find all nodes with no in-nodes in DAG graph G\"\"\"\n",
    "  return [n for n in G if G.in_degree(n) == 0]\n",
    "\n",
    "def find_roots(G):\n",
    "  \"\"\"Find all nodes with no out-nodes in DAG graph G\"\"\"\n",
    "  return [n for n in G if G.out_degree(n) == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test that it works on known graphs from previous part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Test find_heads on a crown DAG known as $S_3^0$ graph\n",
    "find_heads(DG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_roots(DG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Test find_heads on a small DAG\n",
    "find_heads(sd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Test find_heads on a didactic example of a DAG\n",
    "find_heads(de)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Test find_heads on example from PReaCH paper\n",
    "find_heads(ch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_roots(ch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Spanning tree / spanning forest\n",
    "\n",
    "These are directed spanning trees (a forest) for a directed acyclic graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title flatten lambda { form-width: \"30%\" }\n",
    "# https://stackoverflow.com/questions/952914/making-a-flat-list-out-of-list-of-lists-in-python\n",
    "flatten = lambda l: [item for sublist in l for item in sublist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def find_dfs_spanning(G) { form-width: \"30%\" }\n",
    "def find_dfs_spanning_overlap(G):\n",
    "  # this does not find disjoint trees (a forest)\n",
    "  return flatten(nx.dfs_edges(G, source=n) \n",
    "                 for n in find_heads(G))\n",
    "\n",
    "def find_dfs_spanning(G):\n",
    "  \"\"\"Find edges of the DFS spanning tree for graph G\n",
    "  \n",
    "  Parameters\n",
    "  ----------\n",
    "  G : NetworkX graph\n",
    "      Graph to find spanning-tree in.\n",
    "  \n",
    "  Returns\n",
    "  -------\n",
    "  edges : list\n",
    "      A list of edges in the depth-first-search.\n",
    "\n",
    "  Examples\n",
    "  --------\n",
    "  >>> G = nx.path_graph(5)\n",
    "  >>> find_dfs_spanning(G)\n",
    "  [(0, 1), (1, 2), (2, 3), (3, 4)]\n",
    "  \n",
    "  Notes\n",
    "  -----\n",
    "  The source is chosen arbitrarily and repeatedly until all\n",
    "  components in the graph are searched.\n",
    "  \"\"\"\n",
    "  # this may not cover all nodes\n",
    "  return list(nx.dfs_edges(G))\n",
    "\n",
    "\n",
    "find_dfs_spanning(nx.path_graph(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_dfs_spanning(sd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw a small DAG and its find_dfs_spanning\n",
    "plt.axis('off')\n",
    "plt.title('Small DAG with the spanning tree overlay '+\n",
    "          '(find_dfs_spanning)')\n",
    "nx.draw_networkx(sd,\n",
    "                 pos=sd.tree,\n",
    "                 node_size=500,width=8.0,\n",
    "                 edge_color='#aaaaaa',node_color='y')\n",
    "edges=nx.draw_networkx_edges(sd,\n",
    "                             pos=sd.tree,\n",
    "                             edgelist=find_dfs_spanning(sd),\n",
    "                             node_size=500,width=2.0,\n",
    "                             arrowstyle='->')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw a didactic example of a DAG and its find_dfs_spanning\n",
    "plt.axis('off')\n",
    "plt.title('Didactic example of a DAG '+\n",
    "          'with the DFS spanning-tree overlay')\n",
    "nx.draw_networkx(de,\n",
    "                 pos=de.tree,\n",
    "                 width=8.0,edge_color='#aaaabb',\n",
    "                 node_size=500,node_color='c')\n",
    "edges=nx.draw_networkx_edges(de,\n",
    "                             pos=de.tree,\n",
    "                             edgelist=find_dfs_spanning(de),\n",
    "                             node_size=500,width=2.0,\n",
    "                             arrowstyle='->')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw DAG from level-filter example and its find_dfs_spanning\n",
    "plt.axis('off')\n",
    "plt.title('DAG from level-filter example\\n'+\n",
    "          'drawn using level-draw and level colormap\\n'+\n",
    "          'with DFS spanning tree overlay')\n",
    "nx.draw_networkx(lf,\n",
    "                 pos=lf.tree,\n",
    "                 nodes=lf.lvl.keys(),\n",
    "                 node_size=500,node_color=list(lf.lvl.values()),\n",
    "                 cmap=plt.cm.Greens,vmin=-2,vmax=5,\n",
    "                 width=8.0,edge_color='#aabaaa')\n",
    "edges=nx.draw_networkx_edges(lf,\n",
    "                             pos=lf.tree,\n",
    "                             edgelist=find_dfs_spanning(lf),\n",
    "                             node_size=500,width=2.0,\n",
    "                             arrowstyle='->')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw a crown DAG and its find_dfs_spanning\n",
    "plt.axis('off')\n",
    "DG.tree={\n",
    "  1: (1,2),'u':(2,2),3:(3,2),\n",
    "  2: (1,1),'v':(2,1),4:(3,1),\n",
    "}\n",
    "plt.title('Crown DAG ($S_3^0$ graph) '+\n",
    "          'with DFS spanning tree edges overlay')\n",
    "nx.draw_networkx(DG,\n",
    "                 pos=DG.tree,\n",
    "                 width=8.0,edge_color='#aaaaaa',\n",
    "                 node_size=500,node_color='#ff8888')\n",
    "edges=nx.draw_networkx_edges(DG,\n",
    "                             pos=DG.tree,\n",
    "                             edgelist=find_dfs_spanning(DG),\n",
    "                             node_size=500,width=2.0,\n",
    "                             arrowstyle='->')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reach of the node\n",
    "\n",
    "This can be calculated in a way similar to how levels are calculated (below). The amount of nodes given node can reach can be used as heuristic to select \\[DFS\\] spanning-tree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def find_reachable { form-width: \"30%\" }\n",
    "def find_reachable(DG, attr=None):\n",
    "  \"\"\"Find reachable vertices for all vertices in graph G\n",
    "  \n",
    "  The reachability list information can be optionally saved in the graph,\n",
    "  under given node attribute (name given by `attr` parameter).\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  attr : str, optional (default=None)\n",
    "      If set, name of a node attribute under which store reachable list.\n",
    "      \n",
    "  Returns:\n",
    "  --------\n",
    "  dict of lists\n",
    "      Dictionary, where keys are node indices, and values are lists\n",
    "      of all nodes reachable from given node.\n",
    "  \"\"\"\n",
    "  reachable = {}\n",
    "  \n",
    "  # defined only for Directed Acyclic Graphs\n",
    "  if not DG.is_directed():\n",
    "    raise nx.NetworkXNotImplemented(\n",
    "      \"Vertex reach is not implemented for undirected graphs.\")\n",
    "  if not nx.is_directed_acyclic_graph(DG):\n",
    "    raise nx.NetworkXNotImplemented(\n",
    "      \"Vertex reach is not defined on directed graphs with loops\")\n",
    "  \n",
    "  # it can be any post-order ordering\n",
    "  nodelist = nx.dfs_postorder_nodes(DG)\n",
    "  for node in nodelist:\n",
    "    reachable[node] = []\n",
    "    \n",
    "    for neigh in DG.successors(node):\n",
    "      reachable[node].extend(reachable[neigh])\n",
    "      reachable[node].append(neigh)\n",
    "  \n",
    "  if attr is not None:\n",
    "    for node, r in reach.items():\n",
    "      DG.nodes[node][attr] = reachable\n",
    "  \n",
    "  return reachable\n",
    "\n",
    "\n",
    "find_reachable(DG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def find_reach { form-width: \"30%\" }\n",
    "def find_reach(DG, attr=None):\n",
    "  \"\"\"Find reach (number of reachable vertices) of all vertices in graph G\n",
    "  \n",
    "  The reach of a vertex v, which we denote as r_v, can be defined\n",
    "  as number of vertices reachable from v.\n",
    "  \n",
    "  The reach information can be optionally saved in the graph,\n",
    "  under given node attribute (name given by `attr` parameter).\n",
    "  \n",
    "  NOTE: whether for nodes without outcoming edges (without any neighbours)\n",
    "  r_v is defined to be 0, or defined to be 1, is a matter of convention.\n",
    "  Here we exclude v from the set of nodes reachable from v.\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  attr : str, optional (default=None)\n",
    "      If set, name of a node attribute under which store vertex level.\n",
    "      \n",
    "  Returns:\n",
    "  --------\n",
    "  dict of ints\n",
    "      Dictionary, where keys are node indices, and values are node reach\n",
    "  \"\"\"\n",
    "  reachable = find_reachable(DG)\n",
    "  \n",
    "  reach = {n: len(set(rl)) for (n,rl) in reachable.items()}\n",
    "  \n",
    "  if attr is not None:\n",
    "    for node, r in reach.items():\n",
    "      DG.nodes[node][attr] = reach\n",
    "  \n",
    "  return reach\n",
    "\n",
    "\n",
    "find_reach(DG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('reach:     %r' % find_reach(lf))\n",
    "print('reachable: %r' % find_reachable(lf))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('reach:     %r' % find_reach(sd))\n",
    "print('reachable: %r' % find_reachable(sd))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimizations algorithms\n",
    "\n",
    "Those are the algorithms used to speed-up the reachability queries *in addition to* FELINE index (Algorithm 3: Reachable)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Levels\n",
    "\n",
    "> The **level** of a vertex $v$ (denoted as $l_v$) can be defined as its depth: if $v$ has no immediate predecessors, then $l_v = 0$, otherwise it is maximum of levels of its immediate predecessors plus one: $$l_v = \\max\\limits_{u\\colon (v,u)\\in E}(l_u)+1$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def find_levels { form-width: \"30%\" }\n",
    "def find_levels(DG, attr=None):\n",
    "  \"\"\"Find levels (generation number) of all vertices in graph G\n",
    "  \n",
    "  The level of a vertex v, which we denote as l_v, can be defined as its\n",
    "  depth, or the length of shortest path to the leaf node.\n",
    "  \n",
    "   - if v has no immediate predecessors, then l_v = 0\n",
    "   - otherwise l_v = 1 + max_{u: predecessors}(l_u)\n",
    "  \n",
    "  The levels / generation number information can be optionally saved in\n",
    "  the graph, under given node attribute (name given by `attr` parameter).\n",
    "  \n",
    "  NOTE: whether for nodes without outcoming edges (without any neighbours)\n",
    "  l_v is defined to be 0, or defined to be 1, is a matter of convention.\n",
    "  Here the same convention as in FELINE paper is used.\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  attr : str, optional (default=None)\n",
    "      If set, name of a node attribute under which store vertex level.\n",
    "      \n",
    "  Returns:\n",
    "  --------\n",
    "  dict of ints\n",
    "      Dictionary, where keys are node indices, and values are node levels\n",
    "  \"\"\"\n",
    "  lvl = {}\n",
    "  \n",
    "  # defined only for Directed Acyclic Graphs\n",
    "  if not DG.is_directed():\n",
    "    raise nx.NetworkXNotImplemented(\n",
    "      \"Vertex level is not defined on undirected graphs.\")\n",
    "  if not nx.is_directed_acyclic_graph(DG):\n",
    "    raise nx.NetworkXNotImplemented(\n",
    "      \"Vertex level is not defined on directed graphs with loops\")\n",
    "  \n",
    "  # it can be any post-order ordering\n",
    "  nodelist = nx.dfs_postorder_nodes(DG)\n",
    "  for node in nodelist:\n",
    "    if DG.out_degree(node) == 0:\n",
    "      lvl[node] = 0\n",
    "      continue\n",
    "    \n",
    "    lvl[node] = max([lvl[neigh] \n",
    "                     for neigh in DG.successors(node)]) + 1\n",
    "  \n",
    "  if attr is not None:\n",
    "    for node, level in lvl.items():\n",
    "      DG.nodes[node][attr] = level\n",
    "  \n",
    "  return lvl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test that it works on known graphs from previous part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title find_levels tests { form-width: \"30%\" }\n",
    "print('crown DAG: %r' % find_levels(DG))\n",
    "print('small DAG: %r' % find_levels(sd))\n",
    "print('level DAG:\\n  %r\\n  %r (pre-defined, corrected)' %\n",
    "      (find_levels(lf), lf.lvl))\n",
    "print('didactic:  %r' % find_levels(de))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# do all graphs have positions for level-based drawing?\n",
    "[(graph,graph.tree) for graph in [DG,sd,de,lf]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw a DAG with levels shown (levels-based)  { run: \"auto\" }\n",
    "graphs = {\n",
    "  'crown DAG': DG,\n",
    "  'small DAG': sd,\n",
    "  'didactic': de,\n",
    "  'levels DAG': lf,\n",
    "}\n",
    "palettes = {\n",
    "  'Greens': plt.cm.Greens,\n",
    "  'Reds': plt.cm.Reds,\n",
    "  'Blues': plt.cm.Blues,\n",
    "  'cool': plt.cm.cool,\n",
    "  'hot': plt.cm.hot,\n",
    "  'Wistia': plt.cm.Wistia,\n",
    "  'viridis': plt.cm.viridis,\n",
    "  'jet': plt.cm.jet,\n",
    "}\n",
    "\n",
    "graph_name = 'didactic' #@param [\"crown DAG\", \"small DAG\", \"didactic\", \"levels DAG\"]\n",
    "cmap_name = 'Greens' #@param [\"Reds\",\"Greens\",\"Blues\",\"hot\",\"cool\",\"Wistia\",\"viridis\",\"jet\"]\n",
    "vmin = -2 #@param {type:\"integer\"}\n",
    "vmax =  5 #@param {type:\"integer\"}\n",
    "\n",
    "graph = graphs[graph_name]\n",
    "cmap  = palettes[cmap_name]\n",
    "lvls=find_levels(graph)\n",
    "\n",
    "plt.figure(figsize=(15,10), dpi=72) # https://stackoverflow.com/q/36367986/46058\n",
    "plt.axis('off')\n",
    "plt.ylabel('level')\n",
    "plt.title('DAG with levels shown as labels beside nodes\\n'+\n",
    "          'nodes colored according to their level')\n",
    "\n",
    "nx.draw_networkx(graph,\n",
    "                 pos=graph.tree,\n",
    "                 nodes=lvls.keys(),\n",
    "                 node_color=list(lvls.values()),cmap=cmap,\n",
    "                 vmin=vmin,vmax=vmax,\n",
    "                 node_size=500,width=2.0)\n",
    "labels=nx.draw_networkx_labels(graph,\n",
    "                               pos={k: (v[0]+0.17,v[1]-0.04) \n",
    "                                    for (k,v) in graph.tree.items()},\n",
    "                               labels=lvls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw a DAG with reach shown (levels-based)  { run: \"auto\" }\n",
    "graphs = {\n",
    "  'crown DAG': DG,\n",
    "  'small DAG': sd,\n",
    "  'didactic': de,\n",
    "  'levels DAG': lf,\n",
    "}\n",
    "palettes = {\n",
    "  'Greens': plt.cm.Greens,\n",
    "  'Reds': plt.cm.Reds,\n",
    "  'Blues': plt.cm.Blues,\n",
    "  'cool': plt.cm.cool,\n",
    "  'hot': plt.cm.hot,\n",
    "  'Wistia': plt.cm.Wistia,\n",
    "  'viridis': plt.cm.viridis,\n",
    "  'jet': plt.cm.jet,\n",
    "}\n",
    "\n",
    "graph_name = 'small DAG' #@param [\"crown DAG\", \"small DAG\", \"didactic\", \"levels DAG\"]\n",
    "cmap_name = 'Blues' #@param [\"Reds\",\"Greens\",\"Blues\",\"hot\",\"cool\",\"Wistia\",\"viridis\",\"jet\"]\n",
    "vmin = -2 #@param {type:\"integer\"}\n",
    "vmax =  4 #@param {type:\"integer\"}\n",
    "scale= 100 #@param {type:\"integer\"}\n",
    "start_size = 400 #@param {type:\"integer\"}\n",
    "\n",
    "graph = graphs[graph_name]\n",
    "cmap  = palettes[cmap_name]\n",
    "lvls=find_levels(graph)\n",
    "reach=find_reach(graph)\n",
    "ginfo=[(v,lvls[v],reach[v]) for v in lvls.keys()]\n",
    "\n",
    "plt.figure(figsize=(13,8), dpi=72) # https://stackoverflow.com/q/36367986/46058\n",
    "plt.axis('off')\n",
    "plt.ylabel('level')\n",
    "plt.title('DAG with reach shown as labels beside nodes\\n'+\n",
    "          'nodes colored according to their level (broken)\\n'+\n",
    "          'size of node denotes their reach (broken for Python3)')\n",
    "\n",
    "nx.draw_networkx(graph,\n",
    "                 pos=graph.tree,\n",
    "                 nodes=[k[0] for k in ginfo],\n",
    "                 node_size=[start_size+scale*k[2]\n",
    "                            for k in ginfo],\n",
    "                 node_color=[k[1] for k in ginfo],\n",
    "                 cmap=cmap,\n",
    "                 vmin=vmin,vmax=vmax,\n",
    "                 width=2.0)\n",
    "labels=nx.draw_networkx_labels(graph,\n",
    "                               pos={k: (v[0]+0.17+0.01*reach[k],\n",
    "                                        v[1]-0.04) \n",
    "                                    for (k,v) in graph.tree.items()},\n",
    "                               labels=reach)\n",
    "\n",
    "ginfo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *Min-post* intervals\n",
    "\n",
    "> Interval labeling (*min-post* strategy) labels each node $u$ with a range $I_u = [s_u, e_u]$, where $e_u$ denotes the rank of the node $u$ in ***some*** post-order traversal of the tree, where the ranks are assumed to begin at 1, and all the children of a node are assumed to be ordered and fixed for that traversal. Further, $s_u$ denotes the lowest rank for any node $x$ in the subtree rooted at $u$ (i.e., including $u$).\n",
    "\n",
    "For more see node *\"[Optimizations: _min-post_ interval (positive-cut filter)](#scrollTo=_rP8JdufWvCd&line=5&uniqifier=1)\"* section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def find_dfs_intervals { form-width: \"30%\" }\n",
    "def find_dfs_intervals(DG, attr=None):\n",
    "  \"\"\"Find min-post labeling of all vertices in graph G, using DFS spanning-tree\n",
    "  \n",
    "  Min-post interval labeling strategy labels each node 'u' in the directed\n",
    "  spanning tree (DFS tree here) of the acyclic graph `DG` with a range\n",
    "  I_u = [s_u, e_u], where e_u denotes the rank of the node 'u' in post-order\n",
    "  traversal of the tree (ranks assumed to begin at 1), and s_u denotes the\n",
    "  lowest rank of any node 'w' in the subtree rooted at 'u' (including 'u').\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  attr : str, optional (default=None)\n",
    "      If set, name of a node attribute under which store min-post intervals.\n",
    "      \n",
    "  Returns:\n",
    "  --------\n",
    "  dict of two-element lists of ints\n",
    "      Dictionary, where keys are node indices, and values are two element\n",
    "      lists storing min-post interval (of integers)\n",
    "  \"\"\"\n",
    "  ivl = {}\n",
    "  # create graph of spanning tree (DFS spanning tree) of DG\n",
    "  span=nx.DiGraph()\n",
    "  span.add_nodes_from(DG)\n",
    "  span.add_edges_from(find_dfs_spanning(DG))\n",
    "  # DEBUG\n",
    "  #print('span=%r' % find_dfs_spanning(DG))\n",
    "  \n",
    "  # any post-order ordering would be good\n",
    "  nodelist = nx.dfs_postorder_nodes(DG)\n",
    "  for pos, node in enumerate(nodelist, start=1):\n",
    "    ivl[node] = [pos, pos]\n",
    "    if span.out_degree(node) > 0:\n",
    "      ivl[node][0] = min(pos,\n",
    "                         *[ivl[neigh][0] \n",
    "                           for neigh in span.successors(node)])\n",
    "    # DEBUG\n",
    "    #print('node=%s [%d,%d] -> %r' %\n",
    "    #      (node, ivl[node][0],ivl[node][1],list(span.successors(node))))\n",
    "  \n",
    "  if attr is not None:\n",
    "    for node, interval in ivl.items():\n",
    "      DG.nodes[node][attr] = deepcopy(interval)\n",
    "  \n",
    "  return ivl\n",
    "\n",
    "\n",
    "# DEBUG\n",
    "find_dfs_intervals(sd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title find_dfs_intervals tests { form-width: \"30%\" }\n",
    "# note that min-post intervals depend on spanning-tree chosen\n",
    "# and may not be the same as precomputed ones from FELINE paper\n",
    "print('crown DAG: %r' % find_dfs_intervals(DG))\n",
    "print('small DAG: %r' % find_dfs_intervals(sd))\n",
    "print('level DAG: %r' % find_dfs_intervals(lf))\n",
    "print('didactic:  %r' % find_dfs_intervals(de))\n",
    "print('-------------')\n",
    "print('small DAG: %r' % (sd.mpi_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw a DAG with min-post intervals (levels-based)  { run: \"auto\" }\n",
    "graphs = {\n",
    "  'crown DAG': DG,\n",
    "  'small DAG': sd,\n",
    "  'didactic': de,\n",
    "  'levels DAG': lf,\n",
    "}\n",
    "\n",
    "graph_name = 'small DAG' #@param [\"crown DAG\", \"small DAG\", \"didactic\", \"levels DAG\"]\n",
    "node_color = \"#ffaaaa\" #@param [\"y\", \"c\", \"b\", \"g\", \"r\"] {allow-input: true}\n",
    "draw_edge_labels = True #@param {type:\"boolean\"}\n",
    "\n",
    "\n",
    "graph=graphs[graph_name]\n",
    "intervals=find_dfs_intervals(graph)\n",
    "intervals_repr={\n",
    "  v:('[%d,%d]'%(i[0],i[1]))\n",
    "  for (v,i) in intervals.items()\n",
    "}\n",
    "edge_labels={\n",
    "  (u,v):l \n",
    "  for (u,v,l) in nx.dfs_labeled_edges(graph)\n",
    "  if u != v\n",
    "}\n",
    "max_pos=(\n",
    "  max([pos[0] for (node,pos) in graph.tree.items()]),\n",
    "  max([pos[1] for (node,pos) in graph.tree.items()])\n",
    ")\n",
    "dd=(\n",
    "   0.25*(max_pos[0]/5.0),\n",
    "  -0.02*(max_pos[1]/4.0)\n",
    ")\n",
    "\n",
    "plt.figure(figsize=(15,10), dpi=72) # https://stackoverflow.com/q/36367986/46058\n",
    "plt.axis('off')\n",
    "plt.title('DAG with min-post intervals shown as labels beside nodes')\n",
    "\n",
    "nx.draw_networkx(graph,\n",
    "                 pos=graph.tree,\n",
    "                 width=8.0,edge_color='#aaaaaa',\n",
    "                 node_size=500,node_color=node_color)\n",
    "edges=nx.draw_networkx_edges(graph,\n",
    "                             pos=graph.tree,\n",
    "                             edgelist=find_dfs_spanning(graph),\n",
    "                             node_size=500,width=2.0,\n",
    "                             arrowstyle='->')\n",
    "if draw_edge_labels:\n",
    "  nx.draw_networkx_edge_labels(graph,\n",
    "                               pos=graph.tree,\n",
    "                               edge_labels=edge_labels,\n",
    "                               font_size=10)\n",
    "labels=nx.draw_networkx_labels(graph,\n",
    "                               pos={k: (v[0]+dd[0],v[1]+dd[1]) \n",
    "                                    for (k,v) in graph.tree.items()},\n",
    "                               labels=intervals_repr)\n",
    "#print(edge_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(13,8), dpi=72) # https://stackoverflow.com/q/36367986/46058\n",
    "nx.draw_networkx(sd,\n",
    "                 pos=sd.tree,\n",
    "                 node_size=500,width=8.0,\n",
    "                 edge_color='#aaaaaa',node_color='y')\n",
    "edges=nx.draw_networkx_edges(sd,\n",
    "                             pos=sd.tree,\n",
    "                             edgelist=[\n",
    "                               ('a','c'),('a','d'),('a','e'),\n",
    "                               ('e','h'),\n",
    "                               ('b','f'),('b','g')\n",
    "                             ],\n",
    "                             node_size=500,width=2.0,\n",
    "                             arrowstyle='->')\n",
    "labels=nx.draw_networkx_labels(sd,\n",
    "                               pos=sd.lpos,\n",
    "                               labels=sd.mpi_labels)\n",
    "\n",
    "plt.axis(\"off\")\n",
    "plt.title('Draw a small DAG and its spanning-tree, as in Figure 8');\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chosing \"small DAG\" in the form above one can compare spanning-tree and min-post intervals index for DFS search from NetworkX and the one from FELINE paper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw a DAG with min-post intervals (post+level) { run: \"auto\", form-width: \"30%\" }\n",
    "import matplotlib.ticker as mticker\n",
    "\n",
    "graphs = {\n",
    "  'crown DAG': DG,\n",
    "  'small DAG': sd,\n",
    "  'didactic': de,\n",
    "  'levels DAG': lf,\n",
    "  'PReaCH DAG': ch,\n",
    "}\n",
    "\n",
    "graph_name = 'PReaCH DAG' #@param [\"crown DAG\", \"small DAG\", \"didactic\", \"levels DAG\", \"PReaCH DAG\"]\n",
    "node_color = \"#ffaaaa\" #@param [\"y\", \"m\", \"c\", \"b\", \"g\", \"r\"] {allow-input: true}\n",
    "draw_intervals = True #@param {type:\"boolean\"}\n",
    "ytick_spacing = 1 #@param {type:\"integer\"}\n",
    "\n",
    "\n",
    "graph=graphs[graph_name]\n",
    "intervals=find_dfs_intervals(graph)\n",
    "lvls=find_levels(graph)\n",
    "#reach=find_reach(graph)\n",
    "intervals_repr={\n",
    "  v:('[%d,%d]'%(i[0],i[1]))\n",
    "  for (v,i) in intervals.items()\n",
    "}\n",
    "pos={v: (intervals[v][1]+0.2*(lvls[v]%2)-0.1,lvls[v]) for v in graph}\n",
    "max_pos=(\n",
    "  max([x for (x,y) in pos.values()]),\n",
    "  max([y for (x,y) in pos.values()])\n",
    ")\n",
    "dd=(\n",
    "  -0.30*(max_pos[0]/5.0),\n",
    "  +0.14*(max_pos[1]/4.0)\n",
    ")\n",
    "\n",
    "plt.figure(figsize=(13,8), dpi=72) # https://stackoverflow.com/q/36367986/46058\n",
    "ax=plt.gca()\n",
    "#ax.xaxis.set_major_locator(mticker.MultipleLocator(ytick_spacing)\n",
    "ax.yaxis.set_ticks(np.arange(0, max(lvls.values())+1, ytick_spacing))\n",
    "if draw_intervals:\n",
    "  for v in graph:\n",
    "    if intervals[v][0] == intervals[v][1]:\n",
    "      continue\n",
    "    ax.add_line(Line2D([intervals[v][0],intervals[v][1]],\n",
    "                       [lvls[v],lvls[v]],\n",
    "                       lw=5., alpha=0.3))\n",
    "\n",
    "#plt.axis('off')\n",
    "plt.xlabel('$\\phi(v)$ -- post-numbering of nodes in spanning tree')\n",
    "plt.ylabel('$l_v = l(v)$ -- sink-based level of node')\n",
    "plt.title('DAG with min-post intervals shown as labels beside nodes\\n'+\n",
    "          'post DFS number (slightly perturbed) vs node level')\n",
    "\n",
    "nx.draw_networkx(graph,\n",
    "                 pos=pos,\n",
    "                 width=8.0,edge_color='#aaaaaa',\n",
    "                 node_size=500,node_color=node_color)\n",
    "edges=nx.draw_networkx_edges(graph,\n",
    "                             pos=pos,\n",
    "                             edgelist=find_dfs_spanning(graph),\n",
    "                             node_size=500,width=2.0,\n",
    "                             arrowstyle='->')\n",
    "labels=nx.draw_networkx_labels(graph,\n",
    "                               pos={k: (v[0]+dd[0],v[1]+dd[1]) \n",
    "                                    for (k,v) in pos.items()},\n",
    "                               labels=intervals_repr)\n",
    "#print(edge_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DFS spanning-tree extra data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def find_dfs_intervals_extra { form-width: \"30%\" }\n",
    "def find_dfs_intervals_extra(DG, extra=True):\n",
    "  \"\"\"Find DFS-derived data of all vertices in graph G\n",
    "  \n",
    "  Min-post interval labeling strategy labels each node 'u' in the directed\n",
    "  spanning tree (DFS tree here) of the acyclic graph `DG` with a range\n",
    "  I_u = [s_u, e_u], where e_u denotes the rank of the node 'u' in post-order\n",
    "  traversal of the tree (ranks assumed to begin at 1), and s_u denotes the\n",
    "  lowest rank of any node 'w' in the subtree rooted at 'u' (including 'u').\n",
    "  This interval is stored under 'min' and 'post' keys in returned dict.\n",
    "  \n",
    "  For depth first-search (DFS) all nodes reachable from node 'u' have their\n",
    "  topological ordering in DFS tree, i.e. 'post', smaller than the 'post'\n",
    "  value for 'u'.  Additionally we can define 'f_min' as minimum 'post'\n",
    "  number for each node reachable from 'u', and 'f_gap' as maximum 'post'\n",
    "  number of nodes reachable from 'u' that are not in DFS subtree rooted\n",
    "  at 'u' or None if 'f_gap' would be equal to 'u' node's 'min' number.\n",
    "  \n",
    "  We can also define 'p_tree' to be node reachable from 'u', but not in\n",
    "  subtree rooted at 'u', that ('p_tree') has largest subtree.  If such\n",
    "  node does not exist it is set to None.  For DFS spanning tree we can\n",
    "  calculate this value effectively.\n",
    "  \n",
    "  This is based on *modified* algorithms from PReaCH paper [1];\n",
    "  note that the original version in the paper [1] uses\n",
    "  preorder not postorder numbers (pre-max not min-post).\n",
    "  \n",
    "  References:\n",
    "  -----------\n",
    "  [1] Florian Merz, Peter Sanders \"PReaCH: A Fast Lightweight\n",
    "      Reachability Index using Pruning and Contraction Hierarchies\" (2014)\n",
    "      In: Schulz A.S., Wagner D. (eds) Algorithms - ESA 2014. ESA 2014.\n",
    "      Lecture Notes in Computer Science, vol 8737. Springer, Berlin,\n",
    "      Heidelberg (Conference Paper: European Symposium on Algorithms)\n",
    "      https://doi.org/10.1007/978-3-662-44777-2_58\n",
    "      http://arxiv.org/abs/1404.4465\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  extra : bool, optional (default=True)\n",
    "      Whether to compute extra DFS data in addition to min-post interval.\n",
    "          \n",
    "  Returns:\n",
    "  --------\n",
    "  dict of dicts\n",
    "      Dictionary, where keys are node indices, and values are dictionaries\n",
    "      with various DFS spanning-tree derived data.\n",
    "  \"\"\"\n",
    "  data = {}\n",
    "  # create graph of spanning tree (DFS spanning tree) of DG\n",
    "  span=nx.DiGraph()\n",
    "  span.add_nodes_from(DG)\n",
    "  span.add_edges_from(find_dfs_spanning(DG))\n",
    "  \n",
    "  # needs depth-first search for some of indices to actually work\n",
    "  nodelist = nx.dfs_postorder_nodes(DG)\n",
    "  for pos, node in enumerate(nodelist, start=1):\n",
    "    data[node] = {}\n",
    "    \n",
    "    # DEBUG\n",
    "    #print('node=%s\\n -> %r\\n => %r' %\n",
    "    #      (node,\n",
    "    #       list(span.successors(node)),\n",
    "    #       list(DG.successors(node))))\n",
    "    \n",
    "    data[node]['post'] = pos\n",
    "    if span.out_degree(node) == 0:\n",
    "      data[node]['min'] = pos\n",
    "    else:\n",
    "      data[node]['min'] = min(pos,\n",
    "                              *[data[neigh]['min'] \n",
    "                                for neigh in span.successors(node)])\n",
    "    \n",
    "    #print(\"data[%s]: %r\" % (node, data[node]))\n",
    "\n",
    "    if not extra:\n",
    "      continue\n",
    "    \n",
    "    if DG.out_degree(node) == 0:\n",
    "      data[node]['f_min'] = pos\n",
    "      data[node]['f_gap'] = None\n",
    "      data[node]['p_tree'] = None\n",
    "    else:\n",
    "      data[node]['f_min'] = min(pos,\n",
    "                                *[data[neigh]['f_min'] \n",
    "                                  for neigh in DG.successors(node)])\n",
    "      \n",
    "      f_gap_candidates = \\\n",
    "        [data[neigh]['post']\n",
    "         for neigh in DG.successors(node)\n",
    "         if data[neigh]['post'] < data[node]['min']] + \\\n",
    "        [data[neigh]['f_gap']\n",
    "         for neigh in DG.successors(node)\n",
    "         if data[neigh]['f_gap'] is not None]\n",
    "      if f_gap_candidates:\n",
    "        data[node]['f_gap'] = max(f_gap_candidates)\n",
    "      else:\n",
    "        data[node]['f_gap'] = None\n",
    "      #print(\"f_gap[%s]: %r\" % (node, data[node]['f_gap']))\n",
    "\n",
    "      #print(\"p_tree: %r (candidates, part 1)\" % \n",
    "      #      [data[neigh]['p_tree']\n",
    "      #       for neigh in DG.successors(node)])\n",
    "      p_tree_candidates = \\\n",
    "        [data[neigh]['p_tree']\n",
    "         for neigh in DG.successors(node)\n",
    "         if data[neigh]['p_tree'] is not None and \\\n",
    "            data[neigh]['post'] < data[node]['min']] + \\\n",
    "        [neigh\n",
    "         for neigh in DG.successors(node)\n",
    "         if data[neigh]['post'] < data[node]['min']]\n",
    "      if p_tree_candidates:\n",
    "        data[node]['p_tree'] = max(\n",
    "          p_tree_candidates,\n",
    "          key=lambda n: data[n]['post'] - data[n]['min']\n",
    "        )\n",
    "        #print(\"p_tree[%s]: %r\" % (node, data[node]['p_tree']))\n",
    "      else:\n",
    "        data[node]['p_tree'] = None\n",
    "\n",
    "    #print(\"\\n\")\n",
    "\n",
    "\n",
    "  return data\n",
    "\n",
    "\n",
    "# DEBUG\n",
    "find_dfs_intervals_extra(sd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_dfs_intervals(sd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def find_dfs_preorder_intervals_extra { form-width: \"30%\" }\n",
    "def find_dfs_preorder_intervals_extra(DG):\n",
    "  \"\"\"Find DFS-derived data of all vertices in graph G\n",
    "  \n",
    "  TODO: <description from PReaCH paper here>.\n",
    "  \n",
    "  This is based on algorithms from PReaCH paper [1].\n",
    "  \n",
    "  References:\n",
    "  -----------\n",
    "  [1] Florian Merz, Peter Sanders \"PReaCH: A Fast Lightweight\n",
    "      Reachability Index using Pruning and Contraction Hierarchies\" (2014)\n",
    "      http://arxiv.org/abs/1404.4465\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "          \n",
    "  Returns:\n",
    "  --------\n",
    "  dict of dicts\n",
    "      Dictionary, where keys are node indices, and values are dictionaries\n",
    "      with various DFS spanning-tree derived data.\n",
    "  \"\"\"\n",
    "  data = {}\n",
    "  # create graph of spanning tree (DFS spanning tree) of DG\n",
    "  span=nx.DiGraph()\n",
    "  span.add_nodes_from(DG)\n",
    "  span.add_edges_from(find_dfs_spanning(DG))\n",
    "  \n",
    "  # needs depth-first search for some of indices to actually work\n",
    "  nodelist = list(nx.dfs_preorder_nodes(DG))\n",
    "  nodepos = order_to_pos(nodelist, start=1)\n",
    "  # DEBUG\n",
    "  #print('nodelist = %r\\nnodepos  = %r' % (nodelist, nodepos))\n",
    "  for node in nx.dfs_postorder_nodes(DG):\n",
    "    pos = nodepos[node]\n",
    "    data[node] = {}\n",
    "\n",
    "    # DEBUG\n",
    "    #print('node=%s [%d]\\n -> %r\\n => %r' %\n",
    "    #      (node,pos,\n",
    "    #       list(span.successors(node)),\n",
    "    #       list(DG.successors(node))))\n",
    "    \n",
    "    data[node]['pre'] = pos\n",
    "    if span.out_degree(node) == 0:\n",
    "      data[node]['max'] = pos\n",
    "    else:\n",
    "      data[node]['max'] = max(pos,\n",
    "                              *[data[neigh]['max'] \n",
    "                                for neigh in span.successors(node)])  \n",
    "      \n",
    "    if DG.out_degree(node) == 0:\n",
    "      data[node]['f_min'] = pos\n",
    "      data[node]['f_gap'] = None\n",
    "      data[node]['p_tree'] = None\n",
    "    else:\n",
    "      data[node]['f_min'] = min(pos,\n",
    "                                *[data[neigh]['f_min'] \n",
    "                                  for neigh in DG.successors(node)])\n",
    "\n",
    "      f_gap_candidates = \\\n",
    "        [data[neigh]['max']\n",
    "         for neigh in DG.successors(node)\n",
    "         if data[neigh]['pre'] < data[node]['pre']] + \\\n",
    "        [data[neigh]['f_gap']\n",
    "         for neigh in DG.successors(node)\n",
    "         if data[neigh]['f_gap'] is not None]\n",
    "      if f_gap_candidates:\n",
    "        data[node]['f_gap'] = max(f_gap_candidates)\n",
    "      else:\n",
    "        data[node]['f_gap'] = None\n",
    "     \n",
    "      p_tree_candidates = \\\n",
    "        [data[neigh]['p_tree']\n",
    "         for neigh in DG.successors(node)\n",
    "         if data[neigh]['p_tree'] is not None and \\\n",
    "            data[neigh]['pre'] < data[node]['pre']] + \\\n",
    "        [neigh\n",
    "         for neigh in DG.successors(node)\n",
    "         if data[neigh]['pre'] < data[node]['pre']]\n",
    "      if p_tree_candidates:\n",
    "        data[node]['p_tree'] = max(\n",
    "          p_tree_candidates,\n",
    "          key=lambda n: data[n]['max'] - data[n]['pre']\n",
    "        )\n",
    "      else:\n",
    "        data[node]['p_tree'] = None\n",
    "  \n",
    "  return data\n",
    "\n",
    "\n",
    "# DEBUG\n",
    "find_dfs_preorder_intervals_extra(sd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw a DAG with DFS numbering data (post+level) { run: \"auto\", form-width: \"30%\" }\n",
    "graphs = {\n",
    "  'crown DAG': DG,\n",
    "  'small DAG': sd,\n",
    "  'didactic': de,\n",
    "  'levels DAG': lf,\n",
    "  'PReaCH DAG': ch,\n",
    "}\n",
    "\n",
    "graph_name = 'PReaCH DAG' #@param [\"crown DAG\", \"small DAG\", \"didactic\", \"levels DAG\", \"PReaCH DAG\"]\n",
    "node_color = \"#ffaaaa\" #@param [\"y\", \"m\", \"c\", \"b\", \"g\", \"r\"] {allow-input: true}\n",
    "show_p_tree = \"low\" #@param [\"none\",\"low\",\"high\"]\n",
    "xtick_spacing = 1 #@param {type:\"integer\"}\n",
    "ytick_spacing = 1 #@param {type:\"integer\"}\n",
    "fig_sizex = 14 #@param {type:\"slider\", min:5, max:25, step:1}\n",
    "fig_sizey = 10 #@param {type:\"slider\", min:5, max:25, step:1}\n",
    "fig_square = False #@param {type:\"boolean\"}\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches(fig_sizex,fig_sizey)\n",
    "\n",
    "ax=plt.gca()\n",
    "if fig_square:\n",
    "  ax.set(adjustable='box-forced', aspect='equal')\n",
    "\n",
    "graph=graphs[graph_name]\n",
    "intervals=find_dfs_intervals_extra(graph)\n",
    "lvls=find_levels(graph)\n",
    "#reach=find_reach(graph)\n",
    "\n",
    "pos={v: (intervals[v]['post']+0.2*(lvls[v]%2)-0.1,\n",
    "         lvls[v])\n",
    "     for v in graph}\n",
    "max_pos=(\n",
    "  max([x for (x,y) in pos.values()]),\n",
    "  max([y for (x,y) in pos.values()])\n",
    ")\n",
    "dd=(\n",
    "  -0.30*(max_pos[0]/5.0),\n",
    "  +0.14*(max_pos[1]/4.0)\n",
    ")\n",
    "\n",
    "ax.xaxis.set_ticks(np.arange(1, len(graph)+1, xtick_spacing))\n",
    "ax.yaxis.set_ticks(np.arange(0, max_pos[1]+2, ytick_spacing))\n",
    "\n",
    "for v in graph:\n",
    "  if intervals[v]['min'] != intervals[v]['post']:\n",
    "    ax.add_line(Line2D([intervals[v]['min'],intervals[v]['post']],\n",
    "                       [lvls[v],lvls[v]],\n",
    "                       lw=5., alpha=0.3))\n",
    "  if intervals[v]['p_tree'] is not None and \\\n",
    "     show_p_tree != \"none\":\n",
    "    p = intervals[v]['p_tree']\n",
    "    vx= intervals[v]['post']\n",
    "    if show_p_tree == \"low\":\n",
    "      yy= lvls[v]-0.02-0.020*vx - 1\n",
    "    else:\n",
    "      yy= lvls[v]+0.02+0.015*vx\n",
    "    ax.add_line(Line2D([intervals[p]['min']-0.1,intervals[p]['post']+0.1],\n",
    "                       [yy,yy],\n",
    "                       lw=5., alpha=0.3, c='y'))\n",
    "    ax.annotate(str(v),\n",
    "                xy=(0.5*(intervals[p]['min']+intervals[p]['post']),\n",
    "                    yy),\n",
    "                horizontalalignment='center', verticalalignment='center',\n",
    "                fontsize=9)\n",
    "\n",
    "#plt.axis('off')\n",
    "plt.xlabel('$\\phi(v)$ -- post-numbering of nodes in DFS spanning tree')\n",
    "plt.ylabel('$l_v = l(v)$ -- sink-based level of node')\n",
    "plt.title(graph_name+' with DFS spanning-tree derived data\\n'+\n",
    "          'post DFS number (slightly perturbed) vs node level')\n",
    "\n",
    "nx.draw_networkx(graph,\n",
    "                 pos=pos,\n",
    "                 width=8.0,edge_color='#aaaaaa',\n",
    "                 node_size=500,node_color=node_color)\n",
    "edges=nx.draw_networkx_edges(graph,\n",
    "                             pos=pos,\n",
    "                             edgelist=find_dfs_spanning(graph),\n",
    "                             node_size=500,width=2.0,\n",
    "                             arrowstyle='->')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_dfs_intervals_extra(ch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Visualize DFS numbering data (post+level) for PReaCH graph { run: \"auto\", form-width: \"30%\" }\n",
    "graphs = {\n",
    "  'crown DAG': DG,\n",
    "  'small DAG': sd,\n",
    "  'didactic': de,\n",
    "  'levels DAG': lf,\n",
    "  'PReaCH DAG': ch,\n",
    "}\n",
    "\n",
    "graph_name = 'PReaCH DAG'\n",
    "node_color = \"#ffaaaa\" #@param [\"y\", \"m\", \"c\", \"b\", \"g\", \"r\"] {allow-input: true}\n",
    "\n",
    "xtick_spacing = 1 #@param {type:\"integer\"}\n",
    "ytick_spacing = 1 #@param {type:\"integer\"}\n",
    "fig_sizex = 14 #@param {type:\"slider\", min:5, max:25, step:1}\n",
    "fig_sizey = 10 #@param {type:\"slider\", min:5, max:25, step:1}\n",
    "fig_square = False #@param {type:\"boolean\"}\n",
    "src = \"d\" #@param [\"a\",\"c\",\"b\",\"d\",\"g\",\"f\",\"k\"]\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches(fig_sizex,fig_sizey)\n",
    "\n",
    "ax=plt.gca()\n",
    "if fig_square:\n",
    "  ax.set(adjustable='box-forced', aspect='equal')\n",
    "\n",
    "graph=graphs[graph_name]\n",
    "intervals=find_dfs_intervals_extra(graph)\n",
    "lvls=find_levels(graph)\n",
    "reachable=find_reachable(graph)\n",
    "\n",
    "pos={v: (intervals[v]['post']+0.2*(lvls[v]%2)-0.1,\n",
    "         lvls[v])\n",
    "     for v in graph}\n",
    "max_pos=(\n",
    "  max([x for (x,y) in pos.values()]),\n",
    "  max([y for (x,y) in pos.values()])\n",
    ")\n",
    "dd=(\n",
    "  -0.30*(max_pos[0]/5.0),\n",
    "  +0.14*(max_pos[1]/4.0)\n",
    ")\n",
    "\n",
    "ax.xaxis.set_ticks(np.arange(0, max_pos[0]+1, xtick_spacing))\n",
    "ax.yaxis.set_ticks(np.arange(0, max_pos[1]+2, ytick_spacing))\n",
    "\n",
    "v = src\n",
    "n_pos=0\n",
    "n_neg=0\n",
    "n_all=len(graph)\n",
    "if True:\n",
    "  if intervals[v]['p_tree'] is not None:\n",
    "    p = intervals[v]['p_tree']\n",
    "    vx= intervals[v]['post']\n",
    "    yy=-0.3\n",
    "    ax.add_line(Line2D([intervals[p]['min']-0.15,intervals[p]['post']+0.15],\n",
    "                       [yy,yy],\n",
    "                       lw=5., alpha=0.3, c='c'))\n",
    "    #ax.annotate(str(v),\n",
    "    #            xy=(0.5*(intervals[p]['min']+intervals[p]['post']),\n",
    "    #                yy),\n",
    "    #            horizontalalignment='center', verticalalignment='center',\n",
    "    #            fontsize=9)\n",
    "    ax.add_patch(Rectangle((intervals[p]['min']-0.6,-0.25),\n",
    "                           intervals[p]['post']-intervals[p]['min']+1.2,\n",
    "                           max_pos[1]+0.5, facecolor=\"#99ee99\",alpha=0.3))\n",
    "    ax.add_line(Line2D([intervals[p]['min']-0.6,intervals[p]['min']-0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dotted',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "    ax.add_line(Line2D([intervals[p]['post']+0.6,intervals[p]['post']+0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dotted',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "    n_pos += intervals[p]['post']-intervals[p]['min']+1\n",
    "    nx.draw_networkx_nodes(graph,\n",
    "                       pos=pos,\n",
    "                       nodelist=[p],\n",
    "                       node_size=750,node_color='#22dd22')\n",
    "  \n",
    "  if intervals[v]['post'] < max_pos[0]:\n",
    "    ax.add_line(Line2D([intervals[v]['post']+1-0.15,max_pos[0]],\n",
    "                       [-0.25,-0.25],\n",
    "                       lw=5., alpha=0.3, c='r'))\n",
    "    n_neg += n_all - intervals[v]['post']\n",
    "  if intervals[v]['f_min'] > 1:\n",
    "    ax.add_line(Line2D([1,intervals[v]['f_min']-1+0.15],\n",
    "                       [-0.25,-0.25],\n",
    "                       lw=5., alpha=0.3, c='r'))\n",
    "    n_neg += intervals[v]['f_min']-1\n",
    "  if intervals[v]['f_gap'] is not None and \\\n",
    "     intervals[v]['f_gap']+1 <= intervals[v]['min']-1:\n",
    "    ax.add_line(Line2D([intervals[v]['f_gap']+1-0.15,\n",
    "                        intervals[v]['min']  -1+0.15],\n",
    "                       [-0.23,-0.23],\n",
    "                       lw=5., alpha=0.3, c='#ff4400'))\n",
    "    n_neg += intervals[v]['min']-intervals[v]['f_gap']-1\n",
    "    ax.add_patch(Rectangle((intervals[v]['f_min']-0.6,-0.30),\n",
    "                           intervals[v]['f_gap']-intervals[v]['f_min']+1.2,\n",
    "                           max_pos[1]+0.6, facecolor=\"#aa99aa\",alpha=0.2))\n",
    "    ax.add_patch(Rectangle((intervals[v]['min']-0.6,-0.30),\n",
    "                           intervals[v]['post']-intervals[v]['min']+1.2,\n",
    "                           max_pos[1]+0.6, facecolor=\"#aa99aa\",alpha=0.2))\n",
    "  else:\n",
    "    ax.add_patch(Rectangle((intervals[v]['f_min']-0.6,-0.30),\n",
    "                           intervals[v]['post']-intervals[v]['f_min']+1.2,\n",
    "                           max_pos[1]+0.60, facecolor=\"#aa88bb\",alpha=0.2))\n",
    "    \n",
    "  if intervals[v]['min'] != intervals[v]['post']:\n",
    "    ax.add_line(Line2D([intervals[v]['min']-0.15,intervals[v]['post']+0.15],\n",
    "                       [-0.2,-0.2],\n",
    "                       lw=5., alpha=0.3, c='b'))\n",
    "    ax.add_patch(Rectangle((intervals[v]['min']-0.6,-0.25),\n",
    "                           intervals[v]['post']-intervals[v]['min']+1.2,\n",
    "                           max_pos[1]+0.5, facecolor=\"#99ff99\",alpha=0.3))\n",
    "    ax.add_line(Line2D([intervals[v]['min']-0.6,intervals[v]['min']-0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dashed',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "    ax.add_line(Line2D([intervals[v]['post']+0.6,intervals[v]['post']+0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dashed',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "  n_pos += intervals[v]['post']-intervals[v]['min']\n",
    "\n",
    "#plt.axis('off')\n",
    "plt.xlabel('$\\phi(v)$ -- post-numbering of nodes in spanning tree')\n",
    "plt.ylabel('$l_v = l(v)$ -- sink-based level of node')\n",
    "plt.title(graph_name+' with DFS spanning-tree derived data\\n'+\n",
    "          'post DFS number (slightly perturbed) vs node level\\n'+\n",
    "          'starting from node \"'+str(src)+'\"')\n",
    "\n",
    "nx.draw_networkx(graph,\n",
    "                 pos=pos,\n",
    "                 width=8.0,edge_color='#aaaaaa',\n",
    "                 node_size=500,node_color=node_color)\n",
    "nx.draw_networkx_edges(graph,\n",
    "                       pos=pos,\n",
    "                       edgelist=find_dfs_spanning(graph),\n",
    "                       node_size=500,width=2.0,\n",
    "                       arrowstyle='->')\n",
    "nx.draw_networkx_nodes(graph,\n",
    "                       pos=pos,\n",
    "                       nodelist=reachable[src]+[src],\n",
    "                       node_size=550,node_color='#aaffaa')\n",
    "nx.draw_networkx_nodes(graph,\n",
    "                       pos=pos,\n",
    "                       nodelist=[src],\n",
    "                       node_size=650,node_color='#22dd22')\n",
    "\n",
    "plt.show()\n",
    "\n",
    "print('source = %s (%s)' % (src, graph_name))\n",
    "print('- %d nodes' % n_all)\n",
    "print('- %d non n_neg (%d n_neg)' % (n_all - n_neg, n_neg))\n",
    "print('- %d reachable' % len(set(reachable[src])))\n",
    "print('  * %d false positives (not excluded but unreachable)' %\n",
    "      (n_all - n_neg - 1 - len(set(reachable[src]))))\n",
    "print('  * %d false negatives (not included but reachable)' %\n",
    "      (len(set(reachable[src]))-n_pos))\n",
    "print('- %d n_pos (%d n_pos incl.)' % (n_pos, n_pos+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Visualize DFS numbering data (pre+level) for PReaCH graph { run: \"auto\", form-width: \"30%\" }\n",
    "from matplotlib.lines import Line2D\n",
    "from matplotlib.patches import Rectangle\n",
    "\n",
    "#graphs = {\n",
    "#  'crown DAG': DG,\n",
    "#  'small DAG': sd,\n",
    "#  'didactic': de,\n",
    "#  'levels DAG': lf,\n",
    "#  'PReaCH DAG': ch,\n",
    "#}\n",
    "\n",
    "graph_name = 'PReaCH DAG'\n",
    "node_color = \"#ffaaaa\" #@param [\"y\", \"m\", \"c\", \"b\", \"g\", \"r\"] {allow-input: true}\n",
    "\n",
    "xtick_spacing = 1 #@param {type:\"integer\"}\n",
    "ytick_spacing = 1 #@param {type:\"integer\"}\n",
    "fig_sizex = 14 #@param {type:\"slider\", min:5, max:25, step:1}\n",
    "fig_sizey = 10 #@param {type:\"slider\", min:5, max:25, step:1}\n",
    "fig_square = False #@param {type:\"boolean\"}\n",
    "src = \"d\" #@param [\"a\",\"c\",\"b\",\"d\",\"g\",\"f\",\"k\"]\n",
    "#fig_rch_map = False #@param {type:\"boolean\"}\n",
    "#interpolation = \"bicubic\" #@param [\"none\", \"nearest\", \"bilinear\", \"bicubic\", \"spline16\", \"spline36\", \"hanning\", \"hamming\", \"hermite\", \"kaiser\", \"quadric\", \"catrom\", \"gaussian\", \"bessel\", \"mitchell\", \"sinc\", \"lanczos\"]\n",
    "fig_rch_map = False\n",
    "interpolation = 'bicubic'\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches(fig_sizex,fig_sizey)\n",
    "\n",
    "ax=plt.gca()\n",
    "if fig_square:\n",
    "  ax.set(adjustable='box-forced', aspect='equal')\n",
    "\n",
    "#graph=graphs[graph_name]\n",
    "graph=ch\n",
    "intervals=find_dfs_preorder_intervals_extra(graph)\n",
    "lvls=find_levels(graph)\n",
    "reachable=find_reachable(graph)\n",
    "\n",
    "pos={v: (intervals[v]['pre']+0.2*(lvls[v]%2)-0.1,\n",
    "         lvls[v])\n",
    "     for v in graph}\n",
    "max_pos=(\n",
    "  max([x for (x,y) in pos.values()]),\n",
    "  max([y for (x,y) in pos.values()])\n",
    ")\n",
    "dd=(\n",
    "  -0.30*(max_pos[0]/5.0),\n",
    "  +0.14*(max_pos[1]/4.0)\n",
    ")\n",
    "\n",
    "ax.xaxis.set_ticks(np.arange(0, max_pos[0]+1, xtick_spacing))\n",
    "ax.yaxis.set_ticks(np.arange(0, max_pos[1]+2, ytick_spacing))\n",
    "\n",
    "# NOTE: map has sense only for planar drawing of graph\n",
    "if fig_rch_map:\n",
    "  oxy=np.full((4,19),np.nan)\n",
    "  for n in ch.labels:\n",
    "    oxy[lvls[n],intervals[n]['pre']] = ch.labels[n]\n",
    "  oxy[np.isnan(oxy)] = 0\n",
    "  plt.imshow(oxy,\n",
    "             origin='lower',\n",
    "             # https://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.imshow.html\n",
    "             # https://matplotlib.org/gallery/images_contours_and_fields/interpolation_methods.html\n",
    "             interpolation=interpolation,\n",
    "             aspect='auto',\n",
    "             #cmap=plt.cm.Purples,\n",
    "             cmap=plt.cm.terrain,\n",
    "             #vmin=-8,vmax=len(ch)*2,\n",
    "             alpha=0.3)\n",
    "\n",
    "v = src\n",
    "n_pos=0\n",
    "n_neg=0\n",
    "n_all=len(graph)\n",
    "if True:\n",
    "  if intervals[v]['p_tree'] is not None:\n",
    "    p = intervals[v]['p_tree']\n",
    "    vx= intervals[v]['pre']\n",
    "    yy=-0.3\n",
    "    x_s = intervals[p]['pre']\n",
    "    x_e = intervals[p]['max']\n",
    "    ax.add_line(Line2D([x_s-0.15,x_e+0.15],\n",
    "                       [yy,yy],\n",
    "                       lw=5., alpha=0.3, c='c'))\n",
    "    ax.add_patch(Rectangle((x_s-0.6,-0.25),\n",
    "                           x_e-x_s+1.2,\n",
    "                           max_pos[1]+0.5, facecolor=\"#99ee99\",alpha=0.3))\n",
    "    ax.add_line(Line2D([x_s-0.6,x_s-0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dotted',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "    ax.add_line(Line2D([x_e+0.6,x_e+0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dotted',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "    n_pos += intervals[p]['max']-intervals[p]['pre']+1\n",
    "    nx.draw_networkx_nodes(graph,\n",
    "                       pos=pos,\n",
    "                       nodelist=[p],\n",
    "                       node_size=750,node_color='#22dd22')\n",
    "  \n",
    "  if intervals[v]['max'] < n_all:\n",
    "    ax.add_line(Line2D([intervals[v]['max']+1-0.15,n_all+0.15],\n",
    "                       [-0.25,-0.25],\n",
    "                       lw=5., alpha=0.3, c='r'))\n",
    "    n_neg += n_all - intervals[v]['max']\n",
    "  if intervals[v]['f_min'] > 1:\n",
    "    ax.add_line(Line2D([1,intervals[v]['f_min']-1+0.15],\n",
    "                       [-0.25,-0.25],\n",
    "                       lw=5., alpha=0.3, c='r'))\n",
    "    n_neg += intervals[v]['f_min']-1\n",
    "  if intervals[v]['f_gap'] is not None and \\\n",
    "     intervals[v]['f_gap']+1 <= intervals[v]['pre']-1:\n",
    "    ax.add_line(Line2D([intervals[v]['f_gap']+1-0.15,\n",
    "                        intervals[v]['pre']  -1+0.15],\n",
    "                       [-0.23,-0.23],\n",
    "                       lw=5., alpha=0.3, c='#ff4400'))\n",
    "    n_neg += intervals[v]['pre']-intervals[v]['f_gap']-1\n",
    "    \n",
    "    ax.add_patch(Rectangle((intervals[v]['f_min']-0.6,-0.30),\n",
    "                           intervals[v]['f_gap']-intervals[v]['f_min']+1.2,\n",
    "                           max_pos[1]+0.6, facecolor=\"#aa99aa\",alpha=0.2))\n",
    "    ax.add_patch(Rectangle((intervals[v]['pre']-0.6,-0.30),\n",
    "                           intervals[v]['max']-intervals[v]['pre']+1.2,\n",
    "                           max_pos[1]+0.6, facecolor=\"#aa99aa\",alpha=0.2))\n",
    "  else:\n",
    "    ax.add_patch(Rectangle((intervals[v]['f_min']-0.6,-0.30),\n",
    "                           intervals[v]['max']-intervals[v]['f_min']+1.2,\n",
    "                           max_pos[1]+0.60, facecolor=\"#aa88bb\",alpha=0.2))\n",
    "    \n",
    "  if intervals[v]['pre'] != intervals[v]['max']:\n",
    "    x_s = intervals[v]['pre']\n",
    "    x_e = intervals[v]['max']\n",
    "    ax.add_line(Line2D([x_s-0.15,x_e+0.15],\n",
    "                       [-0.2,-0.2],\n",
    "                       lw=5., alpha=0.3, c='b'))\n",
    "    ax.add_patch(Rectangle((x_s-0.6,-0.25),\n",
    "                           x_e-x_s+1.2,\n",
    "                           max_pos[1]+0.5, facecolor=\"#99ff99\",alpha=0.3))\n",
    "    ax.add_line(Line2D([x_s-0.6,x_s-0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dashed',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "    ax.add_line(Line2D([x_e+0.6,x_e+0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dashed',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "  n_pos += intervals[v]['max']-intervals[v]['pre']\n",
    "\n",
    "#plt.axis('off')\n",
    "plt.xlabel('$\\phi(v)$ -- pre-numbering of nodes in DFS spanning tree')\n",
    "plt.ylabel('$l_v = l(v)$ -- sink-based level of node')\n",
    "plt.title(graph_name+' with DFS spanning-tree derived data\\n'+\n",
    "          'pre DFS number (slightly perturbed) vs node level\\n'+\n",
    "          'starting from node \"'+str(src)+'\"')\n",
    "\n",
    "nx.draw_networkx(graph,\n",
    "                 pos=pos,\n",
    "                 width=8.0,edge_color='#aaaaaa',\n",
    "                 node_size=500,node_color=node_color)\n",
    "nx.draw_networkx_edges(graph,\n",
    "                       pos=pos,\n",
    "                       edgelist=find_dfs_spanning(graph),\n",
    "                       node_size=500,width=2.0,\n",
    "                       arrowstyle='->')\n",
    "nx.draw_networkx_nodes(graph,\n",
    "                       pos=pos,\n",
    "                       nodelist=reachable[src]+[src],\n",
    "                       node_size=550,node_color='#aaffaa')\n",
    "nx.draw_networkx_nodes(graph,\n",
    "                       pos=pos,\n",
    "                       nodelist=[src],\n",
    "                       node_size=650,node_color='#22dd22')\n",
    "\n",
    "plt.show()\n",
    "\n",
    "print('source = %s (%s)' % (src, graph_name))\n",
    "print('- %d nodes' % n_all)\n",
    "print('- %d non n_neg (%d n_neg)' % (n_all - n_neg, n_neg))\n",
    "print('- %d reachable' % len(set(reachable[src])))\n",
    "print('  * %d false positives (not excluded but unreachable)' %\n",
    "      (n_all - n_neg - 1 - len(set(reachable[src]))))\n",
    "print('  * %d false negatives (not included but reachable)' %\n",
    "      (len(set(reachable[src]))-n_pos))\n",
    "print('- %d n_pos (%d n_pos incl.)' % (n_pos, n_pos+1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FERRARI exact and inextact intervals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FELINE-index algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# draw a graph using level-based layout, show its topological ordering\n",
    "\n",
    "nodes=list(nx.topological_sort(sd))\n",
    "#order=order_to_pos(reversed(nodes))\n",
    "order=order_to_pos(nodes)\n",
    "print(nodes)\n",
    "#print(order_to_pos(nodes))\n",
    "print(order)\n",
    "\n",
    "plt.title('Topological order of the small DAG, starting from tips')\n",
    "nx.draw_networkx(sd,\n",
    "                 pos=sd.tree,\n",
    "                 node_size=500,width=3.0,\n",
    "                 edge_color='0.3',node_color='y')\n",
    "nx.draw_networkx_labels(sd,\n",
    "                        pos={k: (v[0]+0.20,v[1]-0.00) \n",
    "                             for (k,v) in sd.tree.items()},\n",
    "                        labels=order);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodes=list(nx.lexicographical_topological_sort(sd))\n",
    "order=order_to_pos(nodes)\n",
    "print(nodes)\n",
    "print(order)\n",
    "\n",
    "plt.title('Lexicograhical topological order of the small DAG, starting from tips')\n",
    "nx.draw_networkx(sd,\n",
    "                 pos=sd.tree,\n",
    "                 node_size=500,width=3.0,\n",
    "                 edge_color='0.3',node_color='y')\n",
    "nx.draw_networkx_labels(sd,\n",
    "                        pos={k: (v[0]+0.20,v[1]-0.00) \n",
    "                             for (k,v) in sd.tree.items()},\n",
    "                        labels=order);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Calculating FELINE index\n",
    "\n",
    "**Algorithm 1:** Index construction (FELINE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def find_feline { form-width: \"30%\" }\n",
    "def find_feline(DG, attr=None, topological_sort=nx.topological_sort):\n",
    "  \"\"\"Generate the coordinates that compose the FELINE index\n",
    "  \n",
    "  The FELINE (Fast rEfined onLINE search) index for a vertex is a unique\n",
    "  ordered pair of natural integers chosen in such way, that the implication\n",
    "  \n",
    "    r(u, v)  =>  x_u <= x_v && y_u <= y_v\n",
    "    \n",
    "  Here r(u, v) means that v is reachable from u, that is that there exist\n",
    "  a path from u to v in directed graph DG.\n",
    "  \n",
    "  The method is based on the idea of weak dominance drawing, where\n",
    "  the above relation for pairs is true for each edge in the DAG.\n",
    "  \n",
    "  One can think of the pair of integers associated with a vertex as\n",
    "  coordinates in the Cartesian plane.\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  attr : str, optional (default=None)\n",
    "      If set, name of a node attribute under which store FELINE index.\n",
    "      \n",
    "  topological_sort : function, optional (default=nx.topological_sort)\n",
    "      Function that given NetworkX DiGraph returns list of its nodes\n",
    "      (vertices) sorted in topological order, starting from \"tips\" nodes\n",
    "      without any incoming edges, and always having vertices before their\n",
    "      descendants.\n",
    "      \n",
    "      Any topological ordering algorithm can be used, but the quality of\n",
    "      the FELINE index generated from it, namely the number of falsely\n",
    "      implied paths, depends on the order chosen.\n",
    "      \n",
    "  Returns:\n",
    "  --------\n",
    "  dict of two-element tuples of ints\n",
    "      Dictionary, where keys are node indices, and values are two element\n",
    "      tuples storing the X and Y coordinates of FELINE index.\n",
    "  \"\"\"\n",
    "  # X and Y are dictionaries of positions,\n",
    "  # xl and yl are sorted lists of nodes\n",
    "  X = order_to_pos(topological_sort(DG))\n",
    "  yl = []\n",
    "  \n",
    "  d = {v: DG.in_degree(v) for v in DG}\n",
    "  roots = [node for node in DG if d[node] == 0]\n",
    "  while roots:\n",
    "    # $u = argmax_{v \\in roots}(X_v)$\n",
    "    u = max(roots, key=X.get)\n",
    "    # Append $u$ to $Y$\n",
    "    yl.append(u)\n",
    "    # Update $d$ and the $roots$ set\n",
    "    roots = [node for node in roots if node != u]\n",
    "    for n in DG.successors(u):\n",
    "      d[n] -= 1\n",
    "      if d[n] == 0:\n",
    "        roots.append(n)\n",
    "    \n",
    "  Y = order_to_pos(yl)\n",
    "  \n",
    "  feline = {v: (X[v],Y[v]) for v in DG}\n",
    "  \n",
    "  if attr is not None:\n",
    "    for node, pos in feline.items():\n",
    "      DG.nodes[node][attr] = deepcopy(pos)\n",
    "  \n",
    "  return feline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testing find_feline on known graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title test find_feline { form-width: \"30%\" }\n",
    "lf.pos=lf.fel\n",
    "for graph_name, graph in graphs.items():\n",
    "  print('%s:' % graph_name)\n",
    "  print(' --> %r' % find_feline(graph))\n",
    "  if hasattr(graph, 'pos'):\n",
    "    print(' pos=%r' % graph.pos)\n",
    "  if hasattr(graph, 'fel'):\n",
    "    print(' fel=%r' % graph.fel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that FELINE index depends on the topological sort ordering of nodes in graph, and there are usually many equivalent topological orderings.  That is why calculated FELINE index differs (or can differ) from the one in FELINE paper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quality of FELINE index (and comparison with paper's version)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def feline_fp (falsely-implied paths) { form-width: \"30%\" }\n",
    "def feline_fp(DG, index):\n",
    "  \"\"\"Given graph and FELINE index, find all falsely implied paths\n",
    "  \n",
    "  Falsely implied paths, or false positives, are those pairs of (u, v) of\n",
    "  vertices, where FELINE indices fullfill the partial order, that is\n",
    "  i(u) ≼ i(v) but vertex 'v' is not reachable from 'u', r(u,v) is false.\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  index : dictionary of two element tuples of ints\n",
    "      Dictionary where keys are vertices (nodes) in graph `DG`, and values\n",
    "      are FELINE index for those vertices.\n",
    "      \n",
    "      Note: currently there is no support for passing FELINE index as\n",
    "      attributes of vertices (of nodes) in the NetworkX graph.\n",
    "      \n",
    "  Returns:\n",
    "  --------\n",
    "  list of two element tuples\n",
    "      The list of (u,v) ∈ V² pairs, where FELINE index implies that there\n",
    "      can exist path from u to v, but v is not reachable from u.\n",
    "  \"\"\"\n",
    "  false_positives = []\n",
    "  \n",
    "  for u in DG:\n",
    "    for v in DG:\n",
    "      # ignore self\n",
    "      if u == v:\n",
    "        continue\n",
    "      # does FELINE index imply reachability u->v\n",
    "      if index[u][0] <= index[v][0] and \\\n",
    "         index[u][1] <= index[v][1]:\n",
    "        # is there no true reachability\n",
    "        if not nx.has_path(DG,u,v):\n",
    "          false_positives.append((u,v))\n",
    "\n",
    "  return false_positives\n",
    "\n",
    "\n",
    "def feline_fp_sample(DG, index, conn, r=None):\n",
    "  \"\"\"Given graph, FELINE index and list of (u,v) pairs, find falsely implied paths\n",
    "  \n",
    "  Falsely implied paths, or false positives, are those pairs of (u, v) of\n",
    "  vertices, where FELINE indices fullfill the partial order, that is\n",
    "  i(u) ≼ i(v) but vertex 'v' is not reachable from 'u', r(u,v) is false.\n",
    "  \n",
    "  This function find false positives only among selected subset of ordered\n",
    "  pairs of vertices.\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  index : dictionary of two element tuples of ints\n",
    "      Dictionary where keys are vertices (nodes) in graph `DG`, and values\n",
    "      are FELINE index for those vertices.\n",
    "      \n",
    "      Note: currently there is no support for passing FELINE index as\n",
    "      attributes of vertices (of nodes) in the NetworkX graph.\n",
    "      \n",
    "  conn : list of  of ordered pairs of vertices\n",
    "      The list defining subset of V² (all possible combinations of vertices\n",
    "      in the graph `DG`) that will be checked for being false positives.\n",
    "  \n",
    "  r : dict, optional\n",
    "      The dictionary where keys are two element tuples of graph nodes, and\n",
    "      values are whether one node is reachable from the other.  r[(u,v)] is\n",
    "      True if r(u,v), that is if v is reachable from u.  r[(u,v)] is False\n",
    "      if r(u,v), that is if v is not reachable from u.\n",
    "      \n",
    "      This information should cover all vertices pairs in `conn` (in the\n",
    "      sample).  It is used to speed up calculations.\n",
    "      \n",
    "      Such data can be calculated by `split_connected_ex()` function,\n",
    "      defined later.\n",
    "  \n",
    "  Returns:\n",
    "  --------\n",
    "  list of two element tuples\n",
    "      The list of (u,v) ∈ `conn` pairs, where FELINE index implies that there\n",
    "      can exist path from u to v, but v is not reachable from u.\n",
    "  \"\"\"\n",
    "  false_positives = []\n",
    "  \n",
    "  for (u,v) in conn:\n",
    "      # ignore self\n",
    "      if u == v:\n",
    "        continue\n",
    "      # does FELINE index imply reachability u->v\n",
    "      if index[u][0] <= index[v][0] and \\\n",
    "         index[u][1] <= index[v][1]:\n",
    "        # is there no true reachability\n",
    "        if r is not None:\n",
    "          # use reachability information from the 'r' hash\n",
    "          if not r[(u,v)]:\n",
    "            false_positives.append((u,v))\n",
    "        else:\n",
    "          # use NetworkX to find reachability\n",
    "          if not nx.has_path(DG,u,v):\n",
    "            false_positives.append((u,v))\n",
    "\n",
    "  return false_positives\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use both feline_fp() and feline_fp_sample() to check both\n",
    "import itertools\n",
    "\n",
    "#@title test feline_fp (falsely-implied paths)\n",
    "print('crown DAG: %r' % feline_fp(DG, DG.pos))\n",
    "print('level DAG: %r' % feline_fp(lf, lf.pos))\n",
    "print('small DAG: %r' %\n",
    "     (feline_fp_sample(sd, sd.pos, itertools.product(sd,sd))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The FELINE paper states that for a small DAG with their FELINE index choice, the vertex $h$, $i(h)$ is in the upper-right quadrant of $i(d)$, but it is not reachable according to the graph (Figure 2-(A) in the FELINE paper).  This means that for \"`small DAG`\"\" the result should include `('d','h')` pair.\n",
    "\n",
    "For the crown DAG known as $S_3^0$ graph, in the related index, we have $i(u) \\preceq i(v)$ even if $r(u, v)$ is false *(false-positive)*.  Graphs such as $S_3^0$ do not admit 2D index which is free of false-positives.  This means that for \"`crown DAG`\" the result should include `('u','v')` pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def level_fp (falsely-implied paths) { form-width: \"25%\" }\n",
    "def level_fp(DG, level):\n",
    "  \"\"\"Given graph and level index, find falsely implied paths\n",
    "  \n",
    "  Falsely implied paths, or false positives, are those pairs of (u, v)\n",
    "  of vertices, where we have l_v < l_u (for u != v), but vertex 'v' is\n",
    "  not reachable from 'u', that is r(u,v) is false.\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  index : dictionary of ints\n",
    "      Dictionary where keys are vertices (nodes) in graph `DG`, and values\n",
    "      are levels (generation numbers) for those vertices.\n",
    "      \n",
    "      Note: currently there is no support for passing level index as\n",
    "      attributes of vertices (of nodes) in the NetworkX graph.\n",
    "      \n",
    "  Returns:\n",
    "  --------\n",
    "  list of two element tuples\n",
    "      The list of (u,v) ∈ V² pairs, where level index implies that there\n",
    "      can exist path from u to v, but v is not reachable from u.\n",
    "  \"\"\"\n",
    "  false_positives = []\n",
    "  \n",
    "  for u in DG:\n",
    "    for v in DG:\n",
    "      # ignore self\n",
    "      if u == v:\n",
    "        continue\n",
    "      # does level index imply/allow reachability u->v\n",
    "      if level[v] < level[u]:\n",
    "        # is there no true reachability\n",
    "        if not nx.has_path(DG,u,v):\n",
    "          false_positives.append((u,v))\n",
    "\n",
    "  return false_positives\n",
    "\n",
    "\n",
    "def level_fp_sample(DG, level, conn, r=None):\n",
    "  \"\"\"Given graph, level index and list of (u,v) pair, find falsely implied paths\n",
    "  \n",
    "  Falsely implied paths, or false positives, are those pairs of (u, v)\n",
    "  of vertices, where we have l_v < l_u (for u != v), but vertex 'v' is\n",
    "  not reachable from 'u', that is r(u,v) is false.\n",
    "  \n",
    "  This function find false positives only among selected subset of ordered\n",
    "  pairs of vertices.\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  index : dictionary of ints\n",
    "      Dictionary where keys are vertices (nodes) in graph `DG`, and values\n",
    "      are levels (generation numbers) for those vertices.\n",
    "      \n",
    "      Note: currently there is no support for passing level index as\n",
    "      attributes of vertices (of nodes) in the NetworkX graph.\n",
    "      \n",
    "  conn : list of  of ordered pairs of vertices\n",
    "      The list defining subset of V² (all possible combinations of vertices\n",
    "      in the graph `DG`) that will be checked for being false positives.\n",
    "  \n",
    "  r : dict, optional\n",
    "      The dictionary where keys are two element tuples of graph nodes, and\n",
    "      values are whether one node is reachable from the other.  r[(u,v)] is\n",
    "      True if r(u,v), that is if v is reachable from u.  r[(u,v)] is False\n",
    "      if r(u,v), that is if v is not reachable from u.\n",
    "      \n",
    "      This information should cover all vertices pairs in `conn` (in the\n",
    "      sample).  It is used to speed up calculations.\n",
    "      \n",
    "      Such data can be calculated by `split_connected_ex()` function,\n",
    "      defined later.\n",
    "        \n",
    "  Returns:\n",
    "  --------\n",
    "  list of two element tuples\n",
    "      The list of (u,v) ∈ V² pairs, where level index implies that there\n",
    "      can exist path from u to v, but v is not reachable from u.\n",
    "  \"\"\"\n",
    "  false_positives = []\n",
    "  \n",
    "  for (u,v) in conn:\n",
    "      \n",
    "      # ignore self\n",
    "      if u == v:\n",
    "        continue\n",
    "      # does level index imply/allow reachability u->v\n",
    "      if level[v] < level[u]:\n",
    "        # is there no true reachability\n",
    "        if (r     and not r[(u,v)]) or \\\n",
    "           (not r and not nx.has_path(DG,u,v)):\n",
    "          false_positives.append((u,v))\n",
    "      \n",
    "      #debug\n",
    "      #print('%s->%s %r %r (%d vs %d)' %\n",
    "      #      (u,v,nx.has_path(DG,u,v),level[v]<level[u],level[u],level[v]))\n",
    "\n",
    "  return false_positives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title test level_fp (falsely-implied paths) { form-width: \"30%\" }\n",
    "import itertools\n",
    "\n",
    "if not hasattr(DG, 'lvl'):\n",
    "  DG.lvl = find_levels(DG)\n",
    "if not hasattr(sd, 'lvl'):\n",
    "  sd.lvl = find_levels(sd)\n",
    "print('crown DAG: %r' % level_fp(DG, DG.lvl))\n",
    "print('crown DAG: %r (sample=full)' %\n",
    "      level_fp_sample(DG, DG.lvl, itertools.product(DG,DG)))\n",
    "print('small DAG: %r' % level_fp(sd, sd.lvl))\n",
    "print('level DAG: %r' % level_fp(lf, lf.lvl))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For crown DAG ($S_3^0$ graph) we have only two levels, each consisting of three nodes.  Each of three source nodes is connected only to two sink nodes.  This means that the false positives / falsely-implied paths for level index in crown DAG should consist of three paths:\n",
    "\n",
    "* $(1, 4)$\n",
    "* $(3, 2)$\n",
    "* $(u, v)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def interval_fn (false negatives) { form-width: \"25%\" }\n",
    "def is_interval_subseteq(a, b):\n",
    "  \"\"\"Whether one interval is subset of or equal to other interval\n",
    "  \n",
    "  Whether interval a = [s_a, e_a] is subset or equal to interval\n",
    "  b = [s_b, e_b]:  I_a ⊆ I_b\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  a : two element list\n",
    "      Two-element list representing an interval.\n",
    "      \n",
    "  b : two element list\n",
    "      Two-element list representing an interval.\n",
    "      \n",
    "  Returns:\n",
    "  --------\n",
    "  bool\n",
    "      Whether I_a ⊆ I_b\n",
    "  \"\"\"\n",
    "  return ((b[0] <= a[0]) and (a[1] <= b[1]))\n",
    "\n",
    "\n",
    "def is_interval_connected(DG, interval, u, v):\n",
    "  \"\"\"Do min-post intervals imply that u->v in graph DG\"\"\"\n",
    "  # II_v ⊆ II_u (positive cut)\n",
    "  return is_interval_subseteq(interval[v], interval[u])\n",
    "\n",
    "  \n",
    "def interval_fn(DG, intervals):\n",
    "  \"\"\"Given graph and min-post index, find false negatives\n",
    "  \n",
    "  False negatives for min-post spanning-tree intervals are those pairs (u,v)\n",
    "  of vertices where r(u,v) but I_v is not subset of I_u; that is min-post\n",
    "  interval doesn't detect existing path.\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  index : dictionary of lists of ints\n",
    "      Dictionary where keys are vertices (nodes) in graph `DG`, and values\n",
    "      are two-element list representing min-post intervals for those vertices.\n",
    "      \n",
    "      Note: currently there is no support for passing min-post index as\n",
    "      attributes of vertices (of nodes) in the NetworkX graph.\n",
    "      \n",
    "  Returns:\n",
    "  --------\n",
    "  list of two element tuples\n",
    "      The list of (u,v) ∈ V² pairs, where v is reachable from u, but the\n",
    "      min-post intervals index doesn't detect this.  Equivalently, where\n",
    "      min-post intervals shows that there could be no path, but it is there.\n",
    "  \"\"\"\n",
    "  false_negatives = []\n",
    "  \n",
    "  for u in DG:\n",
    "    for v in DG:\n",
    "      # ignore self\n",
    "      if u == v:\n",
    "        continue\n",
    "      # does min-post level index imply/allow reachability u->v\n",
    "      if not is_interval_connected(DG, intervals, u, v):\n",
    "        # is there true reachability\n",
    "        if nx.has_path(DG,u,v):\n",
    "          false_negatives.append((u,v))\n",
    "\n",
    "  return false_negatives\n",
    "\n",
    "\n",
    "def interval_fn_sample(DG, intervals, conn, r=None):\n",
    "  \"\"\"Given graph, min-post intervals and list of (u,v) pair, find false negatives\n",
    "  \n",
    "  False negatives for min-post spanning-tree intervals are those pairs (u,v)\n",
    "  of vertices where r(u,v) but I_v is not subset of I_u; that is min-post\n",
    "  interval doesn't detect existing path.\n",
    "  \n",
    "  This function finds false negatives only among selected subset of ordered\n",
    "  pairs of vertices.\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  DG : NetworkX DiGraph\n",
    "      Directed acyclic graph.\n",
    "      \n",
    "  index : dictionary of lists of ints\n",
    "      Dictionary where keys are vertices (nodes) in graph `DG`, and values\n",
    "      are two-element list representing min-post intervals for those vertices.\n",
    "      \n",
    "      Note: currently there is no support for passing min-post index as\n",
    "      attributes of vertices (of nodes) in the NetworkX graph.\n",
    "      \n",
    "  conn : list of  of ordered pairs of vertices\n",
    "      The list defining subset of V² (all possible combinations of vertices\n",
    "      in the graph `DG`) that will be checked for being false positives.\n",
    "  \n",
    "  r : dict, optional\n",
    "      The dictionary where keys are two element tuples of graph nodes, and\n",
    "      values are whether one node is reachable from the other.  r[(u,v)] is\n",
    "      True if r(u,v), that is if v is reachable from u.  r[(u,v)] is False\n",
    "      if r(u,v), that is if v is not reachable from u.\n",
    "      \n",
    "      This information should cover all vertices pairs in `conn` (in the\n",
    "      sample).  It is used to speed up calculations.\n",
    "      \n",
    "      Such data can be calculated by `split_connected_ex()` function,\n",
    "      defined later.\n",
    "        \n",
    "  Returns:\n",
    "  --------\n",
    "  list of two element tuples\n",
    "      The list of (u,v) ∈ V² pairs, where v is reachable from u, but the\n",
    "      min-post intervals index doesn't detect this.  Equivalently, where\n",
    "      min-post intervals shows that there could be no path, but it is there.\n",
    "  \"\"\"\n",
    "  false_negatives = []\n",
    "  \n",
    "  for (u,v) in conn:\n",
    "      \n",
    "      # ignore self\n",
    "      if u == v:\n",
    "        continue\n",
    "      # does min-post level index imply/allow reachability u->v\n",
    "      if not is_interval_connected(DG, intervals, u, v):\n",
    "        # is there true reachability\n",
    "        if (r     and r[(u,v)]) or \\\n",
    "           (not r and nx.has_path(DG,u,v)):\n",
    "          false_negatives.append((u,v))\n",
    "\n",
    "  return false_negatives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title test interval_fn (false negatives)\n",
    "if not hasattr(DG, 'mpi'):\n",
    "  DG.mpi = find_dfs_intervals(DG)\n",
    "if not hasattr(sd, 'mpi'):\n",
    "  sd.mpi = find_dfs_intervals(sd)\n",
    "if not hasattr(lf, 'mpi'):\n",
    "  lf.mpi = find_dfs_intervals(lf)\n",
    "if not hasattr(de, 'mpi'):\n",
    "  de.mpi = find_dfs_intervals(de)\n",
    "print('crown DAG: %r' % interval_fn(DG, DG.mpi))\n",
    "print('crown DAG: %r (sample=full)' %\n",
    "      interval_fn_sample(DG, DG.mpi,\n",
    "                         itertools.product(DG,DG)))\n",
    "print('small DAG: %r' % interval_fn(sd, sd.mpi))\n",
    "print('level DAG: %r' % interval_fn(lf, lf.mpi))\n",
    "print('didactics: %r' % interval_fn(de, de.mpi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a spanning-tree (a spanning-forest, in this case) extracted from the small DAG and indexed with the *min-post* strategy from the FELINE paper, we can conclude that the query $r(a,h)$ will return true, without a search, because $[3,3] \\subseteq [1,5]$ (that is, $I_h \\subseteq I_a$).  However, we can say nothing about the query $r(b,h)$, because there are no tree edges connecting the two vertices.\n",
    "\n",
    "Looking at the small DAG itself instead of just it's spanning tree we wee that $r(b,h)$ is true, despite *min-post* intervals not saying that - *false negative*.  This means that the result for \"`small DAG`\" should include `('b','h')` pair.\n",
    "\n",
    "For DAG that are trees the spanning tree is equal to the graph, so *min-post* intervals give exact results.  This means that the result for \"`didactics`\" should be empty list `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def draw_fp and draw_fp_path { form-width: \"30%\" }\n",
    "def draw_fp_path(ax, pos, path, color='orange'):\n",
    "  \"\"\"Draw single false-positive path using given ax\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  ax : matplotlib Axes object\n",
    "      An ax to add arrow patch (from first vertex to the\n",
    "      second) to the list of axes patches; defines where to draw.\n",
    "      \n",
    "  pos : dictionary of tuples\n",
    "      Dictionary where keys are graph nodes (vertices), including the two\n",
    "      given in `path` parameter, and values are 2D positions.\n",
    "      \n",
    "  path : two-element tuple\n",
    "      Tuple (u,v) where the first element 'u' is the source vertex (node),\n",
    "      and the second element 'v' is the target vertex (node).  This\n",
    "      function draws u->v arrow.\n",
    "      \n",
    "  color : str, optional (default='orange')\n",
    "      The color of the arrow.\n",
    "  \"\"\"\n",
    "  ax.add_patch(\n",
    "    FancyArrowPatch(pos[path[0]],pos[path[1]],\n",
    "                    shrinkA=15,shrinkB=15,\n",
    "                    arrowstyle='fancy',mutation_scale=18,\n",
    "                    linestyle='dashed',hatch='\\\\',color=color)\n",
    "  )\n",
    "\n",
    "  \n",
    "def draw_fp(ax, pos, false_positives, color='orange'):\n",
    "  \"\"\"Draw given false-positive paths using given ax\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  ax : matplotlib Axes object\n",
    "      An ax to add arrow patch (from first vertex to the\n",
    "      second) to the list of axes patches; defines where to draw.\n",
    "      \n",
    "  pos : dictionary of tuples\n",
    "      Dictionary where keys are graph nodes (vertices) and values\n",
    "      are 2D positions.\n",
    "      \n",
    "  false_positives : list of two-element tuple\n",
    "      List of (u_i,v_i) tuples, where for each tuple the first element\n",
    "      u_i is the source node, and the second element v_i is the target\n",
    "      node.\n",
    "      \n",
    "  color : str, optional (default='orange')\n",
    "      The color of drawn arrows.\n",
    "  \"\"\"\n",
    "  for path in false_positives:\n",
    "    draw_fp_path(ax, pos, path, color=color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NetworkX supports the following topological sort algorithms:\n",
    "\n",
    "* `networkx.algorithms.dag.topological_sort` -- Returns nodes in topologically sorted order.\n",
    "* `networkx.algorithms.dag.lexicographical_topological_sort` -- Returns nodes in lexicographically topologically sorted order.\n",
    "\n",
    "Both are based on a description and proof in Manber, U. “_Introduction to Algorithms: A Creative Approach_”, Addison-Wesley (1989)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title topological sorting algorithms list/dict { form-width: \"30%\" }\n",
    "topo_sort_algorithms = {\n",
    "    'lexicographical topological sort (NetworkX)': nx.lexicographical_topological_sort,\n",
    "    'topological sort (NetworkX)': nx.topological_sort,\n",
    "}\n",
    "topo_sort_algorithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Draw known graphs using precomputed (from the FELINE paper) and computed FELINE index as coordinates for 2d weak dominance drawing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Draw a DAG using weak dominance drawing (with FELINE)  { run: \"auto\" }\n",
    "\n",
    "graph_name = 'small DAG' #@param [\"crown DAG\", \"small DAG\", \"didactic\", \"levels DAG\"]\n",
    "topo_sort = 'topological sort (NetworkX)' #@param [\"lexicographical topological sort (NetworkX)\", \"topological sort (NetworkX)\"]\n",
    "fig_sizex = 10 #@param {type:\"slider\", min:5, max:25, step:1}\n",
    "fig_sizey = 15 #@param {type:\"slider\", min:5, max:25, step:1}\n",
    "fig_square = False #@param {type:\"boolean\"}\n",
    "\n",
    "\n",
    "graph=graphs[graph_name]\n",
    "\n",
    "## based on https://matplotlib.org/examples/pylab_examples/subplots_demo.html\n",
    "# Two subplots sharing both x/y axes\n",
    "#fig, (ax1, ax2) = plt.subplots(2, sharex=True, sharey=True)\n",
    "fig, (ax1, ax2) = plt.subplots(2, sharex=False, sharey=False)\n",
    "fig.set_size_inches(fig_sizex,fig_sizey)\n",
    "fig.suptitle(topo_sort, fontsize=14)\n",
    "\n",
    "fp_pos=feline_fp(graph, graph.pos)\n",
    "ax1.set_title('DAG graph \"%s\" and its dominance drawing (from paper) - %d false positives' %\n",
    "              (graph_name, len(fp_pos)))\n",
    "if fig_square:\n",
    "  ax1.set(adjustable='box-forced', aspect='equal')\n",
    "draw_fp(ax1, graph.pos, fp_pos)\n",
    "nx.draw_networkx(graph,pos=graph.pos,\n",
    "                 ax=ax1,\n",
    "                 node_size=500,width=2.0,\n",
    "                 node_color='y')\n",
    "\n",
    "graph.fel=find_feline(graph,\n",
    "                      topological_sort=topo_sort_algorithms[topo_sort])\n",
    "fp_fel=feline_fp(graph, graph.fel)\n",
    "ax2.set_title('DAG graph \"%s\" and its dominance drawing (calculated) - %d false positives' %\n",
    "              (graph_name, len(fp_fel)))\n",
    "if fig_square:\n",
    "  ax2.set(adjustable='box-forced', aspect='equal')\n",
    "draw_fp(ax2, graph.fel, fp_fel)\n",
    "nx.draw_networkx(graph,\n",
    "                 pos=graph.fel,\n",
    "                 ax=ax2,\n",
    "                 node_size=500,width=2.0,\n",
    "                 node_color='c')\n",
    "\n",
    "# Fine-tune figure; make subplots close to each other and hide x ticks for\n",
    "# all but bottom plot.\n",
    "#fig.subplots_adjust(hspace=0)\n",
    "#plt.setp([ax.get_xticklabels() for ax in fig.axes[:-1]], visible=False);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here one can compare FELINE index calculated using NetworkX and the one from FELINE paper for various small DAG used in the description part of the FELINE paper."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reachability queries with FELINE index\n",
    "\n",
    "In this section there would be algorithms for FELINE's query strategy, namely:\n",
    "\n",
    "- **Algorithm 2:** Reachable  \n",
    "from page 515, section 3.3 in FELINE paper\n",
    "- **Algorithm 3:** Reachable  \n",
    "from page 517, section 3.4 in FELINE paper, using  \n",
    "  - min-post interval filter (positive-cut) and \n",
    "  - level filter (negative cut)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def feline_is_reachable, etc. (Algorithm 1: Reachable) { form-width: \"30%\" }\n",
    "def is_pair_leq(a, b):\n",
    "  \"\"\"Whether 2d-pair a precedes pair b in dominance partial order\n",
    "  \n",
    "  For a = (a_x, a_y) and b = (b_x, b_y), the 'precedes or equal' partial\n",
    "  order on ℕ² is defined as:  a ⪯ b  ⇔  a_x <= b_y ∧ a_y <= b_y\n",
    "  \n",
    "  Parameters:\n",
    "  -----------\n",
    "  a, b : tuple\n",
    "      Two-element tuples representing position in 2D space,\n",
    "      an ordered pair of numbers.\n",
    "      \n",
    "  Returns:\n",
    "  --------\n",
    "  bool\n",
    "      Whether pair 'a' is less or equal (precedes or equals) pair 'b'\n",
    "  \"\"\"\n",
    "  return ((a[0] <= b[0]) and (a[1] <= b[1]))\n",
    "\n",
    "\n",
    "def naive_is_reachable(DG, u, v):\n",
    "  \"\"\"Whether in graph DG $v$ is reachable from $u$, naive implemenation\"\"\"\n",
    "  if u == v:\n",
    "    return True\n",
    "  \n",
    "  for w in DG.successors(u):\n",
    "    if naive_is_reachable(DG, w, v):\n",
    "      return True\n",
    "  return False\n",
    "\n",
    "\n",
    "def feline_is_reachable(DG, i, u, v):\n",
    "  \"\"\"Whether in graph DG $v$ is reachable from $u$, utilizing FELINE index\"\"\"\n",
    "  if u == v:\n",
    "    return True\n",
    "  if is_pair_leq(i[u],i[v]):\n",
    "    for w in DG.successors(u):\n",
    "      if feline_is_reachable(DG, i, w, v):\n",
    "        return True\n",
    "  return False\n",
    "\n",
    "\n",
    "def networkx_is_reachable(DG, u, v):\n",
    "  \"\"\"Wrapper around NetworkX reachability method\"\"\"\n",
    "  return nx.has_path(DG,u,v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testing and timing of reachability queries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# falsely-implied path in crown DAG\n",
    "DG.fel=find_feline(DG)\n",
    "#%timeit naive_is_reachable(DG, 'u', 'v')\n",
    "#%timeit feline_is_reachable(DG, DG.pos, 'u', 'v')\n",
    "#%timeit feline_is_reachable(DG, DG.fel, 'u', 'v')\n",
    "#%timeit networkx_is_reachable(DG, 'u', 'v')\n",
    "print('crown DAG: %r' % DG)\n",
    "print('* naive')\n",
    "%time naive_is_reachable(DG, 'u', 'v')\n",
    "print('* FELINE (pre-computed)')\n",
    "%time feline_is_reachable(DG, DG.pos, 'u', 'v')\n",
    "print('* FELINE (find_feline)')\n",
    "%time feline_is_reachable(DG, DG.fel, 'u', 'v')\n",
    "print('* NetworkX')\n",
    "%time networkx_is_reachable(DG, 'u', 'v')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_interval_subseteq(a, b):\n",
    "  \"\"\"Whether one interval is subset of or equal to other interval\n",
    "  \n",
    "  The interval is represented by two-element list or two-element tuple\n",
    "  of numbers (the former implementation is more often used).\n",
    "  \n",
    "  We have for a ≡ I_a = [s_a, e_a] and a ≡ I_a = [s_b, e_b]:\n",
    "  \n",
    "    [s_a, e_a] ⊆ [s_b, e_b]  ⇔   s_b <= s_a ∧ e_a <= e_b\n",
    "    \n",
    "  Parameters\n",
    "  ----------\n",
    "  a : list of numbers\n",
    "      First interval [s_a, e_a] to compare.\n",
    "      \n",
    "  b : list of numbers\n",
    "      Second interval [s_b, e_b] to compare.\n",
    "      \n",
    "  Returns\n",
    "  -------\n",
    "  bool\n",
    "      Whether I_a ⊆ I_b\n",
    "  \"\"\"\n",
    "  return ((b[0] <= a[0]) and (a[1] <= b[1]))\n",
    "\n",
    "\n",
    "a = [0,5]\n",
    "b = [1,3]\n",
    "print(\"%r ⊆ %r: %s\" % (a,b,is_interval_subseteq(a,b)))\n",
    "a = [1,3]\n",
    "b = [0,5]\n",
    "print(\"%r ⊆ %r: %s\" % (a,b,is_interval_subseteq(a,b)))\n",
    "a = [0,3]\n",
    "b = [2,5]\n",
    "print(\"%r ⊆ %r: %s\" % (a,b,is_interval_subseteq(a,b)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def generic_is_reachable (Algorithm 3: Reachable) { form-width: \"30%\" }\n",
    "\n",
    "def generic_is_reachable(DG, u, v,\n",
    "                         i=None, II=None, l=None,\n",
    "                         stats=None, verbose=None):\n",
    "  \"\"\"Whether in graph DG $v$ is reachable from $u$, utilizing given indices\n",
    "  \n",
    "  Given (u, v) ∈ V², two vertices in the DAG given by the DG parameter,\n",
    "  calculate r(u,v), whether vertex v is reachable from vertex u.\n",
    "  \n",
    "  This is Algorithm 3 from FELINE paper, translated from pseudocode to\n",
    "  Python (and NetworkX).\n",
    "  \n",
    "  Parameters\n",
    "  ----------\n",
    "  G : NetworkX digraph\n",
    "      Directed acyclic graph.\n",
    "\n",
    "  u : node\n",
    "      Source node.\n",
    "\n",
    "  v : node\n",
    "      Target node.\n",
    "  \n",
    "  i : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and FELINE index as values\n",
    "      (2d tuples / positions in weak dominance drawing of a graph).\n",
    "  \n",
    "  II : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and min-post interval index as values\n",
    "      (2-element lists, representing intervals).\n",
    "  \n",
    "  l : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and vertex level as values\n",
    "      (vertex level is also known as generation number).\n",
    "  \n",
    "  stats : dict or None, optional (default=None)\n",
    "      A dictionary gathering statistics about calls.  Currently supported\n",
    "      are:\n",
    "       * 'access' key, counting the number of intermediate vertices it\n",
    "         checks / accesses.\n",
    "       * 'feline' key, storing list of vertices where FELINE cut off search\n",
    "       * 'level' key, storing list of vertices where level index cut off\n",
    "         further walk (further search)\n",
    "       * 'walk' key, with list of all vertices walked, in order\n",
    "         \n",
    "  verbose : bool or None, optional (default=None)\n",
    "      Whether to print debugging information.  If set to None (the default),\n",
    "      it prints debugging information if stats parameter is set.\n",
    "  \n",
    "  Returns\n",
    "  -------\n",
    "  r(u,v) : bool\n",
    "      Whether v is reachable from u\n",
    "  \"\"\"\n",
    "  if isinstance(stats, dict):\n",
    "    if verbose is None:\n",
    "      verbose = True\n",
    "    stats.setdefault('access', 0)\n",
    "    stats.setdefault('feline', [])\n",
    "    stats.setdefault('level', [])\n",
    "    stats.setdefault('walk', [])\n",
    "    \n",
    "    stats['walk'].append(u)\n",
    "    \n",
    "  if u == v:\n",
    "    return True\n",
    "  \n",
    "  # II_v ⊆ II_u (positive cut)\n",
    "  if II and is_interval_subseteq(II[v], II[u]):\n",
    "    if verbose:\n",
    "      print('%s->%s min-post resolved %r ⊆ %r' %\n",
    "            (u,v,II[u],II[v]))\n",
    "    if isinstance(stats, dict):\n",
    "      stats['min-post'] = u\n",
    "    return True\n",
    "  \n",
    "  # debugging\n",
    "  if verbose:\n",
    "    if i and not is_pair_leq(i[u], i[v]):\n",
    "      print('%s->%s FELINE cut ¬%r ≼ %r' %\n",
    "            (u,v,i[u],i[v]))\n",
    "    if l and not l[v] < l[u]:\n",
    "      print('%s->%s level cut ¬%d < %d' %\n",
    "            (u,v,l[v],l[u]))\n",
    "  \n",
    "  # i(u) ≼ i(v)  ∧  l_u < l_v (negative cut)\n",
    "  if ((i and is_pair_leq(i[u], i[v])) or (not i)) and \\\n",
    "     ((l and l[v] < l[u]) or (not l)):\n",
    "    # debugging\n",
    "    if verbose:\n",
    "      print('%s->%r' %(u,list(DG.successors(u))))\n",
    "    # worst case analysis\n",
    "    result=False\n",
    "    for w in DG.successors(u):\n",
    "      if isinstance(stats, dict):  \n",
    "        stats['access'] += 1\n",
    "\n",
    "      if generic_is_reachable(DG, w, v, i=i, II=II, l=l,\n",
    "                              stats=stats, verbose=verbose):\n",
    "        # average case\n",
    "        #return True\n",
    "        # worst case analysis\n",
    "        result=True\n",
    "    \n",
    "    # worst case analysis\n",
    "    if result:\n",
    "      return True\n",
    "\n",
    "  else:\n",
    "    # negative cut, but which one\n",
    "    if isinstance(stats, dict):\n",
    "      if i and not is_pair_leq(i[u], i[v]):\n",
    "        stats['feline'].append(u)\n",
    "      if l and not l[v] < l[u]:\n",
    "        stats['level'].append(u)\n",
    "      \n",
    "  \n",
    "  return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def generic_is_reachable_large_v1 (Algorithm 3: Reachable) { form-width: \"30%\" }\n",
    "\n",
    "def generic_is_reachable_large_v1(DG, u, v,\n",
    "                                  i=None, II=None, l=None,\n",
    "                                  stats=None):\n",
    "  \"\"\"Whether in large graph DG $v$ is reachable from $u$, utilizing given indices\n",
    "  \n",
    "  Given (u, v) ∈ V², two vertices in the DAG given by the DG parameter,\n",
    "  calculate r(u,v), whether vertex v is reachable from vertex u.\n",
    "  \n",
    "  This is non-recursive version of the function, without verbose mode,\n",
    "  intended for larger graphs.\n",
    "  \n",
    "  Parameters\n",
    "  ----------\n",
    "  G : NetworkX digraph\n",
    "      Directed acyclic graph.\n",
    "\n",
    "  u : node\n",
    "      Source node.\n",
    "\n",
    "  v : node\n",
    "      Target node.\n",
    "  \n",
    "  i : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and FELINE index as values\n",
    "      (2d tuples / positions in weak dominance drawing of a graph),\n",
    "      e.g. result of find_feline(DG).\n",
    "  \n",
    "  II : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and min-post interval index as values\n",
    "      (2-element lists, representing intervals), e.g. result of\n",
    "      find_dfs_intervals().\n",
    "  \n",
    "  l : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and vertex level as values\n",
    "      (vertex level is also known as generation number), e.g. result of\n",
    "      find_levels().\n",
    "  \n",
    "  stats : dict or None, optional (default=None)\n",
    "      A dictionary gathering statistics about calls.  Currently supported\n",
    "      are:\n",
    "       * 'access' key, counting the number of intermediate vertices it\n",
    "         checks / accesses.\n",
    "       * 'feline-filter' key, storing nodes that FELINE index stopped seaching at\n",
    "       * 'level-filter' key, storing nodes that level index stopped searching at\n",
    "       * 'walk' key, storing all walked nodes\n",
    "       * 'min-post' key, storing node where min-post filter found reachable\n",
    "       * 'maxdepth' key, with maximum stack depth\n",
    "  \n",
    "  Returns\n",
    "  -------\n",
    "  r(u,v) : bool\n",
    "      Whether v is reachable from u\n",
    "  \"\"\"\n",
    "  # initialize stats\n",
    "  if isinstance(stats, dict):\n",
    "    stats['access'] = 0\n",
    "    if i:\n",
    "      stats['feline-filter'] = []\n",
    "    if l:\n",
    "      stats['level-filter'] = []\n",
    "    stats['walk'] = []\n",
    "    stats['maxdepth'] = 0\n",
    "    stats['visited-filter'] = 0\n",
    "\n",
    "  # iteration in place of recursion\n",
    "  stack = []\n",
    "  visited = set() # it somewhat duplicates stats['walk'] list\n",
    "  while u is not None:\n",
    "    \n",
    "    # mark 'u' as visited\n",
    "    visited.add(u)\n",
    "    \n",
    "    if isinstance(stats, dict):\n",
    "      stats['walk'].append(u)\n",
    "      stats['maxdepth'] = max(stats['maxdepth'], len(stack))\n",
    "    \n",
    "    # have we arrived at destintion?\n",
    "    if u == v:\n",
    "      return True\n",
    "  \n",
    "    # II_v ⊆ II_u (positive cut)\n",
    "    if II and is_interval_subseteq(II[v], II[u]):\n",
    "      if isinstance(stats, dict):\n",
    "        stats['min-post'] = u\n",
    "      return True\n",
    "  \n",
    "    # i(u) ≼ i(v)  ∧  l_v < l_u (no negative cut; note: u != v)\n",
    "    if ((i and is_pair_leq(i[u], i[v])) or (not i)) and \\\n",
    "       ((l and l[v] < l[u]) or (not l)):\n",
    "    \n",
    "      # TODO: sort successors\n",
    "      for w in DG.successors(u):\n",
    "        if isinstance(stats, dict):  \n",
    "          stats['access'] += 1\n",
    "\n",
    "        if w not in visited:\n",
    "          stack.append(w)\n",
    "          # TODO: break out of loop, to have DFS\n",
    "          # TODO= needs to remember which successors visited\n",
    "        elif isinstance(stats, dict):\n",
    "          stats['visited-filter'] += 1\n",
    "    \n",
    "    else:\n",
    "      # negative cut, but which one\n",
    "      if isinstance(stats, dict):\n",
    "        if i and not is_pair_leq(i[u], i[v]):\n",
    "          stats['feline-filter'].append(u)\n",
    "        if l and not l[v] < l[u]:\n",
    "          stats['level-filter'].append(u)\n",
    "    \n",
    "    # next iteration\n",
    "    if stack:\n",
    "      u = stack.pop()\n",
    "    else:\n",
    "      # return False only if there is nothing left to do\n",
    "      u = None\n",
    "      return False\n",
    "    # end while\n",
    "    \n",
    "  # haven't found v\n",
    "  return False\n",
    "\n",
    "\n",
    "generic_is_reachable_large = generic_is_reachable_large_v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def generic_is_reachable_large_bfs (breadth-first walk) { form-width: \"30%\" }\n",
    "\n",
    "#from Queue import Queue, PriorityQueue # queue in Python 3\n",
    "from collections import deque\n",
    "\n",
    "\n",
    "def reachable_positive_cut(u, v,\n",
    "                           II=None,\n",
    "                           stats=None):\n",
    "  \"\"\"Whether given indices say that $v$ is reachable from $u$\n",
    "  \n",
    "  Given (u, v) ∈ V², a positive cut is if index implies that\n",
    "  vertex v is reachable from vertex u.\n",
    "  \n",
    "    test(u,v) => r(u,v)\n",
    "    \n",
    "  Parameters\n",
    "  ----------\n",
    "  u : node\n",
    "      Source node.\n",
    "\n",
    "  v : node\n",
    "      Target node.\n",
    "      \n",
    "  II : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and min-post interval index as values\n",
    "      (2-element lists, representing intervals), e.g. result of\n",
    "      find_dfs_intervals().\n",
    "      \n",
    "      Or a dictionary with nodes as keys and dict describing DFS-derived\n",
    "      info, with keys such as 'min' and 'post' describing min-post interval,\n",
    "      and 'f_min', 'f_gap' and 'p_tree' - like in PReaCH paper; e.g result\n",
    "      of find_dfs_intervals_extra().\n",
    "      \n",
    "  stats : dict or None, optional (default=None)\n",
    "      A dictionary gathering statistics about calls (positive cuts).\n",
    "  \n",
    "  Returns\n",
    "  -------\n",
    "  test(u,v) : bool\n",
    "      Whether index indicates that v is reachable from u\n",
    "  \"\"\"\n",
    "  if stats is None:\n",
    "    stats = {}\n",
    "  # no data to indicate that v is reachable from u\n",
    "  if not II:\n",
    "    return False\n",
    "  \n",
    "  # find_dfs_intervals() case\n",
    "  if isinstance(II[u], list):\n",
    "    # II_v ⊆ II_u (positive cut)\n",
    "    if is_interval_subseteq(II[v], II[u]):\n",
    "      stats['positive-cut'] = {\n",
    "        'type': 'min-post',\n",
    "        'node': u\n",
    "      }\n",
    "      return True\n",
    "    \n",
    "  # find_dfs_intervals_extra() case\n",
    "  else:\n",
    "    # ϕ(v) ∈ range(u)  ⇒  r(u,v)\n",
    "    if II[u]['min'] <= II[v]['post'] <= II[u]['post']:\n",
    "      stats['positive-cut'] = {\n",
    "        'type': 'min-post(node)',\n",
    "        'node': u\n",
    "      }\n",
    "      return True\n",
    "    elif II[u]['p_tree'] is not None:\n",
    "      p = II[u]['p_tree']\n",
    "      # r(u,p_tree) ∧ ϕ(v) ∈ range(p_tree)  ⇒  r(u,v)\n",
    "      if II[p]['min'] <= II[v]['post'] <= II[p]['post']:\n",
    "        stats['positive-cut'] = {\n",
    "          'type': 'min-post(p_tree)',\n",
    "          'p_tree': p,\n",
    "          'node': u\n",
    "        }\n",
    "        return True\n",
    "      \n",
    "  # no positive cut\n",
    "  return False\n",
    "        \n",
    "\n",
    "def reachable_negative_cut(u, v,\n",
    "                           i=None, II=None, l=None,\n",
    "                           stats=None):\n",
    "  \"\"\"Whether given indices say that $v$ is not reachable from $u$\n",
    "  \n",
    "  Given (u, v) ∈ V², a positive cut is if index implies that\n",
    "  vertex v is not reachable from vertex u.\n",
    "  \n",
    "    r(u,v) => test(u,v)\n",
    "    \n",
    "  Parameters\n",
    "  ----------\n",
    "  u : node\n",
    "      Source node.\n",
    "\n",
    "  v : node\n",
    "      Target node.\n",
    "\n",
    "  i : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and FELINE index as values\n",
    "      (2d tuples / positions in weak dominance drawing of a graph),\n",
    "      e.g. result of find_feline(DG).\n",
    "\n",
    "  II : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and min-post interval index as values\n",
    "      (2-element lists, representing intervals), e.g. result of\n",
    "      find_dfs_intervals().\n",
    "      \n",
    "      Or a dictionary with nodes as keys and dict describing DFS-derived\n",
    "      info, with keys such as 'min' and 'post' describing min-post interval,\n",
    "      and 'f_min', 'f_gap' and 'p_tree' - like in PReaCH paper; e.g result\n",
    "      of find_dfs_intervals_extra().\n",
    "      \n",
    "  l : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and vertex level as values\n",
    "      (vertex level is also known as generation number), e.g. result of\n",
    "      find_levels().\n",
    "      \n",
    "  stats : dict or None, optional (default=None)\n",
    "      A dictionary gathering statistics about calls (negative cuts).\n",
    "  \n",
    "  Returns\n",
    "  -------\n",
    "  test(u,v) : bool\n",
    "      Whether index indicates that v is not reachable from u\n",
    "  \"\"\"\n",
    "  if stats is None:\n",
    "    stats = {}\n",
    "  # find all conditions that match\n",
    "  # otherwise stats would depend on check order\n",
    "  result = False  # no negative cut\n",
    "  \n",
    "  # we can use levels filter\n",
    "  if l:\n",
    "    # r(u,v)    ∧ u ≠ v  ⇒  l_v < l_u, thus\n",
    "    # l_u ≤ l_v ∧ u ≠ v  ⇒  ¬r(u,v)\n",
    "    if l[u] < l[v]:\n",
    "      stats['negative-cut']['level_lite'].append(u)\n",
    "      result = True\n",
    "    if u != v and l[u] <= l[v]:\n",
    "      stats['negative-cut']['level_full'].append(u)\n",
    "      result = True\n",
    "  \n",
    "  # we can use FELINE index filter ≦ ≧ ≼\n",
    "  if i:\n",
    "    # r(u,v)  ⇒  i(u) ≦ i(v) - vector inequality\n",
    "    if not is_pair_leq(i[u], i[v]):\n",
    "      stats['negative-cut']['FELINE'].append(u)\n",
    "      result = True\n",
    "  \n",
    "  # we can use DFS numbering filter\n",
    "  # from find_dfs_intervals_extended()\n",
    "  if II and isinstance(II[u],dict):\n",
    "    pos = II[v]['post']\n",
    "    if 'f_min' in II[u] and \\\n",
    "       pos < II[u]['f_min']:\n",
    "      stats['negative-cut']['f_min'].append(u)\n",
    "      result = True\n",
    "    if pos > II[u]['post']:\n",
    "      stats['negative-cut']['f_max'].append(u)\n",
    "      result = True\n",
    "    if 'f_gap' in II[u] and \\\n",
    "       II[u]['f_gap'] is not None and \\\n",
    "       II[u]['f_gap'] < pos < II[u]['min']:\n",
    "      stats['negative-cut']['f_gap'].append(u)\n",
    "      result = True\n",
    "  \n",
    "  # no further checks\n",
    "  return result\n",
    "\n",
    "\n",
    "def walk_spanning(DG, u, v, II):\n",
    "  \"\"\"Walk spanning tree from $u$ to $v$, return path or []\"\"\"\n",
    "  path = [u]\n",
    "  while u != v:\n",
    "    for w in DG.successors(u):\n",
    "      # is it in spanning tree\n",
    "      if not reachable_positive_cut(u, w, II):\n",
    "        continue\n",
    "      # can it reach target\n",
    "      if reachable_positive_cut(w, v, II):\n",
    "        u = w\n",
    "        path.append(u)\n",
    "        break\n",
    "    else:\n",
    "      # should not happen - cannot walk spanning tree to v\n",
    "      return None\n",
    "    \n",
    "  return path\n",
    "  \n",
    "\n",
    "def generic_is_reachable_large_bfs(DG, u, v,\n",
    "                                   i=None, II=None, l=None,\n",
    "                                   stats=None):\n",
    "  \"\"\"Whether in large graph DG $v$ is reachable from $u$, utilizing given indices\n",
    "  \n",
    "  Given (u, v) ∈ V², two vertices in the DAG given by the DG parameter,\n",
    "  calculate r(u,v), whether vertex v is reachable from vertex u.\n",
    "  \n",
    "  This is non-recursive version of the function, without verbose mode,\n",
    "  intended for larger graphs.\n",
    "  \n",
    "  Parameters\n",
    "  ----------\n",
    "  G : NetworkX digraph\n",
    "      Directed acyclic graph.\n",
    "\n",
    "  u : node\n",
    "      Source node.\n",
    "\n",
    "  v : node\n",
    "      Target node.\n",
    "  \n",
    "  i : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and FELINE index as values\n",
    "      (2d tuples / positions in weak dominance drawing of a graph),\n",
    "      e.g. result of find_feline(DG).\n",
    "  \n",
    "  II : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and min-post interval index as values\n",
    "      (2-element lists, representing intervals), e.g. result of\n",
    "      find_dfs_intervals().\n",
    "      \n",
    "      Or a dictionary with nodes as keys and dict describing DFS-derived\n",
    "      info, with keys such as 'min' and 'post' describing min-post interval,\n",
    "      and 'f_min', 'f_gap' and 'p_tree' - like in PReaCH paper; e.g result\n",
    "      of find_dfs_intervals_extra().\n",
    "  \n",
    "  l : dict or None, optional (default=None)\n",
    "      A dictionary with nodes as keys and vertex level as values\n",
    "      (vertex level is also known as generation number), e.g. result of\n",
    "      find_levels().\n",
    "  \n",
    "  stats : dict or None, optional (default=None)\n",
    "      A dictionary gathering statistics about calls.\n",
    "  \n",
    "  Returns\n",
    "  -------\n",
    "  r(u,v) : bool\n",
    "      Whether v is reachable from u\n",
    "  \"\"\"\n",
    "  # helper function\n",
    "  def calc_path(u):\n",
    "    path = [u]\n",
    "    u = stats['prev'][u]\n",
    "    while u is not None:\n",
    "      path.append(u)\n",
    "      u = stats['prev'][u]\n",
    "    return list(reversed(path))\n",
    "  \n",
    "  # initialize stats\n",
    "  if stats is None:\n",
    "    stats = {} # to simplify code always gather stats\n",
    "  \n",
    "  # gather info about negative and postive cuts\n",
    "  stats['negative-cut'] = {}\n",
    "  if i:\n",
    "    # using FELINE index for negative cut\n",
    "    stats['negative-cut']['FELINE'] = []\n",
    "  if l:\n",
    "    # using topological levels / generation numbers for negative cut\n",
    "    stats['negative-cut']['level_lite'] = []\n",
    "    stats['negative-cut']['level_full'] = []\n",
    "  if II and isinstance(II[u], dict):\n",
    "    # using DFS traversal data from PReaCH paper for negative cut\n",
    "    stats['negative-cut']['f_max']  = []\n",
    "    if 'f_min' in II[u]:\n",
    "      stats['negative-cut']['f_min'] = []\n",
    "    if 'f_gap' in II[u]:\n",
    "      stats['negative-cut']['f_gap'] = []\n",
    "  # do not visit any node twice\n",
    "  stats['negative-cut']['visited'] = []\n",
    "  \n",
    "  # for finding length of path and path itself\n",
    "  # compare Dijkstra algorithm\n",
    "  stats['depth'] = {}\n",
    "  stats['prev'] = {}\n",
    "  \n",
    "  stats['access'] = 0\n",
    "  stats['walk'] = []\n",
    "  stats['max_queue_size'] = 0\n",
    "\n",
    "  # breadth-first walk in place of recursion\n",
    "  #queue = Queue() # or PriorityQueue()\n",
    "  queue = deque([u])\n",
    "  stats['depth'][u] = 0\n",
    "  stats['prev'][u] = None\n",
    "  visited = set() # it somewhat duplicates stats['walk'] list\n",
    "  stats['visited'] = visited\n",
    "  \n",
    "  while queue:\n",
    "    if len(queue) > stats['max_queue_size']:\n",
    "      stats['max_queue_size'] = len(queue)\n",
    "    \n",
    "    u = queue.popleft()\n",
    "    \n",
    "    # mark 'u' as visited, add to walked\n",
    "    visited.add(u)\n",
    "    stats['walk'].append(u)\n",
    "    \n",
    "    # have we arrived at destination?\n",
    "    if u == v:\n",
    "      stats['path'] = calc_path(u)\n",
    "      stats['len'] = stats['depth'][u]\n",
    "      return True\n",
    "    \n",
    "    # positive cut: we know that 'v' is reachable from 'u'\n",
    "    # end search (in the future: find full path to 'v')\n",
    "    if reachable_positive_cut(u,v,II=II,stats=stats):\n",
    "      stats['path-pre']  = calc_path(u)\n",
    "      stats['path-post'] = walk_spanning(DG,u,v,II=II)\n",
    "      stats['len-pre']  = stats['depth'][u]\n",
    "      stats['len-post'] = len(stats['path-post'])-1\n",
    "      stats['path'] = stats['path-pre'][:-1] + stats['path-post']\n",
    "      stats['len'] = stats['len-pre'] + stats['len-post']\n",
    "      return True\n",
    "    \n",
    "    # negative cut: we know that 'v' is not reachable from 'u'\n",
    "    # continue with next node on the list\n",
    "    if reachable_negative_cut(u,v,l=l,i=i,II=II,stats=stats):\n",
    "      continue\n",
    "    \n",
    "    # walk unvisited parents / successors if not known\n",
    "    for w in DG.successors(u):\n",
    "      stats['access'] += 1\n",
    "\n",
    "      if w not in visited:\n",
    "        queue.append(w)\n",
    "        stats['depth'][w] = stats['depth'][u]+1\n",
    "        stats['prev'][w] = u\n",
    "      else:\n",
    "        stats['negative-cut']['visited'].append(w)\n",
    "        \n",
    "  # we have exhausted search space\n",
    "  return False\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "recalculate = True\n",
    "if recalculate or not hasattr(ch, 'lvl'):\n",
    "  ch.lvl = find_levels(ch) # TODO: pre-computed levels are forward levels\n",
    "if recalculate or not hasattr(ch, 'fel'):\n",
    "  ch.fel = find_feline(ch)\n",
    "if recalculate or not hasattr(ch, 'mpi'):\n",
    "  ch.mpi = find_dfs_intervals(ch)\n",
    "if recalculate or not hasattr(ch, 'mpi_x'):\n",
    "  ch.mpi_x = find_dfs_intervals_extra(ch)\n",
    "\n",
    "print('%r' % ch)\n",
    "for (attr,val) in ch.__dict__.items():\n",
    "  if isinstance(val, dict) and not attr.startswith('_'):\n",
    "    print('- %s' % attr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title test generic_is_reachable_large_bfs { form-width: \"30%\" }\n",
    "print('crown DAG: %r' % DG)\n",
    "print('- r(u,v): %r' % \n",
    "      generic_is_reachable_large_bfs(DG,'u','v',\n",
    "                                     i=DG.fel,l=DG.lvl,II=DG.mpi))\n",
    "print('- r(1,2): %r' %\n",
    "      generic_is_reachable_large_bfs(DG, 1,  2,\n",
    "                                     i=DG.fel,l=DG.lvl,II=DG.mpi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Reachability in PReaCH graph { run: \"auto\", form-width: \"30%\" }\n",
    "import pprint\n",
    "\n",
    "graph_name = 'PReaCH DAG'\n",
    "node_color = \"#ffaaaa\" #@param [\"y\", \"m\", \"c\", \"b\", \"g\", \"r\"] {allow-input: true}\n",
    "\n",
    "xtick_spacing = 1\n",
    "ytick_spacing = 1\n",
    "fig_sizex = 14\n",
    "fig_sizey =  7\n",
    "\n",
    "src = \"d\" #@param [\"a\",\"c\",\"b\",\"d\",\"g\",\"f\",\"k\"]\n",
    "dst = \"q\" #@param [\"p\",\"o\",\"q\",\"n\",\"l\",\"e\",\"i\"]\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches(fig_sizex,fig_sizey)\n",
    "\n",
    "ax=plt.gca()\n",
    "\n",
    "graph=ch\n",
    "intervals=ch.mpi_x\n",
    "lvls=ch.lvl\n",
    "reachable=find_reachable(graph)\n",
    "\n",
    "pos={v: (intervals[v]['post']+0.2*(lvls[v]%2)-0.1,\n",
    "         lvls[v])\n",
    "     for v in graph}\n",
    "max_pos=(\n",
    "  max([x for (x,y) in pos.values()]),\n",
    "  max([y for (x,y) in pos.values()])\n",
    ")\n",
    "dd=(\n",
    "  -0.30*(max_pos[0]/5.0),\n",
    "  +0.14*(max_pos[1]/4.0)\n",
    ")\n",
    "max_level = max(lvls.values())\n",
    "\n",
    "ax.xaxis.set_ticks(np.arange(0, max_pos[0]+1, xtick_spacing))\n",
    "ax.yaxis.set_ticks(np.arange(0, max_pos[1]+2, ytick_spacing))\n",
    "\n",
    "v = src\n",
    "n_all=len(graph)\n",
    "\n",
    "stats = {}\n",
    "res = generic_is_reachable_large_bfs(ch,\n",
    "                                     src,dst,\n",
    "                                     l=ch.lvl,II=ch.mpi_x,\n",
    "                                     stats=stats)\n",
    "\n",
    "if True:\n",
    "  if intervals[v]['p_tree'] is not None:\n",
    "    p = intervals[v]['p_tree']\n",
    "    vx= intervals[v]['post']\n",
    "    yy=-0.3\n",
    "    ax.add_line(Line2D([intervals[p]['min']-0.15,intervals[p]['post']+0.15],\n",
    "                       [yy,yy],\n",
    "                       lw=5., alpha=0.3, c='c'))\n",
    "    ax.add_patch(Rectangle((intervals[p]['min']-0.6,-0.25),\n",
    "                           intervals[p]['post']-intervals[p]['min']+1.2,\n",
    "                           max_pos[1]+0.5, facecolor=\"#99ee99\",alpha=0.3))\n",
    "    ax.add_line(Line2D([intervals[p]['min']-0.6,intervals[p]['min']-0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dotted',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "    ax.add_line(Line2D([intervals[p]['post']+0.6,intervals[p]['post']+0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dotted',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "  \n",
    "  if intervals[v]['post'] < n_all:\n",
    "    ax.add_line(Line2D([intervals[v]['post']+1-0.15,n_all+0.15],\n",
    "                       [-0.25,-0.25],\n",
    "                       lw=5., alpha=0.3, c='r'))\n",
    "\n",
    "  if intervals[v]['f_min'] > 1:\n",
    "    ax.add_line(Line2D([1,intervals[v]['f_min']-1+0.15],\n",
    "                       [-0.25,-0.25],\n",
    "                       lw=5., alpha=0.3, c='r'))\n",
    "\n",
    "  if lvls[dst] == 0:\n",
    "    y_low = -0.30\n",
    "  else:\n",
    "    y_low = lvls[dst] - 0.5\n",
    "  if lvls[src] == max_level:\n",
    "    y_high = max_level + 0.30\n",
    "  else:\n",
    "    y_high = lvls[src] + 0.5\n",
    "  if intervals[v]['f_gap'] is not None and \\\n",
    "     intervals[v]['f_gap']+1 <= intervals[v]['min']-1:\n",
    "    ax.add_line(Line2D([intervals[v]['f_gap']+1-0.15,\n",
    "                        intervals[v]['min']  -1+0.15],\n",
    "                       [-0.23,-0.23],\n",
    "                       lw=5., alpha=0.3, c='#ff4400'))\n",
    "    ax.add_patch(Rectangle((intervals[v]['f_min']-0.6,y_low),\n",
    "                           intervals[v]['f_gap']-intervals[v]['f_min']+1.2,\n",
    "                           y_high-y_low, facecolor=\"#aa99aa\",alpha=0.2))\n",
    "    ax.add_patch(Rectangle((intervals[v]['min']  -0.6,y_low),\n",
    "                           intervals[v]['post']-intervals[v]['min']+1.2,\n",
    "                           y_high-y_low, facecolor=\"#aa99aa\",alpha=0.2))\n",
    "    \n",
    "  else:\n",
    "    ax.add_patch(Rectangle((intervals[v]['f_min']-0.6,y_low),\n",
    "                           intervals[v]['post']-intervals[v]['f_min']+1.2,\n",
    "                           y_high-y_low, facecolor=\"#aa88bb\",alpha=0.2))\n",
    "    \n",
    "  if intervals[v]['min'] != intervals[v]['post']:\n",
    "    ax.add_line(Line2D([intervals[v]['min']-0.15,intervals[v]['post']+0.15],\n",
    "                       [-0.2,-0.2],\n",
    "                       lw=5., alpha=0.3, c='b'))\n",
    "    ax.add_patch(Rectangle((intervals[v]['min']-0.6,-0.25),\n",
    "                           intervals[v]['post']-intervals[v]['min']+1.2,\n",
    "                           max_pos[1]+0.5, facecolor=\"#99ff99\",alpha=0.3))\n",
    "    ax.add_line(Line2D([intervals[v]['min']-0.6,intervals[v]['min']-0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dashed',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "    ax.add_line(Line2D([intervals[v]['post']+0.6,intervals[v]['post']+0.6],\n",
    "                       [-0.25,max_pos[1]+0.25],\n",
    "                       linestyle='dashed',\n",
    "                       lw=2.5,c='g',alpha=0.3))\n",
    "\n",
    "  nx.draw_networkx_nodes(graph,\n",
    "                         pos=pos,\n",
    "                         nodelist=stats['depth'].keys(),\n",
    "                         node_size=910,node_color='#ffffcc') # cream yellow\n",
    "  nx.draw_networkx_nodes(graph,\n",
    "                         pos=pos,\n",
    "                         nodelist=stats['walk'],\n",
    "                         node_size=900,node_color='#fedf00') # Yellow (Pantone)\n",
    "  \n",
    "  if intervals[v]['p_tree'] is not None:\n",
    "    nx.draw_networkx_nodes(graph,\n",
    "                           pos=pos,\n",
    "                           nodelist=[p],\n",
    "                           node_size=750,node_color='#22dd22')\n",
    "\n",
    "#plt.axis('off')\n",
    "plt.xlabel('$\\phi(v)$ -- post-numbering of nodes in spanning tree')\n",
    "plt.ylabel('$l_v = l(v)$ -- sink-based level of node')\n",
    "plt.title(graph_name+' with DFS spanning-tree derived data\\n'+\n",
    "          'post DFS number (slightly perturbed) vs node level\\n'+\n",
    "          'checking reachability \"'+str(src)+'\" -> \"'+str(dst)+'\"')\n",
    "\n",
    "# draw path, if it exists\n",
    "if res:\n",
    "  if 'path-pre' in stats:\n",
    "    nx.draw_networkx_edges(graph,\n",
    "                           pos=pos,\n",
    "                           edgelist=zip(stats['path-pre'],\n",
    "                                        stats['path-pre'][1:]),\n",
    "                           width=16.0,edge_color='#A020F0',alpha=0.4,\n",
    "                           arrowstyle='-')\n",
    "    nx.draw_networkx_edges(graph,\n",
    "                           pos=pos,\n",
    "                           edgelist=zip(stats['path-post'],\n",
    "                                        stats['path-post'][1:]),\n",
    "                           width=14.0,edge_color='#E0B0FF',alpha=0.9,\n",
    "                           arrowstyle='-')\n",
    "  else:\n",
    "    nx.draw_networkx_edges(graph,\n",
    "                           pos=pos,\n",
    "                           edgelist=zip(stats['path'],stats['path'][1:]),\n",
    "                           width=16.0,edge_color='#f300fe',alpha=0.5,\n",
    "                           arrowstyle='-')\n",
    "\n",
    "nx.draw_networkx(graph,\n",
    "                 pos=pos,\n",
    "                 width=8.0,edge_color='#aaaaaa',\n",
    "                 node_size=500,node_color=node_color)\n",
    "nx.draw_networkx_edges(graph,\n",
    "                       pos=pos,\n",
    "                       edgelist=find_dfs_spanning(graph),\n",
    "                       node_size=500,width=2.0,\n",
    "                       arrowstyle='->')\n",
    "nx.draw_networkx_nodes(graph,\n",
    "                       pos=pos,\n",
    "                       nodelist=reachable[src]+[src],\n",
    "                       node_size=550,node_color='#aaffaa')\n",
    "nx.draw_networkx_nodes(graph,\n",
    "                       pos=pos,\n",
    "                       nodelist=[src],\n",
    "                       node_size=650,node_color='#22dd22')\n",
    "nx.draw_networkx_nodes(graph,\n",
    "                       pos=pos,\n",
    "                       nodelist=[dst],\n",
    "                       node_size=650,node_color='#4444dd')\n",
    "\n",
    "if res:\n",
    "  nx.draw_networkx_labels(graph,\n",
    "                          pos=pos,\n",
    "                          labels={n:n for n in stats['path']},\n",
    "                          font_weight='bold')\n",
    "\n",
    "plt.show()\n",
    "\n",
    "print('%s: %s -> %s' % (graph_name, src, dst))\n",
    "print('- %d nodes' % n_all)\n",
    "print('- r(%s,%s): %r (NetworkX)' % (src, dst, nx.has_path(ch,src,dst)))\n",
    "\n",
    "print('- r(%s,%s): %r' % (src, dst, res))\n",
    "pp = pprint.PrettyPrinter(indent=2)\n",
    "pp.pprint(stats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test that using indices leads to accessing less nodes:\n",
    "\n",
    "* didactic example of a DAG from Figure 6 in the FELINE paper, where FELINE index discards vertices\n",
    "* example from Figure 9 in the FELINE paper, where there is false-implied path between them by FELINE index, but the *level filter* prunes the search\n",
    "* example where we can use *min-post* indexing for a spanning tree extracted from the small DAG (Figure 8 in the FELINE paper) can answer reachability query without search\n",
    "* example where we can use *min-post* indexing cannot answer reachability query without search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title generic_is_reachable in a didactic example of a DAG { form-width: \"30%\" }\n",
    "stats = {}\n",
    "result = generic_is_reachable(de, 'a', 'g', stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (naive)\\n  %r\\n' %\n",
    "      ('a', 'g', result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable(de, 'a', 'g', i=de.pos, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE, pre-calculated)\\n  %r' %\n",
    "      ('a', 'g', result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats = {}\n",
    "result = generic_is_reachable_large(de, 'a', 'g', stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (naive)\\n  %r' %\n",
    "      ('a', 'g', result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable_large(de, 'a', 'g', i=de.pos, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE, pre-calculated)\\n  %r' %\n",
    "      ('a', 'g', result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not hasattr(de, 'lvl'):\n",
    "  print('find_levels(de)\\n')\n",
    "  de.lvl=find_levels(de)\n",
    "\n",
    "stats = {}\n",
    "result = generic_is_reachable(de, 'a', 'c', stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (naive)\\n' %\n",
    "      ('a', 'c', result, stats['access']))\n",
    "stats = {}\n",
    "result = generic_is_reachable(de, 'a', 'c', l=de.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (levels)\\n  %r\\n' %\n",
    "      ('a', 'c', result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable(de, 'a', 'c', i=de.pos, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE, pre-calculated)\\n  %r' %\n",
    "      ('a', 'c', result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats = {}\n",
    "result = generic_is_reachable_large(de, 'a', 'c', stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (naive)\\n  %r' %\n",
    "      ('a', 'c', result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable_large(de, 'a', 'c', l=de.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (levels)\\n  %r' %\n",
    "      ('a', 'c', result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable_large(de, 'a', 'c', i=de.pos, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE, pre-calculated)\\n  %r' %\n",
    "      ('a', 'c', result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title generic_is_reachable in a level-filter example { form-width: \"30%\" }\n",
    "print('Level filter example (Figure 9 in FELINE paper)\\n')\n",
    "\n",
    "graph=lf\n",
    "u='e'\n",
    "v='g'\n",
    "stats = {}\n",
    "result = generic_is_reachable(graph, u, v, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (naive)\\n' %\n",
    "      (u, v, result, stats['access']))\n",
    "stats = {}\n",
    "result = generic_is_reachable(graph, u, v, i=graph.pos, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE, pre-calculated)\\n' %\n",
    "      (u, v, result, stats['access']))\n",
    "stats = {}\n",
    "result = generic_is_reachable(graph, u, v, l=graph.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (levels, pre-calculated)\\n' %\n",
    "      (u, v, result, stats['access']))\n",
    "stats = {}\n",
    "result = generic_is_reachable(graph, u, v, i=graph.pos, l=graph.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE+levels, pre-calculated)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph=lf\n",
    "u='e'\n",
    "v='g'\n",
    "stats = {}\n",
    "result = generic_is_reachable_large(graph, u, v, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (naive)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable_large(graph, u, v, i=graph.pos, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE, pre-calculated)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable_large(graph, u, v, l=graph.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (levels, pre-calculated)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable_large(graph, u, v, i=graph.pos, l=graph.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE+levels, pre-calculated)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph=lf\n",
    "for (u,v) in [('a','h'), ('b','h')]:\n",
    "  print('r(%s,%s) ###################################\\n' % (u,v))\n",
    "  stats = {}\n",
    "  result = generic_is_reachable_large(graph, u, v, stats=stats)\n",
    "  print('r(%s,%s)=%r in %d steps (naive)\\n  %r' %\n",
    "        (u, v, result, stats['access'], stats))\n",
    "\n",
    "  stats = {}\n",
    "  result = generic_is_reachable_large(graph, u, v, l=graph.lvl, stats=stats)\n",
    "  print('r(%s,%s)=%r in %d steps (levels, pre-calculated)\\n  %r' %\n",
    "        (u, v, result, stats['access'], stats))\n",
    "\n",
    "  stats = {}\n",
    "  result = generic_is_reachable_large(graph, u, v, i=graph.pos, stats=stats)\n",
    "  print('r(%s,%s)=%r in %d steps (FELINE, pre-calculated)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))\n",
    "\n",
    "  stats = {}\n",
    "  result = generic_is_reachable_large(graph, u, v, i=graph.pos, l=graph.lvl, stats=stats)\n",
    "  print('r(%s,%s)=%r in %d steps (FELINE+level, pre-calculated)\\n  %r\\n' %\n",
    "        (u, v, result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title generic_is_reachable in a small DAG, with min-post intervals { form-width: \"30%\" }\n",
    "print('Min-post interval filter example (Figure 8 in FELINE paper)\\n')\n",
    "\n",
    "u='a'\n",
    "v='h'\n",
    "print('r(%s,%s) ###################################\\n' % (u,v))\n",
    "stats = {}\n",
    "result = generic_is_reachable(sd, u, v, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (naive)\\n' %\n",
    "      (u, v, result, stats['access']))\n",
    "stats = {}\n",
    "result = generic_is_reachable(sd, u, v, i=sd.pos, II=sd.mpi, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE+min-post, pre-calculated)\\n  %r\\n' %\n",
    "      (u, v, result, stats['access'], stats))\n",
    "\n",
    "u='b'\n",
    "v='h'\n",
    "print('r(%s,%s) ###################################\\n' % (u,v))\n",
    "stats = {}\n",
    "result = generic_is_reachable(sd, u, v, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (naive)\\n  %r\\n' %\n",
    "      (u, v, result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable(sd, u, v, i=sd.pos, II=sd.mpi, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE+min-post, pre-calculated)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u='a'\n",
    "v='h'\n",
    "print('r(%s,%s) ###################################\\n' % (u,v))\n",
    "stats = {}\n",
    "result = generic_is_reachable_large(sd, u, v, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (naive)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable_large(sd, u, v, i=sd.pos, II=sd.mpi, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE+min-post, pre-calculated)\\n  %r\\n' %\n",
    "      (u, v, result, stats['access'], stats))\n",
    "\n",
    "u='b'\n",
    "v='h'\n",
    "print('r(%s,%s) ###################################\\n' % (u,v))\n",
    "stats = {}\n",
    "result = generic_is_reachable_large(sd, u, v, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (naive)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable_large(sd, u, v, i=sd.pos, II=sd.mpi, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (FELINE+min-post, pre-calculated)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reachability query stats for sample\n",
    "\n",
    "Given sample of $(u,v) \\in V^2$ pairs and some \"is reachable\" query, gather statistics about processing reachability query, like e.g. number of nodes walked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title TODO: def sample_queries { form-width: \"25%\" }\n",
    "\n",
    "import itertools\n",
    "\n",
    "graph = ch\n",
    "srclist = ['a','c','b','d','g','f','k']\n",
    "dstlist = ['p','o','q','n','l','e','i']\n",
    "\n",
    "stats_x = {}\n",
    "\n",
    "for (src,dst) in itertools.product(srclist,dstlist):\n",
    "  stats_x[(src,dst)] = {}\n",
    "  result = generic_is_reachable_large_bfs(graph, src, dst,\n",
    "                                          l=graph.lvl, II=graph.mpi_x,\n",
    "                                          i=graph.fel,\n",
    "                                          stats=stats_x[(src,dst)])\n",
    "  stats_x[(src,dst)]['result'] = result\n",
    "  stats_x[(src,dst)]['has_path'] = nx.has_path(graph, src, dst)\n",
    "\n",
    "stats_items = []\n",
    "stats_columns = ['res','path','access','maxdepth','maxqueue',\n",
    "                 'walk','len','len-pre',\n",
    "                 'visited','lvl_lite','lvl_full',\n",
    "                 'f_max','f_rest','p_tree','FEL','FEL/max','pos-cut']\n",
    "for t in sorted(stats_x, key=lambda k: stats_x[k]['access']):\n",
    "  stats_items_values = []\n",
    "  for st in ['result','has_path','access']:\n",
    "    stats_items_values.append(stats_x[t][st])\n",
    "  stats_items_values.append(max(stats_x[t]['depth'].values()))\n",
    "  for st in ['max_queue_size']:\n",
    "    stats_items_values.append(stats_x[t][st])\n",
    "  for st in ['walk']:\n",
    "    stats_items_values.append(len(stats_x[t][st]))\n",
    "  for st in ['len','len-pre']:\n",
    "    if st in stats_x[t]:\n",
    "      stats_items_values.append(stats_x[t][st])\n",
    "    else:\n",
    "      #stats_items_values.append(np.nan)\n",
    "      stats_items_values.append(None)\n",
    "      \n",
    "  if 'negative-cut' in stats_x[t]:\n",
    "    if 'visited' in stats_x[t]['negative-cut']:\n",
    "      stats_items_values.append(len(stats_x[t]['negative-cut']['visited']))\n",
    "    else:\n",
    "      stats_items_values.append(np.nan)\n",
    "    if 'level_full' in stats_x[t]['negative-cut']:\n",
    "      stats_items_values.extend([\n",
    "        len(stats_x[t]['negative-cut']['level_lite']),\n",
    "        len(stats_x[t]['negative-cut']['level_full']),\n",
    "      ])\n",
    "    else:\n",
    "      stats_items_values.extend([np.nan,np.nan])\n",
    "    if 'f_max' in stats_x[t]['negative-cut']:\n",
    "      stats_items_values.append(len(stats_x[t]['negative-cut']['f_max']))\n",
    "    else:\n",
    "      stats_items_values.append(np.nan)\n",
    "    if 'f_min' in stats_x[t]['negative-cut']:\n",
    "      stats_items_values.append(len(\n",
    "            (set(stats_x[t]['negative-cut']['f_min']) |\n",
    "             set(stats_x[t]['negative-cut']['f_gap']))\n",
    "            -\n",
    "            set(stats_x[t]['negative-cut']['f_max'])\n",
    "      ))\n",
    "      if 'positive-cut' in stats_x[t] and \\\n",
    "         'p_tree' in stats_x[t]['positive-cut']:\n",
    "        stats_items_values.append(stats_x[t]['positive-cut']['p_tree'])\n",
    "      else:\n",
    "        stats_items_values.append(None)\n",
    "    else:\n",
    "      stats_items_values.extend([np.nan,np.nan])\n",
    "    if 'FELINE' in stats_x[t]['negative-cut']:\n",
    "      stats_items_values.append(len(stats_x[t]['negative-cut']['FELINE']))\n",
    "      if 'f_max' in stats_x[t]['negative-cut']:\n",
    "        stats_items_values.append(len(\n",
    "            set(stats_x[t]['negative-cut']['FELINE']) -\n",
    "            set(stats_x[t]['negative-cut']['f_max'])))\n",
    "      else:\n",
    "        stats_items_values.append(np.nan)\n",
    "    else:\n",
    "      stats_items_values.extend([np.nan,np.nan])\n",
    "      \n",
    "  else:\n",
    "    stats_items_values.extend([np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan])\n",
    "  \n",
    "  if 'positive-cut' in stats_x[t]:\n",
    "    stats_items_values.append(True)\n",
    "  else:\n",
    "    stats_items_values.append(False)\n",
    "  \n",
    "  stats_items.append((t, stats_items_values))                         \n",
    "\n",
    "# .astype({col: 'int64' for col in stats_columns[2:]})\n",
    "stats_df = pd.DataFrame.from_items(stats_items,orient='index',\n",
    "                                   columns=stats_columns)\\\n",
    "                       .sort_values('access', ascending=False)\n",
    "#pp.pprint(stats_x)\n",
    "stats_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title reachability queries for PReaCH graph { form-width: \"25%\" }\n",
    "stats_df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('positive queries: u can reach v:')\n",
    "stats_df[stats_df['res']]['res'].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Weak dominance drawing (and related drawing algorithms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def draw_dominance { form-width: \"25%\" }\n",
    "def draw_dominance(graph,title=None,\n",
    "                   draw_false_positives=False,square=False,\n",
    "                   with_labels=True,\n",
    "                   ax=None,node_color='y',node_size=500,edge_width=2.0):\n",
    "  \"\"\"Draw graph using weak dominance drawing with FELINE index\n",
    "  \n",
    "  The FELINE index, where every vertex in the DAG is associated with a pair\n",
    "  (x,y) ∈ ℕ² can be represented graphically; each such pair is understood\n",
    "  as 2D coordinates in the Cartesian plane.  This function uses this\n",
    "  representation to draw given graph.\n",
    "  \n",
    "  TODO: using colormap to show level index value.\n",
    "  TODO: modify false-positives marker width to match edges width.\n",
    "  TODO: configure false-positives marker color.\n",
    "  \n",
    "  Parameters\n",
    "  ----------\n",
    "  graph : NetworkX graph\n",
    "      Graph to draw.  If the graph has 'pos' attribute, or 'fel' attribute,\n",
    "      its values are used as positions of vertices.  Otherwise `find_feline()`\n",
    "      is used to calculate FELINE index and store it in 'fel' attribute\n",
    "      of the graph.\n",
    "      \n",
    "  title : str, optional\n",
    "      Title of the plot, shown above the drawn graph.\n",
    "      \n",
    "  draw_false_positives : bool (optional, default: False)\n",
    "      Whether to draw arrows showing false positives, that is paths \n",
    "      falsely-implied by FELINE index.\n",
    "      \n",
    "      NOTE: currently not configurable wrt. color or arrow width/size.\n",
    "      \n",
    "  square : bool (optional, default: False)\n",
    "      Whether to enforce square aspect ratio of the plot.\n",
    "      \n",
    "  with_labels : bool (optional, default: True)\n",
    "      Set to True to draw labels on the nodes.  Not recommended for larger\n",
    "      graphs.\n",
    "      \n",
    "  ax : Matplotlib Axes object, optional\n",
    "       Draw the graph in the specified Matplotlib axes.\n",
    "       \n",
    "  node_color : color string (optional, default: 'y')\n",
    "       Node color. Can be a single color format string,\n",
    "       or may be a sequence of colors with the same length as nodelist.\n",
    "       See matplotlib.scatter for more details.\n",
    "       \n",
    "  node_size : number (optional, default=500)\n",
    "       Size of nodes.\n",
    "       If an array is specified it must be the same length as nodelist.\n",
    "       You are recommended to set it to sufficiently small value for\n",
    "       large graphs.\n",
    "       \n",
    "  edge_width : float (optional, default: 2.0)\n",
    "       Line width of edges.  You are recommended to set it to smaller value\n",
    "       for large graphs.\n",
    "  \"\"\"\n",
    "  try:\n",
    "    pos=graph.pos\n",
    "  except AttributeError:\n",
    "    try:\n",
    "      pos=graph.fel\n",
    "    except AttributeError:\n",
    "      graph.fel=find_feline(graph)\n",
    "      pos=graph.fel\n",
    "  \n",
    "  if ax is None:\n",
    "    ax=plt.gca()\n",
    "  \n",
    "  if title is not None:\n",
    "    ax.set_title(title)\n",
    "  \n",
    "  if draw_false_positives:\n",
    "    fp_pos=feline_fp(graph, pos)\n",
    "    draw_fp(ax, pos, fp_pos)\n",
    "    \n",
    "  if square:\n",
    "    ax.set(adjustable='box-forced', aspect='equal')\n",
    "\n",
    "  nx.draw_networkx(graph,\n",
    "                   pos=pos,\n",
    "                   ax=ax,\n",
    "                   with_labels=with_labels,\n",
    "                   node_size=node_size,width=edge_width,\n",
    "                   node_color=node_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title test draw_dominance { run: \"auto\", form-width: \"30%\", display-mode: \"form\" }\n",
    "\n",
    "graph_name = 'small DAG' #@param [\"crown DAG\", \"small DAG\", \"didactic\", \"levels DAG\"]\n",
    "fig_false_positives = True #@param {type:\"boolean\"}\n",
    "fig_square = True #@param {type:\"boolean\"}\n",
    "\n",
    "graph=graphs[graph_name]\n",
    "\n",
    "plt.title('Dominance drawing of '+graph_name)\n",
    "draw_dominance(graph,\n",
    "               draw_false_positives=fig_false_positives,\n",
    "               square=fig_square)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### TODO: Reverse FELINE index\n",
    "\n",
    "In section _\"4.3.3  FELINE-B Approach\"_ (page 518) in FELINE paper, authors point out that in many graphs, the out-degrees and in-degrees follow different distribution.  They have examined FELINE index for reversed graph (with reversed edges) $G^T$, and noticed that they present different placements.\n",
    "\n",
    "Obviously the query $r(u,v)$ in the DAG $G$ is equivalent to the $r(v,u)$ in the reversed DAG $G^T$, but as the vertices have different coordinates in each index, each one performs different to the same query."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Version control graphs\n",
    "\n",
    "In this section we will test how well FELINE index (and other things) help with version-control graphs, mainly with commit graphs in Git."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# http://gitpython.readthedocs.io/en/stable/intro.html#installing-gitpython\n",
    "!pip install -q gitpython\n",
    "import git\n",
    "\n",
    "print(git.__version__)\n",
    "git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above ensures that [GitPython][] is installed.  This is one of ways to access Git repositories in Python, besides [pygit2][] and running and parsing git commands output.\n",
    "\n",
    "[GitPython]: http://gitpython.readthedocs.io/en/stable/index.html \"GitPython Documentation\"\n",
    "[pygit2]: http://www.pygit2.org/index.html \"pygit2 documentation\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### git.git commit graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "!git clone -q https://github.com/git/git.git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time to clone `git.git` repository is counted in tens of seconds (around 20-30 s)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get that repo to GitPython\n",
    "repo = git.Repo('git')\n",
    "repo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use GitPython's git.Repo() to create graph of commits\n",
    "# (limited to first 50 commits)\n",
    "count = 0\n",
    "for commit in repo.iter_commits(all=True, max_count=50):\n",
    "  count += 1\n",
    "  if count < 10:\n",
    "    print(commit.hexsha)\n",
    "    \n",
    "print('\\ncount:')\n",
    "print(count)\n",
    "!git -C git rev-list -50 --all | wc -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# progress bar for Python\n",
    "!pip install -q tqdm\n",
    "from tqdm import tqdm\n",
    "tqdm\n",
    "\n",
    "# Google Colaboratory is incompatible with IPyWidgets\n",
    "# https://stackoverflow.com/questions/47269168/ipywidgets-with-google-colaboratory\n",
    "#!pip install -q ipywidgets\n",
    "#from tqdm import tqdm, tnrange, tqdm_notebook\n",
    "#from ipywidgets import IntProgress"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create commit graph out of git command output\n",
    "!git -C git log --format=\"%h %p\" -10 --topo-order\n",
    "!git -C git log --format=\"%h %p\" -20 --topo-order >git-commit_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# preliminary calculations for creating git.git commit graph\n",
    "n_commits = 0\n",
    "n_edges = 0\n",
    "max_parents = 0\n",
    "\n",
    "lines = [line.rstrip('\\n') for line in open('git-commit_list')]\n",
    "edges = []\n",
    "for line in tqdm(lines):\n",
    "  elems = line.split()\n",
    "  commit, parents = (elems[0], elems[1:])\n",
    "  n_commits += 1\n",
    "  max_parents = max(max_parents, len(parents))\n",
    "  for parent in parents:\n",
    "    edges.append((commit, parent))\n",
    "    n_edges += 1 \n",
    "\n",
    "print('\\n') # progress bar from tqdm\n",
    "print('%d lines in \"%s\" file' % (len(lines), 'git-commit_list'))\n",
    "print('commits = %d; edges = %d; max_parents = %d' % (n_commits, n_edges, max_parents))\n",
    "print('edges=%r' % edges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%%prun\n",
    "#repo_graph = nx.DiGraph()\n",
    "#repo_graph.clear()\n",
    "#print('nodes in graph: %d (clear)' % repo_graph.number_of_nodes())\n",
    "\n",
    "#with tqdm(total=count,desc='commits') as pbar:\n",
    "#  for commit in repo.iter_commits(all=True, max_count=50):\n",
    "#    commit += 1\n",
    "#    for parent in commit.iter_parents():\n",
    "#      edges += 1\n",
    "#      repo_graph.add_edge(commit.hexsha, parent.hexsha)\n",
    "#    pbar.update(1)\n",
    "\n",
    "print('create commit graph out of \"edges\" list, from \"%s\" file:' % 'git-commit_list')\n",
    "%time repo_graph=nx.DiGraph(edges)\n",
    "\n",
    "print('\\n\\nnodes in graph: %d' % repo_graph.number_of_nodes())\n",
    "print('edges in graph: %d (graph size)' % repo_graph.size())\n",
    "print('commits = %d; edges = %d' % (n_commits, n_edges))\n",
    "print('graph: %r' % repo_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the graph would have more than 20 nodes, because it includes parents of each of 20 commits.  \n",
    "Time to create 20+ commit graph is around 200 microseconds."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Draw fragment of git.git commit graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('Position nodes using spring layout: '+\n",
    "          'Fruchterman-Reingold force-directed algorithm (draw_spring).\\n'+\n",
    "          'NOTE: initial positions are randomized')\n",
    "nx.draw_spring(repo_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('Position nodes using Kamada-Kawai force-directed layout: '+\n",
    "          'Kamada-Kawai path-length cost-function (draw_kamada_kawai).')\n",
    "nx.draw_kamada_kawai(repo_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('Position nodes using spectral layout: '+\n",
    "          'using the eigenvectors of the graph Laplacian (draw_spectral).')\n",
    "nx.draw_spectral(repo_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# git own's textual graphing\n",
    "!git -C git log --graph --color=never --decorate --format=\"%h: %p\" -20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat git-commit_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find all nodes, based on source used to create graph\n",
    "import itertools\n",
    "chain = itertools.chain.from_iterable([[a,b] for (a,b) in edges])\n",
    "nodes = set(chain)\n",
    "nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find all nodes that have more than one incoming and more than one outcoming edge\n",
    "from collections import defaultdict\n",
    "in_degree =defaultdict(int)\n",
    "out_degree=defaultdict(int)\n",
    "\n",
    "for (u,v) in edges:\n",
    "  out_degree[u] += 1\n",
    "  in_degree[v]  += 1\n",
    "\n",
    "print('out_degree=%r' % out_degree)\n",
    "print(' in_degree=%r' %  in_degree)\n",
    "print('')\n",
    "\n",
    "# these may be no longer present in first 20 commits of newer clone\n",
    "#for c in ['7be97e414', '6a0714835', '1614dd0fb']:\n",
    "#  print c\n",
    "#  print '  edges containing: ',[(u,v) for (u,v) in edges if u == c or v == c]\n",
    "#  print '  in / out degrees: ',in_degree[c], out_degree[c]\n",
    "\n",
    "print('nodes with  in-degree > 1:\\n* %r' %\n",
    "      [u for u in nodes if in_degree[u] > 1])\n",
    "print('nodes with out-degree > 1:\\n* %r' %\n",
    "      [u for u in nodes if out_degree[u] > 1])\n",
    "print('nodes with both in-degree and out-degree > 1:\\n* %r' %\n",
    "      [u for u in nodes if in_degree[u] > 1 and out_degree[u] > 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('First 20+ commits in the git.git repository')\n",
    "draw_dominance(repo_graph,with_labels=False,draw_false_positives=True,node_size=100,edge_width=1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Draw fragment of larger part of git.git commit graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git -C git log --format=\"%h %p\" origin/master origin/next origin/maint --topo-order -40 >git-commit_list_x\n",
    "\n",
    "edges = []\n",
    "with open('git-commit_list_x', 'r') as f:\n",
    "  for line in f:\n",
    "    elems = line.split()\n",
    "    commit, parents = (elems[0], elems[1:])\n",
    "    for parent in parents:\n",
    "      edges.append((commit, parent))\n",
    "repo_graph_x = nx.DiGraph(edges)\n",
    "\n",
    "print('repo_graph_x %r has %d nodes and %d edges' %\n",
    "      (repo_graph_x, repo_graph_x.number_of_nodes(), repo_graph_x.size()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('First 40+ commits in the git.git repository\\ndominance drawing')\n",
    "draw_dominance(repo_graph_x,with_labels=False,draw_false_positives=False,node_size=50,edge_width=1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('First 40+ commits in the git.git repository\\ndominance drawing, smallnode size')\n",
    "draw_dominance(repo_graph_x,with_labels=False,node_size=15,edge_width=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('FELINE index positions for first 40+ commits in the git.git repository')\n",
    "plt.scatter(x=np.array([x for (x,y) in repo_graph_x.fel.values()]),\n",
    "            y=np.array([y for (x,y) in repo_graph_x.fel.values()]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def draw_feline { form-width: \"25%\" }\n",
    "def draw_feline(graph,title=None,color='b'):\n",
    "  \"\"\"Draw FELINE index positions for a graph\n",
    "  \n",
    "  The FELINE index, where every vertex in the DAG is associated with a pair\n",
    "  (x,y) ∈ ℕ² can be represented graphically; each such pair is understood\n",
    "  as 2D coordinates in the Cartesian plane.  This function uses this\n",
    "  representation to draw scatter plot.\n",
    "  \n",
    "  TODO: draw multiple graphs, or multiple versions of FELINE index, like\n",
    "  FELINE and FELINE-I (for inverted graph) on one plot.\n",
    "  \n",
    "  Parameters\n",
    "  ----------\n",
    "  graph : NetworkX graph\n",
    "      Graph to draw.  If the graph has 'pos' attribute, or 'fel' attribute,\n",
    "      its values are used as positions of vertices.  Otherwise `find_feline()`\n",
    "      is used to calculate FELINE index and store it in 'fel' attribute\n",
    "      of the graph.\n",
    "      \n",
    "  title : str, optional\n",
    "      Title of the plot, shown above the drawn graph.\n",
    "            \n",
    "  color : color string (optional, default: 'b')\n",
    "       Node color. Can be a single color format string,\n",
    "       or may be a sequence of colors with the same length as nodelist.\n",
    "       See matplotlib.scatter for more details.\n",
    "  \"\"\"\n",
    "  try:\n",
    "    pos=graph.pos\n",
    "  except AttributeError:\n",
    "    try:\n",
    "      pos=graph.fel\n",
    "    except AttributeError:\n",
    "      graph.fel=find_feline(graph)\n",
    "      pos=graph.fel\n",
    "  \n",
    "  if title is not None:\n",
    "    plt.title(title)\n",
    "    \n",
    "  plt.scatter(x=np.array([x for (x,y) in pos.values()]),\n",
    "              y=np.array([y for (x,y) in pos.values()]),\n",
    "              c=color)\n",
    "  plt.show()\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Full git.git commit graph and its properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "!git -C git log --format=\"%h %p\" --all --topo-order >git-commit_list_full\n",
    "\n",
    "edges = []\n",
    "commits = []\n",
    "with open('git-commit_list_full', 'r') as f:\n",
    "  for line in f:\n",
    "    elems = line.split()\n",
    "    commit, parents = (elems[0], elems[1:])\n",
    "    commits.append(commit)\n",
    "    for parent in parents:\n",
    "      edges.append((commit, parent))\n",
    "repo_graph_full = nx.DiGraph(edges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('%d commits, %d edges' % (len(commits), len(edges)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "repo_graph_full.topo=commits\n",
    "repo_graph_full.topo[:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating `git.git` commit graph takes around 2.5 seconds (in remote runtime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('find levels:')\n",
    "%time repo_graph_full.lvl = find_levels(repo_graph_full)\n",
    "print('\\nfind FELINE:')\n",
    "%time repo_graph_full.fel = find_feline(repo_graph_full)\n",
    "print('\\nfind min-post intervals:')\n",
    "%time repo_graph_full.mpi = find_dfs_intervals(repo_graph_full)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All times to calculate different graph indices for `git.git` commit graph take around 1 second;  \n",
    "levels / generation numbers and FELINE index around 0.8 s, while min-post intervals around 1.3 s."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **Table 1: Datasets** in FELINE paper (page 517) describes various small and large, sparse and dense real-world DAGs.  This tale shows some characteristics of graphs, such as:\n",
    "\n",
    "*   number of vertices $\\lvert V \\rvert$\n",
    "*   number of edges $\\lvert E \\rvert$, where $E \\subseteq V^2$\n",
    "*   clustering coefficient\n",
    "*   effective diameter (instead of diameter)\n",
    "*   number of \"roots\", vertices with no incoming edges\n",
    "*   number of \"leafs\", vertices with no outgoing edges\n",
    "\n",
    "The authors (of either the dataset collection, or of FELINE paper) used the SNAP software <http://snap.stanford.edu/snap/> to compute these values.\n",
    "\n",
    "The NetworkX package has []`average_clustering`][average_clustering] method to estimate the clustering coefficient (or to be more exact, for DAG `graph` it is `nx.average_clustering(graph.to_undirected())`).\n",
    "\n",
    "[average_clustering]: https://networkx.github.io/documentation/latest/reference/algorithms/generated/networkx.algorithms.approximation.clustering_coefficient.average_clustering.html#networkx.algorithms.approximation.clustering_coefficient.average_clustering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Table 1: Datasets { form-width: \"25%\" }\n",
    "\n",
    "import io\n",
    "\n",
    "csv=u\"\"\"Graph;vertices;edges;Cluster coeff.;Eff. diameter;roots;leafs\n",
    "arXiv;6000;66707;0.35;5.48;961;624\n",
    "Yago;6642;42392;0.24;6.57;5176;263\n",
    "Go;6793;13361;0.07;10.92;64;3087\n",
    "Pubmed;9000;40028;0.10;6.32;2609;4702\n",
    "citeseer;10720;44258;0.28;8.36;4572;1868\n",
    "Uniprot22m;1595444;1595442;0.00;3.3;1556157;1\n",
    "Cit-patents;3774768;16518047;0.09;10.5;515785;1685423\n",
    "citeseerx;6540401;15011260;0.06;8.4;567149;5740710\n",
    "Go-uniprot;6967956;34770235;0.00;4.8;6945721;4\n",
    "Uniprot100m;16087295;16087293;0.00;4.1;14598959;1\n",
    "Uniprot150m;25037600;25037598;0.00;4.4;21650056;1\n",
    "\"\"\"\n",
    "csv_stream = io.StringIO(csv)\n",
    "\n",
    "table_1=pd.read_csv(csv_stream,sep=';',index_col=0)\n",
    "table_1.insert(loc=2,column='edges[%]',\n",
    "               value=100.0*(table_1['edges']/(table_1['vertices']**2)))\n",
    "table_1.insert(loc=3,column='edges/vertices',\n",
    "               value=table_1['edges']/table_1['vertices'])\n",
    "table_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "graph = repo_graph_full\n",
    "graph_name = 'git.git'\n",
    "\n",
    "n_nodes = graph.number_of_nodes()\n",
    "n_edges = graph.size()\n",
    "print('%s commit graph has %d nodes and %d edges (size)' %\n",
    "      (graph_name, n_nodes, n_edges))\n",
    "print('%s commit graph has %d possible paths\\n' %\n",
    "      (graph_name, n_nodes*(n_nodes-1)))\n",
    "\n",
    "heads = find_heads(graph)\n",
    "roots = find_roots(graph)\n",
    "print('%s commit graph has %d tips / heads (\"roots\"): %r' %\n",
    "      (graph_name, len(heads),heads))\n",
    "print('%s commit graph has %d roots (\"leaves\"): %r' %\n",
    "      (graph_name, len(roots),roots))\n",
    "\n",
    "clustering_coeff = nx.average_clustering(graph.to_undirected())\n",
    "print('%s commit graph has average clustering coefficient %g (%d trials ?)\\n' %\n",
    "      (graph_name, clustering_coeff, 1000))\n",
    "# NetworkXError: Found infinite path length because the digraph is not strongly connected\n",
    "#print('%s commit graph has the diameter of %g\\n' %\n",
    "#      (graph_name, nx.diameter(graph)))\n",
    "\n",
    "commit_graphs_df = pd.DataFrame({\n",
    "    'Graph': [graph_name],\n",
    "    'vertices': [n_nodes],\n",
    "    'edges': [n_edges],\n",
    "    'Cluster coeff.': [clustering_coeff],\n",
    "    'roots': [len(heads)],\n",
    "    'leafs': [len(roots)],\n",
    "},columns=['Graph','vertices','edges',\n",
    "           'Cluster coeff.','Eff. diameter',\n",
    "           'roots','leafs']).set_index('Graph')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wall time for computing different parameters of the git.git commit graph take around 2.5 seconds; mainly (?) in finding estimation of the clustering coefficient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git commit graph dataset { form-width: \"25%\" }\n",
    "df=commit_graphs_df\n",
    "\n",
    "df.insert(loc=2,column='edges[%]',\n",
    "          value=100.0*(df['edges']/(df['vertices']**2)))\n",
    "df.insert(loc=3,column='edges/vertices',\n",
    "          value=df['edges']/df['vertices'])\n",
    "commit_graphs_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculating parameters of the git.git commit graphs: distribution of in-degree, out-degree and level\n",
    "graph_info_df=pd.DataFrame.from_dict(repo_graph_full.lvl,orient='index').rename(columns={0: 'level'})\n",
    "graph_info_df.index.name='node'\n",
    "graph_info_df['FELINE']=pd.Series(repo_graph_full.fel)\n",
    "graph_info_df['min-post']=pd.Series(repo_graph_full.mpi)\n",
    "graph_info_df['in degree']=pd.Series(dict(repo_graph_full.in_degree()))\n",
    "graph_info_df['out degree']=pd.Series(dict(repo_graph_full.out_degree()))\n",
    "graph_info_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph_info_df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "level_counts=graph_info_df['level'].value_counts()\n",
    "level_counts_values=level_counts.values\n",
    "\n",
    "plt.title('Histogram of level counts')\n",
    "plt.xlabel('Level counts')\n",
    "level_counts.plot.hist(bins=50)\n",
    "#pd.cut(level_counts_values,50)\n",
    "\n",
    "level_counts.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git levels count plot { form-width: \"30%\" }\n",
    "import seaborn as sns\n",
    "sns.set()\n",
    "\n",
    "level_counts_df=pd.DataFrame({'counts': level_counts})\n",
    "level_counts_df.index.name='level'\n",
    "level_counts_df.sort_index(inplace=True)\n",
    "level_counts_df.plot();\n",
    "\n",
    "plt.title('%s commit graph - number of nodes with given level' %\n",
    "          'git.git');\n",
    "plt.xlabel('level of node / vertex');\n",
    "plt.ylabel('number of nodes / vertices');\n",
    "\n",
    "level_counts_df.describe().T.rename(index={'counts': 'level counts'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "roll_10=level_counts_df.rolling(10, min_periods=1).min().rename(columns={'counts': 'roll=10'})\n",
    "roll_20=level_counts_df.rolling(20, min_periods=1).min().rename(columns={'counts': 'roll=20'})\n",
    "combined_df=level_counts_df.join(roll_10).join(roll_20)\n",
    "combined_df.plot(color=['b','g','r']);\n",
    "\n",
    "plt.title('%s commit graph - number of nodes with given level, or rolling minumim' %\n",
    "          'git.git');\n",
    "plt.xlabel('level of node / vertex');\n",
    "plt.ylabel('number of nodes / vertices');\n",
    "\n",
    "combined_df.describe(percentiles=[.1, .25, .5, .75, .9, .99]).T.rename(index={'counts': 'level counts'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git feline plot, level colormap { form-width: \"30%\" }\n",
    "%%time\n",
    "graph=repo_graph_full\n",
    "pos=graph.fel\n",
    "\n",
    "plt.title('git.git commit graph nodes in dominance drawing (FELINE)\\n'+\n",
    "          'colored according to node level / generation number')\n",
    "plt.xlabel('FELINE x / topological order position')\n",
    "plt.ylabel('FELINE $\\Delta$ = x-y')\n",
    "\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([(x-y) for (x,y) in pos.values()])\n",
    "larr = np.array([graph.lvl[n] for n in pos.keys()])\n",
    "\n",
    "ax = plt.gca()\n",
    "sc = plt.scatter(x=xarr, y=yarr,\n",
    "                 c=larr, cmap=plt.cm.jet,\n",
    "                 s=5,\n",
    "                 label='graph')\n",
    "cbar = plt.colorbar(sc, extend='both', shrink=0.9, ax=ax)\n",
    "cbar.set_label('level')\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "graph=repo_graph_full\n",
    "pos=graph.fel\n",
    "\n",
    "plt.title('git.git commit graph nodes in dominance drawing (FELINE)\\n'+\n",
    "          'colored according to node level / generation number')\n",
    "plt.xlabel('FELINE x / topological order position')\n",
    "plt.ylabel('FELINE y')\n",
    "\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "larr = np.array([graph.lvl[n] for n in pos.keys()])\n",
    "\n",
    "ax = plt.gca()\n",
    "sc = plt.scatter(x=xarr, y=yarr,\n",
    "                 c=larr, cmap=plt.cm.jet,\n",
    "                 s=5,\n",
    "                 label='graph')\n",
    "cbar = plt.colorbar(sc, extend='both', shrink=0.9, ax=ax)\n",
    "cbar.set_label('level')\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git draw_feline { form-width: \"30%\" }\n",
    "draw_feline(repo_graph_full, title='git.git commit graph - FELINE positions')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "draw_feline(repo_graph_full.reverse(copy=True),\n",
    "            title='git.git commit graph - FELINE-I positions')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git FELINE and FELINE-I { form-width: \"30%\" }\n",
    "plt.title('git.git commit graph - FELINE positons')\n",
    "\n",
    "pos=repo_graph_full.fel\n",
    "plt.scatter(x=np.array([x for (x,y) in pos.values()]),\n",
    "            y=np.array([y for (x,y) in pos.values()]),\n",
    "            c='b',s=20, label='FELINE')\n",
    "pos=find_feline(repo_graph_full.reverse())\n",
    "plt.scatter(x=np.array([x for (x,y) in pos.values()]),\n",
    "            y=np.array([y for (x,y) in pos.values()]),\n",
    "            c='g',s=20, label='FELINE-I')\n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('git.git commit graph - FELINE positons')\n",
    "\n",
    "pos=repo_graph_full.fel\n",
    "plt.scatter(x=np.array([x for (x,y) in pos.values()]),\n",
    "            y=np.array([y for (x,y) in pos.values()]),\n",
    "            c='b',s=20, label='FELINE (topo)')\n",
    "pos=find_feline(repo_graph_full,topological_sort=nx.lexicographical_topological_sort)\n",
    "plt.scatter(x=np.array([x for (x,y) in pos.values()]),\n",
    "            y=np.array([y for (x,y) in pos.values()]),\n",
    "            c='g',s=15, label='FELINE (lexi)')\n",
    "pos=find_feline(repo_graph_full,topological_sort=lambda G: G.topo)\n",
    "plt.scatter(x=np.array([x for (x,y) in pos.values()]),\n",
    "            y=np.array([y for (x,y) in pos.values()]),\n",
    "            c='m',s=10, label='FELINE (git)')\n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos=repo_graph_full.fel\n",
    "plt.scatter(x=np.array([x for (x,y) in pos.values()]),\n",
    "            y=np.array([y for (x,y) in pos.values()]),\n",
    "            c='b',s=20, label='FELINE (topo)')\n",
    "#pos=find_feline(repo_graph_full,topological_sort=nx.lexicographical_topological_sort)\n",
    "#plt.scatter(x=np.array([x for (x,y) in pos.values()]),\n",
    "#            y=np.array([y for (x,y) in pos.values()]),\n",
    "#            c='g',s=15, label='FELINE (lexi)')\n",
    "pos=find_feline(repo_graph_full,topological_sort=lambda G: G.topo)\n",
    "plt.scatter(x=np.array([x for (x,y) in pos.values()]),\n",
    "            y=np.array([y for (x,y) in pos.values()]),\n",
    "            c='m',s=15, alpha=0.9, marker='+', label='FELINE (git)')\n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Finding paths / checking reachability between two commits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "graph = repo_graph_full\n",
    "\n",
    "print('max level in %s commit graph is %d (out of %d nodes)\\n' % \n",
    "      ('git.git', max(graph.lvl.values()),graph.number_of_nodes()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('max commits at given level: %d' %max(level_counts))\n",
    "lmax=max(level_counts.keys(), key=lambda k: level_counts[k])\n",
    "print('level with max commits is %d (out of %d) with %d commits' %\n",
    "      (lmax, max(graph.lvl.values()), level_counts[lmax]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "graph = repo_graph_full\n",
    "\n",
    "print('commits with level %d:\\n* %r\\n' %\n",
    "      (lmax, [c for (c,l) in graph.lvl.items() if l == lmax]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tags = sorted([tagref for tagref in repo.tags if tagref.object.object.type == 'commit'], \n",
    "              key=lambda t: t.commit.committed_datetime,\n",
    "              reverse=True)\n",
    "[(t, str(t.commit.hexsha[:9])) for t in tags[:10]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = repo_graph_full\n",
    "\n",
    "c='468165c1d'\n",
    "l=graph.lvl[c]\n",
    "n=level_counts[l]\n",
    "\n",
    "#print('commit %s in %s commit graph has level=%d;\\n'+\n",
    "#      'there are %d commits with the same level' %\n",
    "#      (c, 'git.git', l, n))\n",
    "print('commit %s in %s commit graph has level=%d\\nthere are %d commits with the same level\\n* %r' %\n",
    "      (c, 'git.git', l, n,\n",
    "       [cc for (cc,ll) in graph.lvl.items() if ll == l]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hex1 = repo.tag('refs/tags/v2.17.0').tag.object.hexsha\n",
    "print('%s -> %s\\n         %r' %\n",
    "      ('v2.17.0', hex1, [n for n in repo_graph_full if hex1.startswith(n)]))\n",
    "hex2 = repo.tag('refs/tags/v2.17.0-rc2').tag.object.hexsha\n",
    "print('%s -> %s\\n             %r' %\n",
    "      ('v2.17.0-rc2', hex2, [n for n in repo_graph_full if hex2.startswith(n)]))\n",
    "hex3 = repo.tag('refs/tags/v2.16.2').tag.object.hexsha\n",
    "print('%s -> %s\\n         %r' %\n",
    "      ('v2.16.2', hex3, [n for n in repo_graph_full if hex3.startswith(n)]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git -C git rev-list --count v2.17.0-rc2..v2.17.0\n",
    "!git -C git rev-list --count v2.16.2..v2.17.0\n",
    "!git -C git rev-list --count v2.16.2..v2.17.0-rc2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git -C git rev-list --count v2.17.0-rc2..2b5ed3736"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git: v2.17.0 -> v2.17.0-rc2 { form-width: \"30%\" }\n",
    "%%time\n",
    "import pprint\n",
    "\n",
    "stats_l={\n",
    "    'naive': {},\n",
    "    'level': {},\n",
    "    'feline': {},\n",
    "    'level+feline':{},\n",
    "    'level+feline+mpi':{},\n",
    "}\n",
    "u='468165c1d' # v2.17.0\n",
    "#u='2b5ed3736'\n",
    "v='03df49594' # v2.17.0-rc2\n",
    "#v='ffa952497' # v2.16.2\n",
    "print('%s -> %s' %(u,v))\n",
    "\n",
    "graph = repo_graph_full\n",
    "\n",
    "if u in graph and v in graph:\n",
    "\n",
    "  print('- naive')\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             stats=stats_l['naive'])\n",
    "  print('- level (generation numbers)')\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             l=graph.lvl,\n",
    "                             stats=stats_l['level'])\n",
    "  print('- FELINE')\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             i=graph.fel,\n",
    "                             stats=stats_l['feline'])\n",
    "  print('- FELINE+level')\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             l=graph.lvl,i=graph.fel,\n",
    "                             stats=stats_l['level+feline'])\n",
    "  print('- FELINE+level+min-post')\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             l=graph.lvl,i=graph.fel,II=graph.mpi,\n",
    "                             stats=stats_l['level+feline+mpi'])\n",
    "  \n",
    "  pp = pprint.PrettyPrinter(indent=4)\n",
    "  stats_l['naive']['len(walk)'] = len(stats_l['naive']['walk'])\n",
    "  del stats_l['naive']['walk']\n",
    "  pp.pprint(stats_l)\n",
    "  \n",
    "else:\n",
    "  print('not in graph')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git -C git rev-list --topo-order --count 03df49594..468165c1d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rev_to_node(repo, graph, revision):\n",
    "  \"\"\"Find node in [commit] graph corresponding to given revision\n",
    "  \n",
    "  Parameters\n",
    "  ----------\n",
    "  repo : GitPython repository\n",
    "      git.Repo used to resolve revisions.  Should be the same repository\n",
    "      the commit graph was created from.\n",
    "      \n",
    "  graph : NetworkX DiGraph\n",
    "      The DAG representing subset of the commit graph of repository.  This\n",
    "      function finds matching nodes in this graph.  It is assumed that node\n",
    "      names are shortened SHA-1 identifiers of commit objects.\n",
    "      \n",
    "  revision : str or unicode\n",
    "      String that can be parsed as git revision in given repository.  It may\n",
    "      be full SHA-1 identifier, or shortened SHA-1, or branch, or tag name.\n",
    "      \n",
    "  Returns\n",
    "  -------\n",
    "  node : str\n",
    "      Node corresponding to given revision.\n",
    "  \"\"\"\n",
    "  try:\n",
    "    hexsha = str(repo.rev_parse(revision+'^{}').hexsha)\n",
    "    nodes = [n for n in graph if hexsha.startswith(n)]\n",
    "    if nodes:\n",
    "      return nodes[0]\n",
    "    else:\n",
    "      return None\n",
    "    \n",
    "  except git.exc.BadName:\n",
    "    return None\n",
    "  \n",
    "\n",
    "rev_to_node(repo, repo_graph_full, 'v2.17.0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rev_to_node(repo, repo_graph_full, '468165c1d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git: src -> dst { form-width: \"30%\" }\n",
    "src = \"468165c1d\" #@param [\"468165c1d\", \"2b5ed3736\", \"03df49594\"] {allow-input: true}\n",
    "dst = \"66d2e04ec\" #@param [\"03df49594\", \"ffa952497\", '777c55a61', '414382fb0', '4bf256d67', \"66d2e04ec\"]  {allow-input: true}\n",
    "\n",
    "stats_l={\n",
    "    'naive': {},\n",
    "    'level': {},\n",
    "    'feline': {},\n",
    "    'level+feline':{},\n",
    "    'level+feline+mpi':{},\n",
    "}\n",
    "print('src=%s -> dst=%s' %(src, dst))\n",
    "\n",
    "v=rev_to_node(repo, repo_graph_full, src)\n",
    "u=rev_to_node(repo, repo_graph_full, dst)\n",
    "\n",
    "graph = repo_graph_full\n",
    "\n",
    "if (u is None) or (v is None):\n",
    "  if u is None:\n",
    "    print('src=%s not in repo or not in graph' % src)\n",
    "  if v is None:\n",
    "    print('dst=%s not in repo or not in graph' % dst)\n",
    "\n",
    "elif u in graph and v in graph:\n",
    "  print('u = %s -> v = %s' %(u,v))\n",
    "  print('* %s has level %d which it shares with %d commits' %\n",
    "        (u, graph.lvl[u], level_counts[graph.lvl[u]]))\n",
    "  print('* %s has level %d which it shares with %d commits' %\n",
    "        (v, graph.lvl[v], level_counts[graph.lvl[v]]))\n",
    "  print('* gen(%s) - gen(%s) = %d' %\n",
    "        (u, v, graph.lvl[u] - graph.lvl[v]))\n",
    "  print('')\n",
    "\n",
    "  #print('- naive')\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             stats=stats_l['naive'])\n",
    "  #print('- level (generation numbers)')\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             l=graph.lvl,\n",
    "                             stats=stats_l['level'])\n",
    "  #print('- FELINE')\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             i=graph.fel,\n",
    "                             stats=stats_l['feline'])\n",
    "  #print('- FELINE+level')\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             l=graph.lvl,i=graph.fel,\n",
    "                             stats=stats_l['level+feline'])\n",
    "  #print('- FELINE+level+min-post')\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             l=graph.lvl,i=graph.fel,II=graph.mpi,\n",
    "                             stats=stats_l['level+feline+mpi'])\n",
    "  \n",
    "  for t in stats_l:\n",
    "    for st in ('walk', 'feline-filter', 'level-filter'):\n",
    "      if st in stats_l[t]:\n",
    "        stats_l[t]['len(%s)' % st] = len(stats_l[t][st])\n",
    "        del stats_l[t][st]\n",
    "     \n",
    "  pp = pprint.PrettyPrinter(indent=4)\n",
    "  pp.pprint(stats_l)\n",
    "  \n",
    "else:\n",
    "  print('not in graph')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# testing different versions of FELINE,\n",
    "# with different topological ordering\n",
    "\n",
    "graph = repo_graph_full\n",
    "stats_x = {}\n",
    "\n",
    "if (u is None) or (v is None):\n",
    "  if u is None:\n",
    "    print('src=%s not in repo or not in graph' % src)\n",
    "  if v is None:\n",
    "    print('dst=%s not in repo or not in graph' % dst)\n",
    "\n",
    "elif u in graph and v in graph:\n",
    "  print('u = %s -> v = %s: %r' %(u,v,nx.has_path(graph,u,v)))\n",
    "  print('* %s has level %d which it shares inclusively with %d commits' %\n",
    "        (u, graph.lvl[u], level_counts[graph.lvl[u]]))\n",
    "  print('* %s has level %d which it shares inclusively with %d commits' %\n",
    "        (v, graph.lvl[v], level_counts[graph.lvl[v]]))\n",
    "  print('* gen(%s) - gen(%s) = %d' %\n",
    "        (u, v, graph.lvl[u] - graph.lvl[v]))\n",
    "  \n",
    "  gray_count = 0\n",
    "  for n in graph:\n",
    "    if graph.lvl[u] >= graph.lvl[n] and \\\n",
    "       graph.lvl[n] >= graph.lvl[v]:\n",
    "      gray_count += 1\n",
    "  print('* %d nodes (around) out of %d in levels inclusion zone' %\n",
    "        (gray_count, graph.number_of_nodes()))\n",
    "  \n",
    "  print('')\n",
    "  \n",
    "  stats_x['naive'] = {}\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             stats=stats_x['naive'])\n",
    "  stats_x['level'] = {}\n",
    "  generic_is_reachable_large(graph, u, v,\n",
    "                             l=graph.lvl,\n",
    "                             stats=stats_x['level'])\n",
    "  \n",
    "  for (pos, name) in [(graph.fel, 'feline'),\n",
    "                      (find_feline(repo_graph_full,\n",
    "                                   topological_sort=nx.lexicographical_topological_sort),'feline(lexi)'),\n",
    "                      (find_feline(repo_graph_full,\n",
    "                                   topological_sort=lambda G: G.topo),'feline(git)')]:\n",
    "    stats_x[name] = {}\n",
    "    generic_is_reachable_large(graph, u, v,\n",
    "                               i=pos,\n",
    "                               stats=stats_x[name])\n",
    "    stats_x['lvl+'+name] = {}\n",
    "    generic_is_reachable_large(graph, u, v,\n",
    "                               l=graph.lvl,i=pos,\n",
    "                               stats=stats_x['lvl+'+name])\n",
    "    stats_x['lvl+'+name+'+mpi'] = {}\n",
    "    generic_is_reachable_large(graph, u, v,\n",
    "                               l=graph.lvl,i=pos,II=graph.mpi,\n",
    "                               stats=stats_x['lvl+'+name+'+mpi'])\n",
    "  \n",
    "  stats_n = {}\n",
    "  for t in sorted(stats_x, key=lambda k: stats_x[k]['access']):\n",
    "    stats_n[t] = {}\n",
    "    for st in stats_x[t]:\n",
    "      if isinstance(stats_x[t][st], list):\n",
    "        stats_n[t]['len(%s)' % st] = len(stats_x[t][st])\n",
    "      elif isinstance(stats_x[t][st], int) or \\\n",
    "           isinstance(stats_x[t][st], float):\n",
    "        stats_n[t][st] = stats_x[t][st]\n",
    "      else:\n",
    "        stats_n[t][st] = bool(stats_x[t][st])\n",
    "        \n",
    "  stats_df = pd.DataFrame.from_dict(stats_n,orient='index')\\\n",
    "                         .sort_index(axis=0,ascending=False)\\\n",
    "                         .filter(items=['access','len(walk)','maxdepth','visited-filter',\n",
    "                                        'len(level-filter)','len(feline-filter)','min-post'])\\\n",
    "                         .sort_values('access', ascending=False)\n",
    "  print(stats_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git -C git describe 468165c1d\n",
    "!git -C git describe 66d2e04ec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "graph=repo_graph_full\n",
    "stats_l={\n",
    "    'naive': {},\n",
    "    'level': {},\n",
    "    'feline': {},\n",
    "    'level+feline':{},\n",
    "    #'level+feline+mpi':{},\n",
    "}\n",
    "\n",
    "(u,v) = (v,u)\n",
    "print('%s -> %s' % (u,v))\n",
    "\n",
    "#print('- naive')\n",
    "generic_is_reachable_large(graph, u, v,\n",
    "                           stats=stats_l['naive'])\n",
    "#print('- level (generation numbers)')\n",
    "generic_is_reachable_large(graph, u, v,\n",
    "                           l=graph.lvl,\n",
    "                           stats=stats_l['level'])\n",
    "#print('- FELINE')\n",
    "generic_is_reachable_large(graph, u, v,\n",
    "                           i=graph.fel,\n",
    "                           stats=stats_l['feline'])\n",
    "#print('- FELINE+level')\n",
    "generic_is_reachable_large(graph, u, v,\n",
    "                           l=graph.lvl,i=graph.fel,\n",
    "                           stats=stats_l['level+feline'])\n",
    "#print('- FELINE+level+min-post')\n",
    "#generic_is_reachable_large(graph, u, v,\n",
    "#                           l=graph.lvl,i=graph.fel,II=graph.mpi,\n",
    "#                           stats=stats_l['level+feline+mpi'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos=graph.fel\n",
    "\n",
    "# Matplotlib recognizes the following formats to specify a color:\n",
    "# + one of {'b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'}\n",
    "# - one of {'tab:blue', 'tab:orange', 'tab:green', 'tab:red', 'tab:purple', 'tab:brown', 'tab:pink', 'tab:gray', 'tab:olive', 'tab:cyan'}\n",
    "#color=np.full(len(pos),'b')\n",
    "#for (i,k) in enumerate(pos):\n",
    "#  if k in stats_l['naive']['walk']:\n",
    "#    color[i] = 'c'\n",
    "#  if k in stats_l['level']['walk']:\n",
    "#    color[i] = 'g'\n",
    "#  if k in stats_l['level+feline']['walk']:\n",
    "#    color[i] = 'r'\n",
    "#  if k in stats_l['level+feline']['feline-filter']:\n",
    "#    color[i] = 'm'\n",
    "#  if graph.lvl[k] == graph.lvl[u] or \\\n",
    "#     graph.lvl[k] == graph.lvl[v]:\n",
    "#    color[i] = 'k'\n",
    "#\n",
    "#plt.title('c for naive, g for levels, r for FELINE')\n",
    "#plt.vlines([pos[u][0],pos[v][0]],0,50000,lw=1.5,linestyles='dotted')\n",
    "#plt.hlines([pos[u][1],pos[v][1]],0,50000,lw=1.5,linestyles='dotted')\n",
    "#plt.scatter(x=np.array([x for (x,y) in pos.values()]),\n",
    "#            y=np.array([y for (x,y) in pos.values()]),\n",
    "#            c=color,s=5,alpha=0.5)\n",
    "#plt.show()\n",
    "#print(color)\n",
    "print('u=%s position is %r, level is %d' % (u,pos[u],graph.lvl[u]))\n",
    "print('v=%s position is %r, level is %d' % (v,pos[v],graph.lvl[v]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def walk_colorize_rgba(i, u, v, nodes, stats, levels):\n",
    "  k = nodes[i]\n",
    "  \n",
    "  # bracketing levels\n",
    "  if (levels[k] == levels[u]) or (levels[k] == levels[v]):\n",
    "    return (0.0,0.0,0.0,1.0) # black\n",
    "  # FELINE - negative cuts\n",
    "  if k in stats['level+feline']['feline-filter']:\n",
    "    return (1.0,0.5,0.0,1.0) # orange\n",
    "  if k in stats['level+feline']['level-filter']:\n",
    "    return (1.0,0.0,0.5,1.0) # magenta-ish\n",
    "  # FELINE - walk\n",
    "  if k in stats['level+feline']['walk']:\n",
    "    return (1.0,0.0,0.0,1.0) # red\n",
    "  # levels - negative cuts\n",
    "  if k in stats['level']['level-filter']:\n",
    "    return (0.0,0.4,0.0,1.0) # dark green\n",
    "  # levels - walk\n",
    "  if k in stats['level']['walk']:\n",
    "    return (0.0,1.0,0.0,1.0) # green\n",
    "  # naive  - walk\n",
    "  if k in stats['naive']['walk']:\n",
    "    return (0.0,0.5,1.0,0.5) # cyan\n",
    "  # the rest\n",
    "  return   (0.0,0.0,0.9,0.2) # blue\n",
    "  \n",
    "  \n",
    "def prepared_stats(stats_l):\n",
    "  stats = {}\n",
    "  for walk in ('naive', 'level', 'level+feline'):\n",
    "    if walk in stats_l:\n",
    "      stats[walk] = {}\n",
    "      for attr in stats_l[walk]:\n",
    "        if isinstance(stats_l[walk][attr], list):\n",
    "          stats[walk][attr] = set(stats_l[walk][attr])\n",
    "          \n",
    "  return stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git: src -> dst plots { form-width: \"30%\" }\n",
    "graph=repo_graph_full\n",
    "pos=graph.fel\n",
    "\n",
    "# https://stackoverflow.com/questions/35215161/most-efficient-way-to-map-function-over-numpy-array/35215329\n",
    "# https://stackoverflow.com/questions/7994394/efficient-thresholding-filter-of-an-array-with-numpy\n",
    "nodes=pos.keys()\n",
    "stats=prepared_stats(stats_l)\n",
    "vc=np.vectorize(lambda i: walk_colorize_rgba(i,u,v,nodes,stats,graph.lvl))\n",
    "\n",
    "print('array_for') # CPU times: user 77 ms, sys: 1e+03 µs, total: 78 ms; Wall time: 78.3 ms\n",
    "%time color = np.array([walk_colorize_rgba(i,u,v,nodes,stats,graph.lvl) for i in xrange(0,len(nodes))])\n",
    "print('%r: %r\\n' % (color.shape, color))\n",
    "\n",
    "#print('array_map') # CPU times: user 77 ms, sys: 1e+03 µs, total: 78 ms; Wall time: 77.5 ms\n",
    "#%time color = np.array(map(lambda i: walk_colorize_rgba(i,u,v,nodes,stats,graph.lvl), xrange(0,len(nodes))))\n",
    "#print('%r: %r\\n' % (color.shape, color))\n",
    "\n",
    "#print('vectorized') # does not return np.array for some reason...\n",
    "#%time color = vc(np.arange(len(nodes)))\n",
    "#print('%r: %r\\n' % (color.shape, color))\n",
    "\n",
    "# Matplotlib recognizes the following formats to specify a color:\n",
    "# - one of {'b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'}\n",
    "# - one of {'tab:blue', 'tab:orange', 'tab:green', 'tab:red', 'tab:purple', 'tab:brown', 'tab:pink', 'tab:gray', 'tab:olive', 'tab:cyan'}\n",
    "# + an RGB or RGBA tuple of float values in [0, 1] (e.g., (0.1, 0.2, 0.5) or (0.1, 0.2, 0.5, 0.3));\n",
    "# - a hex RGB or RGBA string (e.g., '#0F0F0F' or '#0F0F0F0F');\n",
    "# - a string representation of a float value in [0, 1] inclusive for gray level (e.g., '0.5');\n",
    "# - a X11/CSS4 color name;\n",
    "# - ...\n",
    "\n",
    "import matplotlib.patches as mpatches\n",
    "\n",
    "plt.title('git.git commit graph nodes in dominance drawing (FELINE)\\n'+\n",
    "          'c for naive, g for levels, r for level+FELINE\\n'+\n",
    "          ''+u+' -> '+v+'')\n",
    "plt.xlabel('FELINE x / topological order position')\n",
    "plt.ylabel('FELINE y')\n",
    "plt.legend(handles=[mpatches.Patch(color=(0.0,0.5,1.0,0.5), label='naive'),\n",
    "                    mpatches.Patch(color=(0.0,1.0,0.0,1.0), label='level'),\n",
    "                    mpatches.Patch(color=(1.0,0.0,0.0,1.0), label='FELINE')],\n",
    "           loc='upper left')\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "plt.vlines([pos[u][0],pos[v][0]],0,np.amax(yarr),lw=1.5,linestyles='dotted')\n",
    "plt.hlines([pos[u][1],pos[v][1]],0,np.amax(xarr),lw=1.5,linestyles='dotted')\n",
    "plt.scatter(x=xarr,\n",
    "            y=yarr,\n",
    "            c=color,s=10)\n",
    "plt.show()\n",
    "#print(color)\n",
    "print('u=%s position is %r, level is %d' % (u,pos[u],graph.lvl[u]))\n",
    "print('v=%s position is %r, level is %d' % (v,pos[v],graph.lvl[v]))\n",
    "for walk in sorted(stats, key=lambda k: len(stats[k]['walk']), reverse=True):\n",
    "  print('- %s walked %d' % (walk, len(stats[walk]['walk'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git: src -> dst feline plot { form-width: \"30%\" }\n",
    "graph=repo_graph_full\n",
    "pos=graph.fel\n",
    "\n",
    "plt.title('git.git commit graph nodes in dominance drawing (FELINE)\\n'+\n",
    "          ''+u+' -> '+v+'')\n",
    "plt.xlabel('FELINE x / topological order position')\n",
    "plt.ylabel('FELINE y')\n",
    "\n",
    "show_levels = True #@param {type:\"boolean\"}\n",
    "show_feline = True #@param {type:\"boolean\"}\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(\n",
    "  mpatches.Rectangle(\n",
    "    pos[u],\n",
    "    pos[v][0] - pos[u][0],\n",
    "    pos[v][1] - pos[u][1],\n",
    "    facecolor=\"grey\",alpha=0.25\n",
    "  )\n",
    ")\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "plt.vlines([pos[u][0],pos[v][0]],0,np.amax(yarr),lw=1.5,linestyles='dotted')\n",
    "plt.hlines([pos[u][1],pos[v][1]],0,np.amax(xarr),lw=1.5,linestyles='dotted')\n",
    "plt.scatter(x=xarr, y=yarr, s=10,\n",
    "            c=(0.0,0.0,0.9,0.2), label='graph')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['naive']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['naive']['walk']])\n",
    "plt.scatter(x=xarr, y=yarr, s=10,\n",
    "            c=(0.0,0.5,1.0,0.5), label='naive')\n",
    "\n",
    "if show_levels:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level']['walk']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['level']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=10,\n",
    "              c=(0.0,1.0,0.0,1.0), label='level')\n",
    "\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level']['level-filter']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['level']['level-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=12,\n",
    "              c=(0.0,0.35,0.0,1.0), label='level (filtered)')\n",
    "  \n",
    "if show_feline:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=14,\n",
    "              c=(1.0,0.0,0.0,1.0), label='level+FELINE')\n",
    "  \n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=16,\n",
    "              c=(1.0,0.5,0.0,1.0), label='lvl+FEL (filtered)')\n",
    "\n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "plt.show()\n",
    "\n",
    "print('u=%s position is %r, level is %d' % (u,pos[u],graph.lvl[u]))\n",
    "print('v=%s position is %r, level is %d' % (v,pos[v],graph.lvl[v]))\n",
    "for walk in sorted(stats, key=lambda k: len(stats[k]['walk']), reverse=True):\n",
    "  print('- %s walked %d' % (walk, len(stats[walk]['walk'])))\n",
    "  \n",
    "gray_count = 0\n",
    "for n in pos:\n",
    "  if is_pair_leq(pos[u], pos[n]) and \\\n",
    "     is_pair_leq(pos[n], pos[v]):\n",
    "    gray_count += 1\n",
    "print('there are %d nodes out of %d in inclusion zone' %\n",
    "      (gray_count, graph.number_of_nodes()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git: src -> dst feline zoom { form-width: \"30%\" }\n",
    "graph=repo_graph_full\n",
    "pos=graph.fel\n",
    "\n",
    "plt.title('git.git commit graph nodes in dominance drawing (FELINE) zoom\\n'+\n",
    "          ''+u+' -> '+v+'')\n",
    "plt.xlabel('FELINE x / topological order position')\n",
    "plt.ylabel('FELINE y')\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(\n",
    "  mpatches.Rectangle(\n",
    "    pos[u],\n",
    "    pos[v][0] - pos[u][0],\n",
    "    pos[v][1] - pos[u][1],\n",
    "    facecolor=\"grey\",alpha=0.25\n",
    "  )\n",
    ")\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "#plt.vlines([pos[u][0],pos[v][0]],0,np.amax(yarr),lw=1.5,linestyles='dotted')\n",
    "#plt.hlines([pos[u][1],pos[v][1]],0,np.amax(xarr),lw=1.5,linestyles='dotted')\n",
    "plt.scatter(x=xarr, y=yarr, s=10,\n",
    "            c=(0.0,0.0,0.9,0.2), label='graph')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "plt.scatter(x=xarr, y=yarr, s=14,\n",
    "            c=(1.0,0.0,0.0,1.0), label='level+FELINE')\n",
    "\n",
    "xmax = np.amax(xarr)\n",
    "ymax = np.amax(yarr)\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level+feline']['level-filter'] or \n",
    "                    n in stats['level+feline']['feline-filter']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level+feline']['level-filter'] or \n",
    "                    n in stats['level+feline']['feline-filter']])\n",
    "plt.scatter(x=xarr, y=yarr, s=16,\n",
    "            c=(1.0,0.5,0.0,1.0), label='lvl+FEL (filtered)')\n",
    "\n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "ax.set_xlim(0,xmax+1000)\n",
    "ax.set_ylim(0,ymax+1000)\n",
    "plt.show()\n",
    "\n",
    "print('u=%s position is %r, level is %d' % (u,pos[u],graph.lvl[u]))\n",
    "print('v=%s position is %r, level is %d' % (v,pos[v],graph.lvl[v]))\n",
    "for walk in sorted(stats, key=lambda k: len(stats[k]['walk']), reverse=True):\n",
    "  print('- %s walked %d' % (walk, len(stats[walk]['walk'])))\n",
    "  \n",
    "gray_count = 0\n",
    "for n in pos:\n",
    "  if is_pair_leq(pos[u], pos[n]) and \\\n",
    "     is_pair_leq(pos[n], pos[v]):\n",
    "    gray_count += 1\n",
    "print('there are %d nodes out of %d in inclusion zone' %\n",
    "      (gray_count, graph.number_of_nodes()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = repo_graph_full\n",
    "\n",
    "level_counts_dict = defaultdict(int)\n",
    "graph.lvlpos = {}\n",
    "for node in graph:\n",
    "  x = graph.lvl[node]\n",
    "  level_counts_dict[x] += 1\n",
    "  y = level_counts_dict[x]\n",
    "  \n",
    "  graph.lvlpos[node] = (x, y)\n",
    "  \n",
    "pos = graph.lvlpos\n",
    "\n",
    "plt.title('git.git commit graph nodes in level drawing\\n'+\n",
    "          'c for naive, g for levels, r for FELINE\\n'+\n",
    "          ''+u+' -> '+v+'')\n",
    "plt.xlabel('level / generation number')\n",
    "plt.ylabel('nodes with the same level')\n",
    "plt.legend(handles=[mpatches.Patch(color=(0.0,0.5,1.0,0.5), label='naive'),\n",
    "                    mpatches.Patch(color=(0.0,1.0,0.0,1.0), label='level'),\n",
    "                    mpatches.Patch(color=(1.0,0.0,0.0,1.0), label='FELINE'),\n",
    "                    mpatches.Patch(color=(0.0,0.0,0.0,1.0), label='lvl(u)|lvl(v)')],\n",
    "           loc='upper left')\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "plt.vlines([pos[u][0],pos[v][0]],0,np.amax(yarr),lw=1.5,linestyles='dotted')\n",
    "plt.hlines([pos[u][1],pos[v][1]],0,np.amax(xarr),lw=1.5,linestyles='dotted')\n",
    "plt.scatter(x=xarr,\n",
    "            y=yarr,\n",
    "            c=color,s=10)\n",
    "plt.show()\n",
    "#print(color)\n",
    "print('u=%s position is %r, level is %d' % (u,pos[u],graph.lvl[u]))\n",
    "print('v=%s position is %r, level is %d' % (v,pos[v],graph.lvl[v]))\n",
    "for walk in sorted(stats, key=lambda k: len(stats[k]['walk']), reverse=True):\n",
    "  print('- %s walked %d' % (walk, len(stats[walk]['walk'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git: src -> dst levels plot { form-width: \"30%\" }\n",
    "graph=repo_graph_full\n",
    "pos=graph.lvlpos\n",
    "\n",
    "plt.title('git.git commit graph nodes in level drawing\\n'+\n",
    "          ''+u+' -> '+v+'')\n",
    "plt.xlabel('level / generation number')\n",
    "plt.ylabel('nodes with the same level')\n",
    "\n",
    "show_levels = True #@param {type:\"boolean\"}\n",
    "show_feline = True #@param {type:\"boolean\"}\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(\n",
    "  mpatches.Rectangle(\n",
    "    (pos[u][0], 0),\n",
    "    pos[v][0] - pos[u][0],\n",
    "    np.amax(yarr),\n",
    "    facecolor=\"grey\",alpha=0.25\n",
    "  )\n",
    ")\n",
    "\n",
    "plt.vlines([pos[u][0],pos[v][0]],0,np.amax(yarr),lw=1.5,linestyles='dotted')\n",
    "plt.hlines([pos[u][1],pos[v][1]],0,np.amax(xarr),lw=1.5,linestyles='dotted')\n",
    "plt.scatter(x=xarr, y=yarr, s=10,\n",
    "            c=(0.0,0.0,0.9,0.2), label='graph')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['naive']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['naive']['walk']])\n",
    "plt.scatter(x=xarr, y=yarr, s=10,\n",
    "            c=(0.0,0.5,1.0,0.5), label='naive')\n",
    "\n",
    "if show_levels:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level']['walk']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['level']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=10,\n",
    "              c=(0.0,1.0,0.0,1.0), label='level')\n",
    "\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level']['level-filter']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['level']['level-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=12,\n",
    "              c=(0.0,0.35,0.0,1.0), label='level (filtered)')\n",
    "  \n",
    "if show_feline:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=14,\n",
    "              c=(1.0,0.0,0.0,1.0), label='level+FELINE')\n",
    "  \n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=16,\n",
    "              c=(1.0,0.5,0.0,1.0), label='lvl+FEL (filtered)')\n",
    "\n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "plt.show()\n",
    "\n",
    "print('u=%s position is %r, level is %d' % (u,pos[u],graph.lvl[u]))\n",
    "print('v=%s position is %r, level is %d' % (v,pos[v],graph.lvl[v]))\n",
    "for walk in sorted(stats, key=lambda k: len(stats[k]['walk']), reverse=True):\n",
    "  print('- %s walked %d' % (walk, len(stats[walk]['walk'])))\n",
    "  \n",
    "  \n",
    "gray_count = 0\n",
    "for n in pos:\n",
    "  if graph.lvl[u] >= graph.lvl[n] and \\\n",
    "     graph.lvl[n] >= graph.lvl[v]:\n",
    "    gray_count += 1\n",
    "print('there are %d nodes out of %d in inclusion zone' %\n",
    "      (gray_count, graph.number_of_nodes()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git: src -> dst levels zoom { form-width: \"30%\" }\n",
    "graph=repo_graph_full\n",
    "pos=graph.lvlpos\n",
    "\n",
    "plt.title('git.git commit graph nodes in level drawing (zoomed)\\n'+\n",
    "          ''+u+' -> '+v+'')\n",
    "plt.xlabel('level / generation number')\n",
    "plt.ylabel('nodes with the same level')\n",
    "\n",
    "show_levels = True #@param {type:\"boolean\"}\n",
    "show_feline = True #@param {type:\"boolean\"}\n",
    "xmin_plot = 12500 #@param {type:\"slider\", min:0, max:14776, step:1}\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(\n",
    "  mpatches.Rectangle(\n",
    "    (pos[u][0], 0),\n",
    "    pos[v][0] - pos[u][0],\n",
    "    np.amax(yarr),\n",
    "    facecolor=\"grey\",alpha=0.25\n",
    "  )\n",
    ")\n",
    "\n",
    "plt.scatter(x=xarr, y=yarr, s=8,\n",
    "            c=(1.0,1.0,0.0,0.2), label='graph')\n",
    "\n",
    "node_test = lambda n: \\\n",
    "  graph.lvl[u] >= graph.lvl[n] and \\\n",
    "  graph.lvl[n] >= graph.lvl[v]\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                 if node_test(n)])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                 if node_test(n)])\n",
    "\n",
    "#plt.vlines([pos[u][0],pos[v][0]],0,np.amax(yarr),lw=1.5,linestyles='dotted')\n",
    "#plt.hlines([pos[u][1],pos[v][1]],0,np.amax(xarr),lw=1.5,linestyles='dotted')\n",
    "plt.scatter(x=xarr, y=yarr, s=10,\n",
    "            c=(0.0,0.0,0.9,0.2), label='graph (incl.)')\n",
    "\n",
    "if show_levels:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level']['walk']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=10,\n",
    "              c=(0.0,1.0,0.0,1.0), label='level')\n",
    "\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level']['level-filter']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level']['level-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=12,\n",
    "              c=(0.0,0.35,0.0,1.0), label='level (filtered)')\n",
    "  \n",
    "if show_feline:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=14,\n",
    "              c=(1.0,0.0,0.0,1.0), label='level+FELINE')\n",
    "  \n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=16,\n",
    "              c=(1.0,0.5,0.0,1.0), label='lvl+FEL (filtered)')\n",
    "\n",
    "plt.legend(frameon=True,fancybox=False,shadow=True,\n",
    "           title='in order:')\n",
    "ax.set_xlim(12500,max(graph.lvl.values()))\n",
    "plt.show()\n",
    "\n",
    "print('u=%s position is %r, level is %d' % (u,pos[u],graph.lvl[u]))\n",
    "print('v=%s position is %r, level is %d' % (v,pos[v],graph.lvl[v]))\n",
    "for walk in sorted(stats, key=lambda k: len(stats[k]['walk']), reverse=True):\n",
    "  print('- %s walked %d' % (walk, len(stats[walk]['walk'])))\n",
    "  \n",
    "  \n",
    "gray_count = 0\n",
    "for n in pos:\n",
    "  if graph.lvl[u] >= graph.lvl[n] and \\\n",
    "     graph.lvl[n] >= graph.lvl[v]:\n",
    "    gray_count += 1\n",
    "print('there are %d nodes out of %d in inclusion zone' %\n",
    "      (gray_count, graph.number_of_nodes()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git: src -> dst min-post plot { form-width: \"30%\" }\n",
    "graph=repo_graph_full\n",
    "pos=graph.mpi\n",
    "\n",
    "plt.title('git.git commit graph nodes in min-post intervals drawing\\n'+\n",
    "          u+'=['+str(pos[u][0])+','+str(pos[u][1])+'] -> '+\n",
    "          v+'=['+str(pos[v][0])+','+str(pos[v][1])+']')\n",
    "plt.xlabel('beg: $s_n$ from $I_n = [s_n, e_n]$')\n",
    "plt.ylabel('end: $e_n$ from $I_n = [s_n, e_n]$')\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(\n",
    "  mpatches.Rectangle(\n",
    "    pos[v],\n",
    "    - pos[v][0],\n",
    "    np.amax(yarr) - pos[v][1],\n",
    "    facecolor=\"red\",alpha=0.10\n",
    "  )\n",
    ")\n",
    "\n",
    "plt.vlines([pos[u][0],pos[v][0]],0,np.amax(yarr),lw=1.5,linestyles='dotted')\n",
    "plt.hlines([pos[u][1],pos[v][1]],0,np.amax(xarr),lw=1.5,linestyles='dotted')\n",
    "plt.scatter(x=xarr, y=yarr, s=10,\n",
    "            c=(0.0,0.0,0.9,0.2), label='graph')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level']['walk']])\n",
    "plt.scatter(x=xarr, y=yarr, s=8,\n",
    "            c=(0.0,1.0,0.0,1.0), label='level')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level+feline']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level+feline']['walk']])\n",
    "plt.scatter(x=xarr, y=yarr, s=8,\n",
    "            c=(0.7,0.7,0.0,1.0), label='level+FELINE')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                 if n in stats_x['lvl+feline+mpi']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                 if n in stats_x['lvl+feline+mpi']['walk']])\n",
    "plt.scatter(x=xarr, y=yarr, s=20,\n",
    "            c=(1.0,0.0,0.0,1.0), label='level+FELINE+min-post')\n",
    "\n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the commit marked as walked 'level+FELINE+min-post' (using <span style=\"text-color: red;\">**red**</span> color) that is in the light-red area for target commit $v$ is the one that positive-cut of min-post interval filter finds as being child of $v$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### N^2 connectivity on \\[random sample of\\] commit graph nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "print('date = %s' % datetime.datetime.now())\n",
    "\n",
    "graph = repo_graph\n",
    "\n",
    "#print('git commit graph was created from %d edges' % (len(edges)))\n",
    "n_nodes = graph.number_of_nodes()\n",
    "print('git commit graph has %d nodes and %d edges (size)' %\n",
    "      (n_nodes, graph.size()))\n",
    "print('git commit graph has %d possible paths\\n' % (n_nodes*(n_nodes-1)))\n",
    "\n",
    "if False:\n",
    "  %time graph.lvl = find_levels(graph)\n",
    "  %time graph.fel = find_feline(graph)\n",
    "\n",
    "  %time lvl_fp = level_fp(graph, graph.lvl)\n",
    "  %time fel_fp = feline_fp(graph, graph.fel)\n",
    "\n",
    "  n_lvl_fp = len(lvl_fp)\n",
    "  n_fel_fp = len(fel_fp)\n",
    "  print('\\nlevel-filter has %5d = %5.2f%% false positives' %\n",
    "        (n_lvl_fp, 100.0*n_lvl_fp/(n_nodes*(n_nodes-1))))\n",
    "  print('FELINE index has %5d = %5.2f%% false positives' %\n",
    "        (n_fel_fp, 100.0*n_fel_fp/(n_nodes*(n_nodes-1))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('repo_graph_full (for git.git)')\n",
    "graph = repo_graph_full\n",
    "\n",
    "print('git commit graph was created from %d edges' % (len(edges)))\n",
    "n_nodes_full = graph.number_of_nodes()\n",
    "print('git commit graph has %d nodes and %d edges (size)' %\n",
    "      (n_nodes_full, graph.size()))\n",
    "print('git commit graph has %d possible paths\\n' % (n_nodes*(n_nodes-1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%time conns = [(u,v) for u in repo_graph_x for v in repo_graph_x if u != v]\n",
    "print('possible connections in repo_graph_x = %d' % len(conns))\n",
    "conns[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "choice = np.random.choice(n_nodes_full*n_nodes_full, 10000)\n",
    "conn_choice = [(x % n_nodes_full,x // n_nodes_full) for x in choice]\n",
    "print choice[:10]\n",
    "print conn_choice[:10]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodes_dict = {num: v for (num,v) in enumerate(list(repo_graph_full))}\n",
    "conn_nodes = {(nodes_dict[u], nodes_dict[v]) for (u,v) in conn_choice}\n",
    "#conn_nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title def split_connected { form-width: \"25%\" }\n",
    "def split_connected(DG, conn):\n",
    "  has = []\n",
    "  hasnot = []\n",
    "  \n",
    "  for (u,v) in conn:\n",
    "    if u == v:\n",
    "      continue\n",
    "    if nx.has_path(DG,u,v):\n",
    "      has.append((u,v))\n",
    "    else:\n",
    "      hasnot.append((u,v))\n",
    "      \n",
    "  return has, hasnot\n",
    "\n",
    "def split_connected_ex(DG, conn):\n",
    "  has = []\n",
    "  hasnot = []\n",
    "  r = {}\n",
    "  for (u,v) in conn:\n",
    "    if u == v:\n",
    "      r[(u,v)] = True\n",
    "      continue\n",
    "    if nx.has_path(DG,u,v):\n",
    "      r[(u,v)] = True\n",
    "      has.append((u,v))\n",
    "    else:\n",
    "      r[(u,v)] = False\n",
    "      hasnot.append((u,v))\n",
    "      \n",
    "  return has, hasnot, r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git: run split_connected { form-width: \"25%\" }\n",
    "\n",
    "%time pos,neg = split_connected(repo_graph_full, conn_nodes)\n",
    "print('%4d nodes' % len(conn_nodes))\n",
    "print('%4d connected:     %r' % (len(pos), pos[:10]))\n",
    "print('%4d not connected: %r' % (len(neg), neg[:10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = repo_graph_full\n",
    "\n",
    "print('git commit graph was created from %d edges' % (len(edges)))\n",
    "n_nodes = graph.number_of_nodes()\n",
    "print('git commit graph has %d nodes and %d edges (size)' %\n",
    "      (n_nodes, graph.size()))\n",
    "print('git commit graph has %d possible paths\\n' % (n_nodes*(n_nodes-1)))\n",
    "print('sample has %d nodes: %d connected and %d not' %\n",
    "      (len(conn_nodes),len(pos),len(neg)))\n",
    "\n",
    "%time graph.lvl = find_levels(graph)\n",
    "%time graph.fel = find_feline(graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = repo_graph_full\n",
    "\n",
    "heads = find_heads(graph)\n",
    "roots = find_roots(graph)\n",
    "print('git commit graph has %d tips / heads (\"roots\"): %r' % (len(heads),heads))\n",
    "print('git commit graph has %d roots (\"leaves\"): %r' % (len(roots),roots))\n",
    "\n",
    "print('git commit graph has average clustering coefficient %g (%d trials ?)' %\n",
    "      (nx.average_clustering(graph.to_undirected()), 1000))\n",
    "#print('git commit graph has the diameter of %g' % nx.diameter(graph))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title git.git: false positives in random sample { form-width: \"25%\" }\n",
    "graph = repo_graph_full\n",
    "\n",
    "print('git commit graph was created from %d edges' % (len(edges)))\n",
    "n_nodes = graph.number_of_nodes()\n",
    "print('git commit graph has %d nodes and %d edges (size)' %\n",
    "      (n_nodes, graph.size()))\n",
    "print('git commit graph has %d possible paths\\n' % (n_nodes*(n_nodes-1)))\n",
    "print('sample has %d nodes [%g%%]: %d connected and %d not\\n' %\n",
    "      (len(conn_nodes),100.0*len(conn_nodes)/(n_nodes*(n_nodes-1)),\n",
    "       len(pos),len(neg)))\n",
    "\n",
    "%time lvl_fp = level_fp_sample(graph, graph.lvl, neg)\n",
    "%time fel_fp = feline_fp_sample(graph, graph.fel, neg)\n",
    "\n",
    "n_lvl_fp = len(lvl_fp)\n",
    "n_fel_fp = len(fel_fp)\n",
    "n_samples = len(neg)\n",
    "print('\\nlevel-filter has %5d = %5.2f%% false positives' %\n",
    "      (n_lvl_fp, 100.0*n_lvl_fp/n_samples))\n",
    "print('FELINE index has %5d = %5.2f%% false positives' %\n",
    "      (n_fel_fp, 100.0*n_fel_fp/n_samples))\n",
    "print('FELINE index has %g less false positives than level filter' %\n",
    "      (float(n_lvl_fp)/float(n_fel_fp)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linux kernel commit graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "nx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import git\n",
    "git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "!git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "linux_repo = git.Repo('linux')\n",
    "linux_repo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Full linux kernel commit graph and its properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "!git -C linux log --format=\"%h %p\" --all --topo-order >linux-commit_list_full\n",
    "\n",
    "edges = []\n",
    "with open('linux-commit_list_full', 'r') as f:\n",
    "  for line in f:\n",
    "    elems = line.split()\n",
    "    commit, parents = (elems[0], elems[1:])\n",
    "    for parent in parents:\n",
    "      edges.append((commit, parent))\n",
    "linux_graph_full = nx.DiGraph(edges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from google.colab import files\n",
    "\n",
    "files.download('linux-commit_list_full')\n",
    "#uploaded = files.upload()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "graph = linux_graph_full\n",
    "\n",
    "print('linux commit graph was created from %d edges' % (len(edges)))\n",
    "n_nodes = graph.number_of_nodes()\n",
    "print('linux commit graph has %d nodes and %d edges (size)' %\n",
    "      (n_nodes, graph.size()))\n",
    "#print('linux commit graph has %d possible paths\\n' % (n_nodes*(n_nodes-1)))\n",
    "\n",
    "print('\\ncalculating levels')\n",
    "%time graph.lvl = find_levels(graph)\n",
    "print('\\ncalculating FELINE index')\n",
    "%time graph.fel = find_feline(graph)\n",
    "print('\\nfind min-post intervals:')\n",
    "%time graph.mpi = find_dfs_intervals(graph)\n",
    "print('\\nfind min-post intervals with extra data:')\n",
    "%time graph.mpi_x = find_dfs_intervals_extra(graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "graph = linux_graph_full\n",
    "graph_name = 'linux kernel'\n",
    "\n",
    "n_nodes = graph.number_of_nodes()\n",
    "n_edges = graph.size()\n",
    "print('%s commit graph has %d nodes and %d edges (size)' %\n",
    "      (graph_name, n_nodes, n_edges))\n",
    "print('%s commit graph has %d possible paths\\n' %\n",
    "      (graph_name, n_nodes*(n_nodes-1)))\n",
    "\n",
    "heads = find_heads(graph)\n",
    "roots = find_roots(graph)\n",
    "print('%s commit graph has %d tips / heads (\"roots\"): %r' %\n",
    "      (graph_name, len(heads),heads))\n",
    "print('%s commit graph has %d roots (\"leaves\"): %r' %\n",
    "      (graph_name, len(roots),roots))\n",
    "\n",
    "clustering_coeff = nx.average_clustering(graph.to_undirected())\n",
    "print('%s commit graph has average clustering coefficient %g (%d trials ?)\\n' %\n",
    "      (graph_name, clustering_coeff, 1000))\n",
    "# NetworkXError: Found infinite path length because the digraph is not strongly connected\n",
    "#print('%s commit graph has the diameter of %g\\n' %\n",
    "#      (graph_name, nx.diameter(graph)))\n",
    "\n",
    "linux_df = pd.DataFrame({\n",
    "    'Graph': [graph_name],\n",
    "    'vertices': [n_nodes],\n",
    "    'edges': [n_edges],\n",
    "    'Cluster coeff.': [clustering_coeff],\n",
    "    'roots': [len(heads)],\n",
    "    'leafs': [len(roots)],\n",
    "},columns=['Graph','vertices','edges',\n",
    "           'Cluster coeff.','Eff. diameter',\n",
    "           'roots','leafs']).set_index('Graph')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux commit graph dataset { form-width: \"25%\" }\n",
    "df=linux_df\n",
    "\n",
    "df.insert(loc=2,column='edges[%]',\n",
    "          value=100.0*(df['edges']/(df['vertices']**2)))\n",
    "df.insert(loc=3,column='edges/vertices',\n",
    "          value=df['edges']/df['vertices'])\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "commit_graphs_df.append(linux_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculating parameters of the linux commit graph: distribution of in-degree, out-degree and level\n",
    "graph = linux_graph_full\n",
    "\n",
    "linux_info_df=pd.DataFrame.from_dict(graph.lvl,orient='index').rename(columns={0: 'level'})\n",
    "linux_info_df.index.name='node'\n",
    "if hasattr(graph, 'fel'):\n",
    "  linux_info_df['FELINE']=pd.Series(graph.fel)\n",
    "if hasattr(graph, 'mpi'):\n",
    "  linux_info_df['min-post']=pd.Series(graph.mpi)\n",
    "linux_info_df['in  degree']=pd.Series(dict(graph.in_degree()))\n",
    "linux_info_df['out degree']=pd.Series(dict(graph.out_degree()))\n",
    "linux_info_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "linux_info_df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux kernel level counts hist { form-width: \"30%\" }\n",
    "linux_level_counts=linux_info_df['level'].value_counts()\n",
    "linux_level_counts_values=linux_level_counts.values\n",
    "\n",
    "plt.title('Histogram of level counts in linux kernel commit graph')\n",
    "plt.xlabel('Level counts')\n",
    "plt.ylabel('Number of level with given count')\n",
    "linux_level_counts.plot.hist(bins=50)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame({'level counts':linux_level_counts.describe()})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame({'level counts': {'MAD':linux_level_counts.mad()}})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux kernel levels count plot { form-width: \"30%\" }\n",
    "import seaborn as sns\n",
    "sns.set()\n",
    "\n",
    "linux_level_counts_df=pd.DataFrame({'level counts': linux_level_counts})\n",
    "linux_level_counts_df.index.name='level'\n",
    "linux_level_counts_df.sort_index(inplace=True)\n",
    "linux_level_counts_df.plot();\n",
    "\n",
    "plt.title('%s commit graph - number of nodes with given level' %\n",
    "          'linux kernel');\n",
    "plt.xlabel('level of node / vertex');\n",
    "plt.ylabel('number of nodes / vertices');\n",
    "\n",
    "linux_level_counts_df.describe().T.rename(index={'counts': 'level counts'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux kernel feline plot, skewed { form-width: \"30%\" }\n",
    "%%time\n",
    "graph=linux_graph_full\n",
    "pos=graph.fel\n",
    "\n",
    "plt.title('linux kernel commit graph nodes in dominance drawing (FELINE)\\n'+\n",
    "          'colored according to node level / generation number')\n",
    "plt.xlabel('FELINE x / topological order position')\n",
    "plt.ylabel('FELINE $\\Delta$ = x-y')\n",
    "\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([(x-y) for (x,y) in pos.values()])\n",
    "larr = np.array([graph.lvl[n] for n in pos.keys()])\n",
    "\n",
    "ax = plt.gca()\n",
    "sc = plt.scatter(x=xarr, y=yarr,\n",
    "                 c=larr, cmap=plt.cm.jet,\n",
    "                 s=5,\n",
    "                 label='graph')\n",
    "cbar = plt.colorbar(sc, extend='both', shrink=0.9, ax=ax)\n",
    "cbar.set_label('level')\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux kernel feline plot { form-width: \"30%\" }\n",
    "%%time\n",
    "graph=linux_graph_full\n",
    "pos=graph.fel\n",
    "\n",
    "plt.title('linux kernel commit graph nodes in dominance drawing (FELINE)\\n'+\n",
    "          'colored according to node level / generation number')\n",
    "plt.xlabel('FELINE x / topological order position')\n",
    "plt.ylabel('FELINE y')\n",
    "\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "larr = np.array([graph.lvl[n] for n in pos.keys()])\n",
    "\n",
    "ax = plt.gca()\n",
    "sc = plt.scatter(x=xarr, y=yarr,\n",
    "                 c=larr, cmap=plt.cm.jet,\n",
    "                 s=5,\n",
    "                 label='graph')\n",
    "cbar = plt.colorbar(sc, extend='both', shrink=0.9, ax=ax)\n",
    "cbar.set_label('level')\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux kernel post-levels plot { form-width: \"30%\" }\n",
    "%%time\n",
    "graph=linux_graph_full\n",
    "pos={v: (graph.mpi_x[v]['post'], graph.lvl[v])\n",
    "     for v in graph}\n",
    "\n",
    "plt.title('linux kernel commit graph nodes in post-level plot\\n'+\n",
    "          'colored according to node level / generation number')\n",
    "\n",
    "plt.xlabel('$\\phi(v)$ - post-numbering of nodes in DFS spanning tree')\n",
    "plt.ylabel('$l_v = l(v)$ - sink-based level of node')\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "larr = np.array([graph.lvl[n] for n in pos.keys()])\n",
    "\n",
    "ax = plt.gca()\n",
    "sc = plt.scatter(x=xarr, y=yarr,\n",
    "                 c=larr, cmap=plt.cm.jet,\n",
    "                 s=5,\n",
    "                 label='graph')\n",
    "cbar = plt.colorbar(sc, extend='neither', shrink=0.92, ax=ax)\n",
    "cbar.set_label('level')\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux kernel post-levels plot v2 { form-width: \"30%\" }\n",
    "%%time\n",
    "graph=linux_graph_full\n",
    "pos={v: (graph.mpi_x[v]['post'], graph.lvl[v])\n",
    "     for v in graph}\n",
    "\n",
    "plt.figure(figsize=(17,10), dpi=72)\n",
    "plt.title('linux kernel commit graph nodes in post-level plot\\n'+\n",
    "          'colored according to min part of min-post interval')\n",
    "plt.grid(True)\n",
    "\n",
    "plt.xlabel('$\\phi(v)$ - post-numbering of nodes in DFS spanning tree')\n",
    "plt.ylabel('$l_v = l(v)$ - sink-based level of node')\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "larr = np.array([graph.mpi_x[n]['min'] for n in pos.keys()])\n",
    "\n",
    "ax = plt.gca()\n",
    "sc = plt.scatter(x=xarr, y=yarr,\n",
    "                 c=larr, cmap=plt.cm.jet,\n",
    "                 s=5,\n",
    "                 label='graph')\n",
    "cbar = plt.colorbar(sc, extend='neither', shrink=0.92, ax=ax)\n",
    "cbar.set_label('$\\mathrm{min}(v) = \\hat{\\phi}(v)$ - min part of min-post interval in DFS tree')\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux kernel post-levels plot v3 { form-width: \"30%\" }\n",
    "%%time\n",
    "graph=linux_graph_full\n",
    "pos={v: (graph.mpi_x[v]['post'], graph.lvl[v])\n",
    "     for v in graph}\n",
    "\n",
    "plt.figure(figsize=(17,10), dpi=72)\n",
    "plt.title('linux kernel commit graph nodes in post-level plot\\n'+\n",
    "          'colored according to size of min-post interval')\n",
    "plt.grid(True)\n",
    "\n",
    "plt.xlabel('$\\phi(v)$ - post-numbering of nodes in DFS spanning tree')\n",
    "plt.ylabel('$l_v = l(v)$ - sink-based level of node')\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "larr = np.array([(graph.mpi_x[n]['post']-graph.mpi_x[n]['min']) for n in pos.keys()])\n",
    "\n",
    "ax = plt.gca()\n",
    "sc = plt.scatter(x=xarr, y=yarr,\n",
    "                 c=larr, cmap=plt.cm.jet,\n",
    "                 s=5,\n",
    "                 label='graph')\n",
    "cbar = plt.colorbar(sc, extend='neither', shrink=0.92, ax=ax)\n",
    "cbar.set_label('$|\\mathrm{post}(v)-\\mathrm{min}(v)| = |\\phi(v)-\\hat{\\phi}(v)|$ - size of min-post interval in DFS tree')\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "graph=linux_graph_full\n",
    "pos={v: (graph.mpi_x[v]['post'], graph.lvl[v])\n",
    "     for v in graph}\n",
    "\n",
    "plt.figure(figsize=(17,10), dpi=72)\n",
    "plt.title('linux kernel commit graph nodes in post-level plot\\n'+\n",
    "          'colored according to relative size of min-post interval')\n",
    "plt.grid(True)\n",
    "\n",
    "plt.xlabel('$\\phi(v)$ - post-numbering of nodes in DFS spanning tree')\n",
    "plt.ylabel('$l_v = l(v)$ - sink-based level of node')\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "larr = np.array([(graph.mpi_x[n]['post']-graph.mpi_x[n]['min'])/graph.mpi_x[n]['post']\n",
    "                 for n in pos.keys()])\n",
    "\n",
    "ax = plt.gca()\n",
    "sc = plt.scatter(x=xarr, y=yarr,\n",
    "                 c=larr, cmap=plt.cm.jet,\n",
    "                 s=5,\n",
    "                 label='graph')\n",
    "cbar = plt.colorbar(sc, extend='max', shrink=0.92, ax=ax)\n",
    "cbar.set_label('$|\\mathrm{post}(v)-\\mathrm{min}(v)|/\\mathrm{post}(v)$ - relative size of min-post interval in DFS tree')\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux kernel |I_u| histogram { form-width: \"30%\" }\n",
    "%%time\n",
    "graph=linux_graph_full\n",
    "\n",
    "pos={v: (graph.mpi_x[v]['post'], graph.lvl[v])\n",
    "     for v in graph}\n",
    "larr = np.array([(graph.mpi_x[n]['post']-graph.mpi_x[n]['min'])\n",
    "                 for n in pos.keys()])\n",
    "\n",
    "plt.figure(figsize=(17,10), dpi=72)\n",
    "plt.title('linux kernel commit graph\\n'+\n",
    "          'histogram of sizes of min-post interval')\n",
    "plt.grid(True)\n",
    "\n",
    "plt.hist(larr,bins=25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(17,10), dpi=72)\n",
    "plt.title('linux kernel commit graph\\n'+\n",
    "          'histogram of sizes of min-post interval')\n",
    "plt.grid(True)\n",
    "\n",
    "plt.hist(larr,bins=50,log=True)\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux kernel |I_u|/post(u) histogram { form-width: \"30%\" }\n",
    "%%time\n",
    "graph=linux_graph_full\n",
    "\n",
    "pos={v: (graph.mpi_x[v]['post'], graph.lvl[v])\n",
    "     for v in graph}\n",
    "larr = np.array([(graph.mpi_x[n]['post']-graph.mpi_x[n]['min'])/graph.mpi_x[n]['post']\n",
    "                 for n in pos.keys()])\n",
    "\n",
    "plt.figure(figsize=(17,10), dpi=72)\n",
    "plt.title('linux kernel commit graph\\n'+\n",
    "          'histogram of normalized sizes of min-post interval')\n",
    "plt.grid(True)\n",
    "plt.xlabel('$|\\mathit{range}(v)|/\\phi(v)$')\n",
    "\n",
    "#plt.hist(larr,bins=25)\n",
    "#plt.draw()\n",
    "plt.hist(larr,bins=50,log=True)\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(larr,bins=25)\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "sns.set_style('whitegrid')\n",
    "sns.kdeplot(larr, bw=0.05, clip=(0.0,1.0), legend=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Finding paths / checking reachability between two commits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "graph = linux_graph_full\n",
    "\n",
    "print('max level in linux kernel commit graph is %d (out of %d nodes)' % \n",
    "      (max(graph.lvl.values()),graph.number_of_nodes()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print sorted(linux_repo.tags,key=lambda x: x.tag.tag,reverse=True)[:20]\n",
    "hex1 = linux_repo.tag('refs/tags/v4.9').tag.object.hexsha\n",
    "print('%s: %r' % ('v4.9', [n for n in linux_graph_full if hex1.startswith(n)]))\n",
    "hex2 = linux_repo.tag('refs/tags/v4.9-rc5').tag.object.hexsha\n",
    "print('%s: %r' % ('v4.9-rc5', [n for n in linux_graph_full if hex2.startswith(n)]))\n",
    "hex3 = linux_repo.tag('refs/tags/v4.8').tag.object.hexsha\n",
    "print('%s: %r' % ('v4.8', [n for n in linux_graph_full if hex3.startswith(n)]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git -C linux log --oneline --decorate --color=never v4.9-rc5..v4.9 | wc -l "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux: v4.9 -> v4.8 { form-width: \"30%\" }\n",
    "%%time\n",
    "import pprint\n",
    "\n",
    "stats_l={\n",
    "    'naive': {},\n",
    "    'level': {},\n",
    "    'feline': {},\n",
    "    'level+feline':{},\n",
    "}\n",
    "u='69973b830859'\n",
    "#v='a25f0944ba9b'\n",
    "v='c8d2bc9bc39e'\n",
    "print('%s -> %s' %(u,v))\n",
    "# recursion limit exceeded for'naive' (worst case scenario)\n",
    "print('- naive')\n",
    "%time generic_is_reachable_large(linux_graph_full,u,v,stats=stats_l['naive'])\n",
    "print('- level (generation numbers)')\n",
    "generic_is_reachable_large(linux_graph_full,u,v,\n",
    "                           l=linux_graph_full.lvl,\n",
    "                           stats=stats_l['level'])\n",
    "print('- FELINE')\n",
    "generic_is_reachable_large(linux_graph_full,u,v,\n",
    "                           i=linux_graph_full.fel,\n",
    "                           stats=stats_l['feline'])\n",
    "print('- FELINE+level')\n",
    "generic_is_reachable_large(linux_graph_full,u,v,\n",
    "                           l=linux_graph_full.lvl,i=linux_graph_full.fel,\n",
    "                           stats=stats_l['level+feline'])\n",
    "pp = pprint.PrettyPrinter(indent=4)\n",
    "\n",
    "stats_n = {}\n",
    "for t in sorted(stats_l, key=lambda k: stats_l[k]['access']):\n",
    "  stats_n[t] = {}\n",
    "  for st in stats_l[t]:\n",
    "    if isinstance(stats_l[t][st], list):\n",
    "      stats_n[t]['len(%s)' % st] = len(stats_l[t][st])\n",
    "    elif isinstance(stats_l[t][st], int) or \\\n",
    "         isinstance(stats_l[t][st], float):\n",
    "      stats_n[t][st] = stats_l[t][st]\n",
    "    else:\n",
    "      stats_n[t][st] = bool(stats_l[t][st])\n",
    "\n",
    "pp.pprint(stats_n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats_df = pd.DataFrame.from_dict(stats_n,orient='index')\\\n",
    "                       .sort_index(axis=0,ascending=False)\\\n",
    "                       .filter(items=['access','len(walk)','maxdepth','visited-filter',\n",
    "                                      'len(level-filter)','len(feline-filter)'])\\\n",
    "                       .sort_values('access', ascending=False)\n",
    "stats_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = linux_graph_full\n",
    "\n",
    "print('max commits at given level: %d' %max(linux_level_counts))\n",
    "lmax=max(linux_level_counts.keys(), key=lambda k: linux_level_counts[k])\n",
    "print('level with max commits is %d (out of %d) with %d commits' %\n",
    "      (lmax, max(graph.lvl.values()), linux_level_counts[lmax]))\n",
    "\n",
    "print('commits with level %d:\\n* %r\\n' %\n",
    "      (lmax, [c for (c,l) in graph.lvl.items() if l == lmax]))\n",
    "\n",
    "print('levels with max commits:')\n",
    "cc=10\n",
    "for (ll,lc) in sorted(linux_level_counts.items(), key=lambda kv: kv[1], reverse=True):\n",
    "  print('- level %d has %d commits: %r' %\n",
    "        (ll,lc,[c for (c,l) in graph.lvl.items() if l == ll]))\n",
    "  cc -= 1\n",
    "  if cc <= 0:\n",
    "    print('- ...')\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux: v4.9 -> dst { form-width: \"30%\" }\n",
    "%%time\n",
    "\n",
    "graph = linux_graph_full\n",
    "stats_l={\n",
    "    'naive': {},\n",
    "    'level': {},\n",
    "    'feline': {},\n",
    "    'level+feline': {},\n",
    "    'level+feline+mpi': {},\n",
    "}\n",
    "u='69973b830859'\n",
    "v='e31108cad3de'\n",
    "print('%s -> %s' %(u,v))\n",
    "print('* %s has level %d which it shares with %d commits' %\n",
    "      (u, graph.lvl[u], linux_level_counts[graph.lvl[u]]))\n",
    "print('* %s has level %d which it shares with %d commits' %\n",
    "      (v, graph.lvl[v], linux_level_counts[graph.lvl[v]]))\n",
    "print('* gen(%s) - gen(%s) = %d' %\n",
    "      (u, v, graph.lvl[u] - graph.lvl[v]))\n",
    "print('')\n",
    "\n",
    "print('- naive')\n",
    "generic_is_reachable_large(linux_graph_full,u,v,stats=stats_l['naive'])\n",
    "print('- level (generation numbers)')\n",
    "generic_is_reachable_large(linux_graph_full,u,v,\n",
    "                           l=linux_graph_full.lvl,\n",
    "                           stats=stats_l['level'])\n",
    "print('- FELINE')\n",
    "generic_is_reachable_large(linux_graph_full,u,v,\n",
    "                           i=linux_graph_full.fel,\n",
    "                           stats=stats_l['feline'])\n",
    "print('- FELINE+level')\n",
    "generic_is_reachable_large(linux_graph_full,u,v,\n",
    "                           l=linux_graph_full.lvl,i=linux_graph_full.fel,\n",
    "                           stats=stats_l['level+feline'])\n",
    "print('- FELINE+level+min-post')\n",
    "generic_is_reachable_large(graph, u, v,\n",
    "                           l=graph.lvl,i=graph.fel,II=graph.mpi,\n",
    "                           stats=stats_l['level+feline+mpi'])\n",
    "print('')\n",
    "\n",
    "stats_n = {}\n",
    "for t in sorted(stats_l, key=lambda k: stats_l[k]['access']):\n",
    "  stats_n[t] = {}\n",
    "  for st in stats_l[t]:\n",
    "    if isinstance(stats_l[t][st], list):\n",
    "      stats_n[t]['len(%s)' % st] = len(stats_l[t][st])\n",
    "    elif isinstance(stats_l[t][st], int) or \\\n",
    "         isinstance(stats_l[t][st], float):\n",
    "      stats_n[t][st] = stats_l[t][st]\n",
    "    else:\n",
    "      stats_n[t][st] = bool(stats_l[t][st])\n",
    "      \n",
    "stats_df = pd.DataFrame.from_dict(stats_n,orient='index')\\\n",
    "                       .sort_index(axis=0,ascending=False)\\\n",
    "                       .filter(items=['access','len(walk)','maxdepth','visited-filter',\n",
    "                                      'len(level-filter)','len(feline-filter)'])\\\n",
    "                       .sort_values('access', ascending=False)\n",
    "stats_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux: v4.9 -> dst feline plot { form-width: \"30%\" }\n",
    "graph=linux_graph_full\n",
    "stats=prepared_stats(stats_l)\n",
    "pos=graph.fel\n",
    "\n",
    "plt.title('linux commit graph nodes in dominance drawing (FELINE)\\n'+\n",
    "          ''+u+' -> '+v+'')\n",
    "plt.xlabel('FELINE x / topological order position')\n",
    "plt.ylabel('FELINE y')\n",
    "\n",
    "show_graph  = True #@param {type:\"boolean\"}\n",
    "show_naive  = True #@param {type:\"boolean\"}\n",
    "show_levels = True #@param {type:\"boolean\"}\n",
    "show_feline = True #@param {type:\"boolean\"}\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(\n",
    "  mpatches.Rectangle(\n",
    "    pos[u],\n",
    "    pos[v][0] - pos[u][0],\n",
    "    pos[v][1] - pos[u][1],\n",
    "    facecolor=\"grey\",alpha=0.25\n",
    "  )\n",
    ")\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "plt.vlines([pos[u][0],pos[v][0]],0,np.amax(yarr),lw=1.5,linestyles='dotted')\n",
    "plt.hlines([pos[u][1],pos[v][1]],0,np.amax(xarr),lw=1.5,linestyles='dotted')\n",
    "if show_graph:\n",
    "  plt.scatter(x=xarr, y=yarr, s=10,\n",
    "             c=(0.0,0.0,0.9,0.2), label='graph')\n",
    "\n",
    "if show_naive:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['naive']['walk']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['naive']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=10,\n",
    "              c=(0.0,0.5,1.0,0.5), label='naive')\n",
    "\n",
    "if show_levels:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level']['walk']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['level']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=10,\n",
    "              c=(0.0,1.0,0.0,1.0), label='level')\n",
    "\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level']['level-filter']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['level']['level-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=12,\n",
    "              c=(0.0,0.35,0.0,1.0), label='level (filtered)')\n",
    "  \n",
    "if show_feline:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=14,\n",
    "              c=(1.0,0.0,0.0,1.0), label='level+FELINE')\n",
    "  \n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=16,\n",
    "              c=(1.0,0.5,0.0,1.0), label='lvl+FEL (filtered)')\n",
    "\n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "plt.show()\n",
    "\n",
    "print('u=%s position is %r, level is %d' % (u,pos[u],graph.lvl[u]))\n",
    "print('v=%s position is %r, level is %d' % (v,pos[v],graph.lvl[v]))\n",
    "for walk in sorted(stats, key=lambda k: len(stats[k]['walk']), reverse=True):\n",
    "  print('- %s walked %d' % (walk, len(stats[walk]['walk'])))\n",
    "  \n",
    "gray_count = 0\n",
    "for n in pos:\n",
    "  if is_pair_leq(pos[u], pos[n]) and \\\n",
    "     is_pair_leq(pos[n], pos[v]):\n",
    "    gray_count += 1\n",
    "print('there are %d nodes out of %d in inclusion zone' %\n",
    "      (gray_count, graph.number_of_nodes()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "\n",
    "ax = plt.gca()\n",
    "\n",
    "t = np.arange(0.0, 2, 0.01)\n",
    "s = np.sin(2*np.pi*t)\n",
    "\n",
    "clip_rect = mpatches.Rectangle((0,-1),2,2,color='#aaaaaa',alpha=0.3)\n",
    "patch = mpatches.Polygon(\n",
    "        [[1.0,0.0],[1.5,0.5],[1.5,-0.75],[1.0,-1.25]],\n",
    "        closed=True,\n",
    "        color='g',fill=True,\n",
    "        clip_path=clip_rect,clip_on=True,\n",
    "    )\n",
    "# for some reason it doesn't work...\n",
    "patch.set_clip_path(clip_rect)\n",
    "\n",
    "ax.add_patch(clip_rect)\n",
    "ax.add_patch(patch)\n",
    "\n",
    "plt.plot(t, s, color='black', label='sin(x)')\n",
    "xslack=0.1\n",
    "yslack=0.1\n",
    "ax.set_xbound( 0-xslack, 2+xslack)\n",
    "ax.set_ybound(-1-yslack, 1+yslack)\n",
    "plt.show()\n",
    "\n",
    "#matplotlib.artist.getp(patch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux: v4.9 -> dst feline skewed { form-width: \"30%\" }\n",
    "%%time\n",
    "\n",
    "graph=linux_graph_full\n",
    "if not stats:\n",
    "  stats=prepared_stats(stats_l)\n",
    "pos=graph.fel\n",
    "\n",
    "plt.title('linux commit graph nodes in skewed dominance drawing (FELINE)\\n'+\n",
    "          ''+u+' -> '+v+'')\n",
    "plt.xlabel('FELINE x / topological order position')\n",
    "plt.ylabel('FELINE $\\Delta$ = x-y')\n",
    "\n",
    "show_graph  = True #@param {type:\"boolean\"}\n",
    "show_naive  = True #@param {type:\"boolean\"}\n",
    "show_levels = True #@param {type:\"boolean\"}\n",
    "show_feline = True #@param {type:\"boolean\"}\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([(x-y) for (x,y) in pos.values()])\n",
    "xmin = np.amin(xarr)\n",
    "xmax = np.amax(xarr)\n",
    "ymin = np.amin(yarr)\n",
    "ymax = np.amax(yarr)\n",
    "yamax = max(-ymin,ymax)\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(\n",
    "  # assume clipped TODO: fix!!!\n",
    "  mpatches.Polygon(\n",
    "    xy=np.array([\n",
    "        (pos[u][0], pos[u][0]-pos[u][1]),\n",
    "        (pos[u][0]-(pos[u][0]-pos[u][1])+ymax, ymax),\n",
    "        (pos[v][0]+(pos[v][0]-pos[v][1])-ymax, ymax),\n",
    "        (pos[v][0], pos[v][0]-pos[v][1]),\n",
    "        (pos[v][0]-(pos[v][0]-pos[v][1])+ymin, ymin),\n",
    "        (pos[u][0]+(pos[u][0]-pos[u][1])-ymin, ymin),\n",
    "    ]),\n",
    "    closed=True,\n",
    "    facecolor=\"grey\",alpha=0.25\n",
    "  )\n",
    ")\n",
    "\n",
    "plt.vlines([pos[u][0],pos[v][0]],\n",
    "           np.amin(yarr),np.amax(yarr),\n",
    "           lw=1.5,linestyles='dotted')\n",
    "plt.hlines([pos[u][0]-pos[u][1],pos[v][0]-pos[v][1]],\n",
    "           0,np.amax(xarr),\n",
    "           lw=1.5,linestyles='dotted')\n",
    "if show_graph:\n",
    "  plt.scatter(x=xarr, y=yarr, s=10,\n",
    "              c=(0.0,0.0,0.9,0.2), label='graph')\n",
    "\n",
    "if show_naive:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['naive']['walk']])\n",
    "  yarr = np.array([(x-y) for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['naive']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=10,\n",
    "              c=(0.0,0.5,1.0,0.5), label='naive')\n",
    "\n",
    "if show_levels:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level']['walk']])\n",
    "  yarr = np.array([(x-y) for (n,(x,y)) in pos.items() if n in stats['level']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=10,\n",
    "              c=(0.0,1.0,0.0,1.0), label='level')\n",
    "\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level']['level-filter']])\n",
    "  yarr = np.array([(x-y) for (n,(x,y)) in pos.items() if n in stats['level']['level-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=12,\n",
    "              c=(0.0,0.35,0.0,1.0), label='level (filtered)')\n",
    "  \n",
    "if show_feline:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "  yarr = np.array([(x-y) for (n,(x,y)) in pos.items() if n in stats['level+feline']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=14,\n",
    "              c=(1.0,0.0,0.0,1.0), label='level+FELINE')\n",
    "  \n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  yarr = np.array([(x-y) for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=16,\n",
    "              c=(1.0,0.5,0.0,1.0), label='lvl+FEL (filtered)')\n",
    "\n",
    "ax.set_ybound(-yamax*1.1, yamax*1.1)\n",
    "  \n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "plt.show()\n",
    "\n",
    "#print('u=%s position is %r, level is %d' % (u,pos[u],graph.lvl[u]))\n",
    "#print('v=%s position is %r, level is %d' % (v,pos[v],graph.lvl[v]))\n",
    "for walk in sorted(stats, key=lambda k: len(stats[k]['walk']), reverse=True):\n",
    "  print('- %s walked %d' % (walk, len(stats[walk]['walk'])))\n",
    "  \n",
    "gray_count = 0\n",
    "for n in pos:\n",
    "  if is_pair_leq(pos[u], pos[n]) and \\\n",
    "     is_pair_leq(pos[n], pos[v]):\n",
    "    gray_count += 1\n",
    "print('there are %d nodes out of %d in inclusion zone' %\n",
    "      (gray_count, graph.number_of_nodes()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux: v4.9 -> dst levels plot { form-width: \"30%\" }\n",
    "%%time\n",
    "graph = linux_graph_full\n",
    "\n",
    "level_counts_dict = defaultdict(int)\n",
    "graph.lvlpos = {}\n",
    "for node in graph:\n",
    "  x = graph.lvl[node]\n",
    "  level_counts_dict[x] += 1\n",
    "  y = level_counts_dict[x]\n",
    "  \n",
    "  graph.lvlpos[node] = (x, y)\n",
    "  \n",
    "pos = graph.lvlpos\n",
    "\n",
    "plt.title('linux kernel commit graph nodes in level drawing\\n'+\n",
    "          ''+u+' -> '+v+'')\n",
    "plt.xlabel('level / generation number')\n",
    "plt.ylabel('nodes with the same level')\n",
    "\n",
    "show_levels = True #@param {type:\"boolean\"}\n",
    "show_feline = True #@param {type:\"boolean\"}\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(\n",
    "  mpatches.Rectangle(\n",
    "    (pos[u][0], 0),\n",
    "    pos[v][0] - pos[u][0],\n",
    "    np.amax(yarr),\n",
    "    facecolor=\"grey\",alpha=0.25\n",
    "  )\n",
    ")\n",
    "\n",
    "plt.vlines([pos[u][0],pos[v][0]],0,np.amax(yarr),lw=1.5,linestyles='dotted')\n",
    "plt.hlines([pos[u][1],pos[v][1]],0,np.amax(xarr),lw=1.5,linestyles='dotted')\n",
    "plt.scatter(x=xarr, y=yarr, s=10,\n",
    "            c=(0.0,0.0,0.9,0.2), label='graph')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['naive']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['naive']['walk']])\n",
    "plt.scatter(x=xarr, y=yarr, s=10,\n",
    "            c=(0.0,0.5,1.0,0.5), label='naive')\n",
    "\n",
    "if show_levels:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level']['walk']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=10,\n",
    "              c=(0.0,1.0,0.0,1.0), label='level')\n",
    "\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level']['level-filter']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level']['level-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=12,\n",
    "              c=(0.0,0.35,0.0,1.0), label='level (filtered)')\n",
    "  \n",
    "if show_feline:\n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['walk']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['walk']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=14,\n",
    "              c=(1.0,0.0,0.0,1.0), label='level+FELINE')\n",
    "  \n",
    "  xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                   if n in stats['level+feline']['level-filter'] or \n",
    "                      n in stats['level+feline']['feline-filter']])\n",
    "  plt.scatter(x=xarr, y=yarr, s=16,\n",
    "              c=(1.0,0.5,0.0,1.0), label='lvl+FEL (filtered)')\n",
    "\n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "plt.show()\n",
    "\n",
    "print('u=%s position is %r, level is %d' % (u,pos[u],graph.lvl[u]))\n",
    "print('v=%s position is %r, level is %d' % (v,pos[v],graph.lvl[v]))\n",
    "for walk in sorted(stats, key=lambda k: len(stats[k]['walk']), reverse=True):\n",
    "  print('- %s walked %d' % (walk, len(stats[walk]['walk'])))\n",
    "  \n",
    "gray_count = 0\n",
    "for n in pos:\n",
    "  if graph.lvl[u] >= graph.lvl[n] and \\\n",
    "     graph.lvl[n] >= graph.lvl[v]:\n",
    "    gray_count += 1\n",
    "print('there are %d nodes out of %d in level-cut inclusion zone' %\n",
    "      (gray_count, graph.number_of_nodes()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title linux: v4.9 -> dst min-post plot { form-width: \"30%\" }\n",
    "%%time\n",
    "graph=linux_graph_full\n",
    "pos=graph.mpi\n",
    "\n",
    "plt.title('linux commit graph nodes in min-post intervals drawing\\n'+\n",
    "          u+'=['+str(pos[u][0])+','+str(pos[u][1])+'] -> '+\n",
    "          v+'=['+str(pos[v][0])+','+str(pos[v][1])+']')\n",
    "plt.xlabel('beg: $s_n$ from $I_n = [s_n, e_n]$')\n",
    "plt.ylabel('end: $e_n$ from $I_n = [s_n, e_n]$')\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "\n",
    "ax=plt.gca()\n",
    "ax.add_patch(\n",
    "  mpatches.Rectangle(\n",
    "    pos[v],\n",
    "    - pos[v][0],\n",
    "    np.amax(yarr) - pos[v][1],\n",
    "    facecolor=\"red\",alpha=0.10\n",
    "  )\n",
    ")\n",
    "\n",
    "plt.vlines([pos[u][0],pos[v][0]],0,np.amax(yarr),lw=1.5,linestyles='dotted')\n",
    "plt.hlines([pos[u][1],pos[v][1]],0,np.amax(xarr),lw=1.5,linestyles='dotted')\n",
    "plt.scatter(x=xarr, y=yarr, s=10,\n",
    "            c=(0.0,0.0,0.9,0.2), label='graph')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level']['walk']])\n",
    "plt.scatter(x=xarr, y=yarr, s=8,\n",
    "            c=(0.0,1.0,0.0,1.0), label='level')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level+feline']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level+feline']['walk']])\n",
    "plt.scatter(x=xarr, y=yarr, s=8,\n",
    "            c=(0.7,0.7,0.0,1.0), label='level+FELINE')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                 if n in stats_l['level+feline+mpi']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                 if n in stats_l['level+feline+mpi']['walk']])\n",
    "plt.scatter(x=xarr, y=yarr, s=20,\n",
    "            c=(1.0,0.0,0.0,1.0), label='level+FELINE+min-post')\n",
    "\n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%%time\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "graph=linux_graph_full\n",
    "pos=graph.mpi\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "ax.set_title('linux commit graph nodes in min-post intervals + levels 3d drawing')\n",
    "\n",
    "xarr = np.array([x for (x,y) in pos.values()])\n",
    "yarr = np.array([y for (x,y) in pos.values()])\n",
    "larr = np.array([graph.lvl[n] for n in pos.keys()])\n",
    "\n",
    "ax.scatter(xarr, yarr, larr, s=10,\n",
    "           c=(0.0,0.0,0.9,0.2), label='graph')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level+feline']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level+feline']['walk']])\n",
    "larr = np.array([graph.lvl[n] for (n,(x,y)) in pos.items()\n",
    "                 if n in stats['level+feline']['walk']])\n",
    "ax.scatter(xarr, yarr, larr, s=10,\n",
    "           c=(0.7,0.7,0.0,1.0), label='level+FELINE')\n",
    "\n",
    "xarr = np.array([x for (n,(x,y)) in pos.items()\n",
    "                 if n in stats_l['level+feline+mpi']['walk']])\n",
    "yarr = np.array([y for (n,(x,y)) in pos.items()\n",
    "                 if n in stats_l['level+feline+mpi']['walk']])\n",
    "larr = np.array([graph.lvl[n] for (n,(x,y)) in pos.items()\n",
    "                 if n in stats_l['level+feline+mpi']['walk']])\n",
    "plt.scatter(x=xarr, y=yarr, s=20,\n",
    "            c=(1.0,0.0,0.0,1.0), label='level+FELINE+min-post')\n",
    "\n",
    "ax.set_xlabel('s_u')\n",
    "ax.set_ylabel('e_u')\n",
    "ax.set_zlabel('l_u')\n",
    "\n",
    "plt.legend(frameon=True,fancybox=True,shadow=True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### N^2 connectivity on random sample of commits / nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "graph = linux_graph_full\n",
    "n_nodes = graph.number_of_nodes()\n",
    "\n",
    "choice = np.random.choice(n_nodes*n_nodes, 10000)\n",
    "conn_choice = [(x % n_nodes,x // n_nodes) for x in choice]\n",
    "\n",
    "nodes_dict = {num: v for (num,v) in enumerate(list(graph))}\n",
    "conn_nodes = {(nodes_dict[u], nodes_dict[v]) for (u,v) in conn_choice}\n",
    "\n",
    "print('%4d sample size' % len(conn_nodes))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "graph = linux_graph_full\n",
    "\n",
    "heads = find_heads(graph)\n",
    "roots = find_roots(graph)\n",
    "print('linux commit graph has %d tips / heads (\"roots\"): %r' % (len(heads),heads))\n",
    "print('linux commit graph has %d roots (\"leaves\"): %r' % (len(roots),roots))\n",
    "\n",
    "print('linux commit graph has average clustering coefficient %g (%d trials ?)\\n' %\n",
    "      (nx.average_clustering(graph.to_undirected()), 1000))\n",
    "#print('linux commit graph has the diameter of %g\\n' % nx.diameter(graph))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "conn_sample = []\n",
    "print('sample of %d node pairs' % len(conn_nodes))\n",
    "for (u,v) in conn_nodes:\n",
    "  #print('%r -> %r: %r' % (u, v, nx.has_path(linux_graph_full, u, v)))\n",
    "  conn_sample.append({'u':u, 'v':v,\n",
    "                      'l_u':linux_graph_full.lvl[u],\n",
    "                      'l_v':linux_graph_full.lvl[v],\n",
    "                      'min(u)':linux_graph_full.mpi_x[u]['min'],\n",
    "                      'min(v)':linux_graph_full.mpi_x[v]['min'],\n",
    "                      'post(u)':linux_graph_full.mpi_x[u]['post'],\n",
    "                      'post(v)':linux_graph_full.mpi_x[v]['post'],\n",
    "                      'u->v': nx.has_path(linux_graph_full,u,v)})\n",
    "\n",
    "conn_sample[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conn_sample_df = pd.DataFrame.from_records(conn_sample)\n",
    "conn_sample_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('connected:        %d of %d (%g +/- %g)' %\n",
    "      (conn_sample_df['u->v'].sum(),\n",
    "       conn_sample_df['u->v'].count(),\n",
    "       conn_sample_df['u->v'].mean(),\n",
    "       conn_sample_df['u->v'].std()))\n",
    "conn_sample_df['l_v<l_u']=conn_sample_df['l_v']<conn_sample_df['l_u']\n",
    "conn_sample_df['l_v>l_u']=conn_sample_df['l_v']>conn_sample_df['l_u']\n",
    "print('levels l_u < l_v: %d (%g +/- %g)' %\n",
    "      (conn_sample_df['l_v<l_u'].sum(),\n",
    "       conn_sample_df['l_v<l_u'].mean(),\n",
    "       conn_sample_df['l_v<l_u'].std()))\n",
    "print('levels l_u > l_v: %d (%g +/- %g)' %\n",
    "      (conn_sample_df['l_v>l_u'].sum(),\n",
    "       conn_sample_df['l_v>l_u'].mean(),\n",
    "       conn_sample_df['l_v>l_u'].std()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conn_sample_df.to_csv('conn_sample_df.csv')\n",
    "files.download('conn_sample_df.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conn_sample_df['!u->v'] = ~conn_sample_df['u->v']\n",
    "conn_sample_df['fp_levels'] = conn_sample_df['l_v<l_u'] & conn_sample_df['!u->v']\n",
    "print('level: false positives %d out of %d negative queries (%g %%), out of %d total' %\n",
    "      (conn_sample_df['fp_levels'].sum(),\n",
    "       conn_sample_df['!u->v'].sum(),\n",
    "       100.0*conn_sample_df['fp_levels'].sum()/conn_sample_df['!u->v'].sum(),\n",
    "       conn_sample_df['!u->v'].count()))\n",
    "conn_sample_df['fp_levels'].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('connected u->v:   %d of %d (%g)' %\n",
    "      (conn_sample_df['u->v'].sum(),\n",
    "       conn_sample_df['u->v'].count(),\n",
    "       conn_sample_df['u->v'].mean()))\n",
    "conn_sample_df['s_u <= v']=conn_sample_df['min(u)'] <= conn_sample_df['post(v)']\n",
    "conn_sample_df['e_u >= v']=conn_sample_df['post(v)'] <= conn_sample_df['post(u)']\n",
    "conn_sample_df['v in [s_u,e_u]']=conn_sample_df['s_u <= v'] & conn_sample_df['e_u >= v']\n",
    "print('intervals u-~->v: %d (%g)' %\n",
    "      (conn_sample_df['v in [s_u,e_u]'].sum(),\n",
    "       conn_sample_df['v in [s_u,e_u]'].mean()))\n",
    "conn_sample_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ss=conn_sample_df['u'].apply(lambda u: linux_graph_full.mpi_x[u]['p_tree'] or '<empty>')\n",
    "ss.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ss.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = linux_graph_full\n",
    "\n",
    "print('%4d pairs\\n' % len(conn_nodes))\n",
    "%time pos,neg,reach = split_connected_ex(graph, conn_nodes)\n",
    "print('')\n",
    "print('%4d are connected: %r' % (len(pos), pos[:10]))\n",
    "print('%4d not connected: %r' % (len(neg), neg[:10]))\n",
    "print('the hash has %d elements' % len(reach))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = linux_graph_full\n",
    "\n",
    "n_nodes = graph.number_of_nodes()\n",
    "print('linux commit graph has %d possible paths' % (n_nodes*(n_nodes-1)))\n",
    "print('sample has %d node pairs [%g%%]\\n' %\n",
    "      (len(conn_nodes),100.0*len(conn_nodes)/(n_nodes*(n_nodes-1))))\n",
    "\n",
    "%time lvl_fp = level_fp_sample(graph, graph.lvl, conn_nodes)\n",
    "%time fel_fp = feline_fp_sample(graph, graph.fel, conn_nodes)\n",
    "\n",
    "n_lvl_fp = len(lvl_fp)\n",
    "n_fel_fp = len(fel_fp)\n",
    "n_samples = len(conn_nodes)\n",
    "print('\\nlevel-filter has %5d = %5.2f%% [all] false positives' %\n",
    "      (n_lvl_fp, 100.0*n_lvl_fp/n_samples))\n",
    "print('FELINE index has %5d = %5.2f%% [all] false positives' %\n",
    "      (n_fel_fp, 100.0*n_fel_fp/n_samples))\n",
    "print('FELINE index has %g less false positives than level filter' %\n",
    "      (float(n_lvl_fp)/float(n_fel_fp)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = linux_graph_full\n",
    "\n",
    "print('linux commit graph was created from %d edges' % (len(edges)))\n",
    "n_nodes = graph.number_of_nodes()\n",
    "print('linux commit graph has %d nodes and %d edges (size)' %\n",
    "      (n_nodes, graph.size()))\n",
    "print('linux commit graph has %d possible paths\\n' % (n_nodes*(n_nodes-1)))\n",
    "\n",
    "print('\\ncalculating min-post spanning-tree intervals')\n",
    "%time graph.mpi = find_dfs_intervals(graph)\n",
    "graph.mpi_repr={\n",
    "  v:('[%d,%d]'%(i[0],i[1]))\n",
    "  for (v,i) in graph.mpi.items()\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = linux_graph_full\n",
    "\n",
    "n_nodes = graph.number_of_nodes()\n",
    "print('linux commit graph has %d possible paths' % (n_nodes*(n_nodes-1)))\n",
    "print('sample has %d node pairs [%g%%]\\n' %\n",
    "      (len(conn_nodes),100.0*len(conn_nodes)/(n_nodes*(n_nodes-1))))\n",
    "\n",
    "%time mpi_fp = interval_fn_sample(graph, graph.mpi, conn_nodes)\n",
    "\n",
    "n_mpi_fp = len(mpi_fp)\n",
    "n_samples = len(conn_nodes)\n",
    "print('\\nmin-post spanning-tree intervals has %5d = %5.2f%% [all] false negatives' %\n",
    "      (n_mpi_fp, 100.0*n_mpi_fp/n_samples))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}