08_reach.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "---\n",
    "description: Finding if one vertex in the DAG is reachable from another, with the\n",
    "  help of various reachability indexes (labels)\n",
    "output-file: reach.html\n",
    "title: Reachability queries\n",
    "\n",
    "---\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| default_exp reachability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "#| output: false\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imports for the `git_commit_graph_ext.reachability` module generated from this notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "from collections import deque"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reachability queries with topological levels and min-post intervals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Start with what was defined in the original Google Colab notebook, called there `generic_is_reachable()`.\n",
    "\n",
    "It will not be using FELINE index though, as it seems that this type of index is not a good fit for large commit graphs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recursive chatty version (levels + min-post) - `generic_is_reachable`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This recursive version is based on the Algorithm 3 from the FELINE paper, translated from pseudocode to Python (and NetworkX)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def generic_is_reachable(DG, u, v,\n",
    "                         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), that is whether vertex v is reachable from vertex u.\n",
    "  \n",
    "    This is based on the Algorithm 3 from FELINE paper, translated from pseudocode\n",
    "    to Python (and NetworkX).\n",
    "  \n",
    "    NOTE: this is a straightforward recursive version of the function.\n",
    "  \n",
    "    Parameters\n",
    "    ----------\n",
    "    DG : NetworkX digraph\n",
    "         Directed acyclic graph.\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).\n",
    "  \n",
    "    l : dict or None, optional (default=None)\n",
    "        A dictionary with nodes as keys and backward topological 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",
    "         * '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",
    "         * 'min-post' key, storing the vertex at which positive-cut\n",
    "           min-post interval cut-off the need for further search\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('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 <=> π(v) ∈ II_u (positive cut)\n",
    "    # II_v = [min_{w∈T_v}(π(w)),π(v)]\n",
    "    if II and II[u][0] <= II[v][1] <= II[u][1]:\n",
    "        if verbose:\n",
    "            print('%s->%s min-post resolved %s ∈ %r ⊆ %r' %\n",
    "                  (u, v, II[v][1], II[v], II[u]))\n",
    "        if isinstance(stats, dict):\n",
    "            stats['min-post'] = u\n",
    "        return True\n",
    "\n",
    "    # debugging\n",
    "    if verbose:\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",
    "    # l_v < l_u (no negative cut)\n",
    "    if (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, no short-circuit\n",
    "        result = False\n",
    "        for w in DG.successors(u):\n",
    "            if isinstance(stats, dict):\n",
    "                stats['access'] += 1\n",
    "\n",
    "            # recursion\n",
    "            if generic_is_reachable(DG, w, v, 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 l and not l[v] < l[u]:\n",
    "                stats['level'].append(u)\n",
    "\n",
    "    return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test that everything works.  For this we need example graphs, and a way to compute reachability levels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example graphs\n",
    "import git_commit_graph_ext.example_graphs as graphs\n",
    "# reachability indexes\n",
    "from git_commit_graph_ext.labelling.levels import *\n",
    "from git_commit_graph_ext.labelling.dfs_intervals import *\n",
    "# plotting, for visualizations\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the example graph from the PReaCH paper for testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "graph has 17 nodes and 19 edges\n",
      "nodes: ['a', 'e', 'b', 'f', 'g', 'c', 'h', 'i', 'd', 'j', 'o', 'k', 'l', 'm', 'n', 'p', 'q']\n",
      "it has the following attributes:\n",
      "- graph\n",
      "- lvl\n",
      "- pos\n",
      "- mpi\n",
      "Wall time: 6.99 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# lazy generation of the graph\n",
    "try:\n",
    "    ch\n",
    "except NameError:\n",
    "    ch=graphs.RCH_graph()\n",
    "\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, 'mpi'):\n",
    "    ch.mpi = find_dfs_intervals(ch)\n",
    "\n",
    "#print('%r' % ch)\n",
    "print('graph has {} nodes and {} edges'.format(ch.number_of_nodes(), ch.number_of_edges()))\n",
    "print('nodes: {!r}'.format(list(ch.nodes())))\n",
    "print('it has the following attributes:')\n",
    "for (attr,val) in ch.__dict__.items():\n",
    "  if isinstance(val, dict) and not attr.startswith('_'):\n",
    "    #print('- %s: %r' % (attr, ch.__dict__[attr]))\n",
    "    print('- %s' % attr)"
   ]
  },
  {
   "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": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.axis(\"off\")\n",
    "plt.title('Example graph from PReaCH paper (Figures 1 and 2)\\ndraw reversed - with arrows pointing down')\n",
    "nx.draw_networkx(ch,pos={key:(value[0],-value[1]) for (key,value) in ch.pos.items()},\n",
    "                 node_size=500,width=2.0,node_color='#dd44ff')\n",
    "nx.draw_networkx_edges(ch,pos={key:(value[0],-value[1]) for (key,value) in ch.pos.items()},\n",
    "                       edgelist=find_dfs_spanning(ch),\n",
    "                       node_size=500,\n",
    "                       width=8.0,edge_color='#4444ff',alpha=0.4,arrowstyle='->')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a->['e']\n",
      "e->['j']\n",
      "j->['o', 'p']\n",
      "o->[]\n",
      "p->[]\n",
      "r(a,g)=False in 4 steps (naive)\n",
      "  {'access': 4, 'level': [], 'walk': ['a', 'e', 'j', 'o', 'p']}\n",
      "\n",
      "a->['e']\n",
      "e->['j']\n",
      "j->['o', 'p']\n",
      "o->[]\n",
      "p->[]\n",
      "r(a,g)=False in 4 steps (min-post)\n",
      "  {'access': 4, 'level': [], 'walk': ['a', 'e', 'j', 'o', 'p']}\n",
      "\n",
      "a->['e']\n",
      "e->g level cut ¬2 < 2\n",
      "r(a,g)=False in 1 steps (level)\n",
      "  {'access': 1, 'level': ['e'], 'walk': ['a', 'e']}\n"
     ]
    }
   ],
   "source": [
    "# test unreachable\n",
    "stats = {}\n",
    "result = generic_is_reachable(ch, '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(ch, 'a', 'g', II=ch.mpi, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (min-post)\\n  %r\\n' %\n",
    "      ('a', 'g', result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable(ch, 'a', 'g', l=ch.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (level)\\n  %r' %\n",
    "      ('a', 'g', result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b->['e', 'f', 'g']\n",
      "e->['j']\n",
      "j->['o', 'p']\n",
      "p->[]\n",
      "f->['o', 'k']\n",
      "k->['p']\n",
      "p->[]\n",
      "g->['l']\n",
      "l->['q']\n",
      "q->[]\n",
      "r(b,o)=True in 11 steps (naive)\n",
      "  {'access': 11, 'level': [], 'walk': ['b', 'e', 'j', 'o', 'p', 'f', 'o', 'k', 'p', 'g', 'l', 'q']}\n",
      "\n",
      "b->['e', 'f', 'g']\n",
      "e->o min-post resolved 1 ∈ [1, 1] ⊆ [1, 4]\n",
      "f->['o', 'k']\n",
      "k->['p']\n",
      "p->[]\n",
      "g->['l']\n",
      "l->['q']\n",
      "q->[]\n",
      "r(b,o)=True in 8 steps (min-post)\n",
      "  {'access': 8, 'level': [], 'walk': ['b', 'e', 'f', 'o', 'k', 'p', 'g', 'l', 'q'], 'min-post': 'e'}\n",
      "\n",
      "b->['e', 'f', 'g']\n",
      "e->['j']\n",
      "j->['o', 'p']\n",
      "p->o level cut ¬0 < 0\n",
      "f->['o', 'k']\n",
      "k->['p']\n",
      "p->o level cut ¬0 < 0\n",
      "g->['l']\n",
      "l->['q']\n",
      "q->o level cut ¬0 < 0\n",
      "r(b,g)=True in 11 steps (level)\n",
      "  {'access': 11, 'level': ['p', 'p', 'q'], 'walk': ['b', 'e', 'j', 'o', 'p', 'f', 'o', 'k', 'p', 'g', 'l', 'q']}\n",
      "\n",
      "b->['e', 'f', 'g']\n",
      "e->o min-post resolved 1 ∈ [1, 1] ⊆ [1, 4]\n",
      "f->['o', 'k']\n",
      "k->['p']\n",
      "p->o level cut ¬0 < 0\n",
      "g->['l']\n",
      "l->['q']\n",
      "q->o level cut ¬0 < 0\n",
      "r(b,o)=True in 8 steps (min-post + level)\n",
      "  {'access': 8, 'level': ['p', 'q'], 'walk': ['b', 'e', 'f', 'o', 'k', 'p', 'g', 'l', 'q'], 'min-post': 'e'}\n"
     ]
    }
   ],
   "source": [
    "# test reachable\n",
    "stats = {}\n",
    "u='b'\n",
    "v='o'\n",
    "#u='c'\n",
    "#v='q'\n",
    "result = generic_is_reachable(ch, 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(ch, u, v, II=ch.mpi, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (min-post)\\n  %r\\n' %\n",
    "      (u, v, result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable(ch, u, v, l=ch.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (level)\\n  %r\\n' %\n",
    "      (u, 'g', result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable(ch, u, v, II=ch.mpi, l=ch.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (min-post + level)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DFS walk version (levels + min-post) - `generic_is_reachable_dfs`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code below was called `generic_is_reachable_large_v1()` and aliased to `generic_is_reachable_large()` in the original Google Colab notebook (see the [index](index.ipynb) for reference); though the one below has had its support for FELINE labels removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def generic_is_reachable_dfs(DG, u, v,\n",
    "                             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.  It travels the graph using depth-first search (DFS).\n",
    "  \n",
    "    Parameters\n",
    "    ----------\n",
    "    DG : NetworkX digraph\n",
    "         Directed acyclic graph.\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",
    "    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",
    "         * '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",
    "         * 'max-depth' 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 l:\n",
    "            stats['level-filter'] = []\n",
    "        stats['walk'] = []\n",
    "        stats['max-depth'] = 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['max-depth'] = max(stats['max-depth'], len(stack))\n",
    "\n",
    "        # have we arrived at destination?\n",
    "        if u == v:\n",
    "            return True\n",
    "\n",
    "        # II_v ⊆ II_u <=> π(v) ∈ II_u (positive cut)\n",
    "        # II_v = [min_{w∈T_v}(π(w)), π(v)]\n",
    "        if II and II[u][0] <= II[v][1] <= II[u][1]:\n",
    "            if isinstance(stats, dict):\n",
    "                stats['min-post'] = u\n",
    "            return True\n",
    "\n",
    "        # l_v < l_u (no negative cut; note: u != v)\n",
    "        if (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 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",
    "            return False\n",
    "        # end while\n",
    "\n",
    "    # haven't found v\n",
    "    return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic test that `generic_is_reachable_dfs()` works\n",
    "(among others that there are no syntax errors)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "graph has 17 nodes and 19 edges\n",
      "nodes: ['a', 'e', 'b', 'f', 'g', 'c', 'h', 'i', 'd', 'j', 'o', 'k', 'l', 'm', 'n', 'p', 'q']\n",
      "it has the following attributes:\n",
      "- graph\n",
      "- lvl\n",
      "- pos\n",
      "- mpi\n",
      "r(a,o)=True in 0 steps (min-post + level)\n",
      "  {'access': 0, 'level-filter': [], 'walk': ['a'], 'max-depth': 0, 'visited-filter': 0, 'min-post': 'a'}\n"
     ]
    }
   ],
   "source": [
    "stats = {}\n",
    "#u='b'\n",
    "u='a'\n",
    "v='o'\n",
    "\n",
    "print('graph has {} nodes and {} edges'.format(ch.number_of_nodes(), ch.number_of_edges()))\n",
    "print('nodes: {!r}'.format(list(ch.nodes())))\n",
    "print('it has the following attributes:')\n",
    "for (attr,val) in ch.__dict__.items():\n",
    "  if isinstance(val, dict) and not attr.startswith('_'):\n",
    "    #print('- %s: %r' % (attr, ch.__dict__[attr]))\n",
    "    print('- %s' % attr)\n",
    "\n",
    "result = generic_is_reachable_dfs(ch, u, v, II=ch.mpi, l=ch.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (min-post + level)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### BFS walk version, actively developed - `generic_is_reachable_bfs`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is called `generic_is_reachable_large_bfs()` (where BFS = breadth-first search)\n",
    "in the [Google Colab notebook](https://colab.research.google.com/drive/1V-U7_slu5Z3s5iEEMFKhLXtaxSu5xyzg#scrollTo=Zb8cvM3szzuu),\n",
    "but with the support for FELINE index stripped,\n",
    "and the support for PReaCH extensions to the min-post intervals index commented out;\n",
    "the support for min-post graph intervals as negative-cut filters was kept (was part of PReaCH extension).\n",
    "\n",
    "This code tries to be more generic by separating `reachable_positive_cut` and `reachable_negative_cut`\n",
    "into their own functions, but they are still very much tied to given set of reachability indices.\n",
    "\n",
    "Currently there is no way to add another index at later time (the design is not open to extensions),\n",
    "but making something generic may be not necessary as it is mainly exploraatory notebook.\n",
    "The code in Git would be written in C language, not in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\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 happens if the reachability index\n",
    "    implies that 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",
    "        TODO:\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 II[u][0] <= II[v][1] <= II[u][1]:\n",
    "            stats['positive-cut'] = {\n",
    "                'type': 'min-post',\n",
    "                'node': u\n",
    "            }\n",
    "            # print(\"%s -> %s: %d in [%d,%d]\" % (u,v,II[v][1], II[u][0], II[u][1]))\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",
    "\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",
    "                           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 negative cut happens if the 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",
    "    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",
    "        TODO:\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",
    "\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 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 pos < II[u]['f_min']:\n",
    "            stats['negative-cut']['f_min'].append(u)\n",
    "            result = True\n",
    "\n",
    "        if pos > II[u]['post']:\n",
    "            stats['negative-cut']['f_max'].append(u)\n",
    "            result = True\n",
    "\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",
    "\n",
    "            # can it reach target 'v'\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_bfs(DG, u, v,\n",
    "                             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",
    "    DG : NetworkX digraph\n",
    "        Directed acyclic graph.\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",
    "        TODO:\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",
    "\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",
    "\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 positive cuts\n",
    "    stats['negative-cut'] = {}\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'] = len(stats['path-pre']) - 1\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",
    "            stats['depth'] = stats['depth'][u]\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, 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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "graph has 17 nodes and 19 edges\n",
      "nodes: ['a', 'e', 'b', 'f', 'g', 'c', 'h', 'i', 'd', 'j', 'o', 'k', 'l', 'm', 'n', 'p', 'q']\n",
      "it has the following attributes:\n",
      "- graph\n",
      "- lvl\n",
      "- pos\n",
      "- mpi\n",
      "- mpi_ext\n"
     ]
    }
   ],
   "source": [
    "# lazy generation of the graph\n",
    "try:\n",
    "    ch\n",
    "except NameError:\n",
    "    ch=graphs.RCH_graph()\n",
    "\n",
    "recalculate = False\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, 'mpi'):\n",
    "    ch.mpi = find_dfs_intervals(ch)\n",
    "if recalculate or not hasattr(ch, 'mpi_ext'):\n",
    "    ch.mpi_ext = find_dfs_intervals_extra(ch)\n",
    "\n",
    "#print('%r' % ch)\n",
    "print('graph has {} nodes and {} edges'.format(ch.number_of_nodes(), ch.number_of_edges()))\n",
    "print('nodes: {!r}'.format(list(ch.nodes())))\n",
    "print('it has the following attributes:')\n",
    "for (attr,val) in ch.__dict__.items():\n",
    "  if isinstance(val, dict) and not attr.startswith('_'):\n",
    "    #print('- %s: %r' % (attr, ch.__dict__[attr]))\n",
    "    print('- %s' % attr)"
   ]
  },
  {
   "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": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.axis(\"off\")\n",
    "plt.title('Example graph from PReaCH paper (Figures 1 and 2)\\ndraw reversed - with arrows pointing down')\n",
    "nx.draw_networkx(ch,pos={key:(value[0],-value[1]) for (key,value) in ch.pos.items()},\n",
    "                 node_size=500,width=2.0,node_color='#dd44ff')\n",
    "nx.draw_networkx_edges(ch,pos={key:(value[0],-value[1]) for (key,value) in ch.pos.items()},\n",
    "                       edgelist=find_dfs_spanning(ch),\n",
    "                       node_size=500,\n",
    "                       width=8.0,edge_color='#4444ff',alpha=0.4,arrowstyle='->')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r(a,g)=False in 4 steps (naive)\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'negative-cut': {'visited': []},\n",
       " 'depth': {'a': 0, 'e': 1, 'j': 2, 'o': 3, 'p': 3},\n",
       " 'prev': {'a': None, 'e': 'a', 'j': 'e', 'o': 'j', 'p': 'j'},\n",
       " 'access': 4,\n",
       " 'walk': ['a', 'e', 'j', 'o', 'p'],\n",
       " 'max_queue_size': 2,\n",
       " 'visited': {'a', 'e', 'j', 'o', 'p'}}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test unreachable\n",
    "stats = {}\n",
    "result = generic_is_reachable_bfs(ch, 'a', 'g', stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (naive)\\n' %\n",
    "      ('a', 'g', result, stats['access']))\n",
    "stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r(a,g)=False in 1 steps (level)\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'negative-cut': {'level_lite': [], 'level_full': ['e'], 'visited': []},\n",
       " 'depth': {'a': 0, 'e': 1},\n",
       " 'prev': {'a': None, 'e': 'a'},\n",
       " 'access': 1,\n",
       " 'walk': ['a', 'e'],\n",
       " 'max_queue_size': 1,\n",
       " 'visited': {'a', 'e'}}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test unreachable\n",
    "stats = {}\n",
    "result = generic_is_reachable_bfs(ch, 'a', 'g', l=ch.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (level)\\n' %\n",
    "      ('a', 'g', result, stats['access']))\n",
    "stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testing `find_dfs_intervals_extra()` computing min-post graph intervals (negative-cut filter) and `generic_is_reachable_bfs()` ability to handle this information and use it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r(a,g)=False in 0 steps (level + min-post graph + min-post tree)\n",
      "\n",
      "a: level=3, interval_graph = [ 1,  5]\n",
      "g: level=2, interval_graph = [ 8, 10]\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'negative-cut': {'level_lite': [],\n",
       "  'level_full': [],\n",
       "  'f_max': ['a'],\n",
       "  'f_min': [],\n",
       "  'visited': []},\n",
       " 'depth': {'a': 0},\n",
       " 'prev': {'a': None},\n",
       " 'access': 0,\n",
       " 'walk': ['a'],\n",
       " 'max_queue_size': 1,\n",
       " 'visited': {'a'}}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test unreachable\n",
    "stats = {}\n",
    "result = generic_is_reachable_bfs(ch, 'a', 'g', II=ch.mpi_ext, l=ch.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (level + min-post graph + min-post tree)\\n' %\n",
    "      ('a', 'g', result, stats['access']))\n",
    "print('%s: level=%d, interval_graph = [%2d, %2d]'   % ('a',ch.lvl['a'],ch.mpi_ext['a']['f_min'],ch.mpi_ext['a']['post']))\n",
    "print('%s: level=%d, interval_graph = [%2d, %2d]\\n' % ('g',ch.lvl['g'],ch.mpi_ext['g']['f_min'],ch.mpi_ext['g']['post']))\n",
    "stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r(b,o)=True in 9 steps (naive)\n",
      "  {'negative-cut': {'visited': []}, 'depth': {'b': 0, 'e': 1, 'f': 1, 'g': 1, 'j': 2, 'o': 3, 'k': 2, 'l': 2, 'p': 3}, 'prev': {'b': None, 'e': 'b', 'f': 'b', 'g': 'b', 'j': 'e', 'o': 'j', 'k': 'f', 'l': 'g', 'p': 'j'}, 'access': 9, 'walk': ['b', 'e', 'f', 'g', 'j', 'o'], 'max_queue_size': 5, 'visited': {'b', 'e', 'g', 'j', 'f', 'o'}, 'path': ['b', 'e', 'j', 'o'], 'len': 3}\n",
      "\n",
      "r(b,o)=True in 3 steps (min-post)\n",
      "  {'negative-cut': {'visited': []}, 'depth': 1, 'prev': {'b': None, 'e': 'b', 'f': 'b', 'g': 'b'}, 'access': 3, 'walk': ['b', 'e'], 'max_queue_size': 3, 'visited': {'b', 'e'}, 'positive-cut': {'type': 'min-post', 'node': 'e'}, 'path-pre': ['b', 'e'], 'path-post': ['e', 'j', 'o'], 'len-pre': 1, 'len-post': 2, 'path': ['b', 'e', 'j', 'o'], 'len': 3}\n",
      "\n",
      "r(b,g)=True in 9 steps (level)\n",
      "  {'negative-cut': {'level_lite': [], 'level_full': [], 'visited': []}, 'depth': {'b': 0, 'e': 1, 'f': 1, 'g': 1, 'j': 2, 'o': 3, 'k': 2, 'l': 2, 'p': 3}, 'prev': {'b': None, 'e': 'b', 'f': 'b', 'g': 'b', 'j': 'e', 'o': 'j', 'k': 'f', 'l': 'g', 'p': 'j'}, 'access': 9, 'walk': ['b', 'e', 'f', 'g', 'j', 'o'], 'max_queue_size': 5, 'visited': {'b', 'e', 'g', 'j', 'f', 'o'}, 'path': ['b', 'e', 'j', 'o'], 'len': 3}\n",
      "\n",
      "r(b,o)=True in 3 steps (min-post + level)\n",
      "  {'negative-cut': {'level_lite': [], 'level_full': [], 'visited': []}, 'depth': 1, 'prev': {'b': None, 'e': 'b', 'f': 'b', 'g': 'b'}, 'access': 3, 'walk': ['b', 'e'], 'max_queue_size': 3, 'visited': {'b', 'e'}, 'positive-cut': {'type': 'min-post', 'node': 'e'}, 'path-pre': ['b', 'e'], 'path-post': ['e', 'j', 'o'], 'len-pre': 1, 'len-post': 2, 'path': ['b', 'e', 'j', 'o'], 'len': 3}\n"
     ]
    }
   ],
   "source": [
    "# test reachable\n",
    "stats = {}\n",
    "u='b'\n",
    "v='o'\n",
    "#u='c'\n",
    "#v='q'\n",
    "result = generic_is_reachable_bfs(ch, 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_bfs(ch, u, v, II=ch.mpi, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (min-post)\\n  %r\\n' %\n",
    "      (u, v, result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable_bfs(ch, u, v, l=ch.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (level)\\n  %r\\n' %\n",
    "      (u, 'g', result, stats['access'], stats))\n",
    "stats = {}\n",
    "result = generic_is_reachable_bfs(ch, u, v, II=ch.mpi, l=ch.lvl, stats=stats)\n",
    "print('r(%s,%s)=%r in %d steps (min-post + level)\\n  %r' %\n",
    "      (u, v, result, stats['access'], stats))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "crown DAG: <networkx.classes.digraph.DiGraph object at 0x000001963BB1F9D0>\n",
      "- r(u,v): False\n",
      "- r(1,2): True\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#@title test generic_is_reachable_large_bfs { form-width: \"30%\" }\n",
    "\n",
    "# lazy generation of the graph\n",
    "try:\n",
    "    DG\n",
    "except NameError:\n",
    "    DG=graphs.crown_DAG()\n",
    "\n",
    "recalculate = False\n",
    "if recalculate or not hasattr(DG, 'lvl'):\n",
    "    DG.lvl = find_levels(DG)\n",
    "if recalculate or not hasattr(DG, 'mpi'):\n",
    "    DG.mpi = find_dfs_intervals(DG)\n",
    "\n",
    "if recalculate or not hasattr(DG, 'pos'):\n",
    "    DG.pos={1:(1,4),2:(3,6),'u':(2,2),3:(4,1),4:(6,3),'v':(5,5)}\n",
    "if recalculate or not hasattr(DG, 'span'):\n",
    "    DG.span=find_dfs_spanning(DG)\n",
    "    \n",
    "# configure plot\n",
    "plt.axis('off')\n",
    "plt.title('Crown DAG $S_0^3$ with the spanning tree overlay '+\n",
    "          '(find_dfs_spanning)')\n",
    "\n",
    "# draw graph and its spanning tree\n",
    "nx.draw_networkx(DG,\n",
    "                 pos=DG.pos,\n",
    "                 node_size=500,width=8.0,\n",
    "                 edge_color='#aaaaaa')\n",
    "nx.draw_networkx_edges(DG,\n",
    "                       pos=DG.pos,\n",
    "                       edgelist=DG.span,\n",
    "                       node_size=500,width=2.0,\n",
    "                       arrowstyle='->')\n",
    "plt.draw()\n",
    "    \n",
    "print('crown DAG: %r' % DG)\n",
    "print('- r(u,v): %r' % \n",
    "      generic_is_reachable_bfs(DG,'u','v',\n",
    "                               l=DG.lvl,II=DG.mpi))\n",
    "print('- r(1,2): %r' %\n",
    "      generic_is_reachable_bfs(DG, 1,  2,\n",
    "                               l=DG.lvl,II=DG.mpi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> TODO:\n",
    "> - examine other example graphs, or\n",
    "> - create interactive visualization\n",
    "> - examine paths, cutoffs, etc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 01_tools.ipynb.\n",
      "Converted 02_related.ipynb.\n",
      "Converted 03_example_graphs.ipynb.\n",
      "Converted 05_reachability_index.ipynb.\n",
      "Converted 06_levels.ipynb.\n",
      "Converted 07_interval_labels.ipynb.\n",
      "Converted 08_reach.ipynb.\n",
      "Converted index.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#| include: false\n",
    "# this should be the last cell of the notebook\n",
    "from nbdev import nbdev_export\n",
    "nbdev_export()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PyCharm (git-commit-graph-ext)",
   "language": "python",
   "name": "pycharm-704e829d"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}