okstra 0.130.4 → 0.131.1

package/runtime/python/okstra_vendor/networkx/algorithms/polynomials.py

@@ -1,306 +0,0 @@
-"""Provides algorithms supporting the computation of graph polynomials.
-
-Graph polynomials are polynomial-valued graph invariants that encode a wide
-variety of structural information. Examples include the Tutte polynomial,
-chromatic polynomial, characteristic polynomial, and matching polynomial. An
-extensive treatment is provided in [1]_.
-
-For a simple example, the `~sympy.matrices.matrices.MatrixDeterminant.charpoly`
-method can be used to compute the characteristic polynomial from the adjacency
-matrix of a graph. Consider the complete graph ``K_4``:
-
->>> import sympy
->>> x = sympy.Symbol("x")
->>> G = nx.complete_graph(4)
->>> A = nx.to_numpy_array(G, dtype=int)
->>> M = sympy.SparseMatrix(A)
->>> M.charpoly(x).as_expr()
-x**4 - 6*x**2 - 8*x - 3
-
-
-.. [1] Y. Shi, M. Dehmer, X. Li, I. Gutman,
-   "Graph Polynomials"
-"""
-
-from collections import deque
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["tutte_polynomial", "chromatic_polynomial"]
-
-
-@not_implemented_for("directed")
-@nx._dispatchable
-def tutte_polynomial(G):
-    r"""Returns the Tutte polynomial of `G`
-
-    This function computes the Tutte polynomial via an iterative version of
-    the deletion-contraction algorithm.
-
-    The Tutte polynomial `T_G(x, y)` is a fundamental graph polynomial invariant in
-    two variables. It encodes a wide array of information related to the
-    edge-connectivity of a graph; "Many problems about graphs can be reduced to
-    problems of finding and evaluating the Tutte polynomial at certain values" [1]_.
-    In fact, every deletion-contraction-expressible feature of a graph is a
-    specialization of the Tutte polynomial [2]_ (see Notes for examples).
-
-    There are several equivalent definitions; here are three:
-
-    Def 1 (rank-nullity expansion): For `G` an undirected graph, `n(G)` the
-    number of vertices of `G`, `E` the edge set of `G`, `V` the vertex set of
-    `G`, and `c(A)` the number of connected components of the graph with vertex
-    set `V` and edge set `A` [3]_:
-
-    .. math::
-
-        T_G(x, y) = \sum_{A \in E} (x-1)^{c(A) - c(E)} (y-1)^{c(A) + |A| - n(G)}
-
-    Def 2 (spanning tree expansion): Let `G` be an undirected graph, `T` a spanning
-    tree of `G`, and `E` the edge set of `G`. Let `E` have an arbitrary strict
-    linear order `L`. Let `B_e` be the unique minimal nonempty edge cut of
-    $E \setminus T \cup {e}$. An edge `e` is internally active with respect to
-    `T` and `L` if `e` is the least edge in `B_e` according to the linear order
-    `L`. The internal activity of `T` (denoted `i(T)`) is the number of edges
-    in $E \setminus T$ that are internally active with respect to `T` and `L`.
-    Let `P_e` be the unique path in $T \cup {e}$ whose source and target vertex
-    are the same. An edge `e` is externally active with respect to `T` and `L`
-    if `e` is the least edge in `P_e` according to the linear order `L`. The
-    external activity of `T` (denoted `e(T)`) is the number of edges in
-    $E \setminus T$ that are externally active with respect to `T` and `L`.
-    Then [4]_ [5]_:
-
-    .. math::
-
-        T_G(x, y) = \sum_{T \text{ a spanning tree of } G} x^{i(T)} y^{e(T)}
-
-    Def 3 (deletion-contraction recurrence): For `G` an undirected graph, `G-e`
-    the graph obtained from `G` by deleting edge `e`, `G/e` the graph obtained
-    from `G` by contracting edge `e`, `k(G)` the number of cut-edges of `G`,
-    and `l(G)` the number of self-loops of `G`:
-
-    .. math::
-        T_G(x, y) = \begin{cases}
-    	   x^{k(G)} y^{l(G)}, & \text{if all edges are cut-edges or self-loops} \\
-           T_{G-e}(x, y) + T_{G/e}(x, y), & \text{otherwise, for an arbitrary edge $e$ not a cut-edge or loop}
-        \end{cases}
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    Returns
-    -------
-    instance of `sympy.core.add.Add`
-        A Sympy expression representing the Tutte polynomial for `G`.
-
-    Examples
-    --------
-    >>> C = nx.cycle_graph(5)
-    >>> nx.tutte_polynomial(C)
-    x**4 + x**3 + x**2 + x + y
-
-    >>> D = nx.diamond_graph()
-    >>> nx.tutte_polynomial(D)
-    x**3 + 2*x**2 + 2*x*y + x + y**2 + y
-
-    Notes
-    -----
-    Some specializations of the Tutte polynomial:
-
-    - `T_G(1, 1)` counts the number of spanning trees of `G`
-    - `T_G(1, 2)` counts the number of connected spanning subgraphs of `G`
-    - `T_G(2, 1)` counts the number of spanning forests in `G`
-    - `T_G(0, 2)` counts the number of strong orientations of `G`
-    - `T_G(2, 0)` counts the number of acyclic orientations of `G`
-
-    Edge contraction is defined and deletion-contraction is introduced in [6]_.
-    Combinatorial meaning of the coefficients is introduced in [7]_.
-    Universality, properties, and applications are discussed in [8]_.
-
-    Practically, up-front computation of the Tutte polynomial may be useful when
-    users wish to repeatedly calculate edge-connectivity-related information
-    about one or more graphs.
-
-    References
-    ----------
-    .. [1] M. Brandt,
-       "The Tutte Polynomial."
-       Talking About Combinatorial Objects Seminar, 2015
-       https://math.berkeley.edu/~brandtm/talks/tutte.pdf
-    .. [2] A. Björklund, T. Husfeldt, P. Kaski, M. Koivisto,
-       "Computing the Tutte polynomial in vertex-exponential time"
-       49th Annual IEEE Symposium on Foundations of Computer Science, 2008
-       https://ieeexplore.ieee.org/abstract/document/4691000
-    .. [3] Y. Shi, M. Dehmer, X. Li, I. Gutman,
-       "Graph Polynomials," p. 14
-    .. [4] Y. Shi, M. Dehmer, X. Li, I. Gutman,
-       "Graph Polynomials," p. 46
-    .. [5] A. Nešetril, J. Goodall,
-       "Graph invariants, homomorphisms, and the Tutte polynomial"
-       https://iuuk.mff.cuni.cz/~andrew/Tutte.pdf
-    .. [6] D. B. West,
-       "Introduction to Graph Theory," p. 84
-    .. [7] G. Coutinho,
-       "A brief introduction to the Tutte polynomial"
-       Structural Analysis of Complex Networks, 2011
-       https://homepages.dcc.ufmg.br/~gabriel/seminars/coutinho_tuttepolynomial_seminar.pdf
-    .. [8] J. A. Ellis-Monaghan, C. Merino,
-       "Graph polynomials and their applications I: The Tutte polynomial"
-       Structural Analysis of Complex Networks, 2011
-       https://arxiv.org/pdf/0803.3079.pdf
-    """
-    import sympy
-
-    x = sympy.Symbol("x")
-    y = sympy.Symbol("y")
-    stack = deque()
-    stack.append(nx.MultiGraph(G))
-
-    polynomial = 0
-    while stack:
-        G = stack.pop()
-        bridges = set(nx.bridges(G))
-
-        e = None
-        for i in G.edges:
-            if (i[0], i[1]) not in bridges and i[0] != i[1]:
-                e = i
-                break
-        if not e:
-            loops = list(nx.selfloop_edges(G, keys=True))
-            polynomial += x ** len(bridges) * y ** len(loops)
-        else:
-            # deletion-contraction
-            C = nx.contracted_edge(G, e, self_loops=True)
-            C.remove_edge(e[0], e[0])
-            G.remove_edge(*e)
-            stack.append(G)
-            stack.append(C)
-    return sympy.simplify(polynomial)
-
-
-@not_implemented_for("directed")
-@nx._dispatchable
-def chromatic_polynomial(G):
-    r"""Returns the chromatic polynomial of `G`
-
-    This function computes the chromatic polynomial via an iterative version of
-    the deletion-contraction algorithm.
-
-    The chromatic polynomial `X_G(x)` is a fundamental graph polynomial
-    invariant in one variable. Evaluating `X_G(k)` for an natural number `k`
-    enumerates the proper k-colorings of `G`.
-
-    There are several equivalent definitions; here are three:
-
-    Def 1 (explicit formula):
-    For `G` an undirected graph, `c(G)` the number of connected components of
-    `G`, `E` the edge set of `G`, and `G(S)` the spanning subgraph of `G` with
-    edge set `S` [1]_:
-
-    .. math::
-
-        X_G(x) = \sum_{S \subseteq E} (-1)^{|S|} x^{c(G(S))}
-
-
-    Def 2 (interpolating polynomial):
-    For `G` an undirected graph, `n(G)` the number of vertices of `G`, `k_0 = 0`,
-    and `k_i` the number of distinct ways to color the vertices of `G` with `i`
-    unique colors (for `i` a natural number at most `n(G)`), `X_G(x)` is the
-    unique Lagrange interpolating polynomial of degree `n(G)` through the points
-    `(0, k_0), (1, k_1), \dots, (n(G), k_{n(G)})` [2]_.
-
-
-    Def 3 (chromatic recurrence):
-    For `G` an undirected graph, `G-e` the graph obtained from `G` by deleting
-    edge `e`, `G/e` the graph obtained from `G` by contracting edge `e`, `n(G)`
-    the number of vertices of `G`, and `e(G)` the number of edges of `G` [3]_:
-
-    .. math::
-        X_G(x) = \begin{cases}
-    	   x^{n(G)}, & \text{if $e(G)=0$} \\
-           X_{G-e}(x) - X_{G/e}(x), & \text{otherwise, for an arbitrary edge $e$}
-        \end{cases}
-
-    This formulation is also known as the Fundamental Reduction Theorem [4]_.
-
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    Returns
-    -------
-    instance of `sympy.core.add.Add`
-        A Sympy expression representing the chromatic polynomial for `G`.
-
-    Examples
-    --------
-    >>> C = nx.cycle_graph(5)
-    >>> nx.chromatic_polynomial(C)
-    x**5 - 5*x**4 + 10*x**3 - 10*x**2 + 4*x
-
-    >>> G = nx.complete_graph(4)
-    >>> nx.chromatic_polynomial(G)
-    x**4 - 6*x**3 + 11*x**2 - 6*x
-
-    Notes
-    -----
-    Interpretation of the coefficients is discussed in [5]_. Several special
-    cases are listed in [2]_.
-
-    The chromatic polynomial is a specialization of the Tutte polynomial; in
-    particular, ``X_G(x) = T_G(x, 0)`` [6]_.
-
-    The chromatic polynomial may take negative arguments, though evaluations
-    may not have chromatic interpretations. For instance, ``X_G(-1)`` enumerates
-    the acyclic orientations of `G` [7]_.
-
-    References
-    ----------
-    .. [1] D. B. West,
-       "Introduction to Graph Theory," p. 222
-    .. [2] E. W. Weisstein
-       "Chromatic Polynomial"
-       MathWorld--A Wolfram Web Resource
-       https://mathworld.wolfram.com/ChromaticPolynomial.html
-    .. [3] D. B. West,
-       "Introduction to Graph Theory," p. 221
-    .. [4] J. Zhang, J. Goodall,
-       "An Introduction to Chromatic Polynomials"
-       https://math.mit.edu/~apost/courses/18.204_2018/Julie_Zhang_paper.pdf
-    .. [5] R. C. Read,
-       "An Introduction to Chromatic Polynomials"
-       Journal of Combinatorial Theory, 1968
-       https://math.berkeley.edu/~mrklug/ReadChromatic.pdf
-    .. [6] W. T. Tutte,
-       "Graph-polynomials"
-       Advances in Applied Mathematics, 2004
-       https://www.sciencedirect.com/science/article/pii/S0196885803000411
-    .. [7] R. P. Stanley,
-       "Acyclic orientations of graphs"
-       Discrete Mathematics, 2006
-       https://math.mit.edu/~rstan/pubs/pubfiles/18.pdf
-    """
-    import sympy
-
-    x = sympy.Symbol("x")
-    stack = deque()
-    stack.append(nx.MultiGraph(G, contraction_idx=0))
-
-    polynomial = 0
-    while stack:
-        G = stack.pop()
-        edges = list(G.edges)
-        if not edges:
-            polynomial += (-1) ** G.graph["contraction_idx"] * x ** len(G)
-        else:
-            e = edges[0]
-            C = nx.contracted_edge(G, e, self_loops=True)
-            C.graph["contraction_idx"] = G.graph["contraction_idx"] + 1
-            C.remove_edge(e[0], e[0])
-            G.remove_edge(*e)
-            stack.append(G)
-            stack.append(C)
-    return polynomial

package/runtime/python/okstra_vendor/networkx/algorithms/reciprocity.py

@@ -1,98 +0,0 @@
-"""Algorithms to calculate reciprocity in a directed graph."""
-
-import networkx as nx
-from networkx import NetworkXError
-
-from ..utils import not_implemented_for
-
-__all__ = ["reciprocity", "overall_reciprocity"]
-
-
-@not_implemented_for("undirected", "multigraph")
-@nx._dispatchable
-def reciprocity(G, nodes=None):
-    r"""Compute the reciprocity in a directed graph.
-
-    The reciprocity of a directed graph is defined as the ratio
-    of the number of edges pointing in both directions to the total
-    number of edges in the graph.
-    Formally, $r = |{(u,v) \in G|(v,u) \in G}| / |{(u,v) \in G}|$.
-
-    The reciprocity of a single node u is defined similarly,
-    it is the ratio of the number of edges in both directions to
-    the total number of edges attached to node u.
-
-    Parameters
-    ----------
-    G : graph
-       A networkx directed graph
-    nodes : container of nodes, optional (default=whole graph)
-       Compute reciprocity for nodes in this container.
-
-    Returns
-    -------
-    out : dictionary
-       Reciprocity keyed by node label.
-
-    Notes
-    -----
-    The reciprocity is not defined for isolated nodes.
-    In such cases this function will return None.
-
-    """
-    # If `nodes` is not specified, calculate the reciprocity of the graph.
-    if nodes is None:
-        return overall_reciprocity(G)
-
-    # If `nodes` represents a single node in the graph, return only its
-    # reciprocity.
-    if nodes in G:
-        reciprocity = next(_reciprocity_iter(G, nodes))[1]
-        if reciprocity is None:
-            raise NetworkXError("Not defined for isolated nodes.")
-        else:
-            return reciprocity
-
-    # Otherwise, `nodes` represents an iterable of nodes, so return a
-    # dictionary mapping node to its reciprocity.
-    return dict(_reciprocity_iter(G, nodes))
-
-
-def _reciprocity_iter(G, nodes):
-    """Return an iterator of (node, reciprocity)."""
-    n = G.nbunch_iter(nodes)
-    for node in n:
-        pred = set(G.predecessors(node))
-        succ = set(G.successors(node))
-        overlap = pred & succ
-        n_total = len(pred) + len(succ)
-
-        # Reciprocity is not defined for isolated nodes.
-        # Return None.
-        if n_total == 0:
-            yield (node, None)
-        else:
-            reciprocity = 2 * len(overlap) / n_total
-            yield (node, reciprocity)
-
-
-@not_implemented_for("undirected", "multigraph")
-@nx._dispatchable
-def overall_reciprocity(G):
-    """Compute the reciprocity for the whole graph.
-
-    See the doc of reciprocity for the definition.
-
-    Parameters
-    ----------
-    G : graph
-       A networkx graph
-
-    """
-    n_all_edge = G.number_of_edges()
-    n_overlap_edge = (n_all_edge - G.to_undirected().number_of_edges()) * 2
-
-    if n_all_edge == 0:
-        raise NetworkXError("Not defined for empty graphs")
-
-    return n_overlap_edge / n_all_edge

package/runtime/python/okstra_vendor/networkx/algorithms/regular.py

@@ -1,167 +0,0 @@
-"""Functions for computing and verifying regular graphs."""
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["is_regular", "is_k_regular", "k_factor"]
-
-
-@nx._dispatchable
-def is_regular(G):
-    """Determines whether a graph is regular.
-
-    A regular graph is a graph where all nodes have the same degree. A regular
-    digraph is a graph where all nodes have the same indegree and all nodes
-    have the same outdegree.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    Returns
-    -------
-    bool
-        Whether the given graph or digraph is regular.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(1, 2), (2, 3), (3, 4), (4, 1)])
-    >>> nx.is_regular(G)
-    True
-
-    """
-    if len(G) == 0:
-        raise nx.NetworkXPointlessConcept("Graph has no nodes.")
-    n1 = nx.utils.arbitrary_element(G)
-    if not G.is_directed():
-        d1 = G.degree(n1)
-        return all(d1 == d for _, d in G.degree)
-    else:
-        d_in = G.in_degree(n1)
-        in_regular = (d_in == d for _, d in G.in_degree)
-        d_out = G.out_degree(n1)
-        out_regular = (d_out == d for _, d in G.out_degree)
-        return all(in_regular) and all(out_regular)
-
-
-@not_implemented_for("directed")
-@nx._dispatchable
-def is_k_regular(G, k):
-    """Determines whether the graph ``G`` is a k-regular graph.
-
-    A k-regular graph is a graph where each vertex has degree k.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    Returns
-    -------
-    bool
-        Whether the given graph is k-regular.
-
-    Examples
-    --------
-    >>> G = nx.Graph([(1, 2), (2, 3), (3, 4), (4, 1)])
-    >>> nx.is_k_regular(G, k=3)
-    False
-
-    """
-    return all(d == k for n, d in G.degree)
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable(preserve_edge_attrs=True, returns_graph=True)
-def k_factor(G, k, matching_weight="weight"):
-    """Compute a `k`-factor of a graph.
-
-    A `k`-factor of a graph is a spanning `k`-regular subgraph.
-    A spanning `k`-regular subgraph of `G` is a subgraph that contains
-    each node of `G` and a subset of the edges of `G` such that each
-    node has degree `k`.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        An undirected graph.
-
-    k : int
-        The degree of the `k`-factor.
-
-    matching_weight: string, optional (default="weight")
-        Edge attribute name corresponding to the edge weight.
-        If not present, the edge is assumed to have weight 1.
-        Used for finding the max-weighted perfect matching.
-
-    Returns
-    -------
-    NetworkX graph
-        A `k`-factor of `G`.
-
-    Examples
-    --------
-    >>> G = nx.Graph([(1, 2), (2, 3), (3, 4), (4, 1)])
-    >>> KF = nx.k_factor(G, k=1)
-    >>> KF.edges()
-    EdgeView([(1, 2), (3, 4)])
-
-    References
-    ----------
-    .. [1] "An algorithm for computing simple k-factors.",
-       Meijer, Henk, Yurai Núñez-Rodríguez, and David Rappaport,
-       Information processing letters, 2009.
-    """
-    # Validate minimum degree requirement.
-    if any(d < k for _, d in G.degree):
-        raise nx.NetworkXUnfeasible("Graph contains a vertex with degree less than k")
-
-    g = G.copy()
-    gadgets = []
-
-    # Replace each node with a gadget.
-    for node, degree in G.degree:
-        is_large = k >= degree / 2.0
-
-        # Create gadget nodes.
-        outer = [(node, i) for i in range(degree)]
-        if is_large:
-            core = [(node, i) for i in range(degree, 2 * degree - k)]
-            inner = []
-        else:
-            core = [(node, i) for i in range(2 * degree, 2 * degree + k)]
-            inner = [(node, i) for i in range(degree, 2 * degree)]
-
-        # Connect gadget nodes to neighbors.
-        g.add_edges_from(zip(outer, inner))
-        for outer_n, (neighbor, attrs) in zip(outer, g[node].items()):
-            g.add_edge(outer_n, neighbor, **attrs)
-
-        # Add internal edges.
-        g.add_edges_from((u, v) for u in core for v in (outer if is_large else inner))
-
-        g.remove_node(node)
-        gadgets.append((node, outer, core, inner))
-
-    # Find perfect matching.
-    m = nx.max_weight_matching(g, maxcardinality=True, weight=matching_weight)
-    if not nx.is_perfect_matching(g, m):
-        raise nx.NetworkXUnfeasible(
-            "Cannot find k-factor because no perfect matching exists"
-        )
-
-    # Keep only edges in matching.
-    g.remove_edges_from(e for e in g.edges if e not in m and e[::-1] not in m)
-
-    # Restore original nodes and remove gadgets.
-    for node, outer, core, inner in gadgets:
-        g.add_node(node)
-        core_set = set(core)
-        for outer_n in outer:
-            for neighbor, attrs in g._adj[outer_n].items():
-                if neighbor not in core_set:
-                    g.add_edge(node, neighbor, **attrs)
-                    break
-        g.remove_nodes_from(outer + core + inner)
-
-    return g