heSrSSKJrJr SSKJrJrJr SSKr SSK J r /SQr \ "S5\ RS55r\ "S5\ RSS j55r\ RSS j5r\ R"S S 9SS j5r\ R"S S 9SSj5r\ RSSj5rSSjr"SS5r\ "S5\ R"SS9SSj55rg)a@Functions for finding and manipulating cliques. Finding the largest clique in a graph is NP-complete problem, so most of these algorithms have an exponential running time; for more information, see the Wikipedia article on the clique problem [1]_. .. [1] clique problem:: https://en.wikipedia.org/wiki/Clique_problem ) defaultdictdeque)chain combinationsisliceN)not_implemented_for) find_cliquesfind_cliques_recursivemake_max_clique_graphmake_clique_bipartitenode_clique_numbernumber_of_cliquesenumerate_all_cliquesmax_weight_cliquedirectedc #^^# 0m0mUH0n[T5TU'XVs1sH o"T;dM UiM snTU'M2 [UU4SjU55nU(a[[UR 55upEUv [ U5HFupaUR [XA/5[TUR[XVS-S5545 MH U(aMggs snf7f)aReturns all cliques in an undirected graph. This function returns an iterator over cliques, each of which is a list of nodes. The iteration is ordered by cardinality of the cliques: first all cliques of size one, then all cliques of size two, etc. Parameters ---------- G : NetworkX graph An undirected graph. Returns ------- iterator An iterator over cliques, each of which is a list of nodes in `G`. The cliques are ordered according to size. Notes ----- To obtain a list of all cliques, use `list(enumerate_all_cliques(G))`. However, be aware that in the worst-case, the length of this list can be exponential in the number of nodes in the graph (for example, when the graph is the complete graph). This function avoids storing all cliques in memory by only keeping current candidate node lists in memory during its search. The implementation is adapted from the algorithm by Zhang, et al. (2005) [1]_ to output all cliques discovered. This algorithm ignores self-loops and parallel edges, since cliques are not conventionally defined with such edges. References ---------- .. [1] Yun Zhang, Abu-Khzam, F.N., Baldwin, N.E., Chesler, E.J., Langston, M.A., Samatova, N.F., "Genome-Scale Computational Approaches to Memory-Intensive Applications in Systems Biology". *Supercomputing*, 2005. Proceedings of the ACM/IEEE SC 2005 Conference, pp. 12, 12--18 Nov. 2005. . c3V># UHo/[TUTRS94v M g7f)keyN)sorted __getitem__).0uindexnbrss L/var/www/html/env/lib/python3.13/site-packages/networkx/algorithms/clique.py (enumerate_all_cliques..Ss'KA3tAwE,=,=>?s&)N) lenrmaplistpopleft enumerateappendrfilter __contains__r) Grvqueuebasecnbrsirrs @@rrrs^ E D u:ad5dun1d5Q KK KE $ 0  e$DA LL$$47//1ud1KL % %6sC% C C B'C%C%c #<^ ^# [U5S:XagUVVs0sHo"XVs1sH o3U:wdM UiM sn_M! snnm UbUSSO/n[U5mUH nUT;a[SUS35eTT U-mM" T(dUSSv gTR5n/nUR S5 [ UU U4SjS9nTT U- nU(aUR 5n TRU 5 XS'T U n Xj-n U (dUSSv OqTU -n U (a@UR UTU45 UR S5 U nU m[ UU U4SjS9nTT U- nO$UR 5 UR 5unmnMs snfs snnf![a gf=f7f) a4Returns all maximal cliques in an undirected graph. For each node *n*, a *maximal clique for n* is a largest complete subgraph containing *n*. The largest maximal clique is sometimes called the *maximum clique*. This function returns an iterator over cliques, each of which is a list of nodes. It is an iterative implementation, so should not suffer from recursion depth issues. This function accepts a list of `nodes` and only the maximal cliques containing all of these `nodes` are returned. It can considerably speed up the running time if some specific cliques are desired. Parameters ---------- G : NetworkX graph An undirected graph. nodes : list, optional (default=None) If provided, only yield *maximal cliques* containing all nodes in `nodes`. If `nodes` isn't a clique itself, a ValueError is raised. Returns ------- iterator An iterator over maximal cliques, each of which is a list of nodes in `G`. If `nodes` is provided, only the maximal cliques containing all the nodes in `nodes` are returned. The order of cliques is arbitrary. Raises ------ ValueError If `nodes` is not a clique. Examples -------- >>> from pprint import pprint # For nice dict formatting >>> G = nx.karate_club_graph() >>> sum(1 for c in nx.find_cliques(G)) # The number of maximal cliques in G 36 >>> max(nx.find_cliques(G), key=len) # The largest maximal clique in G [0, 1, 2, 3, 13] The size of the largest maximal clique is known as the *clique number* of the graph, which can be found directly with: >>> max(len(c) for c in nx.find_cliques(G)) 5 One can also compute the number of maximal cliques in `G` that contain a given node. The following produces a dictionary keyed by node whose values are the number of maximal cliques in `G` that contain the node: >>> pprint({n: sum(1 for c in nx.find_cliques(G) if n in c) for n in G}) {0: 13, 1: 6, 2: 7, 3: 3, 4: 2, 5: 3, 6: 3, 7: 1, 8: 3, 9: 2, 10: 2, 11: 1, 12: 1, 13: 2, 14: 1, 15: 1, 16: 1, 17: 1, 18: 1, 19: 2, 20: 1, 21: 1, 22: 1, 23: 3, 24: 2, 25: 2, 26: 1, 27: 3, 28: 2, 29: 2, 30: 2, 31: 4, 32: 9, 33: 14} Or, similarly, the maximal cliques in `G` that contain a given node. For example, the 4 maximal cliques that contain node 31: >>> [c for c in nx.find_cliques(G) if 31 in c] [[0, 31], [33, 32, 31], [33, 28, 31], [24, 25, 31]] See Also -------- find_cliques_recursive A recursive version of the same algorithm. Notes ----- To obtain a list of all maximal cliques, use `list(find_cliques(G))`. However, be aware that in the worst-case, the length of this list can be exponential in the number of nodes in the graph. This function avoids storing all cliques in memory by only keeping current candidate node lists in memory during its search. This implementation is based on the algorithm published by Bron and Kerbosch (1973) [1]_, as adapted by Tomita, Tanaka and Takahashi (2006) [2]_ and discussed in Cazals and Karande (2008) [3]_. It essentially unrolls the recursion used in the references to avoid issues of recursion stack depth (for a recursive implementation, see :func:`find_cliques_recursive`). This algorithm ignores self-loops and parallel edges, since cliques are not conventionally defined with such edges. References ---------- .. [1] Bron, C. and Kerbosch, J. "Algorithm 457: finding all cliques of an undirected graph". *Communications of the ACM* 16, 9 (Sep. 1973), 575--577. .. [2] Etsuji Tomita, Akira Tanaka, Haruhisa Takahashi, "The worst-case time complexity for generating all maximal cliques and computational experiments", *Theoretical Computer Science*, Volume 363, Issue 1, Computing and Combinatorics, 10th Annual International Conference on Computing and Combinatorics (COCOON 2004), 25 October 2006, Pages 28--42 .. [3] F. Cazals, C. Karande, "A note on the problem of reporting maximal cliques", *Theoretical Computer Science*, Volume 407, Issues 1--3, 6 November 2008, Pages 564--568, rNThe given `nodes`  do not form a cliquec&>[TTU-5$Nr radjcands rfind_cliques.. sD3q6M 2rc&>[TTU-5$r2r3r4s rr7r8 sCs1v 4Fr9) r set ValueErrorcopyr%maxpopremove IndexError)r(nodesrr)Qnodesubgstackext_uqadj_qsubg_qcand_qr5r6s @@rr r esd 1v{34 51a!$)$Qq&q$) )1 5C%a2A q6D t 1%8MNO O D  d  99;D EHHTN D23A 3q6ME IIK A"AA$J!E\F dD%%89%%*FG $s1v $)IIK!dE)-* 5V    sKF F FFFBF B8F FF FFFFc ^^^ [U5S:Xa [/5$UVVs0sHo"XVs1sH o3U:wdM UiM sn_M! snnmUbUSSO/m[U5nTHnXT;a[SUS35eUTU-nM! U(d [T/5$UR 5nUUU 4Sjm T "Xd5$s snfs snnf)aW Returns all maximal cliques in a graph. For each node *v*, a *maximal clique for v* is a largest complete subgraph containing *v*. The largest maximal clique is sometimes called the *maximum clique*. This function returns an iterator over cliques, each of which is a list of nodes. It is a recursive implementation, so may suffer from recursion depth issues, but is included for pedagogical reasons. For a non-recursive implementation, see :func:`find_cliques`. This function accepts a list of `nodes` and only the maximal cliques containing all of these `nodes` are returned. It can considerably speed up the running time if some specific cliques are desired. Parameters ---------- G : NetworkX graph nodes : list, optional (default=None) If provided, only yield *maximal cliques* containing all nodes in `nodes`. If `nodes` isn't a clique itself, a ValueError is raised. Returns ------- iterator An iterator over maximal cliques, each of which is a list of nodes in `G`. If `nodes` is provided, only the maximal cliques containing all the nodes in `nodes` are yielded. The order of cliques is arbitrary. Raises ------ ValueError If `nodes` is not a clique. See Also -------- find_cliques An iterative version of the same algorithm. See docstring for examples. Notes ----- To obtain a list of all maximal cliques, use `list(find_cliques_recursive(G))`. However, be aware that in the worst-case, the length of this list can be exponential in the number of nodes in the graph. This function avoids storing all cliques in memory by only keeping current candidate node lists in memory during its search. This implementation is based on the algorithm published by Bron and Kerbosch (1973) [1]_, as adapted by Tomita, Tanaka and Takahashi (2006) [2]_ and discussed in Cazals and Karande (2008) [3]_. For a non-recursive implementation, see :func:`find_cliques`. This algorithm ignores self-loops and parallel edges, since cliques are not conventionally defined with such edges. References ---------- .. [1] Bron, C. and Kerbosch, J. "Algorithm 457: finding all cliques of an undirected graph". *Communications of the ACM* 16, 9 (Sep. 1973), 575--577. .. [2] Etsuji Tomita, Akira Tanaka, Haruhisa Takahashi, "The worst-case time complexity for generating all maximal cliques and computational experiments", *Theoretical Computer Science*, Volume 363, Issue 1, Computing and Combinatorics, 10th Annual International Conference on Computing and Combinatorics (COCOON 2004), 25 October 2006, Pages 28--42 .. [3] F. Cazals, C. Karande, "A note on the problem of reporting maximal cliques", *Theoretical Computer Science*, Volume 407, Issues 1--3, 6 November 2008, Pages 564--568, rNr/r0c3>^# [UUU4SjS9nTTU- HinTRU5 TRU5 TUnX-nU(dTSSv OTU-nU(aT "XV5ShvN TR5 Mk gN7f)Nc&>[TTU-5$r2r3r4s rr78find_cliques_recursive..expand..sCs1v $6r9r)r?rAr%r@) rFr6rrIrJrKrLrDr5expands ` rrQ&find_cliques_recursive..expands 6 7AA KKN HHQKFE\Fd %f555 EEG6sA,B 0B 1B )r iterr<r=r>) r(rCrr) cand_initrE subg_initrDr5rQs @@@rr r *sd 1v{Bx34 51a!$)$Qq&q$) )1 5C%a2AAI  1%8MNO OSY  QCy I  ) ''=* 5s B? B:B:B?:B?T) returns_graphcUcUR5nO[R"SU5n[[ S[ U5555nUR SU55 [US5nURSU55 U$)auReturns the maximal clique graph of the given graph. The nodes of the maximal clique graph of `G` are the cliques of `G` and an edge joins two cliques if the cliques are not disjoint. Parameters ---------- G : NetworkX graph create_using : NetworkX graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Returns ------- NetworkX graph A graph whose nodes are the cliques of `G` and whose edges join two cliques if they are not disjoint. Notes ----- This function behaves like the following code:: import networkx as nx G = nx.make_clique_bipartite(G) cliques = [v for v in G.nodes() if G.nodes[v]["bipartite"] == 0] G = nx.bipartite.projected_graph(G, cliques) G = nx.relabel_nodes(G, {-v: v - 1 for v in G}) It should be faster, though, since it skips all the intermediate steps. rc38# UHn[U5v M g7fr2)r<rcs rr(make_max_clique_graph..s=_SVV_c3*# UH upUv M g7fr2)rr-rZs rrr[s+741Q7sc3L# UHuupup4X$-(dMX4v M g7fr2r^)rr-c1jc2s rrr[s!LL 0!BGVaVLs$ $) __class__nx empty_graphr"r$r add_nodes_fromradd_edges_from)r( create_usingBcliques clique_pairss rr r sxF KKM NN1l +9=\!_==>G+7+++LLLLL Hr9c^[R"SU5nUR5 URUSS9 [ [ U55H6upVU*S- mUR TSS9 URU4SjU55 M8 U$)aeReturns the bipartite clique graph corresponding to `G`. In the returned bipartite graph, the "bottom" nodes are the nodes of `G` and the "top" nodes represent the maximal cliques of `G`. There is an edge from node *v* to clique *C* in the returned graph if and only if *v* is an element of *C*. Parameters ---------- G : NetworkX graph An undirected graph. fpos : bool If True or not None, the returned graph will have an additional attribute, `pos`, a dictionary mapping node to position in the Euclidean plane. create_using : NetworkX graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Returns ------- NetworkX graph A bipartite graph whose "bottom" set is the nodes of the graph `G`, whose "top" set is the cliques of `G`, and whose edges join nodes of `G` to the cliques that contain them. The nodes of the graph `G` have the node attribute 'bipartite' set to 1 and the nodes representing cliques have the node attribute 'bipartite' set to 0, as is the convention for bipartite graphs in NetworkX. rr) bipartitec3*># UHoT4v M g7fr2r^)rr)names rr(make_clique_bipartite..s/BqTBs)rerfclearrgr$r add_noderh)r(fposrirprjr-cls ` rr r sF q,'AGGIQ!$<?+rAv 41 % /B// , Hr9c ^UcTbvTU;a0[S[[R"UT5555$TVs0sH2oD[S[[R"X5555_M4 sn$[ [U55nTU;a[U4SjU55$[ [ 5nUH%n[U5nUHnXTU:dM XuU'M M' TcU$TVs0sHoDXT_M sn$s snfs snf)aReturns the size of the largest maximal clique containing each given node. Returns a single or list depending on input nodes. An optional list of cliques can be input if already computed. Parameters ---------- G : NetworkX graph An undirected graph. cliques : list, optional (default=None) A list of cliques, each of which is itself a list of nodes. If not specified, the list of all cliques will be computed using :func:`find_cliques`. Returns ------- int or dict If `nodes` is a single node, returns the size of the largest maximal clique in `G` containing that node. Otherwise return a dict keyed by node to the size of the largest maximal clique containing that node. See Also -------- find_cliques find_cliques yields the maximal cliques of G. It accepts a `nodes` argument which restricts consideration to maximal cliques containing all the given `nodes`. The search for the cliques is optimized for `nodes`. c38# UHn[U5v M g7fr2r3rYs rr%node_clique_number..'sP+Oa3q66+Or\c38# UHn[U5v M g7fr2r3rYs rrrx*sH'G!s1vv'Gr\c3J># UHnTU;dM [U5v M g7fr2r3)rrZrCs rrrx2s97aeqj63q667s ##)r?r re ego_graphr"rintr )r(rCrkseparate_nodesn size_for_nrZ size_of_cs ` rr r s B  zP< Q8N+OPPPSXRWQ3H|BLL4F'GHHHRW  |A' z97999S!J F A}y( )1   }&+ ,ez} e ,,+* -s 9D0DcXUc[[U55nUc[UR55n[U[5(d'Un[ UVs/sH oCU;dM SPM sn5nU$0nUH(n[ UVs/sH oCU;dM SPM sn5XS'M* U$s snfs snf)zReturns the number of maximal cliques for each node. Returns a single or list depending on input nodes. Optional list of cliques can be input if already computed. r)r"r rC isinstancer )r(rCrkr)rZnumcliqs rrrAs |A' }QWWY eT " " '4'Q!Vq'45 NA;AFa;/0wwy 9y!Ay 9D WWY+$QE)STF"6**!!''!*V"4c::#F:_QEATUF$V,, AB J 1AGGAJv$6!6 JD !:!Ks C,C1cDX R:aUSSUlX lgg)zYUpdate the incumbent if the node set C has greater weight. C is assumed to be a clique. N)rr)rCC_weights rupdate_incumbent_if_improved,MaxWeightClique.update_incumbent_if_improveds' ++ +#$Q4D $, ! ,r9c/nUSSnU(aZUSnURU5 UVs/sH.oCU:wdM URRX45(aM,UPM0 nnU(aMZU$s snf)z@Greedily find an independent set of nodes from a set of nodes P.Nr)r%r(has_edge)rPindependent_setr)ws rgreedily_find_independent_set-MaxWeightClique.greedily_find_independent_setsj aD!A  " "1 %FAqa0EAAFaGs A+A+A+cT^UVs0sHo3URU_M snmSnUSSnU(anURU5n[U4SjU55nXF- nXB:aU$UHnTU==U-ss'M UVs/sHnTUS:wdMUPM nnU(aMnU$s snfs snf)z!Find a set of nodes to branch on.rNc3.># UH nTUv M g7fr2r^)rr) residual_wts rr7MaxWeightClique.find_branching_nodes..s!J/Q+a./s)rrmin)rrtargetr)total_wtrmin_wt_in_classrs @rfind_branching_nodes$MaxWeightClique.find_branching_nodess89:1$++A..:  aD"@@CO!!J/!JJO  'H %A/1%5AqQ1!4AA5a;6sB < B% B%cURX5 URX0RU- 5nU(aUR5nUR U5 X/-nX R U-nUVs/sH&oR RXX5(dM$UPM( n nURXgU 5 U(aMggs snf)zLook for the best clique that contains all the nodes in C and zero or more of the nodes in P, backtracking if it can be shown that no such clique has greater weight than the incumbent. N) rrrr@rArr(rrQ) rrrrbranching_nodesr)new_C new_C_weightrnew_Ps rrQMaxWeightClique.expands ))!633A7L7Lx7WX##%A HHQKGE#&7&7&::L !;1VV__Q%:QE; KKU 3 o B>c^[TRR5U4SjSS9nUVs/sHnTRUS:dMUPM nnTR /SU5 gs snf)zFind a maximum weight clique.c:>TRRU5$r2)r(degree)r)rs rr78MaxWeightClique.find_max_weight_clique..sTVV]]15Er9T)rreverserN)rr(rCrrQ)rrCr)s` rfind_max_weight_clique&MaxWeightClique.find_max_weight_cliquesYtvv||~+EtT!>EqT%6%6q%9A%=E> B5!?s A$A$)r(rrrN) __name__ __module__ __qualname____firstlineno____doc__rrrrrQr__static_attributes__r^r9rrrXs&2K"-  4"r9rr) node_attrsch[X5nUR5 URUR4$)uFind a maximum weight clique in G. A *clique* in a graph is a set of nodes such that every two distinct nodes are adjacent. The *weight* of a clique is the sum of the weights of its nodes. A *maximum weight clique* of graph G is a clique C in G such that no clique in G has weight greater than the weight of C. Parameters ---------- G : NetworkX graph Undirected graph weight : string or None, optional (default='weight') The node attribute that holds the integer value used as a weight. If None, then each node has weight 1. Returns ------- clique : list the nodes of a maximum weight clique weight : int the weight of a maximum weight clique Notes ----- The implementation is recursive, and therefore it may run into recursion depth issues if G contains a clique whose number of nodes is close to the recursion depth limit. At each search node, the algorithm greedily constructs a weighted independent set cover of part of the graph in order to find a small set of nodes on which to branch. The algorithm is very similar to the algorithm of Tavares et al. [1]_, other than the fact that the NetworkX version does not use bitsets. This style of algorithm for maximum weight clique (and maximum weight independent set, which is the same problem but on the complement graph) has a decades-long history. See Algorithm B of Warren and Hicks [2]_ and the references in that paper. References ---------- .. [1] Tavares, W.A., Neto, M.B.C., Rodrigues, C.D., Michelon, P.: Um algoritmo de branch and bound para o problema da clique máxima ponderada. Proceedings of XLVII SBPO 1 (2015). .. [2] Warren, Jeffrey S, Hicks, Illya V.: Combinatorial Branch-and-Bound for the Maximum Weight Independent Set Problem. Technical Report, Texas A&M University (2016). )rrrr)r(rmwcs rrrs2f ! $C    4 4 44r9r2)NNN)NNF)NN)r)r collectionsrr itertoolsrrrnetworkxrenetworkx.utilsr__all__ _dispatchablerr r r r r rrrr^r9rrs,+11. Z C!CLZ  ! Fr(r(j%, &, ^%- &- `<-<-~.c"c"LZ X&35'!35r9