D3128: fully specify triangle_count, directed_triangle_count, label propagation, and articulation points sections

- Triangle counting: new full spec for triangle_count (undirected) and
  directed_triangle_count, with mandates, preconditions, effects,
  returns, complexity, and remarks; corrected complexity from O(N^3)
  to O(m^(3/2)); fixed characteristic tables as non-floating to prevent
  drift; added directed_triangle_count.hpp prototype source file
- Label propagation: unified two separate itemdescr blocks into one;
  added mandates, throws (std::bad_alloc), step-by-step effects,
  expanded remarks; fixed Throws? No→Yes; documented empty_label
  sentinel overload; removed requires clauses from lp.hpp prototype
- Articulation points: expanded description with Hopcroft-Tarjan DFS
  explanation, disc/low-link definitions, root and non-root rules;
  added mandates, throws, expanded effects and remarks; fixed Throws? No→Yes
- Fixed \tcode inside math mode errors throughout new sections

Author: pratzl

D3128_Algorithms/src/directed_triangle_count.hpp

@@ -0,0 +1,6 @@
+/*
+ * Directed Triangle Counting Algorithm
+ */
+template <adjacency_list G>
+requires ordered_vertex_edges<G>
+[[nodiscard]] size_t directed_triangle_count(G&& g) noexcept;

D3128_Algorithms/src/lp.hpp

@@ -5,9 +5,6 @@ template <adjacency_list G,
           class          Label,
           class Gen = default_random_engine,
           class T   = size_t>
-requires vertex_property_map_for<Label, G> &&
-         equality_comparable<vertex_property_map_value_t<Label>> &&
-         uniform_random_bit_generator<remove_cvref_t<Gen>>
 void label_propagation(G&&    g,
                        Label& label,
                        Gen&&  rng       = default_random_engine{},
@@ -17,9 +14,6 @@ template <adjacency_list G,
           class          Label,
           class Gen = default_random_engine,
           class T   = size_t>
-requires vertex_property_map_for<Label, G> &&
-         equality_comparable<vertex_property_map_value_t<Label>> &&
-         uniform_random_bit_generator<remove_cvref_t<Gen>>
 void label_propagation(G&&                                   g,
                        Label&                                label,
                        vertex_property_map_value_t<Label>    empty_label,

D3128_Algorithms/src/shortest_paths_helpers.hpp

@@ -4,24 +4,25 @@ concept edge_value_function = // For exposition only
       std::invocable<WF, const G&, E> && !std::is_void_v<std::invoke_result_t<WF, const G&, E>>;
 
 template <class G, class WF, class DistanceValue, class Compare, class Combine>
-concept basic_edge_weight_function = // For exposition only
-      edge_value_function<WF, std::remove_reference_t<G>, edge_t<G>> &&
-      is_arithmetic_v<DistanceValue> &&
-      std::strict_weak_order<Compare, DistanceValue, DistanceValue> &&
-      std::assignable_from<
-            std::add_lvalue_reference_t<DistanceValue>,
-            invoke_result_t<Combine,
-                            DistanceValue,
-                            invoke_result_t<WF, const std::remove_reference_t<G>&, edge_t<G>>>>;
+// For exposition only
+template <class G, class WF, class DistanceValue, class Compare, class Combine>
+concept basic_edge_weight_function = // e.g. weight(uv)
+      edge_value_function<WF, std::remove_reference_t<G>, edge_t<G>> && 
+      strict_weak_order<Compare, DistanceValue, DistanceValue> &&
+      assignable_from<add_lvalue_reference_t<DistanceValue>,
+            invoke_result_t<Combine, DistanceValue, invoke_result_t<WF, edge_t<G>>>>;
 
+// For exposition only
 template <class G, class WF, class DistanceValue>
-concept edge_weight_function = // For exposition only
-      is_arithmetic_v<invoke_result_t<WF, const std::remove_reference_t<G>&, edge_t<G>>> &&
+concept edge_weight_function = // e.g. weight(uv)
+      is_arithmetic_v<edge_value_function<WF, std::remove_reference_t<G>, edge_t<G>>> && 
+      is_arithmetic_v<DistanceValue> && 
+      is_arithmetic_v<invoke_result_t<WF, edge_t<G>>> &&
       basic_edge_weight_function<G,
-                                 WF,
-                                 DistanceValue,
-                                 less<DistanceValue>,
-                                 plus<DistanceValue>>;
+                                  WF,
+                                  DistanceValue,
+                                  less<DistanceValue>,
+                                  plus<DistanceValue>>;
 
 template <class DistanceValue>
 constexpr auto shortest_path_infinite_distance() {