diff --git a/D3128_Algorithms/src/alg_comprehensive.hpp b/D3128_Algorithms/src/alg_comprehensive.hpp
index 1f9667e..4bc30f2 100644
--- a/D3128_Algorithms/src/alg_comprehensive.hpp
+++ b/D3128_Algorithms/src/alg_comprehensive.hpp
@@ -125,15 +125,15 @@ void breadth_first_search(ExecutionPolicy&& policy,
  * BFS: multiple source
  */
 template <adjacency_list_graph G, class S, property P, property D>
-requires std::ranges::forward_range<S>
+requires std::forward_range<S>
 void breadth_first_search(const G& graph, S&& sources, P&& predecessors, D&& distances);
 
 template <adjacency_list_graph G, class S, property P, property D, queueable Q>
-requires std::ranges::forward_range<S>
+requires std::forward_range<S>
 void breadth_first_search(const G& graph, S&& sources, P&& predecessors, D&& distances, Q&& q);
 
 template <class ExecutionPolicy, adjacency_list_graph G, class S, property P, property D>
-requires std::ranges::forward_range<S>
+requires std::forward_range<S>
 void breadth_first_search(
       ExecutionPolicy&& policy, const G& graph, S&& sources, P&& predecessors, D&& distances);
 
@@ -143,7 +143,7 @@ template <class ExecutionPolicy,
           property  P,
           property  D,
           queueable Q>
-requires std::ranges::forward_range<S>
+requires std::forward_range<S>
 void breadth_first_search(ExecutionPolicy&& policy,
                           const G&          graph,
                           S&&               sources,
@@ -179,7 +179,7 @@ void dijkstra_shortest_paths(const G&       graph,
                              D&&            distances);
 
 template <adjacency_list_graph G, class S, property P, property D>
-requires std::ranges::forward_range<S>
+requires std::forward_range<S>
 void dijkstra_shortest_paths(const G& graph, S&& sources, P&& predecessors, D&& distances);
 
 /*
@@ -240,7 +240,7 @@ void dijkstra_shortest_paths(const G&       graph,
  */
 
 template <adjacency_list_graph G, class S, class W, property P, property D>
-requires weight_function<W, edge_t<G>> && std::ranges::forward_range<S>
+requires weight_function<W, edge_t<G>> && std::forward_range<S>
 void dijkstra_shortest_paths(
       const G& graph, S&& sources, W&& w, P&& predecessors, D&& distances) {}
 
@@ -251,7 +251,7 @@ template <adjacency_list_graph G,
           property D,
           class Compare,
           class Combine>
-requires weight_function<W, edge_t<G>> && std::ranges::forward_range<S>
+requires weight_function<W, edge_t<G>> && std::forward_range<S>
 void dijkstra_shortest_paths(const G&  graph,
                              S&&       sources,
                              W&&       w,
@@ -299,11 +299,11 @@ void bellman_ford_shortest_paths(ExecutionPolicy&& e,
                                  D&&               distances);
 
 template <edge_list_graph G, class S, property P, property D>
-requires std::ranges::forward_range<S>
+requires std::forward_range<S>
 void bellman_ford_shortest_paths(const G& graph, S&& sources, P&& predecessors, D&& distances);
 
 template <class ExecutionPolicy, edge_list_graph G, class S, property P, property D>
-requires std::ranges::forward_range<S>
+requires std::forward_range<S>
 void bellman_ford_shortest_paths(
       ExecutionPolicy&& e, const G& graph, S&& sources, P&& predecessors, D&& distances);
 
@@ -403,7 +403,7 @@ void bellman_ford_shortest_paths(const G&       graph,
  */
 
 template <edge_list_graph G, class S, class W, property P, property D>
-requires weight_function<W, edge_t<G>> && std::ranges::forward_range<S>
+requires weight_function<W, edge_t<G>> && std::forward_range<S>
 void bellman_ford_shortest_paths(
       const G& graph, S&& sources, W&& w, P&& predecessors, D&& distances) {}
 
@@ -414,7 +414,7 @@ template <edge_list_graph G,
           property D,
           class Compare,
           class Combine>
-requires weight_function<W, edge_t<G>> && std::ranges::forward_range<S>
+requires weight_function<W, edge_t<G>> && std::forward_range<S>
 void bellman_ford_shortest_paths(const G&  graph,
                                  S&&       sources,
                                  W&&       w,
@@ -424,7 +424,7 @@ void bellman_ford_shortest_paths(const G&  graph,
                                  Combine&& comb) {}
 
 template <class ExecutionPolicy, edge_list_graph G, class S, class W, property P, property D>
-requires weight_function<W, edge_t<G>> && std::ranges::forward_range<S>
+requires weight_function<W, edge_t<G>> && std::forward_range<S>
 void bellman_ford_shortest_paths(ExecutionPolicy&& e,
                                  const G&          graph,
                                  S&&               sources,
@@ -440,7 +440,7 @@ template <class ExecutionPolicy,
           property D,
           class Compare,
           class Combine>
-requires weight_function<W, edge_t<G>> && std::ranges::forward_range<S>
+requires weight_function<W, edge_t<G>> && std::forward_range<S>
 void bellman_ford_shortest_paths(ExecutionPolicy&& e,
                                  const G&          graph,
                                  S&&               sources,
@@ -594,7 +594,7 @@ template <class ExecutionPolicy,
           class W,
           property P,
           property D>
-requires weight_function<W, edge_t<G>> && std::ranges::forward_range<S>
+requires weight_function<W, edge_t<G>> && std::forward_range<S>
 void delta_stepping_shortest_paths(ExecutionPolicy&& e,
                                    const G&          graph,
                                    S&&               sources,
@@ -610,7 +610,7 @@ template <class ExecutionPolicy,
           property D,
           class Compare,
           class Combine>
-requires weight_function<W, edge_t<G>> && std::ranges::forward_range<S>
+requires weight_function<W, edge_t<G>> && std::forward_range<S>
 void delta_stepping_shortest_paths(ExecutionPolicy&& e,
                                    const G&          graph,
                                    S&&               sources,
@@ -627,7 +627,7 @@ template <class ExecutionPolicy,
           property P,
           property D,
           class T>
-requires weight_function<W, edge_t<G>> && std::ranges::forward_range<S>
+requires weight_function<W, edge_t<G>> && std::forward_range<S>
 void delta_stepping_shortest_paths(ExecutionPolicy&& e,
                                    const G&          graph,
                                    S&&               sources,
@@ -645,7 +645,7 @@ template <class ExecutionPolicy,
           class Compare,
           class Combine,
           class T>
-requires weight_function<W, edge_t<G>> && std::ranges::forward_range<S>
+requires weight_function<W, edge_t<G>> && std::forward_range<S>
 void delta_stepping_shortest_paths(ExecutionPolicy&& e,
                                    const G&          graph,
                                    S&&               sources,
diff --git a/D3128_Algorithms/src/connected_components.hpp b/D3128_Algorithms/src/connected_components.hpp
index fdbec99..6c326d2 100644
--- a/D3128_Algorithms/src/connected_components.hpp
+++ b/D3128_Algorithms/src/connected_components.hpp
@@ -9,9 +9,9 @@ void articulation_points(G&&  g, Iter cut_vertices);
  * Hopcroft-Tarjan Biconnected Components
  */
 template <index_adjacency_list G,
-          ranges::forward_range OuterContainer>
-requires ranges::forward_range<ranges::range_value_t<OuterContainer>> &&
-         integral<ranges::forward_range_t<ranges::forward_range_t<OuterContainer>>>
+          forward_range OuterContainer>
+requires forward_range<range_value_t<OuterContainer>> &&
+         integral<forward_range_t<forward_range_t<OuterContainer>>>
 void biconnected_components(G&&             g,
 			    OuterContainer& components);
 
@@ -19,7 +19,7 @@ void biconnected_components(G&&             g,
  * Connected Components
  */
 template <index_adjacency_list G,
-          ranges::random_access_range Component>
+          random_access_range Component>
 void connected_components(G&&        g,
 			  Component& component);
 
@@ -28,7 +28,7 @@ void connected_components(G&&        g,
  */
 template <index_adjacency_list G,
           index_adjacency_list GT,
-          ranges::random_access_range Component>
+          random_access_range Component>
 void strongly_connected_components(G&&        g,
 				   GT&&       g_t,
 				   Component& component);
@@ -37,7 +37,7 @@ void strongly_connected_components(G&&        g,
  * Tarjan Strongly Connected Components
  */
 template <adjacency_list G,
-          ranges::random_access_range Component>
-requires ranges::random_access_range<vertex_range_t<G>> && integral<vertex_id_t<G>>
+          random_access_range Component>
+requires random_access_range<vertex_range_t<G>> && integral<vertex_id_t<G>>
 void strongly_connected_components(G&&        g,
 	                          Component& component);
diff --git a/D3128_Algorithms/src/lp.hpp b/D3128_Algorithms/src/lp.hpp
index 7e98cd1..dd0449b 100644
--- a/D3128_Algorithms/src/lp.hpp
+++ b/D3128_Algorithms/src/lp.hpp
@@ -2,7 +2,7 @@
  * Label Propagation Algorithm
  */
 template <index_adjacency_list G,
-	  ranges::random_access_range Label,
+	  random_access_range Label,
 	  class Gen = default_random_engine,
 	  class T = size_t>
 void label_propagation(G&&    g,
@@ -11,11 +11,11 @@ void label_propagation(G&&    g,
 		       T      max_iters = numeric_limits<T>::max());
 
 template <index_adjacency_list G,
-	  ranges::random_access_range Label,
+	  random_access_range Label,
 	  class Gen = default_random_engine
 	  class T = size_t>
 void label_propagation(G&&                                g,
 		       Label&                             label,
-		       ranges::range_value_t<Label>& empty_label
+		       range_value_t<Label>& empty_label
                        Gen&&                              rng = default_random_engine {},
 		       T                                  max_iters = numeric_limits<T>::max());
diff --git a/D3128_Algorithms/src/mis.hpp b/D3128_Algorithms/src/mis.hpp
index 51ba25e..b893468 100644
--- a/D3128_Algorithms/src/mis.hpp
+++ b/D3128_Algorithms/src/mis.hpp
@@ -1,3 +1,3 @@
 template <index_adjacency_list G, class Iter>
 requires output_iterator<Iter, vertex_id_t<G>>
-void maximal_independent_set(G&& g, Iter mis, vertex_id_t<G> seed);
+void maximal_independent_set(G&& g, Iter mis, vertex_id_t<G> source);
diff --git a/D3128_Algorithms/src/mst.hpp b/D3128_Algorithms/src/mst.hpp
index 5e3dcb2..3e3a3b2 100644
--- a/D3128_Algorithms/src/mst.hpp
+++ b/D3128_Algorithms/src/mst.hpp
@@ -11,17 +11,17 @@ void kruskal(IELR&& e, OELR&& t, CompareOp compare);
  * Prim's Algorithm
  */
 template <index_adjacency_list        G,
-          ranges::random_access_range Predecessor,
-          ranges::random_access_range Weight>
-void prim(G&& g, Predecessor& predecessor, Weight& weight, vertex_id_t<G> seed = 0);
+          random_access_range Predecessor,
+          random_access_range Weight>
+void prim(G&& g, Predecessor& predecessor, Weight& weight, vertex_id_t<G> source = 0);
 
 template <index_adjacency_list        G,
-          ranges::random_access_range Predecessor,
-          ranges::random_access_range Weight,
+          random_access_range Predecessor,
+          random_access_range Weight,
           class CompareOp>
 void prim(G&&                           g,
           Predecessor&                  predecessor,
           Weight&                       weight,
           CompareOp                     compare,
-          ranges::range_value_t<Weight> init_dist,
-          vertex_id_t<G>                seed = 0);
+          range_value_t<Weight> init_dist,
+          vertex_id_t<G>                source = 0);
diff --git a/D3128_Algorithms/src/pagerank.hpp b/D3128_Algorithms/src/pagerank.hpp
index b2580d8..c2a0e35 100644
--- a/D3128_Algorithms/src/pagerank.hpp
+++ b/D3128_Algorithms/src/pagerank.hpp
@@ -1,9 +1,9 @@
 template <class ExecutionPolicy,
           adjacency_list_graph        G,
-          ranges::random_access_range P,
-          class EVF = std::function<ranges::range_value_t<P>(edge_reference_t<G>)>>
-requires ranges::random_access_range<vertex_range_t<G>> && integral<vertex_id_t<G>> &&
-      is_arithmetic_v<ranges::range_value_t<P>> && edge_weight_function<G, EVF>
+          random_access_range P,
+          class EVF = std::function<range_value_t<P>(edge_reference_t<G>)>>
+requires random_access_range<vertex_range_t<G>> && integral<vertex_id_t<G>> &&
+      is_arithmetic_v<range_value_t<P>> && edge_weight_function<G, EVF>
 void pagerank(ExecutionPolicy   policy,
               G&&               g,
               P&                scores,
@@ -13,10 +13,10 @@ void pagerank(ExecutionPolicy   policy,
               EVF               weight_fn) {}
 
 template <adjacency_list_graph        G,
-          ranges::random_access_range P,
-          class EVF = std::function<ranges::range_value_t<P>(edge_reference_t<G>)>>
-requires ranges::random_access_range<vertex_range_t<G>> && integral<vertex_id_t<G>> &&
-      is_arithmetic_v<ranges::range_value_t<P>> && edge_weight_function<G, EVF>
+          random_access_range P,
+          class EVF = std::function<range_value_t<P>(edge_reference_t<G>)>>
+requires random_access_range<vertex_range_t<G>> && integral<vertex_id_t<G>> &&
+      is_arithmetic_v<range_value_t<P>> && edge_weight_function<G, EVF>
 void pagerank(G&&               g,
               P&                scores,
               const double      damping_factor,
diff --git a/D3128_Algorithms/src/prim.hpp b/D3128_Algorithms/src/prim.hpp
index 546285b..8e5af38 100644
--- a/D3128_Algorithms/src/prim.hpp
+++ b/D3128_Algorithms/src/prim.hpp
@@ -1,15 +1,15 @@
 template <index_adjacency_list        G,
-          ranges::random_access_range Predecessor,
-          ranges::random_access_range Weight>
-void prim(G&& g, Predecessor& predecessor, Weight& weight, vertex_id_t<G> seed = 0) {}
+          random_access_range Predecessor,
+          random_access_range Weight>
+void prim(G&& g, Predecessor& predecessor, Weight& weight, vertex_id_t<G> source = 0) {}
 
 template <index_adjacency_list        G,
-          ranges::random_access_range Predecessor,
-          ranges::random_access_range Weight,
+          random_access_range Predecessor,
+          random_access_range Weight,
           class CompareOp>
 void prim(G&&                           g,
           Predecessor&                  predecessor,
           Weight&                       weight,
           CompareOp                     compare,
-          ranges::range_value_t<Weight> init_dist,
-          vertex_id_t<G>                seed = 0) {}
\ No newline at end of file
+          range_value_t<Weight> init_dist,
+          vertex_id_t<G>                source = 0) {}
\ No newline at end of file
diff --git a/D3128_Algorithms/src/prototypes.cpp b/D3128_Algorithms/src/prototypes.cpp
index 27ae06d..ff910f6 100644
--- a/D3128_Algorithms/src/prototypes.cpp
+++ b/D3128_Algorithms/src/prototypes.cpp
@@ -134,7 +134,7 @@ template <class G>
 concept edge_list_graph = std::copyable<G>;
 
 template <class P>
-concept property = std::ranges::random_access_range<P>;
+concept property = std::random_access_range<P>;
 
 template <class Q>
 concept queueable = std::copyable<Q> && requires(Q q) {
diff --git a/D3128_Algorithms/src/shortest_paths_helpers.hpp b/D3128_Algorithms/src/shortest_paths_helpers.hpp
index f8fe559..6e38ee9 100644
--- a/D3128_Algorithms/src/shortest_paths_helpers.hpp
+++ b/D3128_Algorithms/src/shortest_paths_helpers.hpp
@@ -10,7 +10,7 @@ template <class Distances>
 constexpr void init_shortest_paths(Distances& distances) {
   // exposition only
   ranges::fill(distances, 
-               shortest_path_infinite_distance<ranges::range_value_t<Distances>>());
+               shortest_path_infinite_distance<range_value_t<Distances>>());
 }
 
 template <class Distances, class Predecessors>
diff --git a/D3128_Algorithms/src/visitor_vertex.hpp b/D3128_Algorithms/src/visitor_vertex.hpp
index e95ad56..c95ca28 100644
--- a/D3128_Algorithms/src/visitor_vertex.hpp
+++ b/D3128_Algorithms/src/visitor_vertex.hpp
@@ -1,25 +1,25 @@
 template <class G, class Visitor>
 concept has_on_initialize_vertex = // For exposition only
-      requires(Visitor& v, vertex_info<vertex_id_t<G>, vertex_reference_t<G>, void> vdesc) {
+      requires(Visitor& v, vertex_info<vertex_reference_t<G>, void> vdesc) {
         { v.on_initialize_vertex(vdesc) };
       };
 template <class G, class Visitor>
 concept has_on_discover_vertex = // For exposition only
-      requires(Visitor& v, vertex_info<vertex_id_t<G>, vertex_reference_t<G>, void> vdesc) {
+      requires(Visitor& v, vertex_info<vertex_reference_t<G>, void> vdesc) {
         { v.on_discover_vertex(vdesc) };
       };
 template <class G, class Visitor>
 concept has_on_start_vertex = // For exposition only
-      requires(Visitor& v, vertex_info<vertex_id_t<G>, vertex_reference_t<G>, void> vdesc) {
+      requires(Visitor& v, vertex_info<vertex_reference_t<G>, void> vdesc) {
         { v.on_start_vertex(vdesc) };
       };
 template <class G, class Visitor>
 concept has_on_examine_vertex = // For exposition only
-      requires(Visitor& v, vertex_info<vertex_id_t<G>, vertex_reference_t<G>, void> vdesc) {
+      requires(Visitor& v, vertex_info<vertex_reference_t<G>, void> vdesc) {
         { v.on_examine_vertex(vdesc) };
       };
 template <class G, class Visitor>
 concept has_on_finish_vertex = // For exposition only
-      requires(Visitor& v, vertex_info<vertex_id_t<G>, vertex_reference_t<G>, void> vdesc) {
+      requires(Visitor& v, vertex_info<vertex_reference_t<G>, void> vdesc) {
         { v.on_finish_vertex(vdesc) };
       };
diff --git a/D3128_Algorithms/tex/algorithms.tex b/D3128_Algorithms/tex/algorithms.tex
index 0e571a1..784a7c1 100644
--- a/D3128_Algorithms/tex/algorithms.tex
+++ b/D3128_Algorithms/tex/algorithms.tex
@@ -4,6 +4,11 @@
 
 \section{Algorithm Selection} \label{other_algo}
 
+% \andrew{I've tagged the algorithms below as Tier 2 or Tier 3 -- denoting whether they should be done right now or done later or done much later.}
+
+% \andrew{I've used NetworkX as inspiration for organization.  Oddly, NetworkX only has DFS as an adaptor (view).}
+% \phil{If the use of Yield is any indicator, then NetworkX implements topological sort as adaptor also.}
+
 \phil{Use \tcode{basic_index_adjacency_list} as the concept for all algorithms.}
 
 When determining the algorithms to propose we split them into different tiers. Tier 1 algorithms are included
@@ -254,7 +259,7 @@ \subsection{Breadth-First Search}
 \label{tab:algo_example}
 \end{table}
 
-\phil{BGL doesn't include distances or predecessors.}
+%\phil{BGL doesn't include distances or predecessors.}
 
 \subsubsection{Single Source Breadth-First Search}
 
@@ -271,10 +276,13 @@ \subsubsection{Multi-Source Breadth-First Search}
 \begin{itemdescr}
       %\pnum\mandates
       % \pnum
-\preconditions
+      \hardprecond
             \begin{itemize}
                   \item
                         \lstinline{0 <= source < num_vertices(graph)} for the single-source version.
+            \end{itemize}
+      \preconditions
+            \begin{itemize}
                   \item
                         \lstinline{0 <= source < num_vertices(graph)}, for each \lstinline{source} in \lstinline{sources}, 
                                    for the multi-source version.
@@ -290,10 +298,6 @@ \subsubsection{Multi-Source Breadth-First Search}
             \end{itemize}
       %\pnum\result
       %\pnum\returns \lstinline{void} \\
-      \pnum\throws
-            \begin{itemize}
-                  \item \tcode{out_of_range} is thrown when \tcode{source} is not in the range \tcode{0 <= source < num_vertices(g)}.
-            \end{itemize}
       \pnum\complexity
             \begin{itemize}
                   \item $\mathcal{O}((|E| + |V|)\log{|V|})$ based on using the binary heap in \tcode{std::priority_queue}.
@@ -347,7 +351,7 @@ \subsubsection{Single Source Depth-First Search}
 \begin{itemdescr}
       %\pnum\mandates
       % \pnum
-\preconditions
+      \hardprecond
             \begin{itemize}
                   \item
                         \lstinline{0 <= source < num_vertices(graph)}.
@@ -369,10 +373,6 @@ \subsubsection{Single Source Depth-First Search}
             \end{itemize}
       %\pnum\result
       %\pnum\returns \lstinline{void} \\
-      \pnum\throws
-            \begin{itemize}
-                  \item \tcode{out_of_range} is thrown when \tcode{source} is not in the range \tcode{0 <= source < num_vertices(g)}.
-            \end{itemize}
       \pnum\complexity
             \begin{itemize}
                   \item $\mathcal{O}(|V| + |E|)$.
@@ -430,10 +430,15 @@ \subsubsection{Multi-Source Topological Sort}
 
 \begin{itemdescr}
       %\pnum\mandates
-      \pnum\preconditions
+      \pnum\hardprecond
             \begin{itemize}
                   \item
                         \lstinline{0 <= source < num_vertices(graph)} for the single-source version.
+                  \item
+                        \lstinline{size(predecessors) >= size(vertices(g))}
+            \end{itemize}
+      \pnum\preconditions
+            \begin{itemize}
                   \item
                         \lstinline{0 <= source < num_vertices(graph)}, for each \lstinline{source} in \lstinline{sources}, 
                                    for the multi-source version.
@@ -450,14 +455,6 @@ \subsubsection{Multi-Source Topological Sort}
             \end{itemize}
       %\pnum\result
       %\pnum\returns \lstinline{void} \\
-      \pnum\throws 
-            \begin{itemize}
-                  \item An \tcode{out_of_range} exception is thrown in the following cases:
-                        \begin{itemize}
-                              \item \lstinline{size(predecessor) < size(vertices(g))}
-                              \item \lstinline{source} is not in the range \lstinline{0 <= source < num_vertices(graph)}.
-                        \end{itemize}
-            \end{itemize}
       \pnum\complexity
             \begin{itemize}
                   \item $\mathcal{O}((|E| + |V|)\log{|V|})$ based on using the binary heap in \tcode{std::priority_queue}.
@@ -559,27 +556,30 @@ \subsubsection{Dijkstra Shortest Paths}
       \lstinputlisting{D3128_Algorithms/src/dijkstra_shortest_paths_multi.hpp}
 }
 
-\andrew{Should we include the check for negative weights (performance)?}
-\phil{It's the cost of safety. BGL did it, so there is precedent. The check isn't done if weights are unsigned 
-integral values.}
+%\andrew{Should we include the check for negative weights (performance)?}
+%\phil{It's the cost of safety. BGL did it, so there is precedent. The check isn't done if weights are unsigned 
+%integral values.}
+%\phil{For the standard, no, because it is an O(n) check.  But we can add it as an option in the future for the
+%      non-standard version.}
 
 \begin{itemdescr}
-      \pnum\mandates
+      \pnum\hardprecond
             \begin{itemize}
-                  \item
-                        \lstinline{0 <= source < num_vertices(graph)} for the single-source version.
-                  \item
-                        \lstinline{0 <= source < num_vertices(graph)}, for each \lstinline{source} in \lstinline{sources}, 
-                                   for the multi-source version.
-                  \item
-                        The weight function \lstinline{w} must return a non-negative value.
+                  \item \lstinline{0 <= source < num_vertices(graph)} for the single-source version.
+                  \item \lstinline{size(distances) >= size(vertices(g))}
+                  \item \lstinline{size(predecessor) >= size(vertices(g))}
             \end{itemize}
       \pnum\preconditions
             \begin{itemize}
+                  \item
+                        \lstinline{0 <= source < num_vertices(graph)}, for each \lstinline{source} in \lstinline{sources}, 
+                                   for the multi-source version.
                   \item
                         \lstinline{distances[i] = shortest_path_infinite_distance()} for \lstinline{0 <= i < num_vertices(g)}.
                   \item
                         \lstinline{predecessors[i] = i} for \lstinline{0 <= i < num_vertices(g)}.
+                  \item
+                        The weight function \lstinline{weight} must return a non-negative value.
             \end{itemize}
       \pnum\effects
             \begin{itemize}
@@ -602,17 +602,6 @@ \subsubsection{Dijkstra Shortest Paths}
             \end{itemize}
       %\pnum\result
       %\pnum\returns \lstinline{void} \\
-      \pnum\throws 
-            \begin{itemize}
-                  \item An \tcode{out_of_range} exception is thrown in the following cases:
-                        \begin{itemize}
-                              \item \lstinline{size(distances) < size(vertices(g))}
-                              \item \lstinline{size(predecessor) < size(vertices(g))}
-                              \item \lstinline{source} is not in the range \lstinline{0 <= source < num_vertices(graph)}.
-                              \item The weight function returns a negative value. This check is not made if the weight
-                                    value type is an unsigned integral type.
-                        \end{itemize}
-            \end{itemize}
       \pnum\complexity
             \begin{itemize}
                   \item $\mathcal{O}((|E| + |V|)\log{|V|})$ based on using the binary heap in \tcode{std::priority_queue}.
@@ -641,20 +630,20 @@ \subsubsection{Dijkstra Shortest Distances}
 }
 
 \begin{itemdescr}
-      \pnum\mandates
+      \pnum\hardprecond
             \begin{itemize}
-                  \item
-                        \lstinline{0 <= source < num_vertices(graph)} for the single-source version. 
-                  \item
-                        \lstinline{0 <= source < num_vertices(graph)}, for each \lstinline{source} in \lstinline{sources}, 
-                                   for the multi-source version.
-                  \item
-                        The weight function \lstinline{w} must return a non-negative value.
+                  \item \lstinline{0 <= source < num_vertices(graph)} for the single-source version. 
+                  \item \lstinline{size(distances) >= size(vertices(g))}
             \end{itemize}
       \pnum\preconditions
             \begin{itemize}
+                  \item
+                        \lstinline{0 <= source < num_vertices(graph)}, for each \lstinline{source} in \lstinline{sources}, 
+                        for the multi-source version.
                   \item
                         \lstinline{distances[i] = shortest_path_infinite_distance()} for \lstinline{0 <= i < num_vertices(g)}.
+                  \item
+                        The weight function \lstinline{weight} must return a non-negative value.
             \end{itemize}
       \pnum\effects
             \begin{itemize}
@@ -672,16 +661,6 @@ \subsubsection{Dijkstra Shortest Distances}
             \end{itemize}
       %\pnum\result
       %\pnum\returns \lstinline{void} \\
-      \pnum\throws 
-            \begin{itemize}
-                  \item An \tcode{out_of_range} exception is thrown in the following cases:
-                        \begin{itemize}
-                              \item \lstinline{size(distances) < size(vertices(g))}
-                              \item \lstinline{source} is not in the range \lstinline{0 <= source < num_vertices(graph)}.
-                              \item The weight function returns a negative value. This check is not made if the weight
-                                    value type is an unsigned integral type.
-                        \end{itemize}
-            \end{itemize}
       \pnum\complexity
             \begin{itemize}
                   \item $\mathcal{O}((|E| + |V|)\log{|V|})$ based on using the binary heap in \tcode{std::priority_queue}.
@@ -746,16 +725,17 @@ \subsubsection{Bellman-Ford Shortest Paths}
 }
 
 \begin{itemdescr}
-      \pnum\mandates
+      \pnum\hardprecond
             \begin{itemize}
-                  \item
-                        \lstinline{0 <= source < num_vertices(graph)} for the single-source version. 
-                  \item
-                        \lstinline{0 <= source < num_vertices(graph)}, for each \lstinline{source} in \lstinline{sources}, 
-                                   for the multi-source version.
+                  \item \lstinline{0 <= source < num_vertices(graph)} for the single-source version. 
+                  \item \lstinline{size(distances) >= size(vertices(g))}
+                  \item \lstinline{size(predecessor) >= size(vertices(g))}
             \end{itemize}
       \pnum\preconditions
             \begin{itemize}
+                  \item
+                        \lstinline{0 <= source < num_vertices(graph)}, for each \lstinline{source} in \lstinline{sources}, 
+                        for the multi-source version.
                   \item
                         \lstinline{distances[i] = shortest_path_infinite_distance()} for \lstinline{0 <= i < num_vertices(g)}.
                   \item
@@ -787,14 +767,6 @@ \subsubsection{Bellman-Ford Shortest Paths}
                         vertex id in the cycle is returned. \lstinline{find_negative_cycle}
                         can be called to get the vertex ids of the cycle.
             \end{itemize}
-      \pnum\throws 
-            \begin{itemize}
-                  \item An \tcode{out_of_range} exception is thrown in the following cases:
-                        \begin{itemize}
-                              \item \lstinline{size(distances) < size(vertices(g))}
-                              \item \lstinline{source} is not in the range \lstinline{0 <= source < num_vertices(graph)}.
-                        \end{itemize}
-            \end{itemize}
       \pnum\complexity $\mathcal{O}(|E| \cdot |V|)$. Complexity may also be affected when visitor events are called. \\
       \pnum\remarks 
             \begin{itemize}
@@ -821,16 +793,18 @@ \subsubsection{Bellman-Ford Shortest Distances}
 }
 
 \begin{itemdescr}
-      \pnum\mandates
+      \pnum\hardprecond
             \begin{itemize}
                   \item
                         \lstinline{0 <= source < num_vertices(graph)} for the single-source version. 
-                  \item
-                        \lstinline{0 <= source < num_vertices(graph)}, for each \lstinline{source} in \lstinline{sources}, 
-                                   for the multi-source version.
+                  \item 
+                        \lstinline{size(distances) >= size(vertices(g))}
             \end{itemize}
       \pnum\preconditions
             \begin{itemize}
+                  \item
+                        \lstinline{0 <= source < num_vertices(graph)}, for each \lstinline{source} in \lstinline{sources}, 
+                                   for the multi-source version.
                   \item
                         \lstinline{distances[i] = shortest_path_infinite_distance()} for \lstinline{0 <= i < num_vertices(g)}.
             \end{itemize}
@@ -849,28 +823,20 @@ \subsubsection{Bellman-Ford Shortest Distances}
             \end{itemize}
       %\pnum\result
       \pnum\returns 
-      \begin{itemize}
-            \item \lstinline{optional<vertex_id_t<G>} If no negative weight cycle is found, 
-                  there is no associated vertex id. If a negative weight cycle is found, a
-                  vertex id in the cycle is returned. \lstinline{bellman_ford_shortest_paths} must be used
-                  to get the predecessors if it is importantant to get the vertex ids of the cycle
-                  using \lstinline{find_negative_cycle}.
-      \end{itemize}
-\pnum\throws 
             \begin{itemize}
-                  \item An \tcode{out_of_range} exception is thrown in the following cases:
-                        \begin{itemize}
-                              \item \lstinline{size(distances) < size(vertices(g))}
-                              \item \lstinline{source} is not in the range \lstinline{0 <= source < num_vertices(graph)}.
-                        \end{itemize}
+                  \item \lstinline{optional<vertex_id_t<G>} If no negative weight cycle is found, 
+                        there is no associated vertex id. If a negative weight cycle is found, a
+                        vertex id in the cycle is returned. \lstinline{bellman_ford_shortest_paths} must be used
+                        to get the predecessors if it is importantant to get the vertex ids of the cycle
+                        using \lstinline{find_negative_cycle}.
             \end{itemize}
       \pnum\complexity $\mathcal{O}(|E| \cdot |V|)$. Complexity may also be affected when visitor events are called. \\
-      \pnum\remarks 
-            \begin{itemize}
-                  \item Duplicate sources do not affect the algorithm's complexity or correctness.
-                  \item Unlike Dijkstra's algorithm, Bellman-Ford allows negative edge weights. 
-                        Performance constraints limit this to smaller graphs.
-            \end{itemize}
+            \pnum\remarks 
+                  \begin{itemize}
+                        \item Duplicate sources do not affect the algorithm's complexity or correctness.
+                        \item Unlike Dijkstra's algorithm, Bellman-Ford allows negative edge weights. 
+                              Performance constraints limit this to smaller graphs.
+                  \end{itemize}
       %\pnum\errors
 \end{itemdescr}
 
@@ -944,10 +910,6 @@ \subsection{Triangle Counting}
             \begin{itemize}
                   \item Number of triangles
             \end{itemize}
-      \pnum\throws
-            \begin{itemize}
-                  \item A \tcode{graph_error} is thrown when the target\_id for an outgoing edge is less than the target\_id of the previous edge.
-            \end{itemize}
       \pnum\complexity $\mathcal{O}(N^3)$ \\
       \pnum\remarks 
             \begin{itemize}
@@ -992,18 +954,22 @@ \subsection{Label Propagation}
       \pnum\preconditions
             \begin{itemize}
                   \item
-                  \lstinline{label} contains initial vertex labels.
+                        \lstinline{label} contains initial vertex labels.
                   \item
-                  \lstinline{rng} is a random number generator for vertex voting order.
+                        \lstinline{rng} is a random number generator for vertex voting order.
                   \item
-                  \lstinline{max_iters} is the maximum number of iterations of the label propagation, or equivalently the maximum distance a label will propagate from its starting vertex.
+                        \lstinline{max_iters} is the maximum number of iterations of the label propagation, or equivalently 
+                        the maximum distance a label will propagate from its starting vertex.
             \end{itemize}
       \pnum\effects \lstinline{label[uid]} is the label assignments of vertex id \lstinline{uid} discovered by label propagation. \\
       %\pnum\result
       %\pnum\returns
       %\pnum\throws
       \pnum\complexity  $\mathcal{O}(M)$ \\
-      \pnum\remarks     User is responsible for initial vertex labels.
+      \pnum\remarks
+            \begin{itemize}
+                  \item User is responsible for initial vertex labels.
+            \end{itemize}
       %\pnum\errors
 \end{itemdescr}
 
@@ -1033,20 +999,27 @@ \subsection{Label Propagation}
       \pnum\preconditions
             \begin{itemize}
                   \item
-                  \lstinline{label} contains initial vertex labels.
+                        \lstinline{label} contains initial vertex labels.
                   \item
-                  \lstinline{empty_label} defines a label that is considered empty and will not be propagated.
+                        \lstinline{empty_label} defines a label that is considered empty and will not be propagated.
                   \item
-                  \lstinline{rng} is a random number generator for vertex voting order.
+                        \lstinline{rng} is a random number generator for vertex voting order.
                   \item
-                  \lstinline{max_iters} is the maximum number of iterations of the label propagation, or equivalently the maximum distance a label will propagate from its starting vertex.
+                        \lstinline{max_iters} is the maximum number of iterations of the label propagation, or equivalently 
+                        the maximum distance a label will propagate from its starting vertex.
+            \end{itemize}
+      \pnum\effects 
+            \begin{itemize}
+                  \item \lstinline{label[uid]} is the label assignments of vertex id \lstinline{uid} discovered by label propagation.
             \end{itemize}
-      \pnum\effects \lstinline{label[uid]} is the label assignments of vertex id \lstinline{uid} discovered by label propagation. \\
       %\pnum\result
       %\pnum\returns
       %\pnum\throws
       \pnum\complexity  $\mathcal{O}(M)$ \\
-      \pnum\remarks     User is responsible for initial vertex labels.
+      \pnum\remarks     
+            \begin{itemize}
+                  \item User is responsible for initial vertex labels.
+            \end{itemize}
       %\pnum\errors
 \end{itemdescr}
 
@@ -1083,12 +1056,14 @@ \subsection{Articulation Points}
       \pnum\preconditions
             \begin{itemize}
                   \item
-                  Output iterator \lstinline{cut_vertices} can be assigned vertices of type \lstinline{vertex_id_t<G>} when dereferenced.
+                        Output iterator \lstinline{cut_vertices} can be assigned vertices of type 
+                        \lstinline{vertex_id_t<G>} when dereferenced.
             \end{itemize}
       \pnum\effects
             \begin{itemize}
                   \item
-                  Output iterator \lstinline{cut_vertices} contains articulation point vertices, those which removed increase the number of components of \lstinline{g}.
+                        Output iterator \lstinline{cut_vertices} contains articulation point 
+                        vertices, those which removed increase the number of components of \lstinline{g}.
             \end{itemize}
       %\pnum\result
       %\pnum\returns
@@ -1099,7 +1074,8 @@ \subsection{Articulation Points}
 \end{itemdescr}
 
 \subsection{BiConnected Components}
-Find the biconnected components, or maximal biconnected subgraphs of a graph, which are components that will remain connected if a vertex is removed. Time complexity based on Hopcroft-Tarjan algorithm.
+Find the biconnected components, or maximal biconnected subgraphs of a graph, which are components that 
+will remain connected if a vertex is removed. Time complexity based on Hopcroft-Tarjan algorithm.
 
 \begin{table}[h]
 \setcellgapes{3pt}
@@ -1133,13 +1109,11 @@ \subsection{BiConnected Components}
       %\pnum\mandates
       \pnum\preconditions
             \begin{itemize}
-                  \item
-                  \lstinline{components} is a container of containers. The inner container stores vertex ids.
+                  \item \lstinline{components} is a container of containers. The inner container stores vertex ids.
             \end{itemize}
       \pnum\effects
             \begin{itemize}
-                  \item
-                  \lstinline{components} contains groups of biconnected components.
+                  \item \lstinline{components} contains groups of biconnected components.
             \end{itemize}
       %\pnum\result
       %\pnum\returns
@@ -1194,7 +1168,14 @@ \subsection{Connected Components}
       %\pnum\returns
       %\pnum\throws
       \pnum\complexity $\mathcal{O}(|E|+|V|)$ \\
-      %\pnum\remarks 
+      \pnum\remarks 
+            \begin{itemize}
+                  \item
+                        If the maximum component id is 0, then all vertices are in a single connected component.
+                  \item
+                        If the maximum component id is \lstinline{num_vertices(g)-1}, each vertex is the sole vertex in its 
+                        own connected component.
+            \end{itemize}
       %\pnum\errors
 \end{itemdescr}
 
@@ -1227,23 +1208,37 @@ \subsubsection{Kosaraju's SCC}
 
 \begin{itemdescr}
       %\pnum\mandates
-      \pnum\preconditions
+      \pnum\hardprecond
             \begin{itemize}
                   \item
-                        \lstinline{g_t} is the transpose of \lstinline{g}. Edge \lstinline{uv} in \lstinline{g} implies edge \lstinline{vu} in \lstinline{g_t}. \lstinline{num_vertices(g)} equals \lstinline{num_vertices(g_t)}.
+                        \lstinline{num_vertices(g) == num_vertices(g_t)}.
                   \item
                         \lstinline{size(component) >= num_vertices(g)}.
             \end{itemize}
+      \pnum\preconditions
+            \begin{itemize}
+                  \item
+                        \lstinline{g_t} is the transpose of \lstinline{g}, where edge \lstinline{uv} in \lstinline{g} implies edge \lstinline{vu} in \lstinline{g_t}.
+            \end{itemize}
       \pnum\effects
             \begin{itemize}
                   \item
                         \lstinline{component[v]} is the strongly connected component id of vertex \lstinline{v}.
+                  \item
+                        The component id {component[v]} is in the range \lstinline{0 <= {component[v] < num_vertices(g)}.
             \end{itemize}
       %\pnum\result
       %\pnum\returns
       %\pnum\throws
       \pnum\complexity $\mathcal{O}(|E|+|V|)$ \\
-      %\pnum\remarks 
+      \pnum\remarks 
+            \begin{itemize}
+                  \item
+                        If the maximum component id is 0, then all vertices are in a single strongly connected component.
+                  \item
+                        If the maximum component id is \lstinline{num_vertices(g)-1}, each vertex is the sole vertex in its 
+                        own strongly connected component.
+            \end{itemize}
       %\pnum\errors
 \end{itemdescr}
 
@@ -1276,7 +1271,7 @@ \subsubsection{Tarjan's SCC}
 
 \begin{itemdescr}
       %\pnum\mandates
-      \pnum\preconditions
+      \pnum\hardprecond
             \begin{itemize}
                   \item
                         \lstinline{size(component) >= num_vertices(g)}.
@@ -1290,13 +1285,20 @@ \subsubsection{Tarjan's SCC}
       %\pnum\returns
       %\pnum\throws
       \pnum\complexity $\mathcal{O}(|E|+|V|)$ \\
-      %\pnum\remarks 
+      \pnum\remarks 
+            \begin{itemize}
+                  \item
+                        If the maximum component id is 0, then all vertices are in a single strongly connected component.
+                  \item
+                        If the maximum component id is \lstinline{num_vertices(g)-1}, each vertex is the sole vertex in its 
+                        own strongly connected component.
+            \end{itemize}
       %\pnum\errors
 \end{itemdescr}
 
 \section{Maximal Independent Set}
 \subsection{Maximal Independent Set}
-Find a maximally independent set of vertices in a graph starting from a seed vertex. An independent vertex set indicates no pair of vertices in the set are adjacent.
+Find a maximally independent set of vertices in a graph starting from a source vertex. An independent vertex set indicates no pair of vertices in the set are adjacent.
 
 \begin{table}[h]
 \setcellgapes{3pt}
@@ -1319,19 +1321,23 @@ \subsection{Maximal Independent Set}
 {\small
       \lstinputlisting{D3128_Algorithms/src/mis.hpp}
 }
+\phil{The mandates condition should be part of the requires clause.}
 \begin{itemdescr}
       %\pnum\mandates
-      \pnum\preconditions
+      \pnum\mandates
             \begin{itemize}
                   \item
-                        \lstinline{0 <= seed < num_vertices(graph)}.
+                        The \tcode{value_type} for the \lstinline{mis} output iterator is convertible to \lstinline{vertex_id_t<G>}.
+      \end{itemize}
+      \pnum\hardprecond
+            \begin{itemize}
                   \item
-                        \lstinline{mis} output iterator can be assigned vertices of type \lstinline{vertex_id_t<G>} when dereferenced.
+                        \lstinline{0 <= source < num_vertices(graph)}.
       \end{itemize}
       \pnum\effects
             \begin{itemize}
                   \item
-                        Output iterator \lstinline{mis} contains maximal independent set of vertices containing \lstinline{seed}, 
+                        Output iterator \lstinline{mis} contains maximal independent set of vertices containing \lstinline{source}, 
                         which is a subset of \lstinline{vertices(graph)}. \\
       \end{itemize}
       %\pnum\result
@@ -1381,8 +1387,9 @@ \subsection{Jaccard Coefficient}
       %\pnum\mandates
       \pnum\preconditions
             \begin{itemize}
-                  \item
-                  \lstinline{out} is an operator for setting the resulting Jaccard coefficient. This function is expected to be of the form \lstinline{out(vertex_id_t<G> uid, vertex_id_t<G> vid, edge_t<G> uv, T val)}.
+                  \item 
+                        \lstinline{out} is an operator for setting the resulting Jaccard coefficient. This function 
+                        is expected to be of the form \lstinline{out(vertex_id_t<G> uid, vertex_id_t<G> vid, edge_t<G> uv, T val)}.
             \end{itemize}
       \pnum\effects 
             \begin{itemize}
@@ -1429,8 +1436,8 @@ \subsection{Kruskal Minimum Spanning Tree}
       %\pnum\mandates
       \pnum\preconditions
             \begin{itemize}
-                  \item
-                        \lstinline{e} is an \lstinline{edgelist}.
+                  %\item
+                  %      \lstinline{e} is an \lstinline{edgelist}.
                   \item
                         \lstinline{compare} operator is a valid comparison operation on two edge values of type \lstinline{range_value_t<EL>::value_type} 
                         which returns a bool.
@@ -1476,23 +1483,28 @@ \subsection{Prim Minimum Spanning Tree}
       \lstinputlisting[firstline=13,lastline=29]{D3128_Algorithms/src/mst.hpp}
 }
 
+\phil{The mandates condition should be part of the requires clause. When done, we don't have to specify a Mandates clause.}
 \begin{itemdescr}
-      %\pnum\mandates
-      \pnum\preconditions
+      \pnum\mandates
             \begin{itemize}
                   \item
-                        \lstinline{0 <= seed < num_vertices(g)}.
+                        \lstinline{compare} operator is a valid comparison operation on two edge values of type \lstinline{edge_value_t<G>} which returns a bool.
+            \end{itemize}
+      \pnum\hardprecond
+            \begin{itemize}
                   \item
-                        Size of \lstinline{weight} and \lstinline{predecessor} is greater than or equal to \lstinline{num_vertices(g)}.
+                        \lstinline{0 <= source < num_vertices(g)}.
                   \item
-                        \lstinline{compare} operator is a valid comparison operation on two edge values of type \lstinline{edge_value_t<G>} which returns a bool.
+                        \lstinline{size(weight) >= to num_vertices(g)}.
+                  \item
+                        \lstinline{size(predecessor >= to num_vertices(g)}.
             \end{itemize}
       \pnum\effects
             \begin{itemize}
                   \item
-                        \lstinline{predecessor[v]} is the parent vertex of \lstinline{v} in a tree rooted at \lstinline{seed} and \lstinline{weight[v]} is the value of the edge between \lstinline{v} and \lstinline{predecessor[v]} in the tree. When \lstinline{compare} is \lstinline{<} and \lstinline{init_dist==+inf}, \lstinline{predecessor} represents a minimum weight spanning tree.
+                        \lstinline{predecessor[v]} is the parent vertex of \lstinline{v} in a tree rooted at \lstinline{source} and \lstinline{weight[v]} is the value of the edge between \lstinline{v} and \lstinline{predecessor[v]} in the tree. When \lstinline{compare} is \lstinline{<} and \lstinline{init_dist==+inf}, \lstinline{predecessor} represents a minimum weight spanning tree.
                   \item
-                        If \lstinline{predecessor} and \lstinline{weight} are not initialized by user, and the graph is not fully connected, \lstinline{predecessor[v]} and \lstinline{weight[v]} will be undefined for vertices not in the same connected component as \lstinline{seed}.
+                        If \lstinline{predecessor} and \lstinline{weight} are not initialized by user, and the graph is not fully connected, \lstinline{predecessor[v]} and \lstinline{weight[v]} will be undefined for vertices not in the same connected component as \lstinline{source}.
             \end{itemize}
       %\pnum\result
       %\pnum\returns
@@ -1502,161 +1514,3 @@ \subsection{Prim Minimum Spanning Tree}
       %\pnum\errors
 \end{itemdescr}
 
-\andrew{I've tagged the algorithms below as Tier 2 or Tier 3 -- denoting whether they should be done right now or done later or done much later.}
-
-\andrew{I've used NetworkX as inspiration for organization.  Oddly, NetworkX only has DFS as an adaptor (view).}
-\phil{If the use of Yield is any indicator, then NetworkX implements topological sort as adaptor also.}
-
-
-
-
-\begin{comment}
-
-      %Algorithms with [TBD] are candidates to consider but having been decided for being in the paper
-      %We are targeting the paper to be under 50pp
-      All algorithms are customization points.
-
-      \phil{Algorithms marked [TBD] are provisional and may be moved to a separate proposal to keep the size of this proposal manageable}
-
-      \subsection{Dijkstra's Shortest Paths and Shortest Distances}
-      %Dijkstra's algorithm \cite{REF_} is a single-source, shortest paths algorithm for non-negative weights. It finds the shortest paths
-      %and their weighted distances to all vertices connected to a single seed vertex.
-
-      \begin{lstlisting}
-      template <adjacency_list G, class DistanceValue>
-      auto dijkstra_infinite_distance() {
-      return numeric_limits<DistanceValue>::max();
-      }
-
-      template <adjacency_list              G,
-            ranges::random_access_range Distance,
-            ranges::random_access_range Predecessor,
-            class EVF   = std::function<ranges::range_value_t<Distance>(edge_reference_t<G>)>,
-            queueable Q = 
-                  priority_queue<
-                        weighted_vertex<G,invoke_result_t<EVF,edge_reference_t<G>>>,
-                        vector<weighted_vertex<G,invoke_result_t<EVF,edge_reference_t<G>>>>,
-                        greater<weighted_vertex<G,invoke_result_t<EVF,edge_reference_t<G>>>>>>
-      requires ranges::random_access_range<vertex_range_t<G>> &&                  //
-            integral<vertex_id_t<G>> &&                                           //
-            is_arithmetic_v<ranges::range_value_t<Distance>> &&                   //
-            convertible_to<vertex_id_t<G>, ranges::range_value_t<Predecessor>> && //
-            edge_weight_function<G, EVF>
-      constexpr void dijkstra_shortest_paths(
-            G&&            g,           // graph
-            vertex_id_t<G> seed,        // starting vertex_id
-            Distance&      distance,    // out: distance[uid] of vertex_id uid from seed
-            Predecessor&   predecessor, // out: predecessor[uid] of vertex_id uid in path
-            EVF            weight_fn = [](edge_reference_t<G> uv)  // weight_fn(uv) -> 1
-                                          { return ranges::range_value_t<Distance>(1); },
-            Q              q = Q()
-            );
-      \end{lstlisting}
-
-      \begin{table}[h!]
-            %\begin{center}
-            %\resizebox{\textwidth}{!}
-            {\begin{tabular}{l l}
-                        \hline
-                        \textit{Complexity}     & O(V log(V)).                                                                                                                                                  \\
-                                                & Additional time will be required to pre-extend  or initialize the \tcode{distance} range by the caller.                                                       \\
-                                                & Additional time may also be required to pre-extend \tcode{predecessor}.                                                                                       \\
-                        \andrew{O((|E| + |V|)log(|V|) or O(|E| + |V|log(|V|).  Initializing distance and predecessor are O(|V|) so don't change the complexity.}
-                        \hline
-                        \textit{Constraints}    & Values returned by \tcode{weight_fn} must be non-negative.                                                                                                    \\
-                        \hline
-                        \textit{Preconditions}  & \tcode{seed >= 0                                                                                                               &  & seed < size(vertices(g))} \\
-                                                & \tcode{size(distance) >= size(vertices(g))}; caller must pre-extend with \tcode{dijkstra_infinite_distance()}                                                   \\
-                                                & \tcode{size(predecessor) >= size(vertices(g))}; caller must pre-extend                                                                                        \\
-                                                & \tcode{distance[i] = dijkstra_infinite_distance()} for \tcode{i < size(vertices(g))}                                                                           \\
-                        \hline
-                        \textit{Postconditions} & \tcode{distance[seed] == 0}                                                                                                                                   \\
-                                                & \tcode{predecessor[seed] == seed}.                                                                                                                            \\
-                        \hline
-                        \textit{\effects}       & \tcode{distance[uid]} will be the shortest, weighted distance of vertex\_id \tcode{uid} from \tcode{seed}.                                                    \\
-                                                & If \tcode{uid} is not connected to \tcode{seed} by any edges then it will have a value of \tcode{dijkstra_infinite_distance()}.                                \\
-                                                &                                                                                                                                                               \\
-                                                & \tcode{predecessor[uid]} will have the preceding vertex\_id of \tcode{uid} in the weighted shortest path to \tcode{seed}                                      \\
-                                                & when \tcode{distance[uid] != dijkstra_infinite_distance()}.                                                                                                    \\
-                        \hline
-                  \end{tabular}}
-            %\caption{\tcode{incidence} View Functions}
-            %\label{tab:incidence}
-            %\end{center}
-      \end{table}
-
-      \phil{Describe the pros and cons of different kinds of queues}
-
-      The default weight function \tcode{weight_fn} returns a value of 1. When that is used, \tcode{distance[uid]} will have the shortest number of edges
-      between vertex \tcode{uid} and vertex \tcode{seed}. The distance from \tcode{seed} to itself is zero.
-
-      If the caller wishes to use a different queue other than \tcode{priority_queue}, the queue will need to have elements of \tcode{weighted_vertex}
-      which is used internally by the algorithm.
-      \begin{lstlisting}
-      template <class G, class W>
-      requires is_default_constructible_v<vertex_id_t<G>> && is_default_constructible_v<W>
-      struct weighted_vertex {
-      vertex_id_t<G> vertex_id = vertex_id_t<G>();
-      W              weight    = W();
-      constexpr auto operator<=>(const weighted_vertex&) const noexcept; // compare vertex_id
-      };
-      \end{lstlisting}
-
-      The \tcode{dijkstra_shortest_distances} function is the same as \tcode{dijkstra_shortest_paths} except that it doesn't include
-      the \tcode{predecessor} parameter.
-      \begin{lstlisting}
-      template <adjacency_list              G,
-            ranges::random_access_range Distance,
-            class EVF   = std::function<ranges::range_value_t<Distance>(edge_reference_t<G>)>,
-            queueable Q = 
-                  priority_queue<
-                        weighted_vertex<G,invoke_result_t<EVF,edge_reference_t<G>>>,
-                        vector<weighted_vertex<G,invoke_result_t<EVF,edge_reference_t<G>>>>,
-                        greater<weighted_vertex<G,invoke_result_t<EVF,edge_reference_t<G>>>>>>
-      requires ranges::random_access_range<vertex_range_t<G>> &&                  //
-            integral<vertex_id_t<G>> &&                                           //
-            is_arithmetic_v<ranges::range_value_t<Distance>> &&                   //
-            edge_weight_function<G, EVF>
-      constexpr void dijkstra_shortest_distances(
-            G&&            g,           // graph
-            vertex_id_t<G> seed,        // starting vertex_id
-            Distance&      distance,    // out: distance[uid] of vertex_id uid from seed
-            EVF            weight_fn = [](edge_reference_t<G> uv)  // weight_fn(uv) -> 1
-                                          { return ranges::range_value_t<Distance>(1); },
-            Q              q = Q()
-            );
-      \end{lstlisting}
-
-      \subsection{[TBD] Delta Stepping Shortest Paths}
-      %The  algorithm \cite{REF_} ...
-
-      \subsection{Bellman-Ford Shortest Paths}
-      %The Bellman-Ford algorithm \cite{REF_} ...
-
-      \subsection{[TBD] Shortest Paths}
-      (Overloads to select appropriate algorithm based on inputs)
-
-      \subsection{Connected Components}
-      %Connected components \cite{REF_} ...
-
-      \subsection{Strongly Connected Components}
-      %Strongly connected components \cite{REF_} ...
-
-      \subsection{Biconnected Components}
-      %Biconnected components \cite{REF_} ...
-
-      \subsection{Articulation Points}
-      %Articulation points \cite{REF_} ...
-
-      \subsection{Minimum Spanning Tree}
-      %Minimum Spanning Tree \cite{REF_} ...
-
-      \subsection{[TBD] Betweenness Centrality}
-      \subsection{[TBD] Triangle Count}
-      \subsection{[TBD] Subgraph Isomorphism}
-      \subsection{[TBD] Kruskal Minimum Spanning Tree}
-      \subsection{[TBD] Prim Minimum Spanning Tree}
-      \subsection{[TBD] Louvain (Community Detection)}
-      \subsection{[TBD] Label propagation (Community Detection)}
-
-\end{comment}
diff --git a/D3128_Algorithms/tex/revision.tex b/D3128_Algorithms/tex/revision.tex
index 93bdfa5..41205fd 100644
--- a/D3128_Algorithms/tex/revision.tex
+++ b/D3128_Algorithms/tex/revision.tex
@@ -50,3 +50,11 @@ \subsection*{\paperno r3}
       \item Update the breadth-first search and topological sort algorithms to be in line with changes made to the 
             Dijkstra and Bellman-Ford algorithms, such as adding a visitor parameter and overloads for multiple sources.
 \end{itemize}
+
+\subsection*{\paperno r4}
+\begin{itemize}
+      \item Added the \textit{Hardened preconditions} section to the algorithms for C++26 which helped to reword
+            the other clauses so they conform to expectations of the standard. Statements incorrectly included in 
+            the \textit{Mandates} and \textit{Preconditions} sections were moved to the \textit{Hardened preconditions} 
+            section and the \textit{Throws} claus was removed, simplifying and clarifying the defintions.
+\end{itemize}
diff --git a/D3129_Views/tex/views.tex b/D3129_Views/tex/views.tex
index 5a204fa..d4125d1 100644
--- a/D3129_Views/tex/views.tex
+++ b/D3129_Views/tex/views.tex
@@ -366,7 +366,7 @@ \subsection{Common Types and Functions for ``Search'' }
 template<class S)
 void cancel(S search, cancel_search);
 
-// Returns distance from the seed vertex to the current vertex, 
+// Returns distance from the source vertex to the current vertex, 
 // or to the target vertex for edge views
 template<class S>
 auto depth(S search) -> integral;
@@ -402,13 +402,13 @@ \subsection{Common Types and Functions for ``Search'' }
 
 \subsection{Depth First Search Views}
 
-Depth First Search views iterate over the vertices and edges from a given seed vertex, returning a \tcode{vertex_info} or \tcode{edge_info} on each iteration when it is first encountered, depending on the function used. 
+Depth First Search views iterate over the vertices and edges from a given source vertex, returning a \tcode{vertex_info} or \tcode{edge_info} on each iteration when it is first encountered, depending on the function used. 
 Table \ref{tab:dfs} shows the functions and their return values.
 
 %The \tcode{alloc} parameter shown in the following examples is optional and defaults to \tcode{std::allocator<bool>}. It is used for containers 
 %that are internal to the view. The \tcode{bool} argument has no particular meaning.
 
-% basic_edges_dfs(g,seed,evf) implies the use of Sourced type internally to have source_id in the call call to evf(eid)
+% basic_edges_dfs(g,source,evf) implies the use of Sourced type internally to have source_id in the call call to evf(eid)
 
 \phil{Consider adding an enum bitset of events matching the visitor events, and creating Overloads
       that accept the bitset. The returned type would be a subclass of \tcode{vertex_info} or \tcode{edge_info}
@@ -424,14 +424,14 @@ \subsection{Depth First Search Views}
 \hline
     \textbf{Example} & \textbf{Return} \\
 \hline
-    \tcode{for(auto\&\& [v] : vertices_dfs(g,seed))} & \tcode{vertex_info<void,V,void>} \\
-    \tcode{for(auto\&\& [v,val] : vertices_dfs(g,seed,vvf))} & \tcode{vertex_info<void,V,VV>} \\
+    \tcode{for(auto\&\& [v] : vertices_dfs(g,source))} & \tcode{vertex_info<void,V,void>} \\
+    \tcode{for(auto\&\& [v,val] : vertices_dfs(g,source,vvf))} & \tcode{vertex_info<void,V,VV>} \\
 \hdashline
-    \tcode{for(auto\&\& [v,uv] : edges_dfs(g,seed))} & \tcode{edge_info<V,false,E,void>} \\
-    \tcode{for(auto\&\& [v,uv,val] : edges_dfs(g,seed,evf))} & \tcode{edge_info<V,false,E,EV>} \\
+    \tcode{for(auto\&\& [v,uv] : edges_dfs(g,source))} & \tcode{edge_info<V,false,E,void>} \\
+    \tcode{for(auto\&\& [v,uv,val] : edges_dfs(g,source,evf))} & \tcode{edge_info<V,false,E,EV>} \\
 \hdashline
-    \tcode{for(auto\&\& [u,v,uv] : sourced_edges_dfs(g,seed))} & \tcode{edge_info<V,true,E,void>} \\
-    \tcode{for(auto\&\& [u,v,uv,val] : sourced_edges_dfs(g,seed,evf))} & \tcode{edge_info<V,true,E,EV>} \\
+    \tcode{for(auto\&\& [u,v,uv] : sourced_edges_dfs(g,source))} & \tcode{edge_info<V,true,E,void>} \\
+    \tcode{for(auto\&\& [u,v,uv,val] : sourced_edges_dfs(g,source,evf))} & \tcode{edge_info<V,true,E,EV>} \\
 \hline
 \end{tabular}}
 \caption{depth\_first\_search View Functions}
@@ -442,14 +442,14 @@ \subsection{Depth First Search Views}
 \subsection{Breadth First Search Views}
 \phil{NetworkX provides an optional depth\_limit parameter for bfs. Add? }
 
-Breadth First Search views iterate over the vertices and edges from a given seed vertex, returning a \tcode{vertex_info} 
+Breadth First Search views iterate over the vertices and edges from a given source vertex, returning a \tcode{vertex_info} 
 or \tcode{edge_info} on each iteration when it is first encountered, depending on the function used. 
 Table \ref{tab:bfs} shows the functions and their return values.
 
 %The \tcode{alloc} parameter shown in the following examples is optional and defaults to \tcode{std::allocator<bool>}. It is used for containers 
 %that are internal to the view. The \tcode{bool} argument has no particular meaning.
 
-% basic_edges_bfs(g,seed,evf) implies the use of Sourced type internally to have source_id in the call call to evf(eid)
+% basic_edges_bfs(g,source,evf) implies the use of Sourced type internally to have source_id in the call call to evf(eid)
 
 \phil{Consider adding an enum bitset of events matching the visitor events, and creating Overloads
       that accept the bitset. The returned type would be a subclass of \tcode{vertex_info} or \tcode{edge_info}
@@ -466,14 +466,14 @@ \subsection{Breadth First Search Views}
     \textbf{Example} & \textbf{Return} \\
 \hline
 \hdashline
-    \tcode{for(auto\&\& [v] : vertices_bfs(g,seed))} & \tcode{vertex_info<void,V,void>} \\
-    \tcode{for(auto\&\& [v,val] : vertices_bfs(g,seed,vvf))} & \tcode{vertex_info<void,V,VV>} \\
+    \tcode{for(auto\&\& [v] : vertices_bfs(g,source))} & \tcode{vertex_info<void,V,void>} \\
+    \tcode{for(auto\&\& [v,val] : vertices_bfs(g,source,vvf))} & \tcode{vertex_info<void,V,VV>} \\
 \hdashline
-    \tcode{for(auto\&\& [v,uv] : edges_bfs(g,seed))} & \tcode{edge_info<V,false,E,void>} \\
-    \tcode{for(auto\&\& [v,uv,val] : edges_bfs(g,seed,evf))} & \tcode{edge_info<V,false,E,EV>} \\
+    \tcode{for(auto\&\& [v,uv] : edges_bfs(g,source))} & \tcode{edge_info<V,false,E,void>} \\
+    \tcode{for(auto\&\& [v,uv,val] : edges_bfs(g,source,evf))} & \tcode{edge_info<V,false,E,EV>} \\
 \hdashline
-    \tcode{for(auto\&\& [u,v,uv] : sourced_edges_bfs(g,seed))} & \tcode{edge_info<V,true,E,void>} \\
-    \tcode{for(auto\&\& [u,v,uv,val] : sourced_edges_bfs(g,seed,evf))} & \tcode{edge_info<V,true,E,EV>} \\
+    \tcode{for(auto\&\& [u,v,uv] : sourced_edges_bfs(g,source))} & \tcode{edge_info<V,true,E,void>} \\
+    \tcode{for(auto\&\& [u,v,uv,val] : sourced_edges_bfs(g,source,evf))} & \tcode{edge_info<V,true,E,EV>} \\
 \hline
 \end{tabular}}
 \caption{breadth\_first\_search View Functions}
@@ -482,14 +482,14 @@ \subsection{Breadth First Search Views}
 \end{table}
 
 \subsection{Topological Sort Views}
-Topological Sort views iterate over the vertices and edges from a given seed vertex, returning a \tcode{vertex_info} or 
+Topological Sort views iterate over the vertices and edges from a given source vertex, returning a \tcode{vertex_info} or 
 \tcode{edge_info} on each iteration when it is first encountered, depending on the function used. 
 Table \ref{tab:topo_sort} shows the functions and their return values.
 
 %The \tcode{alloc} parameter shown in the following examples is optional and defaults to \tcode{std::allocator<bool>}. It is used for containers 
 %that are internal to the view. The \tcode{bool} argument has no particular meaning.
 
-% basic_edges_topological_sort(g,seed,evf) implies the use of Sourced type internally to have source_id in the call call to evf(eid)
+% basic_edges_topological_sort(g,source,evf) implies the use of Sourced type internally to have source_id in the call call to evf(eid)
 
 \phil{Consider adding an enum bitset of events matching the visitor events, and creating Overloads
       that accept the bitset. The returned type would be a subclass of \tcode{vertex_info} or \tcode{edge_info}
@@ -505,14 +505,14 @@ \subsection{Topological Sort Views}
 \hline
     \textbf{Example} & \textbf{Return} \\
 \hline
-    \tcode{for(auto\&\& [v] : vertices_topological_sort(g,seed))} & \tcode{vertex_info<void,V,void>} \\
-    \tcode{for(auto\&\& [v,val] : vertices_topological_sort(g,seed,vvf))} & \tcode{vertex_info<void,V,VV>} \\
+    \tcode{for(auto\&\& [v] : vertices_topological_sort(g,source))} & \tcode{vertex_info<void,V,void>} \\
+    \tcode{for(auto\&\& [v,val] : vertices_topological_sort(g,source,vvf))} & \tcode{vertex_info<void,V,VV>} \\
 \hdashline
-    \tcode{for(auto\&\& [v,uv] : edges_topological_sort(g,seed))} & \tcode{edge_info<V,false,E,void>} \\
-    \tcode{for(auto\&\& [v,uv,val] : edges_topological_sort(g,seed,evf))} & \tcode{edge_info<V,false,E,EV>} \\
+    \tcode{for(auto\&\& [v,uv] : edges_topological_sort(g,source))} & \tcode{edge_info<V,false,E,void>} \\
+    \tcode{for(auto\&\& [v,uv,val] : edges_topological_sort(g,source,evf))} & \tcode{edge_info<V,false,E,EV>} \\
 \hdashline
-    \tcode{for(auto\&\& [u,v,uv] : sourced_edges_topological_sort(g,seed))} & \tcode{edge_info<V,true,E,void>} \\
-    \tcode{for(auto\&\& [u,v,uv,val] : sourced_edges_topological_sort(g,seed,evf))} & \tcode{edge_info<V,true,E,EV>} \\
+    \tcode{for(auto\&\& [u,v,uv] : sourced_edges_topological_sort(g,source))} & \tcode{edge_info<V,true,E,void>} \\
+    \tcode{for(auto\&\& [u,v,uv,val] : sourced_edges_topological_sort(g,source,evf))} & \tcode{edge_info<V,true,E,EV>} \\
 \hline
 \end{tabular}}
 \caption{topological\_sort View Functions}
diff --git a/D3130_Container_Interface/src/concepts_target_edge_range.hpp b/D3130_Container_Interface/src/concepts_target_edge_range.hpp
index 4ffd605..de2b860 100644
--- a/D3130_Container_Interface/src/concepts_target_edge_range.hpp
+++ b/D3130_Container_Interface/src/concepts_target_edge_range.hpp
@@ -4,6 +4,6 @@ template <class G>
 concept targeted_edge_range = 
           basic_targeted_edge_range<G> &&
           requires(G&& g, vertex_reference_t<G> u, vertex_id_t<G> uid) {
-            { edges(g, u) } -> ranges::forward_range;
-            { edges(g, uid) } -> ranges::forward_range; // implies call to find\_vertex(g,uid)
+            { edges(g, u) } -> forward_range;
+            { edges(g, uid) } -> forward_range; // implies call to find\_vertex(g,uid)
           };
diff --git a/D3130_Container_Interface/src/concepts_vertex_range.hpp b/D3130_Container_Interface/src/concepts_vertex_range.hpp
index 379d929..36c7e77 100644
--- a/D3130_Container_Interface/src/concepts_vertex_range.hpp
+++ b/D3130_Container_Interface/src/concepts_vertex_range.hpp
@@ -6,9 +6,9 @@ concept _common_vertex_range = ranges::sized_range<vertex_range_t<G>> &&
 
 template <class G>                                                
 concept vertex_range = _common_vertex_range<vertex_range_t<G>> &&
-                            ranges::forward_range<vertex_range_t<G>>;
+                            forward_range<vertex_range_t<G>>;
 
 template <class G>                                                             
 concept index_vertex_range = _common_vertex_range<vertex_range_t<G>> &&
-                                ranges::random_access_range<vertex_range_t<G>> &&
+                                random_access_range<vertex_range_t<G>> &&
                                 integral<vertex_id_t<G>>;
diff --git a/D3130_Container_Interface/src/edgelist_concepts.hpp b/D3130_Container_Interface/src/edgelist_concepts.hpp
index 294da84..8e0a07b 100644
--- a/D3130_Container_Interface/src/edgelist_concepts.hpp
+++ b/D3130_Container_Interface/src/edgelist_concepts.hpp
@@ -1,20 +1,20 @@
 template <class EL> // For exposition only
 concept sourced_edgelist = ranges::input_range<EL> && 
-                              !ranges::range<ranges::range_value_t<EL>> &&
-                              requires(ranges::range_value_t<EL> e) {
+                              !ranges::range<range_value_t<EL>> &&
+                              requires(range_value_t<EL> e) {
                                 { source_id(e) };
                                 { target_id(e) } -> same_as<decltype(source_id(e))>;
                               };
 
 template <class EL> // For exposition only
 concept sourced_index_edgelist = sourced_edgelist<EL> &&
-                                    requires(ranges::range_value_t<EL> e) {
+                                    requires(range_value_t<EL> e) {
                                       { source_id(e) } -> integral;
                                       { target_id(e) } -> integral; // redundant, for clarity
                                     };
 
 template <class EL> // For exposition only
 concept has_edge_value = sourced_edgelist<EL> && //
-                            requires(ranges::range_value_t<EL> e) {
+                            requires(range_value_t<EL> e) {
                               { edge_value(e) };
                             };
diff --git a/D3130_Container_Interface/src/edgelist_types.hpp b/D3130_Container_Interface/src/edgelist_types.hpp
index b438ea9..3e817c3 100644
--- a/D3130_Container_Interface/src/edgelist_types.hpp
+++ b/D3130_Container_Interface/src/edgelist_types.hpp
@@ -5,7 +5,7 @@ template <basic_sourced_edgelist EL> // For exposition only
 using edge_iterator_t = ranges::iterator_t<edge_range_t<EL>>;
 
 template <basic_sourced_edgelist EL> // For exposition only
-using edge_t = ranges::range_value_t<edge_range_t<EL>>;
+using edge_t = range_value_t<edge_range_t<EL>>;
 
 template <basic_sourced_edgelist EL> // For exposition only
 using edge_reference_t = ranges::range_reference_t<edge_range_t<EL>>;
diff --git a/D3130_Container_Interface/tex/container_interface.tex b/D3130_Container_Interface/tex/container_interface.tex
index 7f42c18..5487cf3 100644
--- a/D3130_Container_Interface/tex/container_interface.tex
+++ b/D3130_Container_Interface/tex/container_interface.tex
@@ -143,7 +143,7 @@ \subsection{Types}
 
 \begin{table}[h!]
 \begin{center}
-\resizebox{\textwidth}{!}
+%\resizebox{\textwidth}{!}
 {\begin{tabular}{l l L{1.5cm}}
 \hline
     \textbf{Type Alias} & \textbf{Definition} & \textbf{Comment} \\
@@ -229,14 +229,16 @@ \subsection{Functions}
 \resizebox{\textwidth}{!}
 {\begin{tabular}{l l p{1.5cm} L{7.0cm}}
 \hline
-    \textbf{Function} & \textbf{Return Type} & \textbf{Complexity} & \textbf{Default Implementation} \\
+    \textbf{Function} & \textbf{Return Type} & \textbf{Cmplx} & \textbf{Default Implementation} \\
 \hline
     \tcode{find_vertex(g,uid)} & \tcode{vertex_iterator_t<G>} & constant & \tcode{begin(vertices(g)) + uid} \\
-    & & & if \tcode{random_access_range<vertex_range_t<G>>}  \\
+                               &                              &          & \hspace{3mm}if \tcode{random_access_range<vertex_range_t<G>>} \\
     \tcode{vertex_id(g,u)} & \tcode{vetex_id_t<G>} & constant & (see Determining the vertex\_id type below) \\
-    & & & Override to define a different \tcode{vertex_id_t<G>} type (e.g. int32\_t). \\
+                           &                       &          & Override to define a different \\
+                           &                       &          & \tcode{vertex_id_t<G>} type (e.g. int32\_t). \\
     \tcode{vertex_value(g,u)} & \tcode{vertex_value_t<G>} & constant & n/a, optional \\
-    \tcode{vertex_value(g,uid)} & \tcode{vertex_value_t<G>} & constant & \tcode{vertex_value(g,*find_vertex(g,uid))}, optional \\
+    \tcode{vertex_value(g,uid)} & \tcode{vertex_value_t<G>} & constant & \tcode{vertex_value(g,*find_vertex(g,uid))}, \\
+                                &                           &          & optional \\
     \tcode{degree(g,u)} & \tcode{integral} & constant & \tcode{size(edges(g,u))} if \tcode{sized_range<vertex_edge_range_t<G>>} \\
     \tcode{degree(g,uid)} & \tcode{integral} & constant & \tcode{size(edges(g,uid))} if \tcode{sized_range<vertex_edge_range_t<G>>} \\
     \tcode{edges(g,u)} & \tcode{vertex_edge_range_t<G>} & constant & \tcode{u} if \tcode{forward range<vertex_t<G>>}, n/a otherwise \\
@@ -259,22 +261,32 @@ \subsection{Functions}
 \begin{table}[h!]
 \begin{center}
 \resizebox{\textwidth}{!}
-{\begin{tabular}{l l p{1.5cm} L{7.0cm}}
+{\begin{tabular}{l l p{1.5cm} L{6.7cm}}
 \hline
-    \textbf{Function} & \textbf{Return Type} & \textbf{Complexity} & \textbf{Default Implementation} \\
+    \textbf{Function} & \textbf{Return Type} & \textbf{Cmplx} & \textbf{Default Implementation} \\
 \hline
     \tcode{target_id(g,uv)} & \tcode{vertex_id_t<G>} & constant & (see below) \\
-    \tcode{target(g,uv)} & \tcode{vertex_t<G>} & constant & \tcode{*(begin(vertices(g)) + target_id(g, uv))} if \tcode{random_access_range<vertex_range_t<G>> \&\& integral<target_id(g,uv)>} \\
-    \tcode{edge_value(g,uv)} & \tcode{edge_value_t<G>} & constant & \tcode{uv} if \tcode{forward_range<vertex_t<G>>}, n/a otherwise, optional \\
-    \tcode{find_vertex_edge(g,u,vid)} & \tcode{vertex_edge_t<G>} & linear & \tcode{find(edges(g,u), [](uv) {target_id(g,uv)==vid;\})}} \\
-    \tcode{find_vertex_edge(g,uid,vid)} & \tcode{vertex_edge_t<G>} & linear & \tcode{find_vertex_edge(g,*find_vertex(g,uid),vid)} \\
-    \tcode{contains_edge(g,uid,vid)} & \tcode{bool} & constant & \tcode{uid < size(vertices(g)) \&\& vid < size(vertices(g))} if \tcode{is_adjacency_matrix_v<G>}.\\
-    & & linear & \tcode{find_vertex_edge(g,uid) != end(edges(g,uid))} otherwise. \\
+    \tcode{target(g,uv)} & \tcode{vertex_t<G>} & constant & \tcode{*(begin(vertices(g)) + target_id(g, uv))} \\
+                         &                     &          & \hspace{3mm}if \tcode{random_access_range<vertex_range_t<G>>} \\
+                         &                     &          & \hspace{3mm}\tcode{\&\& integral<target_id(g,uv)>} \\
+    \tcode{edge_value(g,uv)} & \tcode{edge_value_t<G>} & constant & \tcode{uv} if \tcode{forward_range<vertex_t<G>>}, \\
+                             &                         &          & n/a otherwise, optional \\
+    \tcode{find_vertex_edge(g,u,vid)} & \tcode{vertex_edge_t<G>} & linear & \tcode{find(edges(g,u),} \\
+                                      &                          &        & \hspace{8mm}\tcode{[](uv) {target_id(g,uv)==vid;\})}} \\
+    \tcode{find_vertex_edge(g,uid,vid)} & \tcode{vertex_edge_t<G>} & linear & \tcode{find_vertex_edge(} \\
+                                        &                          &        & \hspace{8mm}\tcode{g, *find_vertex(g,uid), vid)} \\
+    \tcode{contains_edge(g,uid,vid)} & \tcode{bool} & constant & \tcode{uid < size(vertices(g))} \\
+                                     &              &          & \tcode{&& vid < size(vertices(g))} \\
+                                     &              &          & \hspace{3mm}if \tcode{is_adjacency_matrix_v<G>}.\\
+                                     &              & linear   & \tcode{find_vertex_edge(g,uid)} \\
+                                     &              &          & \tcode{!= end(edges(g,uid))} otherwise. \\
 \hdashline
     \multicolumn{4}{c}{The following are only available when the optional \tcode{source_id(g,uv)} is defined for the edge} \\
 \hdashline
     \tcode{source_id(g,uv)} & \tcode{vertex_id_t<G>} & constant & n/a, optional \\
-    \tcode{source(g,uv)} & \tcode{vertex_t<G>} & constant & \tcode{*(begin(vertices(g)) + source_id(g,uv))} if \tcode{random_access_range<vertex_range_t<G>> \&\& integral<target_id(g,uv)>} \\
+    \tcode{source(g,uv)} & \tcode{vertex_t<G>} & constant & \tcode{*(begin(vertices(g)) + source_id(g,uv))} \\
+                         &                     &          & \hspace{3mm}if \tcode{random_access_range<vertex_range_t<G>>} \\
+                         &                     &          & \hspace{3mm}\tcode{&& integral<target_id(g,uv)>} \\
 \hline
 \end{tabular}}
 \caption{Edge Functions}
@@ -302,7 +314,8 @@ \subsection{Determining the vertex\_id and its type}
 To determine the type for \tcode{vertex_id_t<G>} the following steps are taken, in order, to determine its type.
 \begin{enumerate}
     \item Use the type returned by \tcode{vertex_id(g,u)} when overridden for a graph.
-    \item When the graph matches the pattern \tcode{random_access_range<forward_range<integral>>} or \tcode{random_access_range<forward_range<tuple<integral,...>>>},
+    \item When the graph matches the pattern \tcode{random_access_range<forward_range<integral>>} or \\
+          \tcode{random_access_range<forward_range<tuple<integral,...>>>},
           use the \tcode{integral} type specified, which is assumed to be the target\_id on an edge.
     \item Use \tcode{size_t} in all other cases.
 \end{enumerate}
@@ -445,7 +458,7 @@ \subsection{Types}
 \begin{table}[h!]
 \begin{center}
 %\resizebox{\textwidth}{!}
-{\begin{tabular}{l l L{1.5cm}}
+{\begin{tabular}{l l L{1.7cm}}
 \hline
     \textbf{Type Alias} & \textbf{Definition} & \textbf{Comment} \\
 \hline
@@ -474,15 +487,17 @@ \subsection{Functions}
 \begin{table}[h!]
     \begin{center}
     \resizebox{\textwidth}{!}
-    {\begin{tabular}{l l p{1.5cm} L{7.0cm}}
+    {\begin{tabular}{l l p{1.5cm} L{6.7cm}}
     \hline
-        \textbf{Function} & \textbf{Return Type} & \textbf{Complexity} & \textbf{Default Implementation} \\
+        \textbf{Function} & \textbf{Return Type} & \textbf{Cmplx} & \textbf{Default Implementation} \\
     \hline
         \tcode{target_id(e)} & \tcode{vertex_id_t<EL>} & constant & (see below) \\
         \tcode{source_id(e)} & \tcode{vertex_id_t<EL>} & constant & (see below) \\
         \tcode{edge_value(e)} & \tcode{edge_value_t<EL>} & constant & optional, see below \\
     \hdashline
-        \tcode{contains_edge(el,uid,vid)} & \tcode{bool} & linear & \tcode{find_if(el, [](edge_reference_t<EL> e) \{return source_id(e)==uid && target_id(e)==vid\})} \\
+        \tcode{contains_edge(el,uid,vid)} & \tcode{bool} & linear & \tcode{find_if(el, [](edge_reference_t<EL> e) \{} \\
+                                          &              &        & \hspace{7mm}\tcode{return source_id(e)==uid} \\
+                                          &              &        & \hspace{13.5mm}\tcode{&& target_id(e)==vid;\} )} \\
         \tcode{num_edges(el)} & \tcode{integral} & constant & \tcode{size(el)} \\
         \tcode{has_edge(el)} & \tcode{bool} & constant & \tcode{num_edges(el)>0} \\
     \hline
diff --git a/D3131_Containers/src/compressed_graph.hpp b/D3131_Containers/src/compressed_graph.hpp
index 8e7a567..d6a8f27 100644
--- a/D3131_Containers/src/compressed_graph.hpp
+++ b/D3131_Containers/src/compressed_graph.hpp
@@ -26,23 +26,23 @@ class compressed_graph {
   // compressed\_graph(gv\&,  erng, eprojection, alloc)
   // compressed\_graph(gv\&\&, erng, eprojection, alloc)
 
-  template <ranges::forward_range ERng, ranges::forward_range PartRng, class EProj = identity>
-  requires convertible_to<ranges::range_value_t<PartRng>, VId>
+  template <forward_range ERng, forward_range PartRng, class EProj = identity>
+  requires convertible_to<range_value_t<PartRng>, VId>
   constexpr compressed_graph(const ERng&    erng,
                              EProj          eprojection,
                              const PartRng& partition_start_ids = vector<VId>(),
                              const Alloc&   alloc          = Alloc());
 
-  template <ranges::forward_range ERng, ranges::forward_range PartRng, class EProj = identity>
-  requires convertible_to<ranges::range_value_t<PartRng>, VId>
+  template <forward_range ERng, forward_range PartRng, class EProj = identity>
+  requires convertible_to<range_value_t<PartRng>, VId>
   constexpr compressed_graph(const graph_value_type& value,
                              const ERng&             erng,
                              EProj                   eprojection,
                              const PartRng&          partition_start_ids = vector<VId>(),
                              const Alloc&            alloc          = Alloc());
 
-  template <ranges::forward_range ERng, ranges::forward_range PartRng, class EProj = identity>
-  requires convertible_to<ranges::range_value_t<PartRng>, VId>
+  template <forward_range ERng, forward_range PartRng, class EProj = identity>
+  requires convertible_to<range_value_t<PartRng>, VId>
   constexpr compressed_graph(graph_value_type&& value,
                              const ERng&        erng,
                              EProj              eprojection,
@@ -53,12 +53,12 @@ class compressed_graph {
   // compressed\_graph(gv\&,  erng, vrng, eprojection, vprojection, alloc)
   // compressed\_graph(gv\&\&, erng, vrng, eprojection, vprojection, alloc)
 
-  template <ranges::forward_range ERng,
-            ranges::forward_range VRng,
-            ranges::forward_range PartRng,
+  template <forward_range ERng,
+            forward_range VRng,
+            forward_range PartRng,
             class EProj = identity,
             class VProj = identity>
-  requires convertible_to<ranges::range_value_t<PartRng>, VId>
+  requires convertible_to<range_value_t<PartRng>, VId>
   constexpr compressed_graph(const ERng&    erng,
                              const VRng&    vrng,
                              EProj          eprojection    = {},
@@ -66,12 +66,12 @@ class compressed_graph {
                              const PartRng& partition_start_ids = vector<VId>(),
                              const Alloc&   alloc          = Alloc());
 
-  template <ranges::forward_range ERng,
-            ranges::forward_range VRng,
-            ranges::forward_range PartRng,
+  template <forward_range ERng,
+            forward_range VRng,
+            forward_range PartRng,
             class EProj = identity,
             class VProj = identity>
-  requires convertible_to<ranges::range_value_t<PartRng>, VId>
+  requires convertible_to<range_value_t<PartRng>, VId>
   constexpr compressed_graph(const graph_value_type& value,
                              const ERng&             erng,
                              const VRng&             vrng,
@@ -80,12 +80,12 @@ class compressed_graph {
                              const PartRng&          partition_start_ids = vector<VId>(),
                              const Alloc&            alloc          = Alloc());
 
-  template <ranges::forward_range ERng,
-            ranges::forward_range VRng,
-            ranges::forward_range PartRng,
+  template <forward_range ERng,
+            forward_range VRng,
+            forward_range PartRng,
             class EProj = identity,
             class VProj = identity>
-  requires convertible_to<ranges::range_value_t<PartRng>, VId>
+  requires convertible_to<range_value_t<PartRng>, VId>
   constexpr compressed_graph(graph_value_type&& value,
                              const ERng&        erng,
                              const VRng&        vrng,
diff --git a/D3131_Containers/src/compressed_graph_gvoid.hpp b/D3131_Containers/src/compressed_graph_gvoid.hpp
index 3eefeb3..c709f11 100644
--- a/D3131_Containers/src/compressed_graph_gvoid.hpp
+++ b/D3131_Containers/src/compressed_graph_gvoid.hpp
@@ -15,19 +15,19 @@ class compressed_graph<EV, VV, void, VId, EIndex, Alloc>
   constexpr compressed_graph& operator=(compressed_graph&&)      = default;
 
   // edge-only construction
-  template <ranges::forward_range ERng, 
+  template <forward_range ERng, 
             class                 EProj = identity, 
-            ranges::forward_range PartRng = vector<VId>>
-  requires copyable_edge<invoke_result_t<EProj, ranges::range_value_t<ERng>>, VId, EV>
+            forward_range PartRng = vector<VId>>
+  requires copyable_edge<invoke_result_t<EProj, range_value_t<ERng>>, VId, EV>
   constexpr compressed_graph(const ERng&    erng,
                              EProj          eprojection         = identity(),
                              const PartRng& partition_start_ids = vector<VId>(),
                              const Alloc&   alloc               = Alloc())
 
   // edge and vertex value construction
-  template <ranges::forward_range ERng,
-            ranges::forward_range VRng,
-            ranges::forward_range PartRng,
+  template <forward_range ERng,
+            forward_range VRng,
+            forward_range PartRng,
             class EProj = identity,
             class VProj = identity>
   constexpr compressed_graph(const ERng&    erng,
diff --git a/D3131_Containers/tex/containers.tex b/D3131_Containers/tex/containers.tex
index c3557e5..5d707a4 100644
--- a/D3131_Containers/tex/containers.tex
+++ b/D3131_Containers/tex/containers.tex
@@ -224,7 +224,7 @@ \subsubsection{Using Standard Containers for an Edgelist}
 
 \begin{lstlisting}
     using EL = vector<tuple<int, int, double>>;
-    using E  = std::ranges::range_value_t<EL>;
+    using E  = std::range_value_t<EL>;
     EL el{{1, 2, 11.1}, {1, 4, 22.2}, {2, 3, 3.33}, {2, 4, 4.44}};
     for (auto&& e : el) {
       int    sid = source_id(e);
@@ -237,7 +237,7 @@ \subsubsection{Using Standard Containers for an Edgelist}
 is the definition of the edgelist type. All other code is identical to the previous example.
 \begin{lstlisting}
     using EL = vector<edge_info<int, true, void, double>>;
-    using E  = std::ranges::range_value_t<EL>;
+    using E  = std::range_value_t<EL>;
     EL el{{1, 2, 11.1}, {1, 4, 22.2}, {2, 3, 3.33}, {2, 4, 4.44}};
     for (auto&& e : el) {
       int    sid = source_id(e);
diff --git a/D9903/src/degree.hpp b/D9903/src/degree.hpp
index faed2dc..2c55a6e 100644
--- a/D9903/src/degree.hpp
+++ b/D9903/src/degree.hpp
@@ -1,4 +1,4 @@
 template <index_adjacency_list G, 
-          ranges::random_access_range D>
-requires is_integral_v<ranges::range_value_t<D>>
+          random_access_range D>
+requires is_integral_v<range_value_t<D>>
 void degrees(const G& graph, D& degrees_per_vertex);
\ No newline at end of file
diff --git a/tex/P1709-preamble.tex b/tex/P1709-preamble.tex
index 32f2997..a4c12c3 100644
--- a/tex/P1709-preamble.tex
+++ b/tex/P1709-preamble.tex
@@ -130,6 +130,7 @@
 \newcommand{\constraints}{\Fundesc{Constraints}}
 \newcommand{\mandates}{\Fundesc{Mandates}}
 \newcommand{\preconditions}{\Fundesc{Preconditions}}
+\newcommand{\hardprecond}{\Fundesc{Hardened preconditions}}
 \newcommand{\effects}{\Fundesc{Effects}}
 \newcommand{\sync}{\Fundesc{Synchronization}}
 \newcommand{\postconditions}{\Fundesc{Postconditions}}
@@ -140,6 +141,8 @@
 \newcommand{\remarks}{\Fundesc{Remarks}}
 \newcommand{\errors}{\Fundesc{Error conditions}}
 
+%%\newcommand{\concept}[1]{\textit{#1}}
+
 %% \usepackage[⟨options⟩]{fancyhdr}
 \usepackage{fancyhdr}
 \pagestyle{fancy}
diff --git a/tex/conventions.tex b/tex/conventions.tex
index 1d37902..2607e5b 100644
--- a/tex/conventions.tex
+++ b/tex/conventions.tex
@@ -19,7 +19,7 @@ \section{Naming Conventions}
      \hline
      \tcode{V}          & \tcode{vertex_t<G>}               &                      & Vertex descriptor                                                                                                                                                                                \\
                         & \tcode{vertex_reference_t<G>}     & \tcode{u,v}          & Vertex descriptor reference. \tcode{u} is the source (or only) vertex. \tcode{v} is the target vertex.                                                                                           \\
-     \tcode{VId}        & \tcode{vertex_id_t<G>}            & \tcode{uid,vid,seed} & Vertex id. \tcode{uid} is the source (or only) vertex id. \tcode{vid} is the target vertex id.                                                                                                   \\
+     \tcode{VId}        & \tcode{vertex_id_t<G>}            & \tcode{uid,vid,source} & Vertex id. \tcode{uid} is the source (or only) vertex id. \tcode{vid} is the target vertex id.                                                                                                   \\
      \tcode{VV}         & \tcode{vertex_value_t<G>}         & \tcode{val}          & Vertex Value, value or reference. This can be either the user-defined value on a vertex, or a value returned by a function object (e.g. \tcode{VVF}) that is related to the vertex.              \\
      \tcode{VR}         & \tcode{vertex_range_t<G>}         & \tcode{ur,vr}        & Vertex Range                                                                                                                                                                                     \\
      \tcode{VI}         & \tcode{vertex_iterator_t<G>}      & \tcode{ui,vi}        & Vertex Iterator. \tcode{ui} is the source (or only)                                                                                                                                              \\
diff --git a/tex/specification.tex b/tex/specification.tex
index 1bbb503..cb92bb3 100644
--- a/tex/specification.tex
+++ b/tex/specification.tex
@@ -81,15 +81,15 @@ \subsection{Concepts}
 namespace std::graph {
 
 template <class G>
-concept vertex_range = ranges::forward_range<vertex_range_t<G>> && 
+concept vertex_range = forward_range<vertex_range_t<G>> && 
                        ranges::sized_range<vertex_range_t<G>> &&
 requires(G&& g, vertex_iterator_t<G> ui) {
-  { vertices(g) } -> ranges::forward_range;
+  { vertices(g) } -> forward_range;
   vertex_id(g, ui);
 };
 
 template <class G, class ER>
-concept targeted_edge = ranges::forward_range<ER> && 
+concept targeted_edge = forward_range<ER> && 
 requires(G&& g, ranges::range_reference_t<ER> uv) {
   target_id(g, uv);
   target(g, uv);
@@ -105,8 +105,8 @@ \subsection{Concepts}
 template <class G>
 concept adjacency_list = vertex_range<G> && targeted_edge<G, edge_t<G>> &&
       requires(G&& g, vertex_reference_t<G> u, vertex_id_t<G> uid) {
-  { edges(g, u) } -> ranges::forward_range;
-  { edges(g, uid) } -> ranges::forward_range;
+  { edges(g, u) } -> forward_range;
+  { edges(g, uid) } -> forward_range;
 };
 
 template <class G>
@@ -198,16 +198,16 @@ \subsection{Header \tcode{<compressed_graph>} synopsis [graph.syn]}
   constexpr compressed_graph& operator=(const compressed_graph&) = default;
   constexpr compressed_graph& operator=(compressed_graph&&)      = default;
 
-  template <ranges::forward_range ERng, class EProj = identity>
-  requires copyable_edge<invoke_result<EProj, ranges::range_value_t<ERng>>, VId, EV>
+  template <forward_range ERng, class EProj = identity>
+  requires copyable_edge<invoke_result<EProj, range_value_t<ERng>>, VId, EV>
   constexpr compressed_graph(const ERng&  erng, 
                       EProj        eprojection, 
                       const Alloc& alloc = Alloc());
 
-  template <ranges::forward_range ERng, ranges::forward_range VRng,
+  template <forward_range ERng, forward_range VRng,
             class EProj = identity,     class VProj = identity>
-  requires copyable_edge<invoke_result<EProj, ranges::range_value_t<ERng>>, VId, EV> &&
-           copyable_vertex<invoke_result<VProj, ranges::range_value_t<VRng>>, VId, VV>
+  requires copyable_edge<invoke_result<EProj, range_value_t<ERng>>, VId, EV> &&
+           copyable_vertex<invoke_result<VProj, range_value_t<VRng>>, VId, VV>
   constexpr compressed_graph(const ERng&  erng,
                       const VRng&  vrng,
                       EProj        eprojection = {},
@@ -225,25 +225,25 @@ \subsection{Header \tcode{<compressed_graph>} synopsis [graph.syn]}
 When \tcode{GV} is not \tcode{void} the following constructors are also available.
 
 \begin{lstlisting}
-  template <ranges::forward_range ERng, class EProj = identity>
-  requires copyable_edge<invoke_result<EProj, ranges::range_value_t<ERng>>, VId, EV>
+  template <forward_range ERng, class EProj = identity>
+  requires copyable_edge<invoke_result<EProj, range_value_t<ERng>>, VId, EV>
   constexpr compressed_graph(const graph_value_type& value, 
                       const ERng&             erng, 
                       EProj                   eprojection, 
                       const Alloc&            alloc = Alloc());
   
-  template <ranges::forward_range ERng, class EProj = identity>
-  requires copyable_edge<invoke_result<EProj, ranges::range_value_t<ERng>>, VId, EV>
+  template <forward_range ERng, class EProj = identity>
+  requires copyable_edge<invoke_result<EProj, range_value_t<ERng>>, VId, EV>
   constexpr compressed_graph(graph_value_type&& value,
                       const ERng&        erng, 
                       EProj              eprojection, 
                       const Alloc&       alloc = Alloc());
 
 
-  template <ranges::forward_range ERng, ranges::forward_range VRng,
+  template <forward_range ERng, forward_range VRng,
             class EProj = identity,     class VProj = identity>
-  requires copyable_edge<invoke_result<EProj, ranges::range_value_t<ERng>>, VId, EV> &&
-           copyable_vertex<invoke_result<VProj, ranges::range_value_t<VRng>>, VId, VV>
+  requires copyable_edge<invoke_result<EProj, range_value_t<ERng>>, VId, EV> &&
+           copyable_vertex<invoke_result<VProj, range_value_t<VRng>>, VId, VV>
   constexpr compressed_graph(const graph_value_type& value,
                       const ERng&             erng,
                       const VRng&             vrng,
@@ -251,10 +251,10 @@ \subsection{Header \tcode{<compressed_graph>} synopsis [graph.syn]}
                       VProj                   vprojection = {},
                       const Alloc&            alloc       = Alloc());
 
-  template <ranges::forward_range ERng, ranges::forward_range VRng,
+  template <forward_range ERng, forward_range VRng,
             class EProj = identity,     class VProj = identity>
-  requires copyable_edge<invoke_result<EProj, ranges::range_value_t<ERng>>, VId, EV> &&
-           copyable_vertex<invoke_result<VProj, ranges::range_value_t<VRng>>, VId, VV>
+  requires copyable_edge<invoke_result<EProj, range_value_t<ERng>>, VId, EV> &&
+           copyable_vertex<invoke_result<VProj, range_value_t<VRng>>, VId, VV>
   constexpr compressed_graph(graph_value_type&& value,
                       const ERng&        erng,
                       const VRng&        vrng,