+ j%Rt^RIt^RIHt^RIHt^RIHtR.t ]!R4]P!RRR 7RRR ^/R l44t RR R RR/Rllt R#)z?Community detection and quality functions for bipartite graphs.N) is_partition) NotAPartition)not_implemented_for modularitydirectedbipartite_modularityweight)name edge_attrs resolutioncaaaaaaaa a \V\4'g \V4p\SV4'g \SV4h\ V4o \ S4S , o\ SP SR74o\V3RlS 44oS^8XdR#^S^,, o VVVVV V VV3Rlo\V3RlV44#)aReturns Barber's bipartite modularity of the given partition. Bipartite modularity [1]_ adapts Newman's modularity to bipartite networks by replacing the configuration-model null model with one that respects the bipartite structure: expected edges only occur between the two node sets. For a bipartite graph with "red" nodes (one set) and "blue" nodes (the other), it is defined as .. math:: Q_B = \frac{1}{m} \sum_{v=1}^{r} \sum_{w=1}^{c} \left( \tilde{A}_{vw} - \gamma\frac{k_v d_w}{m} \right) \delta(c_v, c_w) where $m$ is the (weighted) number of edges, $\tilde{A}$ is the bipartite adjacency matrix, $k_v$ is the (weighted) degree of red node $v$, $d_w$ is the (weighted) degree of blue node $w$, $\gamma$ is the resolution parameter, and $\delta(c_v, c_w)$ is 1 if $v$ and $w$ are in the same community, else 0. Following Clauset, Newman and Moore [2]_, this can be rewritten as a sum over communities: .. math:: Q_B = \sum_{c=1}^{n} \left[ \frac{L_c}{m} - \gamma\,\frac{k_c d_c}{m^2} \right] where $L_c$ is the (weighted) number of intra-community edges for community $c$, $k_c$ is the sum of degrees of the red nodes in $c$, and $d_c$ is the sum of degrees of the blue nodes in $c$. This is the form used in the implementation. Note the structural analogy with the standard (unipartite) sum formulation `L_c/m - gamma * (k_c / 2m)^2`: the null-model term is a product of two degree sums, and in the undirected unipartite case those two sums coincide so the product becomes a square. In the bipartite case the sums differ (red vs. blue), so the null model term remains a product of two distinct terms. Communities in a bipartite modularity partition may contain nodes from both bipartite sets; the bipartite structure enters only through the null model. Parameters ---------- G : NetworkX Graph An undirected bipartite graph. communities : list or iterable of sets of nodes These node sets must represent a partition of `G`'s nodes. Communities may contain nodes from both bipartite sets. nodes : container of nodes A container with all nodes in **one** bipartite node set (the "red" nodes). The other set is inferred as ``set(G) - set(nodes)``. This follows the convention used throughout the bipartite subpackage. weight : string or None, optional (default="weight") The edge attribute that holds the numerical value used as the edge weight. If None or if an edge does not have the attribute, that edge is treated as having weight 1. resolution : float (default=1) Resolution parameter $\gamma$. With the default ``resolution=1``, $Q_B$ reduces to Barber's original definition. Values smaller than 1 favor larger communities; values greater than 1 favor smaller communities. The resolution parameter is not part of Barber's original definition, but a standard extension consistent with :func:`networkx.community.modularity`. Returns ------- Q_B : float The bipartite modularity of the partition. Raises ------ NotAPartition If `communities` is not a valid partition of the nodes of `G`. NetworkXNotImplemented If `G` is directed. Barber's formulation is for undirected bipartite graphs. Examples -------- Two disconnected :math:`K_{2,2}` components form a strong bipartite community structure: >>> G = nx.Graph([(0, 2), (1, 3)]) >>> red = {0, 1} >>> nx.bipartite.modularity(G, [{0, 2}, {1, 3}], red) 0.5 Notes ----- The functions in the bipartite package do not check that `nodes` is actually one side of a bipartition of `G`. It is the caller's responsibility to provide a valid bipartite graph and a valid bipartite node set. See Also -------- modularity References ---------- .. [1] Barber, M. J. (2007). "Modularity and community detection in bipartite networks." Physical Review E, 76(6), 066102. https://doi.org/10.1103/PhysRevE.76.066102 .. [2] Clauset, A., Newman, M. E. J., and Moore, C. (2004). "Finding community structure in very large networks." Physical Review E, 70(6), 066111. rc36<"TFpSV,xK R#5iN).0vdegrees& h/home/luca/screen-checking/.venv/lib/python3.14/site-packages/networkx/algorithms/bipartite/community.py modularity..s #s!F1IIsgc $<a\V4o\V3RlSPSS ^R744p\V3RlSS ,44p\V3RlSS,44pVS, S V,V,S ,, #)c3><"TFwrq2S9gKVxK R#5irr)r_rwtcomms& rr=modularity..community_contribution..sX%JrSWi""%Js  datadefaultc36<"TFpSV,xK R#5irrrurs& rrrs0Z&))Zrc36<"TFpSV,xK R#5irrr"s& rrrs1[&))[r)setsumedges) communityL_ck_cd_crGbluermnormredr rs & @rcommunity_contribution*modularity..community_contributionss9~ XQWWTW%JXX0TCZ001TD[11Qwc)C/$666c34<"TF pS!V4xK R#5irr)rcr1s& rrrs>+Q%a((+s) isinstancelistrrr%dictrr&) r, communitiesnodesrr r-r1rr.r/r0s f&&dd@@@@@@rrr sn k4 ( (;' ; ' 'A{++ e*C q6C+> >>r3red_degree_attr red_degreeblue_degree_attr blue_degreec aaaa VPo \V V3RlV44p\VV 3RlV44p \V V3RlS44p \VV 3RlS44p \V3RlVPW^R744p W, W8V ,W,,,V^,, , #)a Change in bipartite modularity from merging two disjoint communities. Computes ``Q_B(P') - Q_B(P)`` where P contains `community_a` and `community_b` as separate communities and P' is obtained by replacing them with their union ``community_a U community_b``. For bipartite modularity ``Q_B = sum_c [L_c/m - gamma k_c d_c / m^2]``, the merge delta has the closed form merge_delta = E(A, B) / m - gamma * (k_A d_B + k_B d_A) / m^2 where ``E(A, B)`` is the sum of edge weights between A and B, ``k_C`` is the sum of the "red" degrees of nodes in C, and ``d_C`` is the sum of the "blue" degrees of nodes in C. **Attribute-based interface.** Rather than identifying each node with a single bipartite side (which breaks once Louvain/Leiden has aggregated communities into super-nodes that mix both colors), this helper reads per-node ``red_degree_attr`` and ``blue_degree_attr`` attributes. On the original bipartite graph a red node has ``red_degree = G.degree(v)`` and ``blue_degree = 0`` (and vice versa). On an aggregated graph each super-node carries the sums of both attributes over its constituent nodes; both may be nonzero. This is the same pattern used for directed modularity (in-degree / out-degree tracked as separate attributes). `community_a` and `community_b` must be disjoint and non-empty. Self-loops are tolerated: on the original graph they are absent by the bipartite convention, and on aggregated graphs they represent intra-community edges which are not part of ``E(A, B)`` and are correctly excluded by the ``v in community_b`` filter below. Parameters ---------- G : NetworkX Graph A graph whose nodes carry the red/blue degree attributes. May be an original bipartite graph or an aggregated graph produced by a multilevel optimizer. community_a, community_b : set Two disjoint communities to merge. resolution : float Resolution parameter gamma. weight : str or None Edge weight attribute. red_degree_attr : str Keyword-only. Name of the node attribute holding the "red-side" contribution to the node's degree. blue_degree_attr : str Keyword-only. Name of the node attribute holding the "blue-side" contribution to the node's degree. m : float Keyword-only. Total (weighted) edge count, a graph-level invariant preserved across aggregation. c3V<"TFpSV,PS^4xK R#5iNgetrrr:r;s& rr4_bipartite_modularity_merge_delta..# D 1eAhll?A.. &)c3V<"TFpSV,PS^4xK R#5irArCrrr=r:s& rrrF$ EAeAhll+Q//rHc3V<"TFpSV,PS^4xK R#5irArCrEs& rrrFrGrHc3V<"TFpSV,PS^4xK R#5irArCrJs& rrrFrKrHc3@<"TFwrpVS9gKVxK R#5irr)rrrr community_bs& rrrFs&DHA"  Ds  r)r:r&r')r, community_arOr rr;r=r.k_ad_ak_bd_bE_crossr:s&&f&&dd$ @r!_bipartite_modularity_merge_deltarVsD GGE D D DC E E EC D D DC E E EC  !DG ;Sy39'<=1D DDr3r ) __doc__networkxnx-networkx.algorithms.community.community_utilsr%networkx.algorithms.community.qualityrnetworkx.utils.decoratorsr__all__ _dispatchablerrVrr3rr_s}EF?9 .Z -(CU?U?QU?D!U?pRE!RE#REr3