diff --git a/notebooks/README.md b/notebooks/README.md
index 56eb1d5c317..41952c6cd30 100644
--- a/notebooks/README.md
+++ b/notebooks/README.md
@@ -30,11 +30,11 @@ This repository contains a collection of Jupyter Notebooks that outline how to r
 Layout            |                                                              |                                                              |
 |                 | [Force-Atlas2](algorithms/layout/Force-Atlas2.ipynb)   |A large graph visualization achieved with cuGraph. |
 | Link Analysis   |                                                              |                                                              |
-|                 | [Pagerank](link_analysis/Pagerank.ipynb)                     | Compute the PageRank of every vertex in a graph              |
-|                 | [HITS](link_analysis/HITS.ipynb)                             | Compute the HITS' Hub and Authority scores for every vertex in a graph              |
+|                 | [Pagerank](algorithms/link_analysis/Pagerank.ipynb)                     | Compute the PageRank of every vertex in a graph              |
+|                 | [HITS](algorithms/link_analysis/HITS.ipynb)                             | Compute the HITS' Hub and Authority scores for every vertex in a graph              |
 | Link Prediction |                                                              |                                                              |
-|                 | [Jaccard Similarity](link_prediction/Jaccard-Similarity.ipynb) | Compute vertex similarity score using both:<br />- Jaccard Similarity<br />- Weighted Jaccard |
-|                 | [Overlap Similarity](link_prediction/Overlap-Similarity.ipynb) | Compute vertex similarity score using the Overlap Coefficient |
+|                 | [Jaccard Similarity](algorithms/link_prediction/Jaccard-Similarity.ipynb) | Compute vertex similarity score using both:<br />- Jaccard Similarity<br />- Weighted Jaccard |
+|                 | [Overlap Similarity](algorithms/link_prediction/Overlap-Similarity.ipynb) | Compute vertex similarity score using the Overlap Coefficient |
 | Sampling        |
 |                 | [Random Walk](sampling/RandomWalk.ipynb)                     | Compute Random Walk for a various number of seeds and path lengths |
 | Traversal       |                                                              |                                                              |
@@ -61,21 +61,7 @@ Running the example in these notebooks requires:
 * CUDA 11.4+
 * NVIDIA driver 450.51+
 
-
-
-#### Notebook Credits
-
-- Original Authors: Bradley Rees
-- Last Edit: 04/19/2021
-
-RAPIDS Versions: 0.19  
-
-Test Hardware
-- GV100 32G, CUDA 9,2
-
-
-
-##### Copyright
+#### Copyright
 
 Copyright (c) 2019-2022, NVIDIA CORPORATION.  All rights reserved.
 
diff --git a/notebooks/algorithms/README.md b/notebooks/algorithms/README.md
index 03262336fbc..cfac699ec8e 100644
--- a/notebooks/algorithms/README.md
+++ b/notebooks/algorithms/README.md
@@ -10,33 +10,33 @@ This repository contains a collection of Jupyter Notebooks that outline how to r
 
 | Folder          | Notebook                                                     | Description                                                  |
 | --------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
-| Centrality      |                                                              |                                                              |
+| [Centrality](centrality/README.md)      |                                                              |                                                              |
 |                 | [Centrality](centrality/Centrality.ipynb)                    | Compute and compare multiple (currently 5) centrality scores |
 |                 | [Katz](centrality/Katz.ipynb)                                | Compute the Katz centrality for every vertex                 |
 |                 | [Betweenness](centrality/Betweenness.ipynb)                  | Compute both Edge and Vertex Betweenness centrality          |
 |                 | [Degree](centrality/Degree.ipynb)                            | Compute Degree Centraility for each vertex                   |
 |                 | [Eigenvector](centrality/Eigenvector.ipynb)                  | Compute Eigenvector for every vertex                         |
-| Community       |                                                              |                                                              |
+|[Community](community/README.md)       |                                                              |                                                              |
 |                 | [Louvain](community/Louvain.ipynb)                           | Identify clusters in a graph using both the Louvain and Leiden algorithms     |
 |                 | [ECG](community/ECG.ipynb)                                   | Identify clusters in a graph using the Ensemble Clustering for Graph |
 |                 | [K-Truss](community/ktruss.ipynb)                                | Extracts the K-Truss cluster                                 |
 |                 | [Spectral-Clustering](community/Spectral-Clustering.ipynb)   | Identify clusters in a  graph using Spectral Clustering with both<br> - Balanced Cut<br> - Modularity Modularity |
 |                 | [Subgraph Extraction](community/Subgraph-Extraction.ipynb)   | Compute a subgraph of the existing graph including only the specified vertices |
 |                 | [Triangle Counting](community/Triangle-Counting.ipynb)       | Count the number of Triangle in a graph                      |
-Components      |                                                              |                                                              |
+|[Components](components/README.md)      |                                                              |                                                              |
 |                 | [Connected Components](components/ConnectedComponents.ipynb) | Find weakly and strongly connected components in a graph     |
-| Cores            |                                                              |                                                              |
+| [Cores](cores/README.md)            |                                                              |                                                              |
 |                | [core-number](cores/Core-number.ipynb)   | Computes the core number for every vertex of a graph G. The core number of a vertex is a maximal subgraph that contains only that vertex and others of degree k or more. |
 |                | [kcore](cores/kcore.ipynb)               |Find the k-core of a graph which is a maximal subgraph that contains nodes of degree k or more.|
 Layout            |                                                              |                                                              |
 |                | [Force-Atlas2](layout/Force-Atlas2.ipynb)   |A large graph visualization achieved with cuGraph. |
-<!--| Link Analysis   |                                                              |                                                              |
+| [Link Analysis](link_analysis/README.md)   |                                                              |                                                              |
 |                 | [Pagerank](link_analysis/Pagerank.ipynb)                     | Compute the PageRank of every vertex in a graph              |
 |                 | [HITS](link_analysis/HITS.ipynb)                             | Compute the HITS' Hub and Authority scores for every vertex in a graph              |
-| Link Prediction |                                                              |                                                              |
-|                 | [Jaccard Similarity](link_prediction/Jaccard-Similarity.ipynb) | Compute vertex similarity score using both:<br />- Jaccard Similarity<br />- Weighted Jaccard |
-|                 | [Overlap Similarity](link_prediction/Overlap-Similarity.ipynb) | Compute vertex similarity score using the Overlap Coefficient |
-| Sampling        |
+| [Link Prediction](link_prediction/README.md) |                                                              |                                                              |
+|                 | [Jaccard Similarity](algorithms/link_prediction/Jaccard-Similarity.ipynb) | Compute vertex similarity score using both:<br />- Jaccard Similarity<br />- Weighted Jaccard |
+|                 | [Overlap Similarity](algorithms/link_prediction/Overlap-Similarity.ipynb) | Compute vertex similarity score using the Overlap Coefficient |
+<!--| Sampling        |
 |                 | [Random Walk](sampling/RandomWalk.ipynb)                     | Compute Random Walk for a various number of seeds and path lengths |
 | Traversal       |                                                              |                                                              |
 |                 | [BFS](traversal/BFS.ipynb)                                   | Compute the Breadth First Search path from a starting vertex to every other vertex in a graph |
@@ -51,7 +51,7 @@ Layout            |
 | Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware |
 | --------------|------------|------------------|-----------------|----------------|
 | Brad Rees     | 04/19/2021 | created          | 0.19            | GV100, CUDA 11.0
-| Don Acosta    | 07/05/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5
+| Don Acosta    | 08/02/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5
 
 ### Copyright
 
diff --git a/notebooks/algorithms/centrality/Centrality.ipynb b/notebooks/algorithms/centrality/Centrality.ipynb
index 72909fd81dd..8406ef96da6 100644
--- a/notebooks/algorithms/centrality/Centrality.ipynb
+++ b/notebooks/algorithms/centrality/Centrality.ipynb
@@ -17,7 +17,7 @@
     "| --------------|------------|------------------|-----------------|----------------|\n",
     "| Brad Rees     | 04/16/2021 | created          | 0.19            | GV100, CUDA 11.0\n",
     "| Brad Rees     | 08/05/2021 | tested / updated | 21.10 nightly   | RTX 3090 CUDA 11.4\n",
-    "| Don Acosta    | 07/05/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5\n",
+    "| Don Acosta    | 07/29/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5\n",
     " "
    ]
   },
@@ -27,7 +27,7 @@
    "source": [
     "Centrality is measure of how important, or central, a node or edge is within a graph.  It is useful for identifying influencer in social networks, key routing nodes in communication/computer network infrastructures, \n",
     "\n",
-    "The seminal paper on centrality is:  Freeman, L. C. (1978). Centrality in social networks conceptual clarification. Social networks, 1(3), 215-239.\n",
+    "The seminal paper on centrality is:  Freeman, L. C. (1978). [Centrality in social networks conceptual clarification.](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.320.5551&rep=rep1&type=pdf) Social networks, 1(3), 215-239.\n",
     "\n",
     "__Degree Centrality__ <br>\n",
     "Degree centrality is based on the notion that whoever has the most connections must be important.   \n",
@@ -117,9 +117,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#  Import the cugraph modules\n",
+    "# Import the cugraph modules\n",
     "import cugraph\n",
-    "import cudf"
+    "import cudf\n",
+    "from cugraph.experimental.datasets import karate"
    ]
   },
   {
@@ -128,7 +129,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#import the networkX required modules\n",
+    "# import the non-Rapids required modules\n",
     "import numpy as np\n",
     "import pandas as pd   \n",
     "from IPython.display import display_html "
@@ -196,46 +197,13 @@
     "    display_html(df1_styler._repr_html_()+df2_styler._repr_html_()+df3_styler._repr_html_()+df4_styler._repr_html_()+df5_styler._repr_html_(), raw=True)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Read the data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Define the path to the test data  \n",
-    "datafile='../../data/karate-data.csv'"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "cuGraph does not do any data reading or writing and is dependent on other tools for that, with cuDF being the preferred solution.   \n",
     "\n",
-    "The data file contains an edge list, which represents the connection of a vertex to another.  The `source` to `destination` pairs is in what is known as Coordinate Format (COO).  In this test case, the data is just two columns.  However a third, `weight`, column is also possible"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gdf = cudf.read_csv(datafile, delimiter='\\t', names=['src', 'dst'], dtype=['int32', 'int32'] )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "it was that easy to load data"
+    "The data file contains an edge list, which represents the connections between vertices.  The `source` to `destination` pairs is in what is known as Coordinate Format (COO).  In this test case, the data is just two columns.  However a third, `weight`, column is also possible"
    ]
   },
   {
@@ -251,16 +219,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# create a Graph using the source (src) and destination (dst) vertex pairs from the Dataframe \n",
-    "G = cugraph.Graph()\n",
-    "G.from_cudf_edgelist(gdf, source='src', destination='dst')"
+    "# Create a graph using the imported Dataset object\n",
+    "G = karate.get_graph(fetch=True)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Compute Centrality"
+    "## Compute the Centrality measures in a single function."
    ]
   },
   {
@@ -295,7 +262,7 @@
    "metadata": {},
    "source": [
     "### A Different Dataset\n",
-    "The Karate dataset is not that large or complex, which makes it a perfect test dataset since it is easy to visually verify results.  Let's look at a larger dataset with a lot more edges"
+    "The Karate dataset is not large or complex, which makes it a perfect test dataset since it is easy to visually verify results.  Let's look at a larger dataset with a lot more edges"
    ]
   },
   {
diff --git a/notebooks/algorithms/layout/Force-Atlas2.ipynb b/notebooks/algorithms/layout/Force-Atlas2.ipynb
index 00fb9318790..a0dafbef511 100644
--- a/notebooks/algorithms/layout/Force-Atlas2.ipynb
+++ b/notebooks/algorithms/layout/Force-Atlas2.ipynb
@@ -5,7 +5,7 @@
    "metadata": {},
    "source": [
     "# Force Atlas 2\n",
-    "# Skip notebook test"
+    "# Skip notebook test\n"
    ]
   },
   {
@@ -21,7 +21,14 @@
     "| Hugo Linsenmaier | 11/16/2020 | created          | 0.17            | GV100, CUDA 11.0\n",
     "| Brad Rees        | 01/11/2022 | tested / updated | 22.02 nightly   | RTX A6000 CUDA 11.5\n",
     "| Ralph Liu        | 06/22/2022 | updated/tested   | 22.08           | TV100, CUDA 11.5\n",
-    "    "
+    "| Don Acosta       | 08/01/2022 | tested / updated | 22.08 nightly   | DGX Tesla A100 CUDA 11.5 "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### This notebook will not currently run because there is a conflict between the version of CuPy required by cugraph (11.0) and the version supported in cuxfilter (7.8 to 10.0). Notebook will be updated when cuxfilter supports CuPy 11."
    ]
   },
   {
@@ -225,7 +232,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.9.7 ('base')",
+   "display_name": "Python 3.9.13 ('cugraph_dev')",
    "language": "python",
    "name": "python3"
   },
@@ -239,11 +246,11 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.7"
+   "version": "3.9.13"
   },
   "vscode": {
    "interpreter": {
-    "hash": "f708a36acfaef0acf74ccd43dfb58100269bf08fb79032a1e0a6f35bd9856f51"
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
    }
   }
  },
diff --git a/notebooks/link_analysis/HITS.ipynb b/notebooks/algorithms/link_analysis/HITS.ipynb
similarity index 86%
rename from notebooks/link_analysis/HITS.ipynb
rename to notebooks/algorithms/link_analysis/HITS.ipynb
index 91a78473dae..9578377b747 100755
--- a/notebooks/link_analysis/HITS.ipynb
+++ b/notebooks/algorithms/link_analysis/HITS.ipynb
@@ -4,22 +4,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# HITS\n",
+    "# HITS (Hyperlink-Induced Topic Search)\n",
     "\n",
-    "In this notebook, we will use both NetworkX and cuGraph to compute HITS.  \n",
+    "In this notebook, we will use both NetworkX and cuGraph to compute HITS.\n",
     "The NetworkX and cuGraph processes will be interleaved so that each step can be compared.\n",
     "\n",
-    "Notebook Credits\n",
-    "* Original Authors: Bradley Rees and James Wyles\n",
-    "* Created:   06/09/2020\n",
-    "* Updated:   06/22/2022\n",
-    "\n",
-    "RAPIDS Versions: 0.15  \n",
-    "\n",
-    "Test Hardware\n",
-    "\n",
-    "* Tesla V100 32G, CUDA 11.5\n",
-    "\n",
+    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware |\n",
+    "| --------------|------------|------------------|-----------------|----------------|\n",
+    "| Bradley Rees and James Wyles | 06/09/2020 | created          | 0.15 | GV100, CUDA 10.0\n",
+    "|               | 08/16/2020 | tested / updated | 0.15.1 nightly  | RTX 3090 CUDA 11.4\n",
+    "| Ralph Liu     | 06/22/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5\n",
+    "| Don Acosta    | 07/27/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5\n",
     "\n",
     "## Introduction\n",
     "HITS, also known as hubs and authorities, computes the relative importance of vertices.   \n",
@@ -51,8 +46,11 @@
     "         nstart=None,\n",
     "         normalized=True)**\n",
     "* __G__: cugraph.Graph object\n",
-    "* __max_iter__: int, The maximum number of iterations before an answer is returned. \n",
-    "* __tol__: float, Set the tolerance the approximation, this parameter should be a small magnitude value. \n",
+    "* __max_iter__: int, The maximum number of iterations before an answer is returned.\n",
+    "  * If the algorithm doesnt converge by this number of iterations the algorithm fails..\n",
+    "* __tol__: float, Set the tolerance of the approximation, this parameter should be a small magnitude value.\n",
+    "  * If the algorithm doesnt converge to this tolerance it will error out.\n",
+    "  * The smaller the value the more accurate the results but the longer it will take and higher the likelihood of failure.\n",
     "* __nstart__: cudf.DataFrame - Not currently supported\n",
     "* __normalized_ : bool - Not currently supported, always used as True\n",
     "\n",
@@ -67,7 +65,6 @@
     "\n",
     "\n",
     "### Some notes about vertex IDs...\n",
-    "* The current version of cuGraph requires that vertex IDs be representable as 32-bit integers, meaning graphs currently can contain at most 2^32 unique vertex IDs. However, this limitation is being actively addressed and a version of cuGraph that accommodates more than 2^32 vertices will be available in the near future.\n",
     "* cuGraph will automatically renumber graphs to an internal format consisting of a contiguous series of integers starting from 0, and convert back to the original IDs when returning data to the caller. If the vertex IDs of the data are already a contiguous series of integers starting from 0, the auto-renumbering step can be skipped for faster graph creation times.\n",
     "  * To skip auto-renumbering, set the `renumber` boolean arg to `False` when calling the appropriate graph creation API (eg. `G.from_cudf_edgelist(gdf_r, source='src', destination='dst', renumber=False)`).\n",
     "  * For more advanced renumbering support, see the examples in `structure/renumber.ipynb` and `structure/renumber-2.ipynb`\n"
@@ -83,7 +80,7 @@
     "Anthropological Research 33, 452-473 (1977).*\n",
     "\n",
     "\n",
-    "![Karate Club](../img/zachary_black_lines.png)\n"
+    "<img src=\"../../img/zachary_black_lines.png\" width=\"35%\"/>\n"
    ]
   },
   {
@@ -102,7 +99,7 @@
     "# The notebook compares cuGraph to NetworkX,  \n",
     "# therefore there some additional non-RAPIDS python libraries need to be installed. \n",
     "# Please run this cell if you need the additional libraries\n",
-    "!pip install networkx"
+    "%pip install networkx"
    ]
   },
   {
@@ -158,7 +155,7 @@
    "outputs": [],
    "source": [
     "# Read the data, this also created a NetworkX Graph \n",
-    "datafile = \"../data/karate-data.csv\"\n",
+    "datafile = \"../../data/karate-data.csv\"\n",
     "file = open(datafile, 'rb')\n",
     "Gnx = nx.read_edgelist(file)"
    ]
@@ -321,7 +318,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<img src=\"../img/zachary_graph_hits.png\" width=\"600\">"
+    "<img src=\"../../img/karate_hits.png\" width=\"35%\">"
    ]
   },
   {
@@ -347,7 +344,7 @@
    "metadata": {},
    "source": [
     "___\n",
-    "Copyright (c) 2019-2020, NVIDIA CORPORATION.\n",
+    "Copyright (c) 2019-2022, NVIDIA CORPORATION.\n",
     "\n",
     "Licensed under the Apache License, Version 2.0 (the \"License\");  you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
     "\n",
@@ -358,7 +355,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.9.7 ('base')",
+   "display_name": "Python 3.9.13 ('cugraph_dev')",
    "language": "python",
    "name": "python3"
   },
@@ -372,11 +369,11 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.7"
+   "version": "3.9.13"
   },
   "vscode": {
    "interpreter": {
-    "hash": "f708a36acfaef0acf74ccd43dfb58100269bf08fb79032a1e0a6f35bd9856f51"
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
    }
   }
  },
diff --git a/notebooks/link_analysis/Pagerank.ipynb b/notebooks/algorithms/link_analysis/Pagerank.ipynb
similarity index 89%
rename from notebooks/link_analysis/Pagerank.ipynb
rename to notebooks/algorithms/link_analysis/Pagerank.ipynb
index ebd8d32905b..6b78f5866d9 100755
--- a/notebooks/link_analysis/Pagerank.ipynb
+++ b/notebooks/algorithms/link_analysis/Pagerank.ipynb
@@ -10,17 +10,12 @@
     "\n",
     "In this notebook, we will use both NetworkX and cuGraph to compute the PageRank of each vertex in our test dataset.  The NetworkX and cuGraph processes will be interleaved so that each step can be compared.\n",
     "\n",
-    "Notebook Credits\n",
-    "* Original Authors: Bradley Rees and James Wyles\n",
-    "* Created:   08/13/2019\n",
-    "* Updated:   06/22/2022\n",
-    "\n",
-    "RAPIDS Versions: 22.08 \n",
-    "\n",
-    "Test Hardware\n",
-    "\n",
-    "* Tesla V100 32G, CUDA 11.5\n",
-    "\n",
+    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware |\n",
+    "| --------------|------------|------------------|-----------------|----------------|\n",
+    "| Bradley Rees and James Wyles | 08/13/2019 | created          | 0.15 | GV100, CUDA 10.0\n",
+    "|               | 04/06/2022 | tested / updated | 22.04 nightly  | GV100 32G, CUDA 11.5\n",
+    "| Ralph Liu     | 06/22/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5\n",
+    "| Don Acosta    | 07/27/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5\n",
     "\n",
     "## Introduction\n",
     "Pagerank is measure of the relative importance, also called centrality, of a vertex based on the relative importance of it's neighbors.  PageRank was developed by Google and is (was) used to rank it's search results. PageRank uses the connectivity information of a graph to rank the importance of each vertex. \n",
@@ -42,7 +37,6 @@
     "\n",
     "\n",
     "### Some notes about vertex IDs...\n",
-    "* The current version of cuGraph requires that vertex IDs be representable as 32-bit integers, meaning graphs currently can contain at most 2^32 unique vertex IDs. However, this limitation is being actively addressed and a version of cuGraph that accommodates more than 2^32 vertices will be available in the near future.\n",
     "* cuGraph will automatically renumber graphs to an internal format consisting of a contiguous series of integers starting from 0, and convert back to the original IDs when returning data to the caller. If the vertex IDs of the data are already a contiguous series of integers starting from 0, the auto-renumbering step can be skipped for faster graph creation times.\n",
     "  * To skip auto-renumbering, set the `renumber` boolean arg to `False` when calling the appropriate graph creation API (eg. `G.from_cudf_edgelist(gdf_r, source='src', destination='dst', renumber=False)`).\n",
     "  * For more advanced renumbering support, see the examples in `structure/renumber.ipynb` and `structure/renumber-2.ipynb`\n"
@@ -58,7 +52,7 @@
     "Anthropological Research 33, 452-473 (1977).*\n",
     "\n",
     "\n",
-    "![Karate Club](../img/zachary_black_lines.png)\n"
+    "<img src=\"../../img/zachary_black_lines.png\" width=\"35%\"/>\n"
    ]
   },
   {
@@ -148,7 +142,7 @@
    "outputs": [],
    "source": [
     "# Read the data, this also creates a NetworkX Graph\n",
-    "datafile = \"../data/karate-data.csv\"\n",
+    "datafile = \"../../data/karate-data.csv\"\n",
     "file = open(datafile, 'rb')\n",
     "Gnx = nx.read_edgelist(file)"
    ]
@@ -352,7 +346,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<img src=\"../img/zachary_graph_pagerank.png\" width=\"600\">"
+    "<img src=\"../../img/zachary_graph_pagerank.png\" width=\"35%\">"
    ]
   },
   {
@@ -367,7 +361,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The issue with PageRank is that it sets the initial weights of all the nodes the same. In other words, it assumes a uniform starting probability for every node. What if we have a priori information about the nodes? We can use personalized PageRank (PPR) to assist."
+    "Personalized pagerank is often used in [Recommendation systems](https://en.wikipedia.org/wiki/Recommender_system).\n",
+    "to counter the issue with PageRank that it sets the initial weights of all the nodes the same. In other words, it assumes a uniform starting probability for every node. What if we have a priori information about the nodes? We can use personalized PageRank (PPR) to assist. All non specified nodes are defaulted to zero.  "
    ]
   },
   {
@@ -415,7 +410,7 @@
    "metadata": {},
    "source": [
     "___\n",
-    "Copyright (c) 2019-2020, NVIDIA CORPORATION.\n",
+    "Copyright (c) 2019-2022, NVIDIA CORPORATION.\n",
     "\n",
     "Licensed under the Apache License, Version 2.0 (the \"License\");  you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
     "\n",
@@ -426,7 +421,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.9.7 ('base')",
+   "display_name": "Python 3.9.13 ('cugraph_dev')",
    "language": "python",
    "name": "python3"
   },
@@ -440,11 +435,11 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.7"
+   "version": "3.9.13"
   },
   "vscode": {
    "interpreter": {
-    "hash": "f708a36acfaef0acf74ccd43dfb58100269bf08fb79032a1e0a6f35bd9856f51"
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
    }
   }
  },
diff --git a/notebooks/algorithms/link_analysis/README.md b/notebooks/algorithms/link_analysis/README.md
new file mode 100644
index 00000000000..17d4b8ab6d1
--- /dev/null
+++ b/notebooks/algorithms/link_analysis/README.md
@@ -0,0 +1,36 @@
+
+# cuGraph Link Analysis Algorithms
+
+<img src="../../img/zachary_graph_pagerank.png" width="35%"/>
+
+cuGraph Link Analysis notebooks contain Jupyter Notebooks that demonstrate algorithms to rank the importance of individual vertices within the graph. A good comparison of the two algorithms can be found [here](https://www.ijert.org/research/comparative-analysis-of-pagerank-and-hits-algorithms-IJERTV1IS8530.pdf).
+In general, Pagerank is more popular because it is more efficient and takes less query time. 
+
+Manipulation of the data before or after the graph analytic is not covered here.   Extended, more problem focused, notebooks are being created and available https://github.com/rapidsai/notebooks-extended
+
+## Summary
+
+|Algorithm          |Notebooks Containing                                                     |Description                                                  |
+| --------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
+|HITS (Hyperlink-Induced Topic Search)  | [HITS](HITS.ipynb)   | Identifies hubs and authoritative sources within the graph. Originally meant to evaluate citations and reference lists in web pages. |
+|PageRank | [PageRank](Pagerank.ipynb)               |Determines the importance, also called centrality, of all the vertices based on the relative importance of their neighbors.|
+
+
+[System Requirements](../../README.md#requirements)
+
+| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware |
+| --------------|------------|------------------|-----------------|----------------|
+| Brad Rees     | 04/19/2021 | created          | 0.19            | GV100, CUDA 11.0
+| Don Acosta    | 08/01/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5|
+
+## Copyright
+
+Copyright (c) 2019-2022, NVIDIA CORPORATION.  All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");  you may not use this file except in compliance with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0 
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the License for the specific language governing permissions and limitations under the License.
+
+![RAPIDS](../../img/rapids_logo.png)
diff --git a/notebooks/link_prediction/Jaccard-Similarity.ipynb b/notebooks/algorithms/link_prediction/Jaccard-Similarity.ipynb
similarity index 94%
rename from notebooks/link_prediction/Jaccard-Similarity.ipynb
rename to notebooks/algorithms/link_prediction/Jaccard-Similarity.ipynb
index 1c94ec2a023..4f555753f94 100755
--- a/notebooks/link_prediction/Jaccard-Similarity.ipynb
+++ b/notebooks/algorithms/link_prediction/Jaccard-Similarity.ipynb
@@ -13,16 +13,12 @@
     "\n",
     "Similarity can be between neighboring vertices (default) or second hop neighbors\n",
     "\n",
-    "Notebook Credits\n",
     "\n",
-    "    Original Authors: Brad Rees\n",
-    "    Created:   10/14/2019\n",
-    "    Last Edit: 06/22/2022\n",
     "\n",
-    "RAPIDS Versions: 22.08\n",
-    "\n",
-    "Test Hardware\n",
-    "* Tesla V100 32G, CUDA 11.5\n"
+    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware        |\n",
+    "| --------------|------------|------------------|-----------------|-----------------------|\n",
+    "| Brad Rees     | 10/14/2019 | created          | 0.14            | GV100 32 GB, CUDA 10.2 |\n",
+    "| Don Acosta    | 07/20/2022 | tested/updated   | 22.08 nightly   | DGX Tesla V100 CUDA 11.5   |"
    ]
   },
   {
@@ -127,7 +123,6 @@
    "metadata": {},
    "source": [
     "### Some notes about vertex IDs...\n",
-    "* The current version of cuGraph requires that vertex IDs be representable as 32-bit integers, meaning graphs currently can contain at most 2^32 unique vertex IDs. However, this limitation is being actively addressed and a version of cuGraph that accommodates more than 2^32 vertices will be available in the near future.\n",
     "* cuGraph will automatically renumber graphs to an internal format consisting of a contiguous series of integers starting from 0, and convert back to the original IDs when returning data to the caller. If the vertex IDs of the data are already a contiguous series of integers starting from 0, the auto-renumbering step can be skipped for faster graph creation times.\n",
     "  * To skip auto-renumbering, set the `renumber` boolean arg to `False` when calling the appropriate graph creation API (eg. `G.from_cudf_edgelist(gdf_r, source='src', destination='dst', renumber=False)`).\n",
     "  * For more advanced renumbering support, see the examples in `structure/renumber.ipynb` and `structure/renumber-2.ipynb`\n"
@@ -142,8 +137,7 @@
     "*W. W. Zachary, An information flow model for conflict and fission in small groups, Journal of\n",
     "Anthropological Research 33, 452-473 (1977).*\n",
     "\n",
-    "\n",
-    "![Karate Club](../img/zachary_black_lines.png)\n",
+    "<img src=\"../../img/zachary_black_lines.png\" width=\"35%\"/>\n",
     "\n",
     "This is a small graph which allows for easy visual inspection to validate results.  "
    ]
@@ -221,7 +215,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Create an Edgelist"
+    "### Read the CSV datafile using cuDF\n",
+    "data file is actually _tab_ separated, so we need to set the delimiter"
    ]
   },
   {
@@ -230,8 +225,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "# Test file  \n",
     "from cugraph.experimental.datasets import karate\n",
-    "gdf = karate.get_edgelist()"
+    "gdf = karate.get_edgelist(fetch=True)"
    ]
   },
   {
@@ -476,16 +472,11 @@
     "Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.\n",
     "___"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.9.7 ('base')",
+   "display_name": "Python 3.9.13 ('cugraph_dev')",
    "language": "python",
    "name": "python3"
   },
@@ -499,11 +490,11 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.7"
+   "version": "3.9.13"
   },
   "vscode": {
    "interpreter": {
-    "hash": "f708a36acfaef0acf74ccd43dfb58100269bf08fb79032a1e0a6f35bd9856f51"
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
    }
   }
  },
diff --git a/notebooks/link_prediction/Overlap-Similarity.ipynb b/notebooks/algorithms/link_prediction/Overlap-Similarity.ipynb
similarity index 94%
rename from notebooks/link_prediction/Overlap-Similarity.ipynb
rename to notebooks/algorithms/link_prediction/Overlap-Similarity.ipynb
index 5b3633f4014..20ad406ae4e 100755
--- a/notebooks/link_prediction/Overlap-Similarity.ipynb
+++ b/notebooks/algorithms/link_prediction/Overlap-Similarity.ipynb
@@ -12,12 +12,13 @@
     "\n",
     "Notebook Credits\n",
     "\n",
-    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware     |\n",
-    "| --------------|------------|------------------|-----------------|--------------------|\n",
-    "| Brad Rees     | 10/14/2019 | created          | 0.08            | GV100, CUDA 10.0   |\n",
-    "|               | 08/16/2020 | upadted          | 0.12            | GV100, CUDA 10.0   |\n",
-    "|               | 08/05/2021 | tested / updated | 21.10 nightly   | RTX 3090 CUDA 11.4 |\n",
-    "| Ralph Liu     | 06/22/2022 | updated/tested   | 22.08           | TV100, CUDA 11.5   |\n"
+    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware           |\n",
+    "| --------------|------------|------------------|-----------------|--------------------------|\n",
+    "| Brad Rees     | 10/14/2019 | created          | 0.08            | GV100, CUDA 10.0         |\n",
+    "|               | 08/16/2020 | upadated         | 0.12            | GV100, CUDA 10.0         |\n",
+    "|               | 08/05/2021 | tested / updated | 21.10 nightly   | RTX 3090 CUDA 11.4       |\n",
+    "| Ralph Liu     | 06/22/2022 | updated/tested   | 22.08 nightly   | DGX Tesla V100 CUDA 11.5 |\n",
+    "| Don Acosta    | 08/03/2022 | tested / updated | 22.08 nightly   | DGX Tesla V100 CUDA 11.5 |"
    ]
   },
   {
@@ -26,7 +27,7 @@
    "source": [
     "## Introduction - Common Neighbor Similarity \n",
     "\n",
-    "One of the most common types of vertex similarity is to evaluate the neighborhood of vertex pairs and looks at the number of common neighbors.  TThat type of similar comes from statistics and is based on set comparison.  Both Jaccard and the Overlap Coefficient operate on sets, and in a graph setting, those sets are the list of neighboring vertices. <br>\n",
+    "One of the most common types of vertex similarity is to evaluate the neighborhood of vertex pairs and looks at the number of common neighbors.  That type of similar comes from statistics and is based on set comparison.  Both Jaccard and the Overlap Coefficient operate on sets, and in a graph setting, those sets are the list of neighboring vertices. <br>\n",
     "For those that like math:  The neighbors of a vertex, _v_, is defined as the set, _U_, of vertices connected by way of an edge to vertex v, or _N(v) = {U} where v ∈ V and ∀ u ∈ U ∃ edge(v,u)∈ E_.\n",
     "\n",
     "For the rest of this introduction, set __A__ will equate to _A = N(i)_ and set __B__ will quate to _B = N(j)_.  That just make the rest of the text more readable."
@@ -124,7 +125,7 @@
     "Anthropological Research 33, 452-473 (1977).*\n",
     "\n",
     "\n",
-    "![Karate Club](../img/zachary_black_lines.png)\n",
+    "<img src=\"../../img/zachary_black_lines.png\" width=\"35%\"/>\n",
     "\n",
     "This is a small graph which allows for easy visual inspection to validate results.  "
    ]
@@ -569,7 +570,7 @@
    "metadata": {},
    "source": [
     "___\n",
-    "Copyright (c) 2019-2020, NVIDIA CORPORATION.\n",
+    "Copyright (c) 2019-2022, NVIDIA CORPORATION.\n",
     "\n",
     "Licensed under the Apache License, Version 2.0 (the \"License\");  you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
     "\n",
@@ -580,7 +581,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.9.7 ('base')",
+   "display_name": "Python 3.9.13 ('cugraph_dev')",
    "language": "python",
    "name": "python3"
   },
@@ -594,11 +595,11 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.7"
+   "version": "3.9.13"
   },
   "vscode": {
    "interpreter": {
-    "hash": "f708a36acfaef0acf74ccd43dfb58100269bf08fb79032a1e0a6f35bd9856f51"
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
    }
   }
  },
diff --git a/notebooks/algorithms/link_prediction/README.md b/notebooks/algorithms/link_prediction/README.md
new file mode 100644
index 00000000000..e3391e4d0cf
--- /dev/null
+++ b/notebooks/algorithms/link_prediction/README.md
@@ -0,0 +1,41 @@
+# Vertex Similarity
+----
+
+In this folder we will explore and compare the various vertex similarity metrics available in cuGraph.  [Vertex similarity](https://en.wikipedia.org/wiki/Similarity_(network_science)), as the name implies, is a measure how similar two vertices are.  
+
+|Algorithm          |Notebooks Containing                                                     |Description                                                  |
+| --------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
+|Jaccard Similarity  | [Jaccard](Jaccard-Similarity.ipynb)   | Uses the ratio of the volume of vertex intersection divided by the volume of union to determine similarity  |
+|Jaccard Weighted Similarity  | [Jaccard](Jaccard-Similarity.ipynb)   | Adds weights to the standard Jaccard Similarity  |
+|Overlap Similarity  | [Overlap](Overlap-Similarity.ipynb)               | Evaluates the neighborhood of vertex pairs and looks at the number of common neighbors|
+
+Currently, cuGraph supports the following similarity metrics:
+- Jaccard Similarity (also called the Jaccard Index)
+- Overlap Coefficient
+- Weight Jaccard
+
+Similarity can be between neighboring vertices (default) or second hop neighbors
+
+## Introduction - Overlap (Common Neighbor) Similarity
+
+One of the most common types of vertex similarity is to evaluate the neighborhood of vertex pairs and looks at the number of common neighbors.  That type of similarity comes from statistics and is based on set comparison.  Both Jaccard and the Overlap Coefficient operate on sets, and in a graph setting, those sets are the list of neighboring vertices. <br>
+For those that like math:  The neighbors of a vertex, _v_, is defined as the set, _U_, of vertices connected by way of an edge to vertex v, or _N(v) = {U} where v ∈ V and ∀ u ∈ U ∃ edge(v,u)∈ E_.
+
+For the rest of this introduction, set __A__ will equate to _A = N(i)_ and set __B__ will equate to _B = N(j)_.  That just make the rest of the text more readable.
+
+### Additional Reading
+- [Similarity in graphs: Jaccard versus the Overlap Coefficient](https://medium.com/rapids-ai/similarity-in-graphs-jaccard-versus-the-overlap-coefficient-610e083b877d)
+- [Wikipedia: Jaccard](https://en.wikipedia.org/wiki/Jaccard_index)
+- [Wikipedia: Overlap Coefficient](https://en.wikipedia.org/wiki/Overlap_coefficient)
+
+## Copyright
+
+Copyright (c) 2019-2022, NVIDIA CORPORATION.  All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");  you may not use this file except in compliance with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0 
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the License for the specific language governing permissions and limitations under the License.
+
+![RAPIDS](../../img/rapids_logo.png)
diff --git a/notebooks/applications/CostMatrix.ipynb b/notebooks/applications/CostMatrix.ipynb
new file mode 100644
index 00000000000..687b1526069
--- /dev/null
+++ b/notebooks/applications/CostMatrix.ipynb
@@ -0,0 +1,641 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# How to compute a _Cost Matrix_ by replicating data\n",
+    "# Skip notebook test\n",
+    "\n",
+    "### Approach\n",
+    "A simple approach to creating a cost matrix is to run All-Source Shortest Path (ASSP), however cuGraph currently does not have an All-Source Shortest Path (ASSP) algorithm.  One is on the roadmap, based on Floyd-Warshall, but that doesn't help us today. Luckily there is a work around if the graph to be processed is small.  The hack is to run ASSP by creating a lot of copies of the graph and running the Single Source Shortest Path (SSSP) on one seed per graph copy. Since each SSSP run within its own disjoint component, there is no issue with path collisions between seeds.  \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Notebook Organization\n",
+    "The first portion of the notebook discusses each step independently.  It gives insight into what is going on and how fast each step takes.\n",
+    "\n",
+    "The second section puts it all the steps together in a single function and times how long with would take to compute the matrix\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Data\n",
+    "\n",
+    "In this notebook we will use the email-Eu-core\n",
+    "\n",
+    "* Number of Vertices:  1,005\n",
+    "* Number of Edges:    25,571\n",
+    "\n",
+    "We are using this dataset since it is small with a few communities, meaning that there are paths to be found."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Notebook Revisions\n",
+    "\n",
+    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware |\n",
+    "| --------------|------------|------------------|-----------------|----------------|\n",
+    "| Brad Rees     | 06/21/2022 | created          | 22.08           | V100 w 32 GB, CUDA 11.5\n",
+    "| Don Acosta    | 06/28/2022 | modified         | 22.08           | V100 w 32 GB, CUDA 11.5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### References\n",
+    "\n",
+    "* https://www.sciencedirect.com/topics/mathematics/cost-matrix\n",
+    "* https://en.wikipedia.org/wiki/Shortest_path_problem\n",
+    "\n",
+    "Dataset\n",
+    "* Hao Yin, Austin R. Benson, Jure Leskovec, and David F. Gleich. Local Higher-order Graph Clustering. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining. 2017.\n",
+    "\n",
+    "* J. Leskovec, J. Kleinberg and C. Faloutsos. Graph Evolution: Densification and Shrinking Diameters. ACM Transactions on Knowledge Discovery from Data (ACM TKDD), 1(1), 2007. http://www.cs.cmu.edu/~jure/pubs/powergrowth-tkdd.pdf\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# system and other\n",
+    "import time\n",
+    "from time import perf_counter\n",
+    "import math\n",
+    "\n",
+    "# rapids\n",
+    "import cugraph\n",
+    "import cudf"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "-----\n",
+    "# Reading the data\n",
+    "\n",
+    "Let's start with data read"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# simple function to read in the CSV data file\n",
+    "def read_data_cudf(datafile):\n",
+    "    gdf = cudf.read_csv(datafile,\n",
+    "                     delimiter=\" \",\n",
+    "                     header=None,\n",
+    "                     names=['src','dst', 'wt'])\n",
+    "    return gdf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# function to determine the number of nodes in the dataset\n",
+    "def find_number_of_nodes(df):\n",
+    "    node = cudf.concat([df['src'], df['dst']])\n",
+    "    node = node.unique()\n",
+    "    return len(node)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Read the data and verify that it is zero based (e.g. first vertex is 0)\n",
+    "**IMPORTANT:** The node numbering must be zero based. We use the starting index on the replicated graph to be one larger than the number of vertices.  If the starting index is not zero, then the graph copies will overlap in index space and not be independent (disjoint). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t1 = perf_counter()\n",
+    "gdf = read_data_cudf('../data/email-Eu-core.csv')\n",
+    "read_t = perf_counter() - t1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\" read {len(gdf)} edges in {read_t} seconds\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# verify that the starting ID is zero\n",
+    "min([gdf['src'].min(), gdf['dst'].min()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# check the max ID\n",
+    "max([gdf['src'].max(), gdf['dst'].max()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# the number of nodes should be one greater than the max ID\n",
+    "# that is the ID that we start the next instance of the data at\n",
+    "offset = find_number_of_nodes(gdf)\n",
+    "print(offset)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Now let's dive into how to replicate the data\n",
+    "We will use a model that doubles the data at each pass.  That is a lot faster \n",
+    "than adding one copy at a time.  \n",
+    "The number of disjoint versions of the data will be a power of 2.\n",
+    "Although the power of 2 replication results in faster data set growth and Graph building, the simple order one replication is shown here for illustration purposes.\n",
+    "\n",
+    "\n",
+    "![Data Duplicated](../../notebooks/img/graph_after_replication.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This function creates additional version of the data \n",
+    "\n",
+    "def make_data(base_df, N):\n",
+    "    id = find_number_of_nodes(base_df)\n",
+    "    _d = base_df\n",
+    "\n",
+    "    for x in range(N):\n",
+    "        tmp = _d.copy()\n",
+    "        tmp['src'] += id\n",
+    "        tmp['dst'] += id\n",
+    "        _d = cudf.concat([_d,tmp])\n",
+    "        id = id * 2\n",
+    "    return _d"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%timeit\n",
+    "_ = make_data(gdf, 3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%time\n",
+    "gdf2 = make_data(gdf, 3)\n",
+    "print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# simple print to show tha there is not a lot more data\n",
+    "# print # of Edges and # of Nodes\n",
+    "print(f\"Old {len(gdf)} {find_number_of_nodes(gdf)}\")\n",
+    "print(f\"New {len(gdf2)} {find_number_of_nodes(gdf2)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build the ghost node connection set\n",
+    "A ghost node is an artificially added node to parallelize/simulate the all-points shortest path algorithm which is not yet supported.\n",
+    "After the ghost node is added, the 2nd hop is actually the all points shortest path.\n",
+    "The Ghost node is later removed after the Shortest path algorithms are run.\n",
+    "\n",
+    "![Ghost Node](../../notebooks/img/graph_after_ghost.png)\n",
+    "\n",
+    "The Ghost Node is connected to a different corresponding node in each replication so all sources are covered.\n",
+    "\n",
+    "In this simple example of a four-node 'square' graph after complete replication and adding the ghost node, the graph looks like this:\n",
+    "\n",
+    "![Ghost Node](../../notebooks/img/Full-four_node_replication.png)\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def add_ghost_node(_df, N):\n",
+    "    # get the size of the graph.  That number will be the ghost node ID\n",
+    "    ghost_node_id = find_number_of_nodes(_df)\n",
+    "    \n",
+    "    num_copies = math.floor(math.pow(2, N))\n",
+    "\n",
+    "    seeds = cudf.DataFrame()\n",
+    "    seeds['dst'] = [((offset * x) + x) for x in range(num_copies)]\n",
+    "    seeds['src'] = ghost_node_id\n",
+    "    \n",
+    "    _d = cudf.concat([_df, seeds])\n",
+    "    \n",
+    "    return _d, ghost_node_id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%timeit\n",
+    "_, _ = add_ghost_node(gdf2, 10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gdf_with_ghost, ghost_id = add_ghost_node(gdf2, 10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create an Empty directed Graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G = cugraph.Graph(directed=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Populate the new graph with an edgelist containing\n",
+    "* The original Data\n",
+    "* The replicated data copies\n",
+    "* Each replication connected to the Ghost Node by a single edge from a different node\n",
+    "in each copy of the graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%time\n",
+    "G.from_cudf_edgelist(gdf_with_ghost, source='src', destination='dst', renumber=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%time\n",
+    "G.number_of_edges()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Run Single Source Shortest Path (SSSP) from the ghost node\n",
+    "The single Ghost node source becomes a all-source shortest path after one hop since all the\n",
+    "replicated data is connected through that node. This will include extraneous ghost node related data which will be removed in later steps."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%timeit\n",
+    "X = cugraph.sssp(G, ghost_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = cugraph.sssp(G, ghost_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This result will contain a ghost node like the simple example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X.head(5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Now reset vertex IDs and convert to a cost matrix\n",
+    "All edges with the ghost node as a source are removed here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# drop the ghost node which doesnt exist so remove from matrix.\n",
+    "X = X[X['predecessor'] != ghost_id]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Apply the CuGraph filter which removes all nodes not encountered during the graph traversal. In this case the SSSP."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# drop unreachable\n",
+    "X = cugraph.filter_unreachable(X)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Remove the path cost that was incurred by going to the single seed in each copy from the ghost node."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# adjust distances so that they don't go to the ghost node\n",
+    "X['distance'] -= 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Now the Ghost node and tangential edges are removed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X.head(5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Calculate the seed for each copy. This is where it is critical that the original graph node numbering is zero based."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# add a new column for the seed\n",
+    "# since each seed was a different component with a different offset amount, exploit that to determine the seed number\n",
+    "X['seed'] = (X['vertex'] / offset).astype(int)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X.head(5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Now adjust all vertices to be in the correct range\n",
+    "# resets the seed number to the\n",
+    "X['v2'] = X['vertex'] - (X['seed'] * offset)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Finally just pull out the cost matrix\n",
+    "cost = X.drop(columns=['vertex', 'predecessor'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cost.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# cleanup \n",
+    "del G\n",
+    "del X\n",
+    "del gdf_with_ghost\n",
+    "del gdf2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "----\n",
+    "# Section 2: Do it all in a single function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set the number of replications - 10 will produce 1,024 graphs\n",
+    "N = 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_cost_matrix(_gdf):\n",
+    "    data = make_data(_gdf, N)\n",
+    "    gdf_with_ghost, ghost_id = add_ghost_node(data, N)\n",
+    "    \n",
+    "    G = cugraph.Graph(directed=True)\n",
+    "    G.from_cudf_edgelist(gdf_with_ghost, source='src', destination='dst', renumber=False)\n",
+    "    \n",
+    "    X = cugraph.sssp(G, ghost_id)\n",
+    "    \n",
+    "    X = X[X['predecessor'] != ghost_id]\n",
+    "    X = cugraph.filter_unreachable(X)\n",
+    "    X['distance'] -= 1\n",
+    "    X['seed'] = (X['vertex'] / offset).astype(int)\n",
+    "    X['v2'] = X['vertex'] - (X['seed'] * offset)\n",
+    "    cost = X.drop(columns=['vertex', 'predecessor'])\n",
+    "    \n",
+    "    return cost"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%timeit\n",
+    "CM = build_cost_matrix(gdf)\n",
+    "CM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "CM = build_cost_matrix(gdf)\n",
+    "CM.head(5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "___\n",
+    "Copyright (c) 2022, NVIDIA CORPORATION.\n",
+    "\n",
+    "Licensed under the Apache License, Version 2.0 (the \"License\");  you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
+    "\n",
+    "Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.\n",
+    "___"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "cugraph_dev",
+   "language": "python",
+   "name": "cugraph_dev"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "cee8a395f2f0c5a5bcf513ae8b620111f4346eff6dc64e1ea99c951b2ec68604"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/centrality/Centrality.ipynb b/notebooks/centrality/Centrality.ipynb
deleted file mode 100644
index dbc2a0e18a8..00000000000
--- a/notebooks/centrality/Centrality.ipynb
+++ /dev/null
@@ -1,386 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Centrality"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this notebook, we will compute vertex centrality scores using the various cuGraph algorithms.  We will then compare the similarities and differences.\n",
-    "\n",
-    "| Author Credit |    Date    |  Update          | cuGraph Version |  Test Hardware |\n",
-    "| --------------|------------|------------------|-----------------|----------------|\n",
-    "| Brad Rees     | 04/16/2021 | created          | 0.19            | GV100, CUDA 11.0\n",
-    "|               | 08/05/2021 | tested / updated | 21.10 nightly   | RTX 3090 CUDA 11.4\n",
-    "| Ralph Liu     | 06/22/2022 | test/update      | 22.08           | T100, Cuda 11.5\n",
-    "\n",
-    " "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Centrality is measure of how important, or central, a node or edge is within a graph.  It is useful for identifying influencer in social networks, key routing nodes in communication/computer network infrastructures, \n",
-    "\n",
-    "The seminal paper on centrality is:  Freeman, L. C. (1978). Centrality in social networks conceptual clarification. Social networks, 1(3), 215-239.\n",
-    "\n",
-    "\n",
-    "__Degree centrality__ – _done but needs an API_ <br>\n",
-    "Degree centrality is based on the notion that whoever has the most connections must be important.   \n",
-    "\n",
-    "<center>\n",
-    "    Cd(v) = degree(v)\n",
-    "</center>\n",
-    "\n",
-    "cuGraph currently does not have a Degree Centrality function call. However, since Degree Centrality is just the degree of a node, we can use _G.degree()_ function.\n",
-    "Degree Centrality for a Directed graph can be further divided in _indegree centrality_ and _outdegree centrality_ and can be obtained using _G.degrees()_\n",
-    "\n",
-    "\n",
-    "___Closeness centrality – coming soon___ <br>\n",
-    "Closeness is a measure of the shortest path to every other node in the graph.  A node that is close to every other node, can reach over other node in the fewest number of hops, means that it has greater influence on the network versus a node that is not close.\n",
-    "\n",
-    "__Betweenness Centrality__ <br>\n",
-    "Betweenness is a measure of the number of shortest paths that cross through a node, or over an edge.  A node with high betweenness means that it had a greater influence on the flow of information.  \n",
-    "\n",
-    "Betweenness centrality of a node 𝑣 is the sum of the fraction of all-pairs shortest paths that pass through 𝑣\n",
-    "\n",
-    "<center>\n",
-    "    <img src=\"https://latex.codecogs.com/png.latex?c_B(v)&space;=\\sum_{s,t&space;\\in&space;V}&space;\\frac{\\sigma(s,&space;t|v)}{\\sigma(s,&space;t)}\" title=\"c_B(v) =\\sum_{s,t \\in V} \\frac{\\sigma(s, t|v)}{\\sigma(s, t)}\" />\n",
-    "</center>\n",
-    "\n",
-    "To speedup runtime of betweenness centrailty, the metric can be computed on a limited number of nodes (randomly selected) and then used to estimate the other scores.  For this example, the graphs are relatively small (under 5,000 nodes) so betweenness on every node will be computed.\n",
-    "\n",
-    "___Eigenvector Centrality - coming soon___ <br>\n",
-    "Eigenvectors can be thought of as the balancing points of a graph, or center of gravity of a 3D object.  High centrality means that more of the graph is balanced around that node.\n",
-    "\n",
-    "__Katz Centrality__ <br>\n",
-    "Katz is a variant of degree centrality and of eigenvector centrality. \n",
-    "Katz centrality is a measure of the relative importance of a node within the graph based on measuring the influence across the total number of walks between vertex pairs. \n",
-    "\n",
-    "<center>\n",
-    "    <img src=\"https://latex.codecogs.com/gif.latex?C_{katz}(i)&space;=&space;\\sum_{k=1}^{\\infty}&space;\\sum_{j=1}^{n}&space;\\alpha&space;^k(A^k)_{ji}\" title=\"C_{katz}(i) = \\sum_{k=1}^{\\infty} \\sum_{j=1}^{n} \\alpha ^k(A^k)_{ji}\" />\n",
-    "</center>\n",
-    "\n",
-    "See:\n",
-    "* [Katz on Wikipedia](https://en.wikipedia.org/wiki/Katz_centrality) for more details on the algorithm.\n",
-    "* https://www.sci.unich.it/~francesc/teaching/network/katz.html\n",
-    "\n",
-    "__PageRank__ <br>\n",
-    "PageRank is classified as both a Link Analysis tool and a centrality measure.  PageRank is based on the assumption that important nodes point (directed edge) to other important nodes.  From a social network perspective, the question is who do you seek for an answer and then who does that person seek.  PageRank is good when there is implied importance in the data, for example a citation network, web page linkages, or trust networks.    \n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Test Data\n",
-    "We will be using the Zachary Karate club dataset \n",
-    "*W. W. Zachary, An information flow model for conflict and fission in small groups, Journal of\n",
-    "Anthropological Research 33, 452-473 (1977).*\n",
-    "\n",
-    "\n",
-    "![Karate Club](../img/zachary_black_lines.png)\n",
-    "\n",
-    "\n",
-    "Because the test data has vertex IDs starting at 1, the auto-renumber feature of cuGraph (mentioned above) will be used so the starting vertex ID is zero for maximum efficiency. The resulting data will then be auto-unrenumbered, making the entire renumbering process transparent to users."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#  Import the modules\n",
-    "import cugraph\n",
-    "import cudf\n",
-    "\n",
-    "# Import a built-in dataset\n",
-    "from cugraph.experimental.datasets import karate"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import pandas as pd   \n",
-    "from IPython.display import display_html "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Functions\n",
-    "using underscore variable names to avoid collisions.  \n",
-    "non-underscore names are expected to be global names"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Compute Centrality\n",
-    "# the centrality calls are very straightforward with the graph being the primary argument\n",
-    "# we are using the default argument values for all centrality functions\n",
-    "\n",
-    "def compute_centrality(_graph) :\n",
-    "    # Compute Degree Centrality\n",
-    "    _d = _graph.degree()\n",
-    "        \n",
-    "    # Compute the Betweenness Centrality\n",
-    "    _b = cugraph.betweenness_centrality(_graph)\n",
-    "\n",
-    "    # Compute Katz Centrality\n",
-    "    _k = cugraph.katz_centrality(_graph)\n",
-    "    \n",
-    "    # Compute PageRank Centrality\n",
-    "    _p = cugraph.pagerank(_graph)\n",
-    "    \n",
-    "    return _d, _b, _k, _p"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print function\n",
-    "# being lazy and requiring that the dataframe names are not changed versus passing them in\n",
-    "def print_centrality(_n):\n",
-    "    dc_top = dc.sort_values(by='degree', ascending=False).head(_n).to_pandas()\n",
-    "    bc_top = bc.sort_values(by='betweenness_centrality', ascending=False).head(_n).to_pandas()\n",
-    "    katz_top = katz.sort_values(by='katz_centrality', ascending=False).head(_n).to_pandas()\n",
-    "    pr_top = pr.sort_values(by='pagerank', ascending=False).head(_n).to_pandas()\n",
-    "    \n",
-    "    df1_styler = dc_top.style.set_table_attributes(\"style='display:inline'\").set_caption('Degree').hide_index()\n",
-    "    df2_styler = bc_top.style.set_table_attributes(\"style='display:inline'\").set_caption('Betweenness').hide_index()\n",
-    "    df3_styler = katz_top.style.set_table_attributes(\"style='display:inline'\").set_caption('Katz').hide_index()\n",
-    "    df4_styler = pr_top.style.set_table_attributes(\"style='display:inline'\").set_caption('PageRank').hide_index()\n",
-    "\n",
-    "    display_html(df1_styler._repr_html_()+df2_styler._repr_html_()+df3_styler._repr_html_()+df4_styler._repr_html_(), raw=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Create a Graph"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a graph using the imported Dataset object\n",
-    "G = karate.get_graph(fetch=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Compute Centrality"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dc, bc, katz, pr = compute_centrality(G)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Results\n",
-    "Typically, analysts just look at the top 10% of results.  Basically just those vertices that are the most central or important.  \n",
-    "The karate data has 32 vertices, so let's round a little and look at the top 5 vertices"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print_centrality(5)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### A Different Dataset\n",
-    "The Karate dataset is not that large or complex, which makes it a perfect test dataset since it is easy to visually verify results.  Let's look at a larger dataset with a lot more edges"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Import a different dataset object\n",
-    "from cugraph.experimental.datasets import netscience"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "G = netscience.get_graph(fetch=True)\n",
-    "(G.number_of_nodes(), G.number_of_edges())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dc, bc, katz, pr = compute_centrality(G)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print_centrality(5)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can now see a larger discrepancy between the centrality scores and which nodes rank highest.\n",
-    "Which centrality measure to use is left to the analyst to decide and does require insight into the difference algorithms and graph structure."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### And One More Dataset\n",
-    "Let's look at a Cyber dataset.  The vertex ID are IP addresses"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Import a different dataset object\n",
-    "from cugraph.experimental.datasets import cyber"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Get the edgelist\n",
-    "gdf = cyber.get_edgelist(fetch=True)\n",
-    "\n",
-    "# Create a Graph\n",
-    "G = cugraph.Graph()\n",
-    "G.from_cudf_edgelist(gdf, source='src', destination='dst')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "(G.number_of_nodes(), G.number_of_edges())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dc, bc, katz, pr = compute_centrality(G)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print_centrality(5)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "There are differences in how each centrality measure ranks the nodes. In some cases, every algorithm returns similar results, and in others, the results are different. Understanding how the centrality measure is computed and what edge represent is key to selecting the right centrality metric."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "----\n",
-    "Copyright (c) 2019-2021, NVIDIA CORPORATION.\n",
-    "\n",
-    "Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n",
-    "\n",
-    "Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3.6.9 64-bit",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.9"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/notebooks/img/Full-four_node_replication.png b/notebooks/img/Full-four_node_replication.png
new file mode 100644
index 00000000000..8cbc3cd1dca
Binary files /dev/null and b/notebooks/img/Full-four_node_replication.png differ
diff --git a/notebooks/img/graph_after_ghost.png b/notebooks/img/graph_after_ghost.png
new file mode 100644
index 00000000000..256ac9b5425
Binary files /dev/null and b/notebooks/img/graph_after_ghost.png differ
diff --git a/notebooks/img/graph_after_replication.png b/notebooks/img/graph_after_replication.png
new file mode 100644
index 00000000000..3fba876e899
Binary files /dev/null and b/notebooks/img/graph_after_replication.png differ
diff --git a/notebooks/img/karate_hits.png b/notebooks/img/karate_hits.png
new file mode 100644
index 00000000000..8ef1dbb51ea
Binary files /dev/null and b/notebooks/img/karate_hits.png differ
diff --git a/notebooks/img/zachary_graph_hits.png b/notebooks/img/zachary_graph_hits.png
index 3c33ddb5a48..02893ad8974 100644
Binary files a/notebooks/img/zachary_graph_hits.png and b/notebooks/img/zachary_graph_hits.png differ
diff --git a/notebooks/link_prediction/README.md b/notebooks/link_prediction/README.md
deleted file mode 100644
index 345602a05c1..00000000000
--- a/notebooks/link_prediction/README.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# Vertex Similarity
-----
-
-In this folder we will explore and compare the various vertex similarity metrics available in cuGraph.  [Vertex similarity](https://en.wikipedia.org/wiki/Similarity_(network_science)), as the name implies, is a measure how similar two vertices are.  
-Currently, cuGraph supports the following similarity metrics:
-- Jaccard Similarity (also called the Jaccard Index)
-- Overlap Coefficient
-- Weight Jaccard
-
-Similarity can be between neighboring vertices (default) or second hop neighbors
-
-## Introduction - Common Neighbor Similarity 
-
-One of the most common types of vertex similarity is to evaluate the neighborhood of vertex pairs and looks at the number of common neighbors.  That type of similar comes from statistics and is based on set comparison.  Both Jaccard and the Overlap Coefficient operate on sets, and in a graph setting, those sets are the list of neighboring vertices. <br>
-For those that like math:  The neighbors of a vertex, _v_, is defined as the set, _U_, of vertices connected by way of an edge to vertex v, or _N(v) = {U} where v ∈ V and ∀ u ∈ U ∃ edge(v,u)∈ E_.
-
-For the rest of this introduction, set __A__ will equate to _A = N(i)_ and set __B__ will equate to _B = N(j)_.  That just make the rest of the text more readable.
-
-### Additional Reading
-- [Similarity in graphs: Jaccard versus the Overlap Coefficient](https://medium.com/rapids-ai/similarity-in-graphs-jaccard-versus-the-overlap-coefficient-610e083b877d)
-- [Wikipedia: Jaccard](https://en.wikipedia.org/wiki/Jaccard_index)
-- [Wikipedia: Overlap Coefficient](https://en.wikipedia.org/wiki/Overlap_coefficient)