wg3dZddlZddlmZddlmZddlmZddlZ ddl m Z ddl m Z ddlmZd gZed e j"d dd ZdZddZGdde j*Zy)z,Fast approximation for k-component structureN) defaultdict)Mapping)cached_property)local_node_connectivity) NetworkXError)not_implemented_for k_componentsdirectedapproximate_k_components)namec tt}t}tj}tj }tj }tj}tj|D]0}t|} t| dkDs|dj| 2tj |D]0} t| } t| dkDs|dj| 2||} t| j} td| dzD]9}|||| }||D]}t||kr|j!|}t#}|j%|j'||dD])\}}|||||}||kDs|j)||+||D]}t||kr|j!|}t+||||D]`}||D]S}tj|j!||}t||kr7||jt|Ub"<|S)aReturns the approximate 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. This implementation is based on the fast heuristics to approximate the `k`-component structure of a graph [1]_. Which, in turn, it is based on a fast approximation algorithm for finding good lower bounds of the number of node independent paths between two nodes [2]_. Parameters ---------- G : NetworkX graph Undirected graph min_density : Float Density relaxation threshold. Default value 0.95 Returns ------- k_components : dict Dictionary with connectivity level `k` as key and a list of sets of nodes that form a k-component of level `k` as values. Raises ------ NetworkXNotImplemented If G 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 >>> from networkx.algorithms import approximation as apxa >>> G = nx.petersen_graph() >>> k_components = apxa.k_components(G) Notes ----- The logic of the approximation algorithm for computing the `k`-component structure [1]_ is based on repeatedly applying simple and fast algorithms for `k`-cores and biconnected components in order to narrow down the number of pairs of nodes over which we have to compute White and Newman's approximation algorithm for finding node independent paths [2]_. More formally, this algorithm is based on Whitney's theorem, which states an inclusion relation among node connectivity, edge connectivity, and minimum degree for any graph G. This theorem implies that every `k`-component is nested inside a `k`-edge-component, which in turn, is contained in a `k`-core. Thus, this algorithm computes node independent paths among pairs of nodes in each biconnected part of each `k`-core, and repeats this procedure for each `k` from 3 to the maximal core number of a node in the input graph. Because, in practice, many nodes of the core of level `k` inside a bicomponent actually are part of a component of level k, the auxiliary graph needed for the algorithm is likely to be very dense. Thus, we use a complement graph data structure (see `AntiGraph`) to save memory. AntiGraph only stores information of the edges that are *not* present in the actual auxiliary graph. When applying algorithms to this complement graph data structure, it behaves as if it were the dense version. See also -------- k_components References ---------- .. [1] Torrents, J. and F. Ferraro (2015) Structural Cohesion: Visualization and Heuristics for Fast Computation. https://arxiv.org/pdf/1503.04476v1 .. [2] White, Douglas R., and Mark Newman (2001) A Fast Algorithm for Node-Independent Paths. Santa Fe Institute Working Paper #01-07-035 https://www.santafe.edu/research/results/working-papers/fast-approximation-algorithms-for-finding-node-ind .. [3] Moody, J. and D. White (2003). Social cohesion and embeddedness: A hierarchical conception of social groups. American Sociological Review 68(1), 103--28. https://doi.org/10.2307/3088904 ) core_number)cutoff)rlistrnxk_corerbiconnected_components itertools combinationsconnected_componentssetlenappendmaxvaluesrangesubgraph _AntiGraphadd_nodes_fromnodesadd_edge_cliques_heuristic)G min_densityr node_connectivityrrrr componentcomp bicomponentbicomp g_cnumbermax_corekCr#SGHuvKh_nodesSHGck_nodesGks r/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/networkx/algorithms/approximation/kcomponents.pyr r s;vt$L/ YYF..K66))L,,Q/) 9~ t9q= O " "4 ( ) 003+ [! v;? O " "6 * +AI9##%&H 1hl #8 1aY /+A. 8E5zA~E"B A  RXXZ ($R+ %1%b!Qq9q5JJq!$ %2!4 8w<1$ZZ(,RQ D8B#9"#=8YYr{{7';Q?r7a<$$Q..s2w7 88 8 882 c #Ktj|}ttt |j dD]\}}|j Dchc] \}}||k(s |} }}|dk(rd} n8t j| D cgc]}||D chc] } | | vs|  c} c} }} | r#t| |kr|j| | z} n|j| } tj| } tj|j| |}t| rtj| |k\s|j|j} t| |kr1tj| } t| j}t!|j | j#fd|j Dtj|j| |}t| stj| |k\s|ycc}}wcc} wcc} }ww)NT)reverserFc34K|]\}}|k(s |ywN).0ndmin_degs r; z%_cliques_heuristic..s Ntq!g Ns )rr enumeratesortedrritems intersectionrr r_samedensitycopydictdegreeminremove_nodes_from)r&r2r/r' h_cnumberic_valuerCccandsoverlapxr7 sh_cnumberr1sh_degrEs @r;r%r%sq!Is9+;+;+='> MN 7(0Atq!ALAA 6G&&?DE!ad5aun15EG s7|a'EGO,BE"B^^B' YYqzz"~q )$B;)FB$$&B2w!|+J"))+&F&--/*G  Nv||~ N N1::b>1-B$B;)FH5A 6EsOAI  H8.H82I  I  H>'H>+I 0E&I I 0I >I I clt|j}t|t|z |kryy)NTF)rrrrP)measuretolvalss r;rKrKs. w~~ D D CI#% r<ceZdZdZddiZdZeZdZdZGdde Z Gd d e Z e d Z d ZGd dej j"Ze dZdZy)r!a Class for complement graphs. The main goal is to be able to work with big and dense graphs with a low memory footprint. In this class you add the edges that *do not exist* in the dense graph, the report methods of the class return the neighbors, the edges and the degree as if it was the dense graph. Thus it's possible to use an instance of this class with some of NetworkX functions. In this case we only use k-core, connected_components, and biconnected_components. weightrc|jSr@) all_edge_dictselfs r;single_edge_dictz_AntiGraph.single_edge_dicts!!!r<c|j}t|jt|j|z |hz Dcic]}||c}Scc}w)aReturns a dict of neighbors of node n in the dense graph. Parameters ---------- n : node A node in the graph. Returns ------- adj_dict : dictionary The adjacency dictionary for nodes connected to n. )rbr_adj)rdrCrbnodes r; __getitem__z_AntiGraph.__getitem__sT** ,/ NS1=N,NRSQT,T $(D-    s Ac tt|jt|j|z |hz S#t$r}t d|d|d}~wwxYw)zUReturns an iterator over all neighbors of node n in the dense graph. z The node z is not in the graph.N)iterrrgKeyErrorr)rdrCerrs r; neighborsz_AntiGraph.neighborss] ODIITYYq\)::aS@A A O)A3.C DE3 N Os:= AAAc(eZdZdZdZdZdZdZy)_AntiGraph.AntiAtlasViewz%An adjacency inner dict for AntiGraphcH||_|j||_||_yr@)_graphrg_atlas_node)rdgraphrhs r;__init__z!_AntiGraph.AntiAtlasView.__init__s DK**T*DKDJr<c^t|jt|jz dz S)Nr)rrrrsrcs r;__len__z _AntiGraph.AntiAtlasView.__len__s$t{{#c$++&66: :r<c.fdjDS)Nc3`K|]%}|jvs|jk7s"|'ywr@)rsrt)rBrCrds r;rFz4_AntiGraph.AntiAtlasView.__iter__..s&W!at{{.BqDJJAWs ...)rrrcs`r;__iter__z!_AntiGraph.AntiAtlasView.__iter__sWt{{W Wr<ct|jjt|jz |jhz }||vr|jj St |r@)rrrrgrsrtrbrl)rdnbrnbrss r;riz$_AntiGraph.AntiAtlasView.__getitem__sPt{{''(3t{{+;;tzzlJDd{{{0003- r<N__name__ __module__ __qualname____doc__rvrxr{rirAr<r; AntiAtlasViewrps3   ; X r<rc(eZdZdZdZdZdZdZy)_AntiGraph.AntiAdjacencyViewz%An adjacency outer dict for AntiGraphc4||_|j|_yr@)rrrgrs)rdrus r;rvz%_AntiGraph.AntiAdjacencyView.__init__ sDK**DKr<c,t|jSr@)rrsrcs r;rxz$_AntiGraph.AntiAdjacencyView.__len__st{{# #r<c,t|jSr@)rkrrrcs r;r{z%_AntiGraph.AntiAdjacencyView.__iter__s $ $r<c||jvr t||jj|j|Sr@)rrrlr)rdrhs r;riz(_AntiGraph.AntiAdjacencyView.__getitem__s34;;&tn$;;,,T[[$? ?r<NrrAr<r;AntiAdjacencyViewr s3 % $ % @r<rc$|j|Sr@)rrcs r;adjz_AntiGraph.adjs%%d++r<cVt|}t}|j||D]l}|j}||j|<|j|j D]+\}}||jvs|||<||j||<-n|j |_|S)z9This subgraph method returns a full AntiGraph. Not a View)rr!r"adjlist_inner_dict_factoryrgrIru)rdr#r&rCGnbrsr}rDs r;r z_AntiGraph.subgraph sE  L  'A002EAFF1I))A,,,. 'Q!&&=!"E#J%&AFF3KN ' '**r<ceZdZdZdZy)_AntiGraph.AntiDegreeViewc#Kt|j}|jD]0}|t|j|z |hz }|t|f2ywr@)r_succ_nodesr)rd all_nodesrCr~s r;r{z"_AntiGraph.AntiDegreeView.__iter__0sRDJJI[[ % 3tzz!}#55;#d)n$ %sAAct|jt|j|z |hz }t|||vzSr@)rrr)rdrCr~s r;riz%_AntiGraph.AntiDegreeView.__getitem__6s;tzz?SA%771#=Dt9T * *r<N)rrrr{rirAr<r;AntiDegreeViewr/s  %  +r<rc$|j|S)aReturns an iterator for (node, degree) and degree for single node. The node degree is the number of edges adjacent to the node. Parameters ---------- nbunch : iterable container, optional (default=all nodes) A container of nodes. The container will be iterated through once. weight : string or None, optional (default=None) The edge attribute that holds the numerical value used as a weight. If None, then each edge has weight 1. The degree is the sum of the edge weights adjacent to the node. Returns ------- deg: Degree of the node, if a single node is passed as argument. nd_iter : an iterator The iterator returns two-tuples of (node, degree). See Also -------- degree Examples -------- >>> G = nx.path_graph(4) >>> G.degree(0) # node 0 with degree 1 1 >>> list(G.degree([0, 1])) [(0, 1), (1, 2)] )rrcs r;rOz_AntiGraph.degree;sJ""4((r<c#K|jD]8}|t|jt|j|z |hz f:yw)a{Returns an iterator of (node, adjacency set) tuples for all nodes in the dense graph. This is the fastest way to look at every edge. For directed graphs, only outgoing adjacencies are included. Returns ------- adj_iter : iterator An iterator of (node, adjacency set) for all nodes in the graph. N)rgr)rdrCs r; adjacencyz_AntiGraph.adjacencybsI @Ac$))ns499Q<'88A3>? ? @sA A N)rrrrrbreedge_attr_dict_factoryrirnrrrrrr r reportviews DegreeViewrrOrrAr<r;r!r!s qMM". &O  (@M@$,,  +22 +$)$)L@r<r!)gffffff?)r)rr collectionsrcollections.abcr functoolsrnetworkxr!networkx.algorithms.approximationrnetworkx.exceptionrnetworkx.utilsr__all__ _dispatchabler r%rKGraphr!rAr<r;rsx2##%E,.  Z 12J3!JZ>l@l@r<