Skip to main content
`Ctrl`+`K`

# Source code for networkx.linalg.algebraicconnectivity

    """
    Algebraic connectivity and Fiedler vectors of undirected graphs.
    """

    from functools import partial

    import networkx as nx
    from networkx.utils import (
        not_implemented_for,
        np_random_state,
        reverse_cuthill_mckee_ordering,
    )

    __all__ = [
        "algebraic_connectivity",
        "fiedler_vector",
        "spectral_ordering",
        "spectral_bisection",
    ]

    class _PCGSolver:
        """Preconditioned conjugate gradient method.

        To solve Ax = b:
            M = A.diagonal() # or some other preconditioner
            solver = _PCGSolver(lambda x: A * x, lambda x: M * x)
            x = solver.solve(b)

        The inputs A and M are functions which compute
        matrix multiplication on the argument.
        A - multiply by the matrix A in Ax=b
        M - multiply by M, the preconditioner surrogate for A

        Warning: There is no limit on number of iterations.
        """

        def __init__(self, A, M):
            self._A = A
            self._M = M

        def solve(self, B, tol):
            import numpy as np

            # Densifying step - can this be kept sparse?
            B = np.asarray(B)
            X = np.ndarray(B.shape, order="F")
            for j in range(B.shape[1]):
                X[:, j] = self._solve(B[:, j], tol)
            return X

        def _solve(self, b, tol):
            import numpy as np
            import scipy as sp

            A = self._A
            M = self._M
            tol *= sp.linalg.blas.dasum(b)
            # Initialize.
            x = np.zeros(b.shape)
            r = b.copy()
            z = M(r)
            rz = sp.linalg.blas.ddot(r, z)
            p = z.copy()
            # Iterate.
            while True:
                Ap = A(p)
                alpha = rz / sp.linalg.blas.ddot(p, Ap)
                x = sp.linalg.blas.daxpy(p, x, a=alpha)
                r = sp.linalg.blas.daxpy(Ap, r, a=-alpha)
                if sp.linalg.blas.dasum(r) < tol:
                    return x
                z = M(r)
                beta = sp.linalg.blas.ddot(r, z)
                beta, rz = beta / rz, beta
                p = sp.linalg.blas.daxpy(p, z, a=beta)

    class _LUSolver:
        """LU factorization.

        To solve Ax = b:
            solver = _LUSolver(A)
            x = solver.solve(b)

        optional argument `tol` on solve method is ignored but included
        to match _PCGsolver API.
        """

        def __init__(self, A):
            import scipy as sp

            self._LU = sp.sparse.linalg.splu(
                A,
                permc_spec="MMD_AT_PLUS_A",
                diag_pivot_thresh=0.0,
                options={"Equil": True, "SymmetricMode": True},
            )

        def solve(self, B, tol=None):
            import numpy as np

            B = np.asarray(B)
            X = np.ndarray(B.shape, order="F")
            for j in range(B.shape[1]):
                X[:, j] = self._LU.solve(B[:, j])
            return X

    def _preprocess_graph(G, weight):
        """Compute edge weights and eliminate zero-weight edges."""
        if G.is_directed():
            H = nx.MultiGraph()
            H.add_nodes_from(G)
            H.add_weighted_edges_from(
                ((u, v, e.get(weight, 1.0)) for u, v, e in G.edges(data=True) if u != v),
                weight=weight,
            )
            G = H
        if not G.is_multigraph():
            edges = (
                (u, v, abs(e.get(weight, 1.0))) for u, v, e in G.edges(data=True) if u != v
            )
        else:
            edges = (
                (u, v, sum(abs(e.get(weight, 1.0)) for e in G[u][v].values()))
                for u, v in G.edges()
                if u != v
            )
        H = nx.Graph()
        H.add_nodes_from(G)
        H.add_weighted_edges_from((u, v, e) for u, v, e in edges if e != 0)
        return H

    def _rcm_estimate(G, nodelist):
        """Estimate the Fiedler vector using the reverse Cuthill-McKee ordering."""
        import numpy as np

        G = G.subgraph(nodelist)
        order = reverse_cuthill_mckee_ordering(G)
        n = len(nodelist)
        index = dict(zip(nodelist, range(n)))
        x = np.ndarray(n, dtype=float)
        for i, u in enumerate(order):
            x[index[u]] = i
        x -= (n - 1) / 2.0
        return x

    def _tracemin_fiedler(L, X, normalized, tol, method):
        """Compute the Fiedler vector of L using the TraceMIN-Fiedler algorithm.

        The Fiedler vector of a connected undirected graph is the eigenvector
        corresponding to the second smallest eigenvalue of the Laplacian matrix
        of the graph. This function starts with the Laplacian L, not the Graph.

        Parameters
        ----------
        L : Laplacian of a possibly weighted or normalized, but undirected graph

        X : Initial guess for a solution. Usually a matrix of random numbers.
            This function allows more than one column in X to identify more than
            one eigenvector if desired.

        normalized : bool
            Whether the normalized Laplacian matrix is used.

        tol : float
            Tolerance of relative residual in eigenvalue computation.
            Warning: There is no limit on number of iterations.

        method : string
            Should be 'tracemin_pcg' or 'tracemin_lu'.
            Otherwise exception is raised.

        Returns
        -------
        sigma, X : Two NumPy arrays of floats.
            The lowest eigenvalues and corresponding eigenvectors of L.
            The size of input X determines the size of these outputs.
            As this is for Fiedler vectors, the zero eigenvalue (and
            constant eigenvector) are avoided.
        """
        import numpy as np
        import scipy as sp

        n = X.shape[0]

        if normalized:
            # Form the normalized Laplacian matrix and determine the eigenvector of
            # its nullspace.
            e = np.sqrt(L.diagonal())
            # TODO: rm csr_array wrapper when spdiags array creation becomes available
            D = sp.sparse.csr_array(sp.sparse.spdiags(1 / e, 0, n, n, format="csr"))
            L = D @ L @ D
            e *= 1.0 / np.linalg.norm(e, 2)

        if normalized:

            def project(X):
                """Make X orthogonal to the nullspace of L."""
                X = np.asarray(X)
                for j in range(X.shape[1]):
                    X[:, j] -= (X[:, j] @ e) * e

        else:

            def project(X):
                """Make X orthogonal to the nullspace of L."""
                X = np.asarray(X)
                for j in range(X.shape[1]):
                    X[:, j] -= X[:, j].sum() / n

        if method == "tracemin_pcg":
            D = L.diagonal().astype(float)
            solver = _PCGSolver(lambda x: L @ x, lambda x: D * x)
        elif method == "tracemin_lu":
            # Convert A to CSC to suppress SparseEfficiencyWarning.
            A = sp.sparse.csc_array(L, dtype=float, copy=True)
            # Force A to be nonsingular. Since A is the Laplacian matrix of a
            # connected graph, its rank deficiency is one, and thus one diagonal
            # element needs to modified. Changing to infinity forces a zero in the
            # corresponding element in the solution.
            i = (A.indptr[1:] - A.indptr[:-1]).argmax()
            A[i, i] = np.inf
            solver = _LUSolver(A)
        else:
            raise nx.NetworkXError(f"Unknown linear system solver: {method}")

        # Initialize.
        Lnorm = abs(L).sum(axis=1).flatten().max()
        project(X)
        W = np.ndarray(X.shape, order="F")

        while True:
            # Orthonormalize X.
            X = np.linalg.qr(X)[0]
            # Compute iteration matrix H.
            W[:, :] = L @ X
            H = X.T @ W
            sigma, Y = sp.linalg.eigh(H, overwrite_a=True)
            # Compute the Ritz vectors.
            X = X @ Y
            # Test for convergence exploiting the fact that L * X == W * Y.
            res = sp.linalg.blas.dasum(W @ Y[:, 0] - sigma[0] * X[:, 0]) / Lnorm
            if res < tol:
                break
            # Compute X = L \ X / (X' * (L \ X)).
            # L \ X can have an arbitrary projection on the nullspace of L,
            # which will be eliminated.
            W[:, :] = solver.solve(X, tol)
            X = (sp.linalg.inv(W.T @ X) @ W.T).T  # Preserves Fortran storage order.
            project(X)

        return sigma, np.asarray(X)

    def _get_fiedler_func(method):
        """Returns a function that solves the Fiedler eigenvalue problem."""
        import numpy as np

        if method == "tracemin":  # old style keyword <v2.1
            method = "tracemin_pcg"
        if method in ("tracemin_pcg", "tracemin_lu"):

            def find_fiedler(L, x, normalized, tol, seed):
                q = 1 if method == "tracemin_pcg" else min(4, L.shape[0] - 1)
                X = np.asarray(seed.normal(size=(q, L.shape[0]))).T
                sigma, X = _tracemin_fiedler(L, X, normalized, tol, method)
                return sigma[0], X[:, 0]

        elif method == "lanczos" or method == "lobpcg":

            def find_fiedler(L, x, normalized, tol, seed):
                import scipy as sp

                L = sp.sparse.csc_array(L, dtype=float)
                n = L.shape[0]
                if normalized:
                    # TODO: rm csc_array wrapping when spdiags array becomes available
                    D = sp.sparse.csc_array(
                        sp.sparse.spdiags(
                            1.0 / np.sqrt(L.diagonal()), [0], n, n, format="csc"
                        )
                    )
                    L = D @ L @ D
                if method == "lanczos" or n < 10:
                    # Avoid LOBPCG when n < 10 due to
                    # https://github.com/scipy/scipy/issues/3592
                    # https://github.com/scipy/scipy/pull/3594
                    sigma, X = sp.sparse.linalg.eigsh(
                        L, 2, which="SM", tol=tol, return_eigenvectors=True
                    )
                    return sigma[1], X[:, 1]
                else:
                    X = np.asarray(np.atleast_2d(x).T)
                    # TODO: rm csr_array wrapping when spdiags array becomes available
                    M = sp.sparse.csr_array(sp.sparse.spdiags(1.0 / L.diagonal(), 0, n, n))
                    Y = np.ones(n)
                    if normalized:
                        Y /= D.diagonal()
                    sigma, X = sp.sparse.linalg.lobpcg(
                        L, X, M=M, Y=np.atleast_2d(Y).T, tol=tol, maxiter=n, largest=False
                    )
                    return sigma[0], X[:, 0]

        else:
            raise nx.NetworkXError(f"unknown method {method!r}.")

        return find_fiedler

    @not_implemented_for("directed")
    @np_random_state(5)
    @nx._dispatchable(edge_attrs="weight")
    def algebraic_connectivity(
        G, weight="weight", normalized=False, tol=1e-8, method="tracemin_pcg", seed=None
    ):
        r"""Returns the algebraic connectivity of an undirected graph.

        The algebraic connectivity of a connected undirected graph is the second
        smallest eigenvalue of its Laplacian matrix.

        Parameters
        ----------
        G : NetworkX graph
            An undirected graph.

        weight : object, optional (default: None)
            The data key used to determine the weight of each edge. If None, then
            each edge has unit weight.

        normalized : bool, optional (default: False)
            Whether the normalized Laplacian matrix is used.

        tol : float, optional (default: 1e-8)
            Tolerance of relative residual in eigenvalue computation.

        method : string, optional (default: 'tracemin_pcg')
            Method of eigenvalue computation. It must be one of the tracemin
            options shown below (TraceMIN), 'lanczos' (Lanczos iteration)
            or 'lobpcg' (LOBPCG).

            The TraceMIN algorithm uses a linear system solver. The following
            values allow specifying the solver to be used.

            =============== ========================================
            Value           Solver
            =============== ========================================
            'tracemin_pcg'  Preconditioned conjugate gradient method
            'tracemin_lu'   LU factorization
            =============== ========================================

        seed : integer, random_state, or None (default)
            Indicator of random number generation state.
            See :ref:`Randomness<randomness>`.

        Returns
        -------
        algebraic_connectivity : float
            Algebraic connectivity.

        Raises
        ------
        NetworkXNotImplemented
            If G is directed.

        NetworkXError
            If G has less than two nodes.

        Notes
        -----
        Edge weights are interpreted by their absolute values. For MultiGraph's,
        weights of parallel edges are summed. Zero-weighted edges are ignored.

        See Also
        --------
        laplacian_matrix

        Examples
        --------
        For undirected graphs algebraic connectivity can tell us if a graph is connected or not
        `G` is connected iff  ``algebraic_connectivity(G) > 0``:

        >>> G = nx.complete_graph(5)
        >>> nx.algebraic_connectivity(G) > 0
        True
        >>> G.add_node(10)  # G is no longer connected
        >>> nx.algebraic_connectivity(G) > 0
        False

        """
        if len(G) < 2:
            raise nx.NetworkXError("graph has less than two nodes.")
        G = _preprocess_graph(G, weight)
        if not nx.is_connected(G):
            return 0.0

        L = nx.laplacian_matrix(G)
        if L.shape[0] == 2:
            return 2.0 * float(L[0, 0]) if not normalized else 2.0

        find_fiedler = _get_fiedler_func(method)
        x = None if method != "lobpcg" else _rcm_estimate(G, G)
        sigma, fiedler = find_fiedler(L, x, normalized, tol, seed)
        return float(sigma)

    @not_implemented_for("directed")
    @np_random_state(5)
    @nx._dispatchable(edge_attrs="weight")
    def fiedler_vector(
        G, weight="weight", normalized=False, tol=1e-8, method="tracemin_pcg", seed=None
    ):
        """Returns the Fiedler vector of a connected undirected graph.

        The Fiedler vector of a connected undirected graph is the eigenvector
        corresponding to the second smallest eigenvalue of the Laplacian matrix
        of the graph.

        Parameters
        ----------
        G : NetworkX graph
            An undirected graph.

        weight : object, optional (default: None)
            The data key used to determine the weight of each edge. If None, then
            each edge has unit weight.

        normalized : bool, optional (default: False)
            Whether the normalized Laplacian matrix is used.

        tol : float, optional (default: 1e-8)
            Tolerance of relative residual in eigenvalue computation.

        method : string, optional (default: 'tracemin_pcg')
            Method of eigenvalue computation. It must be one of the tracemin
            options shown below (TraceMIN), 'lanczos' (Lanczos iteration)
            or 'lobpcg' (LOBPCG).

            The TraceMIN algorithm uses a linear system solver. The following
            values allow specifying the solver to be used.

            =============== ========================================
            Value           Solver
            =============== ========================================
            'tracemin_pcg'  Preconditioned conjugate gradient method
            'tracemin_lu'   LU factorization
            =============== ========================================

        seed : integer, random_state, or None (default)
            Indicator of random number generation state.
            See :ref:`Randomness<randomness>`.

        Returns
        -------
        fiedler_vector : NumPy array of floats.
            Fiedler vector.

        Raises
        ------
        NetworkXNotImplemented
            If G is directed.

        NetworkXError
            If G has less than two nodes or is not connected.

        Notes
        -----
        Edge weights are interpreted by their absolute values. For MultiGraph's,
        weights of parallel edges are summed. Zero-weighted edges are ignored.

        See Also
        --------
        laplacian_matrix

        Examples
        --------
        Given a connected graph the signs of the values in the Fiedler vector can be
        used to partition the graph into two components.

        >>> G = nx.barbell_graph(5, 0)
        >>> nx.fiedler_vector(G, normalized=True, seed=1)
        array([-0.32864129, -0.32864129, -0.32864129, -0.32864129, -0.26072899,
                0.26072899,  0.32864129,  0.32864129,  0.32864129,  0.32864129])

        The connected components are the two 5-node cliques of the barbell graph.
        """
        import numpy as np

        if len(G) < 2:
            raise nx.NetworkXError("graph has less than two nodes.")
        G = _preprocess_graph(G, weight)
        if not nx.is_connected(G):
            raise nx.NetworkXError("graph is not connected.")

        if len(G) == 2:
            return np.array([1.0, -1.0])

        find_fiedler = _get_fiedler_func(method)
        L = nx.laplacian_matrix(G)
        x = None if method != "lobpcg" else _rcm_estimate(G, G)
        sigma, fiedler = find_fiedler(L, x, normalized, tol, seed)
        return fiedler

    @np_random_state(5)
    @nx._dispatchable(edge_attrs="weight")
    def spectral_ordering(
        G, weight="weight", normalized=False, tol=1e-8, method="tracemin_pcg", seed=None
    ):
        """Compute the spectral_ordering of a graph.

        The spectral ordering of a graph is an ordering of its nodes where nodes
        in the same weakly connected components appear contiguous and ordered by
        their corresponding elements in the Fiedler vector of the component.

        Parameters
        ----------
        G : NetworkX graph
            A graph.

        weight : object, optional (default: None)
            The data key used to determine the weight of each edge. If None, then
            each edge has unit weight.

        normalized : bool, optional (default: False)
            Whether the normalized Laplacian matrix is used.

        tol : float, optional (default: 1e-8)
            Tolerance of relative residual in eigenvalue computation.

        method : string, optional (default: 'tracemin_pcg')
            Method of eigenvalue computation. It must be one of the tracemin
            options shown below (TraceMIN), 'lanczos' (Lanczos iteration)
            or 'lobpcg' (LOBPCG).

            The TraceMIN algorithm uses a linear system solver. The following
            values allow specifying the solver to be used.

            =============== ========================================
            Value           Solver
            =============== ========================================
            'tracemin_pcg'  Preconditioned conjugate gradient method
            'tracemin_lu'   LU factorization
            =============== ========================================

        seed : integer, random_state, or None (default)
            Indicator of random number generation state.
            See :ref:`Randomness<randomness>`.

        Returns
        -------
        spectral_ordering : NumPy array of floats.
            Spectral ordering of nodes.

        Raises
        ------
        NetworkXError
            If G is empty.

        Notes
        -----
        Edge weights are interpreted by their absolute values. For MultiGraph's,
        weights of parallel edges are summed. Zero-weighted edges are ignored.

        See Also
        --------
        laplacian_matrix
        """
        if len(G) == 0:
            raise nx.NetworkXError("graph is empty.")
        G = _preprocess_graph(G, weight)

        find_fiedler = _get_fiedler_func(method)
        order = []
        for component in nx.connected_components(G):
            size = len(component)
            if size > 2:
                L = nx.laplacian_matrix(G, component)
                x = None if method != "lobpcg" else _rcm_estimate(G, component)
                sigma, fiedler = find_fiedler(L, x, normalized, tol, seed)
                sort_info = zip(fiedler, range(size), component)
                order.extend(u for x, c, u in sorted(sort_info))
            else:
                order.extend(component)

        return order

    @nx._dispatchable(edge_attrs="weight")
    def spectral_bisection(
        G, weight="weight", normalized=False, tol=1e-8, method="tracemin_pcg", seed=None
    ):
        """Bisect the graph using the Fiedler vector.

        This method uses the Fiedler vector to bisect a graph.
        The partition is defined by the nodes which are associated with
        either positive or negative values in the vector.

        Parameters
        ----------
        G : NetworkX Graph

        weight : str, optional (default: weight)
            The data key used to determine the weight of each edge. If None, then
            each edge has unit weight.

        normalized : bool, optional (default: False)
            Whether the normalized Laplacian matrix is used.

        tol : float, optional (default: 1e-8)
            Tolerance of relative residual in eigenvalue computation.

        method : string, optional (default: 'tracemin_pcg')
            Method of eigenvalue computation. It must be one of the tracemin
            options shown below (TraceMIN), 'lanczos' (Lanczos iteration)
            or 'lobpcg' (LOBPCG).

            The TraceMIN algorithm uses a linear system solver. The following
            values allow specifying the solver to be used.

            =============== ========================================
            Value           Solver
            =============== ========================================
            'tracemin_pcg'  Preconditioned conjugate gradient method
            'tracemin_lu'   LU factorization
            =============== ========================================

        seed : integer, random_state, or None (default)
            Indicator of random number generation state.
            See :ref:`Randomness<randomness>`.

        Returns
        -------
        bisection : tuple of sets
            Sets with the bisection of nodes

        Examples
        --------
        >>> G = nx.barbell_graph(3, 0)
        >>> nx.spectral_bisection(G)
        ({0, 1, 2}, {3, 4, 5})

        References
        ----------
        .. [1] M. E. J Newman 'Networks: An Introduction', pages 364-370
           Oxford University Press 2011.
        """
        import numpy as np

        v = nx.fiedler_vector(G, weight, normalized, tol, method, seed)
        nodes = np.array(list(G))
        pos_vals = v >= 0

        return set(nodes[~pos_vals].tolist()), set(nodes[pos_vals].tolist())