okstra 0.130.4 → 0.131.0

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/density.py

@@ -1,396 +0,0 @@
-"""Fast algorithms for the densest subgraph problem"""
-
-import math
-
-import networkx as nx
-
-__all__ = ["densest_subgraph"]
-
-
-def _greedy_plus_plus(G, iterations):
-    if G.number_of_edges() == 0:
-        return 0.0, set()
-    if iterations < 1:
-        raise ValueError(
-            f"The number of iterations must be an integer >= 1. Provided: {iterations}"
-        )
-
-    loads = {node: 0 for node in G.nodes}  # Load vector for Greedy++.
-    best_density = 0.0  # Highest density encountered.
-    best_subgraph = set()  # Nodes of the best subgraph found.
-
-    for _ in range(iterations):
-        # Initialize heap for fast access to minimum weighted degree.
-        heap = nx.utils.BinaryHeap()
-
-        # Compute initial weighted degrees and add nodes to the heap.
-        for node, degree in G.degree:
-            heap.insert(node, loads[node] + degree)
-        # Set up tracking for current graph state.
-        remaining_nodes = set(G.nodes)
-        num_edges = G.number_of_edges()
-        current_degrees = dict(G.degree)
-
-        while remaining_nodes:
-            num_nodes = len(remaining_nodes)
-
-            # Current density of the (implicit) graph
-            current_density = num_edges / num_nodes
-
-            # Update the best density.
-            if current_density > best_density:
-                best_density = current_density
-                best_subgraph = set(remaining_nodes)
-
-            # Pop the node with the smallest weighted degree.
-            node, _ = heap.pop()
-            if node not in remaining_nodes:
-                continue  # Skip nodes already removed.
-
-            # Update the load of the popped node.
-            loads[node] += current_degrees[node]
-
-            # Update neighbors' degrees and the heap.
-            for neighbor in G.neighbors(node):
-                if neighbor in remaining_nodes:
-                    current_degrees[neighbor] -= 1
-                    num_edges -= 1
-                    heap.insert(neighbor, loads[neighbor] + current_degrees[neighbor])
-
-            # Remove the node from the remaining nodes.
-            remaining_nodes.remove(node)
-
-    return best_density, best_subgraph
-
-
-def _fractional_peeling(G, b, x, node_to_idx, edge_to_idx):
-    """
-    Optimized fractional peeling using NumPy arrays.
-
-    Parameters
-    ----------
-    G : networkx.Graph
-        The input graph.
-    b : numpy.ndarray
-        Induced load vector.
-    x : numpy.ndarray
-        Fractional edge values.
-    node_to_idx : dict
-        Mapping from node to index.
-    edge_to_idx : dict
-        Mapping from edge to index.
-
-    Returns
-    -------
-    best_density : float
-        The best density found.
-    best_subgraph : set
-        The subset of nodes defining the densest subgraph.
-    """
-    heap = nx.utils.BinaryHeap()
-
-    remaining_nodes = set(G.nodes)
-
-    # Initialize heap with b values
-    for idx, node in enumerate(G):
-        heap.insert(node, b[idx])
-
-    num_edges = G.number_of_edges()
-
-    best_density = 0.0
-    best_subgraph = set()
-
-    while remaining_nodes:
-        num_nodes = len(remaining_nodes)
-        current_density = num_edges / num_nodes
-
-        if current_density > best_density:
-            best_density = current_density
-            best_subgraph = set(remaining_nodes)
-
-        # Pop the node with the smallest b
-        node, _ = heap.pop()
-        while node not in remaining_nodes:
-            node, _ = heap.pop()  # Clean the heap from stale values
-
-        # Update neighbors b values by subtracting fractional x value
-        for neighbor in G.neighbors(node):
-            if neighbor in remaining_nodes:
-                neighbor_idx = node_to_idx[neighbor]
-                # Take off fractional value
-                b[neighbor_idx] -= x[edge_to_idx[(neighbor, node)]]
-                num_edges -= 1
-                heap.insert(neighbor, b[neighbor_idx])
-
-        remaining_nodes.remove(node)  # peel off node
-
-    return best_density, best_subgraph
-
-
-def _fista(G, iterations):
-    if G.number_of_edges() == 0:
-        return 0.0, set()
-    if iterations < 1:
-        raise ValueError(
-            f"The number of iterations must be an integer >= 1. Provided: {iterations}"
-        )
-    import numpy as np
-
-    # 1. Node Mapping: Assign a unique index to each node and edge
-    node_to_idx = {node: idx for idx, node in enumerate(G)}
-    num_nodes = G.number_of_nodes()
-    num_undirected_edges = G.number_of_edges()
-
-    # 2. Edge Mapping: Assign a unique index to each bidirectional edge
-    bidirectional_edges = [(u, v) for u, v in G.edges] + [(v, u) for u, v in G.edges]
-    edge_to_idx = {edge: idx for idx, edge in enumerate(bidirectional_edges)}
-
-    num_edges = len(bidirectional_edges)
-
-    # 3. Reverse Edge Mapping: Map each (bidirectional) edge to its reverse edge index
-    reverse_edge_idx = np.empty(num_edges, dtype=np.int32)
-    for idx in range(num_undirected_edges):
-        reverse_edge_idx[idx] = num_undirected_edges + idx
-    for idx in range(num_undirected_edges, 2 * num_undirected_edges):
-        reverse_edge_idx[idx] = idx - num_undirected_edges
-
-    # 4. Initialize Variables as NumPy Arrays
-    x = np.full(num_edges, 0.5, dtype=np.float32)
-    y = x.copy()
-    z = np.zeros(num_edges, dtype=np.float32)
-    b = np.zeros(num_nodes, dtype=np.float32)  # Induced load vector
-    tk = 1.0  # Momentum term
-
-    # 5. Precompute Edge Source Indices
-    edge_src_indices = np.array(
-        [node_to_idx[u] for u, _ in bidirectional_edges], dtype=np.int32
-    )
-
-    # 6. Compute Learning Rate
-    max_degree = max(deg for _, deg in G.degree)
-    # 0.9 for floating point errs when max_degree is very large
-    learning_rate = 0.9 / max_degree
-
-    # 7. Iterative Updates
-    for _ in range(iterations):
-        # 7a. Update b: sum y over outgoing edges for each node
-        b[:] = 0.0  # Reset b to zero
-        np.add.at(b, edge_src_indices, y)  # b_u = \sum_{v : (u,v) \in E(G)} y_{uv}
-
-        # 7b. Compute z, z_{uv} = y_{uv} - 2 * learning_rate * b_u
-        z = y - 2.0 * learning_rate * b[edge_src_indices]
-
-        # 7c. Update Momentum Term
-        tknew = (1.0 + math.sqrt(1 + 4.0 * tk**2)) / 2.0
-
-        # 7d. Update x in a vectorized manner, x_{uv} = (z_{uv} - z_{vu} + 1.0) / 2.0
-        new_xuv = (z - z[reverse_edge_idx] + 1.0) / 2.0
-        clamped_x = np.clip(new_xuv, 0.0, 1.0)  # Clamp x_{uv} between 0 and 1
-
-        # Update y using the FISTA update formula (similar to gradient descent)
-        y = (
-            clamped_x
-            + ((tk - 1.0) / tknew) * (clamped_x - x)
-            + (tk / tknew) * (clamped_x - y)
-        )
-
-        # Update x
-        x = clamped_x
-
-        # Update tk, the momemntum term
-        tk = tknew
-
-    # Rebalance the b values! Otherwise performance is a bit suboptimal.
-    b[:] = 0.0
-    np.add.at(b, edge_src_indices, x)  # b_u = \sum_{v : (u,v) \in E(G)} x_{uv}
-
-    # Extract the actual (approximate) dense subgraph.
-    return _fractional_peeling(G, b, x, node_to_idx, edge_to_idx)
-
-
-ALGORITHMS = {"greedy++": _greedy_plus_plus, "fista": _fista}
-
-
-@nx.utils.not_implemented_for("directed")
-@nx.utils.not_implemented_for("multigraph")
-@nx._dispatchable
-def densest_subgraph(G, iterations=1, *, method="fista"):
-    r"""Returns an approximate densest subgraph for a graph `G`.
-
-    This function runs an iterative algorithm to find the densest subgraph,
-    and returns both the density and the subgraph. For a discussion on the
-    notion of density used and the different algorithms available on
-    networkx, please see the Notes section below.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Undirected graph.
-
-    iterations : int, optional (default=1)
-        Number of iterations to use for the iterative algorithm. Can be
-        specified positionally or as a keyword argument.
-
-    method : string, optional (default='fista')
-        The algorithm to use to approximate the densest subgraph. Supported
-        options: 'greedy++' by Boob et al. [2]_ and 'fista' by Harb et al. [3]_.
-        Must be specified as a keyword argument. Other inputs produce a
-        ValueError.
-
-    Returns
-    -------
-    d : float
-        The density of the approximate subgraph found.
-
-    S : set
-        The subset of nodes defining the approximate densest subgraph.
-
-    Examples
-    --------
-    >>> G = nx.star_graph(4)
-    >>> nx.approximation.densest_subgraph(G, iterations=1)
-    (0.8, {0, 1, 2, 3, 4})
-
-    Notes
-    -----
-    **Problem Definition:**
-    The densest subgraph problem (DSG) asks to find the subgraph
-    $S \subseteq V(G)$ with maximum density. For a subset of the nodes of
-    $G$, $S \subseteq V(G)$, define $E(S) = \{ (u,v) : (u,v)\in E(G),
-    u\in S, v\in S \}$ as the set of edges with both endpoints in $S$.
-    The density of $S$ is defined as $|E(S)|/|S|$, the ratio between the
-    edges in the subgraph $G[S]$ and the number of nodes in that subgraph.
-    Note that this is different from the standard graph theoretic definition
-    of density, defined as $\frac{2|E(S)|}{|S|(|S|-1)}$, for historical
-    reasons.
-
-    **Exact Algorithms:**
-    The densest subgraph problem is polynomial time solvable using maximum
-    flow, commonly referred to as Goldberg's algorithm. However, the
-    algorithm is quite involved. It first binary searches on the optimal
-    density, $d^\ast$. For a guess of the density $d$, it sets up a flow
-    network $G'$ with size $O(m)$. The maximum flow solution either
-    informs the algorithm that no subgraph with density $d$ exists, or it
-    provides a subgraph with density at least $d$. However, this is
-    inherently bottlenecked by the maximum flow algorithm. For example, [2]_
-    notes that Goldberg’s algorithm was not feasible on many large graphs
-    even though they used a highly optimized maximum flow library.
-
-    **Charikar's Greedy Peeling:**
-    While exact solution algorithms are quite involved, there are several
-    known approximation algorithms for the densest subgraph problem.
-
-    Charikar [1]_ described a very simple 1/2-approximation algorithm for DSG
-    known as the greedy "peeling" algorithm. The algorithm creates an
-    ordering of the nodes as follows. The first node $v_1$ is the one with
-    the smallest degree in $G$ (ties broken arbitrarily). It selects
-    $v_2$ to be the smallest degree node in $G \setminus v_1$. Letting
-    $G_i$ be the graph after removing $v_1, ..., v_i$ (with $G_0=G$),
-    the algorithm returns the graph among $G_0, ..., G_n$ with the highest
-    density.
-
-    **Greedy++:**
-    Boob et al. [2]_ generalized this algorithm into Greedy++, an iterative
-    algorithm that runs several rounds of "peeling". In fact, Greedy++ with 1
-    iteration is precisely Charikar's algorithm. The algorithm converges to a
-    $(1-\epsilon)$ approximate densest subgraph in $O(\Delta(G)\log
-    n/\epsilon^2)$ iterations, where $\Delta(G)$ is the maximum degree,
-    and $n$ is the number of nodes in $G$. The algorithm also has other
-    desirable properties as shown by [4]_ and [5]_.
-
-    **FISTA Algorithm:**
-    Harb et al. [3]_ gave a faster and more scalable algorithm using ideas
-    from quadratic programming for the densest subgraph, which is based on a
-    fast iterative shrinkage-thresholding algorithm (FISTA) algorithm. It is
-    known that computing the densest subgraph can be formulated as the
-    following convex optimization problem:
-
-    Minimize $\sum_{u \in V(G)} b_u^2$
-
-    Subject to:
-
-    $b_u = \sum_{v: \{u,v\} \in E(G)} x_{uv}$ for all $u \in V(G)$
-
-    $x_{uv} + x_{vu} = 1.0$ for all $\{u,v\} \in E(G)$
-
-    $x_{uv} \geq 0, x_{vu} \geq 0$ for all $\{u,v\} \in E(G)$
-
-    Here, $x_{uv}$ represents the fraction of edge $\{u,v\}$ assigned to
-    $u$, and $x_{vu}$ to $v$.
-
-    The FISTA algorithm efficiently solves this convex program using gradient
-    descent with projections. For a learning rate $\alpha$, the algorithm
-    does:
-
-    1. **Initialization**: Set $x^{(0)}_{uv} = x^{(0)}_{vu} = 0.5$ for all
-    edges as a feasible solution.
-
-    2. **Gradient Update**: For iteration $k\geq 1$, set
-    $x^{(k+1)}_{uv} = x^{(k)}_{uv} - 2 \alpha \sum_{v: \{u,v\} \in E(G)}
-    x^{(k)}_{uv}$. However, now $x^{(k+1)}_{uv}$ might be infeasible!
-    To ensure feasibility, we project $x^{(k+1)}_{uv}$.
-
-    3. **Projection to the Feasible Set**: Compute
-    $b^{(k+1)}_u = \sum_{v: \{u,v\} \in E(G)} x^{(k)}_{uv}$ for all
-    nodes $u$. Define $z^{(k+1)}_{uv} = x^{(k+1)}_{uv} - 2 \alpha
-    b^{(k+1)}_u$. Update $x^{(k+1)}_{uv} =
-    CLAMP((z^{(k+1)}_{uv} - z^{(k+1)}_{vu} + 1.0) / 2.0)$, where
-    $CLAMP(x) = \max(0, \min(1, x))$.
-
-    With a learning rate of $\alpha=1/\Delta(G)$, where $\Delta(G)$ is
-    the maximum degree, the algorithm converges to the optimum solution of
-    the convex program.
-
-    **Fractional Peeling:**
-    To obtain a **discrete** subgraph, we use fractional peeling, an
-    adaptation of the standard peeling algorithm which peels the minimum
-    degree vertex in each iteration, and returns the densest subgraph found
-    along the way. Here, we instead peel the vertex with the smallest
-    induced load $b_u$:
-
-    1. Compute $b_u$ and $x_{uv}$.
-
-    2. Iteratively remove the vertex with the smallest $b_u$, updating its
-    neighbors' load by $x_{vu}$.
-
-    Fractional peeling transforms the approximately optimal fractional
-    values $b_u, x_{uv}$ into a discrete subgraph. Unlike traditional
-    peeling, which removes the lowest-degree node, this method accounts for
-    fractional edge contributions from the convex program.
-
-    This approach is both scalable and theoretically sound, ensuring a quick
-    approximation of the densest subgraph while leveraging fractional load
-    balancing.
-
-    References
-    ----------
-    .. [1] Charikar, Moses. "Greedy approximation algorithms for finding dense
-       components in a graph." In International workshop on approximation
-       algorithms for combinatorial optimization, pp. 84-95. Berlin, Heidelberg:
-       Springer Berlin Heidelberg, 2000.
-
-    .. [2] Boob, Digvijay, Yu Gao, Richard Peng, Saurabh Sawlani, Charalampos
-       Tsourakakis, Di Wang, and Junxing Wang. "Flowless: Extracting densest
-       subgraphs without flow computations." In Proceedings of The Web Conference
-       2020, pp. 573-583. 2020.
-
-    .. [3] Harb, Elfarouk, Kent Quanrud, and Chandra Chekuri. "Faster and scalable
-       algorithms for densest subgraph and decomposition." Advances in Neural
-       Information Processing Systems 35 (2022): 26966-26979.
-
-    .. [4] Harb, Elfarouk, Kent Quanrud, and Chandra Chekuri. "Convergence to
-       lexicographically optimal base in a (contra) polymatroid and applications
-       to densest subgraph and tree packing." arXiv preprint arXiv:2305.02987
-       (2023).
-
-    .. [5] Chekuri, Chandra, Kent Quanrud, and Manuel R. Torres. "Densest
-       subgraph: Supermodularity, iterative peeling, and flow." In Proceedings of
-       the 2022 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pp.
-       1531-1555. Society for Industrial and Applied Mathematics, 2022.
-    """
-    try:
-        algo = ALGORITHMS[method]
-    except KeyError as e:
-        raise ValueError(f"{method} is not a valid choice for an algorithm.") from e
-
-    return algo(G, iterations)

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/distance_measures.py

@@ -1,150 +0,0 @@
-"""Distance measures approximated metrics."""
-
-import networkx as nx
-from networkx.utils.decorators import py_random_state
-
-__all__ = ["diameter"]
-
-
-@py_random_state(1)
-@nx._dispatchable(name="approximate_diameter")
-def diameter(G, seed=None):
-    """Returns a lower bound on the diameter of the graph G.
-
-    The function computes a lower bound on the diameter (i.e., the maximum eccentricity)
-    of a directed or undirected graph G. The procedure used varies depending on the graph
-    being directed or not.
-
-    If G is an `undirected` graph, then the function uses the `2-sweep` algorithm [1]_.
-    The main idea is to pick the farthest node from a random node and return its eccentricity.
-
-    Otherwise, if G is a `directed` graph, the function uses the `2-dSweep` algorithm [2]_,
-    The procedure starts by selecting a random source node $s$ from which it performs a
-    forward and a backward BFS. Let $a_1$ and $a_2$ be the farthest nodes in the forward and
-    backward cases, respectively. Then, it computes the backward eccentricity of $a_1$ using
-    a backward BFS and the forward eccentricity of $a_2$ using a forward BFS.
-    Finally, it returns the best lower bound between the two.
-
-    In both cases, the time complexity is linear with respect to the size of G.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    seed : integer, random_state, or None (default)
-        Indicator of random number generation state.
-        See :ref:`Randomness<randomness>`.
-
-    Returns
-    -------
-    d : integer
-       Lower Bound on the Diameter of G
-
-    Examples
-    --------
-    >>> G = nx.path_graph(10)  # undirected graph
-    >>> nx.diameter(G)
-    9
-    >>> G = nx.cycle_graph(3, create_using=nx.DiGraph)  # directed graph
-    >>> nx.diameter(G)
-    2
-
-    Raises
-    ------
-    NetworkXError
-        If the graph is empty or
-        If the graph is undirected and not connected or
-        If the graph is directed and not strongly connected.
-
-    See Also
-    --------
-    networkx.algorithms.distance_measures.diameter
-
-    References
-    ----------
-    .. [1] Magnien, Clémence, Matthieu Latapy, and Michel Habib.
-       *Fast computation of empirically tight bounds for the diameter of massive graphs.*
-       Journal of Experimental Algorithmics (JEA), 2009.
-       https://arxiv.org/pdf/0904.2728.pdf
-    .. [2] Crescenzi, Pierluigi, Roberto Grossi, Leonardo Lanzi, and Andrea Marino.
-       *On computing the diameter of real-world directed (weighted) graphs.*
-       International Symposium on Experimental Algorithms. Springer, Berlin, Heidelberg, 2012.
-       https://courses.cs.ut.ee/MTAT.03.238/2014_fall/uploads/Main/diameter.pdf
-    """
-    # if G is empty
-    if not G:
-        raise nx.NetworkXError("Expected non-empty NetworkX graph!")
-    # if there's only a node
-    if G.number_of_nodes() == 1:
-        return 0
-    # if G is directed
-    if G.is_directed():
-        return _two_sweep_directed(G, seed)
-    # else if G is undirected
-    return _two_sweep_undirected(G, seed)
-
-
-def _two_sweep_undirected(G, seed):
-    """Helper function for finding a lower bound on the diameter
-        for undirected Graphs.
-
-        The idea is to pick the farthest node from a random node
-        and return its eccentricity.
-
-        ``G`` is a NetworkX undirected graph.
-
-    .. note::
-
-        ``seed`` is a random.Random or numpy.random.RandomState instance
-    """
-    # select a random source node
-    source = seed.choice(list(G))
-    # get the distances to the other nodes
-    distances = nx.shortest_path_length(G, source)
-    # if some nodes have not been visited, then the graph is not connected
-    if len(distances) != len(G):
-        raise nx.NetworkXError("Graph not connected.")
-    # take a node that is (one of) the farthest nodes from the source
-    *_, node = distances
-    # return the eccentricity of the node
-    return nx.eccentricity(G, node)
-
-
-def _two_sweep_directed(G, seed):
-    """Helper function for finding a lower bound on the diameter
-        for directed Graphs.
-
-        It implements 2-dSweep, the directed version of the 2-sweep algorithm.
-        The algorithm follows the following steps.
-        1. Select a source node $s$ at random.
-        2. Perform a forward BFS from $s$ to select a node $a_1$ at the maximum
-        distance from the source, and compute $LB_1$, the backward eccentricity of $a_1$.
-        3. Perform a backward BFS from $s$ to select a node $a_2$ at the maximum
-        distance from the source, and compute $LB_2$, the forward eccentricity of $a_2$.
-        4. Return the maximum between $LB_1$ and $LB_2$.
-
-        ``G`` is a NetworkX directed graph.
-
-    .. note::
-
-        ``seed`` is a random.Random or numpy.random.RandomState instance
-    """
-    # get a new digraph G' with the edges reversed in the opposite direction
-    G_reversed = G.reverse()
-    # select a random source node
-    source = seed.choice(list(G))
-    # compute forward distances from source
-    forward_distances = nx.shortest_path_length(G, source)
-    # compute backward distances  from source
-    backward_distances = nx.shortest_path_length(G_reversed, source)
-    # if either the source can't reach every node or not every node
-    # can reach the source, then the graph is not strongly connected
-    n = len(G)
-    if len(forward_distances) != n or len(backward_distances) != n:
-        raise nx.NetworkXError("DiGraph not strongly connected.")
-    # take a node a_1 at the maximum distance from the source in G
-    *_, a_1 = forward_distances
-    # take a node a_2 at the maximum distance from the source in G_reversed
-    *_, a_2 = backward_distances
-    # return the max between the backward eccentricity of a_1 and the forward eccentricity of a_2
-    return max(nx.eccentricity(G_reversed, a_1), nx.eccentricity(G, a_2))

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/dominating_set.py

@@ -1,149 +0,0 @@
-"""Functions for finding node and edge dominating sets.
-
-A `dominating set`_ for an undirected graph *G* with vertex set *V*
-and edge set *E* is a subset *D* of *V* such that every vertex not in
-*D* is adjacent to at least one member of *D*. An `edge dominating set`_
-is a subset *F* of *E* such that every edge not in *F* is
-incident to an endpoint of at least one edge in *F*.
-
-.. _dominating set: https://en.wikipedia.org/wiki/Dominating_set
-.. _edge dominating set: https://en.wikipedia.org/wiki/Edge_dominating_set
-
-"""
-
-import networkx as nx
-
-from ...utils import not_implemented_for
-from ..matching import maximal_matching
-
-__all__ = ["min_weighted_dominating_set", "min_edge_dominating_set"]
-
-
-# TODO Why doesn't this algorithm work for directed graphs?
-@not_implemented_for("directed")
-@nx._dispatchable(node_attrs="weight")
-def min_weighted_dominating_set(G, weight=None):
-    r"""Returns a dominating set that approximates the minimum weight node
-    dominating set.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Undirected graph.
-
-    weight : string
-        The node attribute storing the weight of an node. If provided,
-        the node attribute with this key must be a number for each
-        node. If not provided, each node is assumed to have weight one.
-
-    Returns
-    -------
-    min_weight_dominating_set : set
-        A set of nodes, the sum of whose weights is no more than `(\log
-        w(V)) w(V^*)`, where `w(V)` denotes the sum of the weights of
-        each node in the graph and `w(V^*)` denotes the sum of the
-        weights of each node in the minimum weight dominating set.
-
-    Examples
-    --------
-    >>> G = nx.Graph([(0, 1), (0, 4), (1, 4), (1, 2), (2, 3), (3, 4), (2, 5)])
-    >>> nx.approximation.min_weighted_dominating_set(G)
-    {1, 2, 4}
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If G is directed.
-
-    Notes
-    -----
-    This algorithm computes an approximate minimum weighted dominating
-    set for the graph `G`. The returned solution has weight `(\log
-    w(V)) w(V^*)`, where `w(V)` denotes the sum of the weights of each
-    node in the graph and `w(V^*)` denotes the sum of the weights of
-    each node in the minimum weight dominating set for the graph.
-
-    This implementation of the algorithm runs in $O(m)$ time, where $m$
-    is the number of edges in the graph.
-
-    References
-    ----------
-    .. [1] Vazirani, Vijay V.
-           *Approximation Algorithms*.
-           Springer Science & Business Media, 2001.
-
-    """
-    # The unique dominating set for the null graph is the empty set.
-    if len(G) == 0:
-        return set()
-
-    # This is the dominating set that will eventually be returned.
-    dom_set = set()
-
-    def _cost(node_and_neighborhood):
-        """Returns the cost-effectiveness of greedily choosing the given
-        node.
-
-        `node_and_neighborhood` is a two-tuple comprising a node and its
-        closed neighborhood.
-
-        """
-        v, neighborhood = node_and_neighborhood
-        return G.nodes[v].get(weight, 1) / len(neighborhood - dom_set)
-
-    # This is a set of all vertices not already covered by the
-    # dominating set.
-    vertices = set(G)
-    # This is a dictionary mapping each node to the closed neighborhood
-    # of that node.
-    neighborhoods = {v: {v} | set(G[v]) for v in G}
-
-    # Continue until all vertices are adjacent to some node in the
-    # dominating set.
-    while vertices:
-        # Find the most cost-effective node to add, along with its
-        # closed neighborhood.
-        dom_node, min_set = min(neighborhoods.items(), key=_cost)
-        # Add the node to the dominating set and reduce the remaining
-        # set of nodes to cover.
-        dom_set.add(dom_node)
-        del neighborhoods[dom_node]
-        vertices -= min_set
-
-    return dom_set
-
-
-@nx._dispatchable
-def min_edge_dominating_set(G):
-    r"""Returns minimum cardinality edge dominating set.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-      Undirected graph
-
-    Returns
-    -------
-    min_edge_dominating_set : set
-      Returns a set of dominating edges whose size is no more than 2 * OPT.
-
-    Examples
-    --------
-    >>> G = nx.petersen_graph()
-    >>> nx.approximation.min_edge_dominating_set(G)
-    {(0, 1), (4, 9), (6, 8), (5, 7), (2, 3)}
-
-    Raises
-    ------
-    ValueError
-        If the input graph `G` is empty.
-
-    Notes
-    -----
-    The algorithm computes an approximate solution to the edge dominating set
-    problem. The result is no more than 2 * OPT in terms of size of the set.
-    Runtime of the algorithm is $O(|E|)$.
-    """
-    if not G:
-        raise ValueError("Expected non-empty NetworkX graph!")
-    return maximal_matching(G)