okstra 0.130.4 → 0.131.0

package/runtime/python/okstra_vendor/networkx/algorithms/connectivity/kcomponents.py

@@ -1,220 +0,0 @@
-"""
-Moody and White algorithm for k-components
-"""
-
-from collections import defaultdict
-from itertools import combinations
-from operator import itemgetter
-
-import networkx as nx
-
-# Define the default maximum flow function.
-from networkx.algorithms.flow import edmonds_karp
-from networkx.utils import not_implemented_for
-
-default_flow_func = edmonds_karp
-
-__all__ = ["k_components"]
-
-
-@not_implemented_for("directed")
-@nx._dispatchable
-def k_components(G, flow_func=None):
-    r"""Returns the k-component structure of a graph G.
-
-    A `k`-component is a maximal subgraph of a graph G that has, at least,
-    node connectivity `k`: we need to remove at least `k` nodes to break it
-    into more components. `k`-components have an inherent hierarchical
-    structure because they are nested in terms of connectivity: a connected
-    graph can contain several 2-components, each of which can contain
-    one or more 3-components, and so forth.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    flow_func : function
-        Function to perform the underlying flow computations. Default value
-        :meth:`edmonds_karp`. This function performs better in sparse graphs with
-        right tailed degree distributions. :meth:`shortest_augmenting_path` will
-        perform better in denser graphs.
-
-    Returns
-    -------
-    k_components : dict
-        Dictionary with all connectivity levels `k` in the input Graph as keys
-        and a list of sets of nodes that form a k-component of level `k` as
-        values.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If the input graph is directed.
-
-    Examples
-    --------
-    >>> # Petersen graph has 10 nodes and it is triconnected, thus all
-    >>> # nodes are in a single component on all three connectivity levels
-    >>> G = nx.petersen_graph()
-    >>> k_components = nx.k_components(G)
-
-    Notes
-    -----
-    Moody and White [1]_ (appendix A) provide an algorithm for identifying
-    k-components in a graph, which is based on Kanevsky's algorithm [2]_
-    for finding all minimum-size node cut-sets of a graph (implemented in
-    :meth:`all_node_cuts` function):
-
-        1. Compute node connectivity, k, of the input graph G.
-
-        2. Identify all k-cutsets at the current level of connectivity using
-           Kanevsky's algorithm.
-
-        3. Generate new graph components based on the removal of
-           these cutsets. Nodes in a cutset belong to both sides
-           of the induced cut.
-
-        4. If the graph is neither complete nor trivial, return to 1;
-           else end.
-
-    This implementation also uses some heuristics (see [3]_ for details)
-    to speed up the computation.
-
-    See also
-    --------
-    node_connectivity
-    all_node_cuts
-    biconnected_components : special case of this function when k=2
-    k_edge_components : similar to this function, but uses edge-connectivity
-        instead of node-connectivity
-
-    References
-    ----------
-    .. [1]  Moody, J. and D. White (2003). Social cohesion and embeddedness:
-            A hierarchical conception of social groups.
-            American Sociological Review 68(1), 103--28.
-            http://www2.asanet.org/journals/ASRFeb03MoodyWhite.pdf
-
-    .. [2]  Kanevsky, A. (1993). Finding all minimum-size separating vertex
-            sets in a graph. Networks 23(6), 533--541.
-            http://onlinelibrary.wiley.com/doi/10.1002/net.3230230604/abstract
-
-    .. [3]  Torrents, J. and F. Ferraro (2015). Structural Cohesion:
-            Visualization and Heuristics for Fast Computation.
-            https://arxiv.org/pdf/1503.04476v1
-
-    """
-    # Dictionary with connectivity level (k) as keys and a list of
-    # sets of nodes that form a k-component as values. Note that
-    # k-components can overlap (but only k - 1 nodes).
-    k_components = defaultdict(list)
-    # Define default flow function
-    if flow_func is None:
-        flow_func = default_flow_func
-    # Bicomponents as a base to check for higher order k-components
-    for component in nx.connected_components(G):
-        # isolated nodes have connectivity 0
-        comp = set(component)
-        if len(comp) > 1:
-            k_components[1].append(comp)
-    bicomponents = [G.subgraph(c) for c in nx.biconnected_components(G)]
-    for bicomponent in bicomponents:
-        bicomp = set(bicomponent)
-        # avoid considering dyads as bicomponents
-        if len(bicomp) > 2:
-            k_components[2].append(bicomp)
-    for B in bicomponents:
-        if len(B) <= 2:
-            continue
-        k = nx.node_connectivity(B, flow_func=flow_func)
-        if k > 2:
-            k_components[k].append(set(B))
-        # Perform cuts in a DFS like order.
-        cuts = list(nx.all_node_cuts(B, k=k, flow_func=flow_func))
-        stack = [(k, _generate_partition(B, cuts, k))]
-        while stack:
-            (parent_k, partition) = stack[-1]
-            try:
-                nodes = next(partition)
-                C = B.subgraph(nodes)
-                this_k = nx.node_connectivity(C, flow_func=flow_func)
-                if this_k > parent_k and this_k > 2:
-                    k_components[this_k].append(set(C))
-                cuts = list(nx.all_node_cuts(C, k=this_k, flow_func=flow_func))
-                if cuts:
-                    stack.append((this_k, _generate_partition(C, cuts, this_k)))
-            except StopIteration:
-                stack.pop()
-
-    # This is necessary because k-components may only be reported at their
-    # maximum k level. But we want to return a dictionary in which keys are
-    # connectivity levels and values list of sets of components, without
-    # skipping any connectivity level. Also, it's possible that subsets of
-    # an already detected k-component appear at a level k. Checking for this
-    # in the while loop above penalizes the common case. Thus we also have to
-    # _consolidate all connectivity levels in _reconstruct_k_components.
-    return _reconstruct_k_components(k_components)
-
-
-def _consolidate(sets, k):
-    """Merge sets that share k or more elements.
-
-    See: http://rosettacode.org/wiki/Set_consolidation
-
-    The iterative python implementation posted there is
-    faster than this because of the overhead of building a
-    Graph and calling nx.connected_components, but it's not
-    clear for us if we can use it in NetworkX because there
-    is no licence for the code.
-
-    """
-    G = nx.Graph()
-    nodes = dict(enumerate(sets))
-    G.add_nodes_from(nodes)
-    G.add_edges_from(
-        (u, v) for u, v in combinations(nodes, 2) if len(nodes[u] & nodes[v]) >= k
-    )
-    for component in nx.connected_components(G):
-        yield set.union(*[nodes[n] for n in component])
-
-
-def _generate_partition(G, cuts, k):
-    def has_nbrs_in_partition(G, node, partition):
-        return any(n in partition for n in G[node])
-
-    components = []
-    n_in_cuts = {n for cut in cuts for n in cut}
-    nodes = {n for n, d in G.degree() if d > k} - n_in_cuts
-    H = G.subgraph(nodes)
-    for cc in map(set, nx.connected_components(H)):
-        component = cc | {n for n in n_in_cuts if has_nbrs_in_partition(G, n, cc)}
-        if len(component) < G.order():
-            components.append(component)
-    yield from _consolidate(components, k + 1)
-
-
-def _reconstruct_k_components(k_comps):
-    result = {}
-    max_k = max(k_comps) if k_comps else 0
-    for k in range(max_k, 0, -1):
-        if k == max_k:
-            result[k] = list(_consolidate(k_comps[k], k))
-        elif k not in k_comps:
-            result[k] = list(_consolidate(result[k + 1], k))
-        else:
-            nodes_at_k = set.union(*k_comps[k])
-            to_add = [c for c in result[k + 1] if any(n not in nodes_at_k for n in c)]
-            if to_add:
-                result[k] = list(_consolidate(k_comps[k] + to_add, k))
-            else:
-                result[k] = list(_consolidate(k_comps[k], k))
-    return result
-
-
-def build_k_number_dict(kcomps):
-    return {
-        node: k
-        for k, comps in sorted(kcomps.items(), key=itemgetter(0))
-        for comp in comps
-        for node in comp
-    }

package/runtime/python/okstra_vendor/networkx/algorithms/connectivity/kcutsets.py

@@ -1,235 +0,0 @@
-"""
-Kanevsky all minimum node k cutsets algorithm.
-"""
-
-import copy
-from collections import defaultdict
-from itertools import combinations
-from operator import itemgetter
-
-import networkx as nx
-from networkx.algorithms.flow import (
-    build_residual_network,
-    edmonds_karp,
-    shortest_augmenting_path,
-)
-
-from .utils import build_auxiliary_node_connectivity
-
-default_flow_func = edmonds_karp
-
-
-__all__ = ["all_node_cuts"]
-
-
-@nx._dispatchable
-def all_node_cuts(G, k=None, flow_func=None):
-    r"""Returns all minimum k cutsets of an undirected graph G.
-
-    This implementation is based on Kanevsky's algorithm [1]_ for finding all
-    minimum-size node cut-sets of an undirected graph G; ie the set (or sets)
-    of nodes of cardinality equal to the node connectivity of G. Thus if
-    removed, would break G into two or more connected components.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Undirected graph
-
-    k : Integer
-        Node connectivity of the input graph. If k is None, then it is
-        computed. Default value: None.
-
-    flow_func : function
-        Function to perform the underlying flow computations. Default value is
-        :func:`~networkx.algorithms.flow.edmonds_karp`. This function performs
-        better in sparse graphs with right tailed degree distributions.
-        :func:`~networkx.algorithms.flow.shortest_augmenting_path` will
-        perform better in denser graphs.
-
-
-    Returns
-    -------
-    cuts : a generator of node cutsets
-        Each node cutset has cardinality equal to the node connectivity of
-        the input graph.
-
-    Examples
-    --------
-    >>> # A two-dimensional grid graph has 4 cutsets of cardinality 2
-    >>> G = nx.grid_2d_graph(5, 5)
-    >>> cutsets = list(nx.all_node_cuts(G))
-    >>> len(cutsets)
-    4
-    >>> all(2 == len(cutset) for cutset in cutsets)
-    True
-    >>> nx.node_connectivity(G)
-    2
-
-    Notes
-    -----
-    This implementation is based on the sequential algorithm for finding all
-    minimum-size separating vertex sets in a graph [1]_. The main idea is to
-    compute minimum cuts using local maximum flow computations among a set
-    of nodes of highest degree and all other non-adjacent nodes in the Graph.
-    Once we find a minimum cut, we add an edge between the high degree
-    node and the target node of the local maximum flow computation to make
-    sure that we will not find that minimum cut again.
-
-    See also
-    --------
-    node_connectivity
-    edmonds_karp
-    shortest_augmenting_path
-
-    References
-    ----------
-    .. [1]  Kanevsky, A. (1993). Finding all minimum-size separating vertex
-            sets in a graph. Networks 23(6), 533--541.
-            http://onlinelibrary.wiley.com/doi/10.1002/net.3230230604/abstract
-
-    """
-    if not nx.is_connected(G):
-        raise nx.NetworkXError("Input graph is disconnected.")
-
-    # Address some corner cases first.
-    # For complete Graphs
-
-    if nx.density(G) == 1:
-        yield from ()
-        return
-
-    # Initialize data structures.
-    # Keep track of the cuts already computed so we do not repeat them.
-    seen = []
-    # Even-Tarjan reduction is what we call auxiliary digraph
-    # for node connectivity.
-    H = build_auxiliary_node_connectivity(G)
-    H_nodes = H.nodes  # for speed
-    mapping = H.graph["mapping"]
-    # Keep a copy of original predecessors, H will be modified later.
-    # Shallow copy is enough.
-    original_H_pred = copy.copy(H._pred)
-    R = build_residual_network(H, "capacity")
-    kwargs = {"capacity": "capacity", "residual": R}
-    # Define default flow function
-    if flow_func is None:
-        flow_func = default_flow_func
-    if flow_func is shortest_augmenting_path:
-        kwargs["two_phase"] = True
-    # Begin the actual algorithm
-    # step 1: Find node connectivity k of G
-    if k is None:
-        k = nx.node_connectivity(G, flow_func=flow_func)
-    # step 2:
-    # Find k nodes with top degree, call it X:
-    X = {n for n, d in sorted(G.degree(), key=itemgetter(1), reverse=True)[:k]}
-    # Check if X is a k-node-cutset
-    if _is_separating_set(G, X):
-        seen.append(X)
-        yield X
-
-    for x in X:
-        # step 3: Compute local connectivity flow of x with all other
-        # non adjacent nodes in G
-        non_adjacent = set(G) - {x} - set(G[x])
-        for v in non_adjacent:
-            # step 4: compute maximum flow in an Even-Tarjan reduction H of G
-            # and step 5: build the associated residual network R
-            R = flow_func(H, f"{mapping[x]}B", f"{mapping[v]}A", **kwargs)
-            flow_value = R.graph["flow_value"]
-
-            if flow_value == k:
-                # Find the nodes incident to the flow.
-                E1 = flowed_edges = [
-                    (u, w) for (u, w, d) in R.edges(data=True) if d["flow"] != 0
-                ]
-                VE1 = incident_nodes = {n for edge in E1 for n in edge}
-                # Remove saturated edges form the residual network.
-                # Note that reversed edges are introduced with capacity 0
-                # in the residual graph and they need to be removed too.
-                saturated_edges = [
-                    (u, w, d)
-                    for (u, w, d) in R.edges(data=True)
-                    if d["capacity"] == d["flow"] or d["capacity"] == 0
-                ]
-                R.remove_edges_from(saturated_edges)
-                R_closure = nx.transitive_closure(R)
-                # step 6: shrink the strongly connected components of
-                # residual flow network R and call it L.
-                L = nx.condensation(R)
-                cmap = L.graph["mapping"]
-                inv_cmap = defaultdict(list)
-                for n, scc in cmap.items():
-                    inv_cmap[scc].append(n)
-                # Find the incident nodes in the condensed graph.
-                VE1 = {cmap[n] for n in VE1}
-                # step 7: Compute all antichains of L;
-                # they map to closed sets in H.
-                # Any edge in H that links a closed set is part of a cutset.
-                for antichain in nx.antichains(L):
-                    # Only antichains that are subsets of incident nodes counts.
-                    # Lemma 8 in reference.
-                    if not set(antichain).issubset(VE1):
-                        continue
-                    # Nodes in an antichain of the condensation graph of
-                    # the residual network map to a closed set of nodes that
-                    # define a node partition of the auxiliary digraph H
-                    # through taking all of antichain's predecessors in the
-                    # transitive closure.
-                    S = set()
-                    for scc in antichain:
-                        S.update(inv_cmap[scc])
-                    S_ancestors = set()
-                    for n in S:
-                        S_ancestors.update(R_closure._pred[n])
-                    S.update(S_ancestors)
-                    if f"{mapping[x]}B" not in S or f"{mapping[v]}A" in S:
-                        continue
-                    # Find the cutset that links the node partition (S,~S) in H
-                    cutset = set()
-                    for u in S:
-                        cutset.update((u, w) for w in original_H_pred[u] if w not in S)
-                    # The edges in H that form the cutset are internal edges
-                    # (ie edges that represent a node of the original graph G)
-                    if any(H_nodes[u]["id"] != H_nodes[w]["id"] for u, w in cutset):
-                        continue
-                    node_cut = {H_nodes[u]["id"] for u, _ in cutset}
-
-                    if len(node_cut) == k:
-                        # The cut is invalid if it includes internal edges of
-                        # end nodes. The other half of Lemma 8 in ref.
-                        if x in node_cut or v in node_cut:
-                            continue
-                        if node_cut not in seen:
-                            yield node_cut
-                            seen.append(node_cut)
-
-                # Add an edge (x, v) to make sure that we do not
-                # find this cutset again. This is equivalent
-                # of adding the edge in the input graph
-                # G.add_edge(x, v) and then regenerate H and R:
-                # Add edges to the auxiliary digraph.
-                # See build_residual_network for convention we used
-                # in residual graphs.
-                H.add_edge(f"{mapping[x]}B", f"{mapping[v]}A", capacity=1)
-                H.add_edge(f"{mapping[v]}B", f"{mapping[x]}A", capacity=1)
-                # Add edges to the residual network.
-                R.add_edge(f"{mapping[x]}B", f"{mapping[v]}A", capacity=1)
-                R.add_edge(f"{mapping[v]}A", f"{mapping[x]}B", capacity=0)
-                R.add_edge(f"{mapping[v]}B", f"{mapping[x]}A", capacity=1)
-                R.add_edge(f"{mapping[x]}A", f"{mapping[v]}B", capacity=0)
-
-                # Add again the saturated edges to reuse the residual network
-                R.add_edges_from(saturated_edges)
-
-
-def _is_separating_set(G, cut):
-    """Assumes that the input graph is connected"""
-    if len(cut) == len(G) - 1:
-        return True
-
-    H = nx.restricted_view(G, cut, [])
-    if nx.is_connected(H):
-        return False
-    return True

package/runtime/python/okstra_vendor/networkx/algorithms/connectivity/stoerwagner.py

@@ -1,152 +0,0 @@
-"""
-Stoer-Wagner minimum cut algorithm.
-"""
-
-from itertools import islice
-
-import networkx as nx
-
-from ...utils import BinaryHeap, arbitrary_element, not_implemented_for
-
-__all__ = ["stoer_wagner"]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable(edge_attrs="weight")
-def stoer_wagner(G, weight="weight", heap=BinaryHeap):
-    r"""Returns the weighted minimum edge cut using the Stoer-Wagner algorithm.
-
-    Determine the minimum edge cut of a connected graph using the
-    Stoer-Wagner algorithm. In weighted cases, all weights must be
-    nonnegative.
-
-    The running time of the algorithm depends on the type of heaps used:
-
-    ============== =============================================
-    Type of heap   Running time
-    ============== =============================================
-    Binary heap    $O(n (m + n) \log n)$
-    Fibonacci heap $O(nm + n^2 \log n)$
-    Pairing heap   $O(2^{2 \sqrt{\log \log n}} nm + n^2 \log n)$
-    ============== =============================================
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Edges of the graph are expected to have an attribute named by the
-        weight parameter below. If this attribute is not present, the edge is
-        considered to have unit weight.
-
-    weight : string
-        Name of the weight attribute of the edges. If the attribute is not
-        present, unit weight is assumed. Default value: 'weight'.
-
-    heap : class
-        Type of heap to be used in the algorithm. It should be a subclass of
-        :class:`MinHeap` or implement a compatible interface.
-
-        If a stock heap implementation is to be used, :class:`BinaryHeap` is
-        recommended over :class:`PairingHeap` for Python implementations without
-        optimized attribute accesses (e.g., CPython) despite a slower
-        asymptotic running time. For Python implementations with optimized
-        attribute accesses (e.g., PyPy), :class:`PairingHeap` provides better
-        performance. Default value: :class:`BinaryHeap`.
-
-    Returns
-    -------
-    cut_value : integer or float
-        The sum of weights of edges in a minimum cut.
-
-    partition : pair of node lists
-        A partitioning of the nodes that defines a minimum cut.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If the graph is directed or a multigraph.
-
-    NetworkXError
-        If the graph has less than two nodes, is not connected or has a
-        negative-weighted edge.
-
-    Examples
-    --------
-    >>> G = nx.Graph()
-    >>> G.add_edge("x", "a", weight=3)
-    >>> G.add_edge("x", "b", weight=1)
-    >>> G.add_edge("a", "c", weight=3)
-    >>> G.add_edge("b", "c", weight=5)
-    >>> G.add_edge("b", "d", weight=4)
-    >>> G.add_edge("d", "e", weight=2)
-    >>> G.add_edge("c", "y", weight=2)
-    >>> G.add_edge("e", "y", weight=3)
-    >>> cut_value, partition = nx.stoer_wagner(G)
-    >>> cut_value
-    4
-    """
-    n = len(G)
-    if n < 2:
-        raise nx.NetworkXError("graph has less than two nodes.")
-    if not nx.is_connected(G):
-        raise nx.NetworkXError("graph is not connected.")
-
-    # Make a copy of the graph for internal use.
-    G = nx.Graph(
-        (u, v, {"weight": e.get(weight, 1)}) for u, v, e in G.edges(data=True) if u != v
-    )
-    G.__networkx_cache__ = None  # Disable caching
-
-    for u, v, e in G.edges(data=True):
-        if e["weight"] < 0:
-            raise nx.NetworkXError("graph has a negative-weighted edge.")
-
-    cut_value = float("inf")
-    nodes = set(G)
-    contractions = []  # contracted node pairs
-
-    # Repeatedly pick a pair of nodes to contract until only one node is left.
-    for i in range(n - 1):
-        # Pick an arbitrary node u and create a set A = {u}.
-        u = arbitrary_element(G)
-        A = {u}
-        # Repeatedly pick the node "most tightly connected" to A and add it to
-        # A. The tightness of connectivity of a node not in A is defined by the
-        # of edges connecting it to nodes in A.
-        h = heap()  # min-heap emulating a max-heap
-        for v, e in G[u].items():
-            h.insert(v, -e["weight"])
-        # Repeat until all but one node has been added to A.
-        for j in range(n - i - 2):
-            u = h.pop()[0]
-            A.add(u)
-            for v, e in G[u].items():
-                if v not in A:
-                    h.insert(v, h.get(v, 0) - e["weight"])
-        # A and the remaining node v define a "cut of the phase". There is a
-        # minimum cut of the original graph that is also a cut of the phase.
-        # Due to contractions in earlier phases, v may in fact represent
-        # multiple nodes in the original graph.
-        v, w = h.min()
-        w = -w
-        if w < cut_value:
-            cut_value = w
-            best_phase = i
-        # Contract v and the last node added to A.
-        contractions.append((u, v))
-        for w, e in G[v].items():
-            if w != u:
-                if w not in G[u]:
-                    G.add_edge(u, w, weight=e["weight"])
-                else:
-                    G[u][w]["weight"] += e["weight"]
-        G.remove_node(v)
-
-    # Recover the optimal partitioning from the contractions.
-    G = nx.Graph(islice(contractions, best_phase))
-    v = contractions[best_phase][1]
-    G.add_node(v)
-    reachable = set(nx.single_source_shortest_path_length(G, v))
-    partition = (list(reachable), list(nodes - reachable))
-
-    return cut_value, partition

package/runtime/python/okstra_vendor/networkx/algorithms/connectivity/utils.py

@@ -1,88 +0,0 @@
-"""
-Utilities for connectivity package
-"""
-
-import networkx as nx
-
-__all__ = ["build_auxiliary_node_connectivity", "build_auxiliary_edge_connectivity"]
-
-
-@nx._dispatchable(returns_graph=True)
-def build_auxiliary_node_connectivity(G):
-    r"""Creates a directed graph D from an undirected graph G to compute flow
-    based node connectivity.
-
-    For an undirected graph G having `n` nodes and `m` edges we derive a
-    directed graph D with `2n` nodes and `2m+n` arcs by replacing each
-    original node `v` with two nodes `vA`, `vB` linked by an (internal)
-    arc in D. Then for each edge (`u`, `v`) in G we add two arcs (`uB`, `vA`)
-    and (`vB`, `uA`) in D. Finally we set the attribute capacity = 1 for each
-    arc in D [1]_.
-
-    For a directed graph having `n` nodes and `m` arcs we derive a
-    directed graph D with `2n` nodes and `m+n` arcs by replacing each
-    original node `v` with two nodes `vA`, `vB` linked by an (internal)
-    arc (`vA`, `vB`) in D. Then for each arc (`u`, `v`) in G we add one
-    arc (`uB`, `vA`) in D. Finally we set the attribute capacity = 1 for
-    each arc in D.
-
-    A dictionary with a mapping between nodes in the original graph and the
-    auxiliary digraph is stored as a graph attribute: D.graph['mapping'].
-
-    References
-    ----------
-    .. [1] Kammer, Frank and Hanjo Taubig. Graph Connectivity. in Brandes and
-        Erlebach, 'Network Analysis: Methodological Foundations', Lecture
-        Notes in Computer Science, Volume 3418, Springer-Verlag, 2005.
-        https://doi.org/10.1007/978-3-540-31955-9_7
-
-    """
-    directed = G.is_directed()
-
-    mapping = {}
-    H = nx.DiGraph()
-
-    for i, node in enumerate(G):
-        mapping[node] = i
-        H.add_node(f"{i}A", id=node)
-        H.add_node(f"{i}B", id=node)
-        H.add_edge(f"{i}A", f"{i}B", capacity=1)
-
-    edges = []
-    for source, target in G.edges():
-        edges.append((f"{mapping[source]}B", f"{mapping[target]}A"))
-        if not directed:
-            edges.append((f"{mapping[target]}B", f"{mapping[source]}A"))
-    H.add_edges_from(edges, capacity=1)
-
-    # Store mapping as graph attribute
-    H.graph["mapping"] = mapping
-    return H
-
-
-@nx._dispatchable(returns_graph=True)
-def build_auxiliary_edge_connectivity(G):
-    """Auxiliary digraph for computing flow based edge connectivity
-
-    If the input graph is undirected, we replace each edge (`u`,`v`) with
-    two reciprocal arcs (`u`, `v`) and (`v`, `u`) and then we set the attribute
-    'capacity' for each arc to 1. If the input graph is directed we simply
-    add the 'capacity' attribute. Part of algorithm 1 in [1]_ .
-
-    References
-    ----------
-    .. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms. (this is a
-        chapter, look for the reference of the book).
-        http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
-    """
-    if G.is_directed():
-        H = nx.DiGraph()
-        H.add_nodes_from(G.nodes())
-        H.add_edges_from(G.edges(), capacity=1)
-        return H
-    else:
-        H = nx.DiGraph()
-        H.add_nodes_from(G.nodes())
-        for source, target in G.edges():
-            H.add_edges_from([(source, target), (target, source)], capacity=1)
-        return H