hNSrSSKJrJr SSKJrJr SSKJr SSK r SSK J r J r /SQr\ "S5\ "S 5\ RSS j555r\ RSS j5rS rS r"SS\5rSrSr\ RSSj5rSr\ "S5\ R"SS9S55r\ RS Sj5r\ "S5\ "S 5\ R"SS9SSj555rSrSr\ "S5\ "S 5\ RS555rg)!zL ======================== Cycle finding algorithms ======================== )Counter defaultdict) combinationsproduct)infN)not_implemented_forpairwise) cycle_basis simple_cyclesrecursive_simple_cycles find_cycleminimum_cycle_basischordless_cyclesgirthdirected multigraphc[RU5n/nU(Ga UcUR5SnU/nX0nU[50nU(aUR 5nXgnXHn X;aXuU 'UR U 5 U1Xi'M$X:XaUR U/5 M=X;dMDXin X/n XWn X;aU R U 5 X\n X;aMU R U 5 UR U 5 XiR U5 M U(aMUHn UR U S5 M SnU(aGM U$)aReturns a list of cycles which form a basis for cycles of G. A basis for cycles of a network is a minimal collection of cycles such that any cycle in the network can be written as a sum of cycles in the basis. Here summation of cycles is defined as "exclusive or" of the edges. Cycle bases are useful, e.g. when deriving equations for electric circuits using Kirchhoff's Laws. Parameters ---------- G : NetworkX Graph root : node, optional Specify starting node for basis. Returns ------- A list of cycle lists. Each cycle list is a list of nodes which forms a cycle (loop) in G. Examples -------- >>> G = nx.Graph() >>> nx.add_cycle(G, [0, 1, 2, 3]) >>> nx.add_cycle(G, [0, 3, 4, 5]) >>> nx.cycle_basis(G, 0) [[3, 4, 5, 0], [1, 2, 3, 0]] Notes ----- This is adapted from algorithm CACM 491 [1]_. References ---------- .. [1] Paton, K. An algorithm for finding a fundamental set of cycles of a graph. Comm. ACM 12, 9 (Sept 1969), 514-518. See Also -------- simple_cycles minimum_cycle_basis Nr)dictfromkeyspopitemsetpopappendadd)Grootgnodescyclesstackpredusedzzusednbrpncyclepnodes L/var/www/html/env/lib/python3.13/site-packages/networkx/algorithms/cycles.pyr r s3\]]1 F F  <>>#A&D|ce} AGEt? !ILL%!"DIXMM1#&%B HEA+ Q G+LLOMM%(IMM!$!e(D JJtT "9 &: Mc#$^^^# UbUS:XagUS:a [S5eTR5nSTRR55ShvN UbUS:XagTR 5(atU(dm[ 5mTRR5HEumnU4SjUR55nU4SjU5ShvN TR T5 MG U(a6[R"STRR555mO5[R"S TRR555mUbqUS :XakU(ac[ 5mTRR5H;umnUU4S jTRU55ShvN TR T5 M= gU(a[TU5ShvN g[TU5ShvN gGNGN4NQN"N7f) aFind simple cycles (elementary circuits) of a graph. A "simple cycle", or "elementary circuit", is a closed path where no node appears twice. In a directed graph, two simple cycles are distinct if they are not cyclic permutations of each other. In an undirected graph, two simple cycles are distinct if they are not cyclic permutations of each other nor of the other's reversal. Optionally, the cycles are bounded in length. In the unbounded case, we use a nonrecursive, iterator/generator version of Johnson's algorithm [1]_. In the bounded case, we use a version of the algorithm of Gupta and Suzumura [2]_. There may be better algorithms for some cases [3]_ [4]_ [5]_. The algorithms of Johnson, and Gupta and Suzumura, are enhanced by some well-known preprocessing techniques. When `G` is directed, we restrict our attention to strongly connected components of `G`, generate all simple cycles containing a certain node, remove that node, and further decompose the remainder into strongly connected components. When `G` is undirected, we restrict our attention to biconnected components, generate all simple cycles containing a particular edge, remove that edge, and further decompose the remainder into biconnected components. Note that multigraphs are supported by this function -- and in undirected multigraphs, a pair of parallel edges is considered a cycle of length 2. Likewise, self-loops are considered to be cycles of length 1. We define cycles as sequences of nodes; so the presence of loops and parallel edges does not change the number of simple cycles in a graph. Parameters ---------- G : NetworkX Graph A networkx graph. Undirected, directed, and multigraphs are all supported. length_bound : int or None, optional (default=None) If `length_bound` is an int, generate all simple cycles of `G` with length at most `length_bound`. Otherwise, generate all simple cycles of `G`. Yields ------ list of nodes Each cycle is represented by a list of nodes along the cycle. Examples -------- >>> G = nx.DiGraph([(0, 0), (0, 1), (0, 2), (1, 2), (2, 0), (2, 1), (2, 2)]) >>> sorted(nx.simple_cycles(G)) [[0], [0, 1, 2], [0, 2], [1, 2], [2]] To filter the cycles so that they don't include certain nodes or edges, copy your graph and eliminate those nodes or edges before calling. For example, to exclude self-loops from the above example: >>> H = G.copy() >>> H.remove_edges_from(nx.selfloop_edges(G)) >>> sorted(nx.simple_cycles(H)) [[0, 1, 2], [0, 2], [1, 2]] Notes ----- When `length_bound` is None, the time complexity is $O((n+e)(c+1))$ for $n$ nodes, $e$ edges and $c$ simple circuits. Otherwise, when ``length_bound > 1``, the time complexity is $O((c+n)(k-1)d^k)$ where $d$ is the average degree of the nodes of `G` and $k$ = `length_bound`. Raises ------ ValueError when ``length_bound < 0``. References ---------- .. [1] Finding all the elementary circuits of a directed graph. D. B. Johnson, SIAM Journal on Computing 4, no. 1, 77-84, 1975. https://doi.org/10.1137/0204007 .. [2] Finding All Bounded-Length Simple Cycles in a Directed Graph A. Gupta and T. Suzumura https://arxiv.org/abs/2105.10094 .. [3] Enumerating the cycles of a digraph: a new preprocessing strategy. G. Loizou and P. Thanish, Information Sciences, v. 27, 163-182, 1982. .. [4] A search strategy for the elementary cycles of a directed graph. J.L. Szwarcfiter and P.E. Lauer, BIT NUMERICAL MATHEMATICS, v. 16, no. 2, 192-204, 1976. .. [5] Optimal Listing of Cycles and st-Paths in Undirected Graphs R. Ferreira and R. Grossi and A. Marino and N. Pisanti and R. Rizzi and G. Sacomoto https://arxiv.org/abs/1205.2766 See Also -------- cycle_basis chordless_cycles Nr!length bound must be non-negativec3:# UHupX;dM U/v M g7fN.0vGvs r) simple_cycles..s:!'  c3R># UHupUT;dM U[U54v M g7fr.lenr1r2Guvvisiteds r)r4r5s#S faa7lMQCM  ''c3@># UHupUS:dM TU/v M g7fr7Nr/)r1r2mus r)r4r5sA<411q5A# UH"nTRUT5(dMUT/v M$ g7fr.has_edge)r1r2rrBs r)r4r5s($H?HH H HHc## [RnU"U5Vs/sHn[U5S:dMUPM nnU(aUR5nUR U5n[ [ U55nUc[XV/5ShvN O[XV/U5ShvN URU5 URSU"U555 U(aMggs snfNYNE7f)aMA dispatch function for `simple_cycles` for directed graphs. We generate all cycles of G through binary partition. 1. Pick a node v in G which belongs to at least one cycle a. Generate all cycles of G which contain the node v. b. Recursively generate all cycles of G \ v. This is accomplished through the following: 1. Compute the strongly connected components SCC of G. 2. Select and remove a biconnected component C from BCC. Select a non-tree edge (u, v) of a depth-first search of G[C]. 3. For each simple cycle P containing v in G[C], yield P. 4. Add the biconnected components of G[C \ v] to BCC. If the parameter length_bound is not None, then step 3 will be limited to simple cycles of length at most length_bound. Parameters ---------- G : NetworkX DiGraph A directed graph length_bound : int or None If length_bound is an int, generate all simple cycles of G with length at most length_bound. Otherwise, generate all simple cycles of G. Yields ------ list of nodes Each cycle is represented by a list of nodes along the cycle. rHNc3H# UHn[U5S:dMUv M g7frHNr9r1cs r)r4)_directed_cycle_search.. u) path P remaining in G[C] \ (u, v), yield P. 4. Add the biconnected components of G[C] \ (u, v) to BCC. If the parameter length_bound is not None, then step 3 will be limited to simple paths of length at most length_bound. Parameters ---------- G : NetworkX Graph An undirected graph length_bound : int or None If length_bound is an int, generate all simple cycles of G with length at most length_bound. Otherwise, generate all simple cycles of G. Yields ------ list of nodes Each cycle is represented by a list of nodes along the cycle. Nc3H# UHn[U5S:dMUv M g7f)rmNr9r\s r)r4+_undirected_cycle_search..Qr_r`) rQbiconnected_componentsr:rrblistrcrdedges remove_edgererfrh)rrWbccr]rjrkuvs r)rVrV"sF # #C V3Vs1v{!VJ3  NN  ZZ] $tBHH~& ' r  ,R4 4 4,R\B B B[URU5=o U'U$r.)rqr)rzr2r3s r) __missing___NeighborhoodCache.__missing___sDFF1I&!W r*ryN)__name__ __module__ __qualname____firstlineno____doc__r{r~__static_attributes__r/r*r)rwrwTsr*rwc## [U5n[U5n[[5nUSn[XS5/nS/nU(Ga@USnUHlnX:XaUSSv SUS'MX;dMUR U5 UR S5 UR [X55 UR U5 O UR 5 UR 5n UR 5(akU(aSUS'U 1n U (aTU R 5n X;a6URU 5 U RX;5 X;R5 U (aMTOX HnX8R U 5 M U(aGM?gg7f)aThe main loop of the cycle-enumeration algorithm of Johnson. Parameters ---------- G : NetworkX Graph or DiGraph A graph path : list A cycle prefix. All cycles generated will begin with this prefix. Yields ------ list of nodes Each cycle is represented by a list of nodes along the cycle. References ---------- .. [1] Finding all the elementary circuits of a directed graph. D. B. Johnson, SIAM Journal on Computing 4, no. 1, 77-84, 1975. https://doi.org/10.1137/0204007 rFNT) rwrrrdrrrremoveupdateclear) rpathblockedBstartrclosednbrswr2 unblock_stackrBs r)reredsL0 1A$iGCA GE !H+  EWF RyAz1g !r ! A e$ T!$Z( A IIK Azz||!%F2J!" #%))+A|q)%,,QT2 $mADHHQK5 %sA'F -C0F &F F c#^ # [U5nUVs0sHo3S_M nn[[5nUSn[XS5/nU/nU(Ga~USn U Hn X:XaUSSv SUS'M[ U5UR X5:dM6UR U 5 UR U5 [ U5XJ'UR [X 55 O UR5 UR5nUR5m U(a[UST 5US'T U:azT U4/n U (amU R5um n UR X5UT - S-:a6UT - S-XL'U RU 4SjX\RU555 U (aMmOXHn XZRU5 M U(aGM}ggs snf7f)a6The main loop of the cycle-enumeration algorithm of Gupta and Suzumura. Parameters ---------- G : NetworkX Graph or DiGraph A graph path : list A cycle prefix. All cycles generated will begin with this prefix. length_bound: int A length bound. All cycles generated will have length at most length_bound. Yields ------ list of nodes Each cycle is represented by a list of nodes along the cycle. References ---------- .. [1] Finding All Bounded-Length Simple Cycles in a Directed Graph A. Gupta and T. Suzumura https://arxiv.org/abs/2105.10094 rrNr7c32># UH nTS-U4v M g7fr@r/)r1rbls r)r4(_bounded_cycle_search..s*V@U1BFA;@Us) rwrrrdr:getrrminrh differencer)rrrWr2lockrrrblenrr relax_stackrBrs @r)rfrfs2 1A $QqD$D CA GE !H+  E >D RyAz1g RTTXXa66 A L)d) T!$Z( IIK ABtBx,RL "Awi !'OO-EBxx0<"3Dq3HH"."3a"7#***VPT@U*VV "k ADHHQK5 % s#G GA+GDG%&GGc #^^^# UbUS:XagUS:a [S5eTR5nTR5nU(a*STRR 55ShvN O)STRR 55ShvN UbUS:XagU(aE[ R "STRR 555mTRSS 9nO7[ R"S TRR 555mSnU(aU(dTR5n[5mTRR 5HupVU(aAS UR 55nUH"upU S:dM TRXX4X445 M$ MMU4S jUR 55nUH)upU S :XaXX/v U S:dMTRXX5 M+ TRU5 M U(aTRR 5HcupZU Vs/sHnTRX5(dMXX/PM n nU ShvN TRU 5 TRSU 55 Me UbUS :XagU(a[ Rn UU4Sjn O[ R n U4Sjn U "T5Vs/sHn[#U5S :dMUPM nnU(aUR%5n['[)U55nTR+U5nS=nnU "UU5HVunnU(aUv MUc*[-U5nUcUO[-UR+U55n[/UUUU5ShvN MX UR1SU "TR+X1- 5555 U(aMggGNwGNPs snfGNs snfNV7f)a Find simple chordless cycles of a graph. A `simple cycle` is a closed path where no node appears twice. In a simple cycle, a `chord` is an additional edge between two nodes in the cycle. A `chordless cycle` is a simple cycle without chords. Said differently, a chordless cycle is a cycle C in a graph G where the number of edges in the induced graph G[C] is equal to the length of `C`. Note that some care must be taken in the case that G is not a simple graph nor a simple digraph. Some authors limit the definition of chordless cycles to have a prescribed minimum length; we do not. 1. We interpret self-loops to be chordless cycles, except in multigraphs with multiple loops in parallel. Likewise, in a chordless cycle of length greater than 1, there can be no nodes with self-loops. 2. We interpret directed two-cycles to be chordless cycles, except in multi-digraphs when any edge in a two-cycle has a parallel copy. 3. We interpret parallel pairs of undirected edges as two-cycles, except when a third (or more) parallel edge exists between the two nodes. 4. Generalizing the above, edges with parallel clones may not occur in chordless cycles. In a directed graph, two chordless cycles are distinct if they are not cyclic permutations of each other. In an undirected graph, two chordless cycles are distinct if they are not cyclic permutations of each other nor of the other's reversal. Optionally, the cycles are bounded in length. We use an algorithm strongly inspired by that of Dias et al [1]_. It has been modified in the following ways: 1. Recursion is avoided, per Python's limitations 2. The labeling function is not necessary, because the starting paths are chosen (and deleted from the host graph) to prevent multiple occurrences of the same path 3. The search is optionally bounded at a specified length 4. Support for directed graphs is provided by extending cycles along forward edges, and blocking nodes along forward and reverse edges 5. Support for multigraphs is provided by omitting digons from the set of forward edges Parameters ---------- G : NetworkX DiGraph A directed graph length_bound : int or None, optional (default=None) If length_bound is an int, generate all simple cycles of G with length at most length_bound. Otherwise, generate all simple cycles of G. Yields ------ list of nodes Each cycle is represented by a list of nodes along the cycle. Examples -------- >>> sorted(list(nx.chordless_cycles(nx.complete_graph(4)))) [[1, 0, 2], [1, 0, 3], [2, 0, 3], [2, 1, 3]] Notes ----- When length_bound is None, and the graph is simple, the time complexity is $O((n+e)(c+1))$ for $n$ nodes, $e$ edges and $c$ chordless cycles. Raises ------ ValueError when length_bound < 0. References ---------- .. [1] Efficient enumeration of chordless cycles E. Dias and D. Castonguay and H. Longo and W.A.R. Jradi https://arxiv.org/abs/1309.1051 See Also -------- simple_cycles Nrr,c3n# UH+up[URUS55S:XdM&U/v M- g7f)r/r7N)r:rr0s r)r4#chordless_cycles..Bs,N]EAc"&&B-6HA6MCQC]s%5 5c3:# UHupX;dM U/v M g7fr.r/r0s r)r4rDs>]EAagCQC]r6r7c3N# UHupX;dM UHo1U4v M M g7fr.r/rDs r)r4rMs$T=%!AKvQSA1vQSv= %%F)as_viewc3N# UHupX;dM UHo1U4v M M g7fr.r/rDs r)r4rPs"R!+Vr!VrVrc3@# UHupU[U54v M g7fr.r9)r1r2r<s r)r4rjsGJ&!CH Jsc3R># UHupUT;dM U[U54v M g7fr.r9r;s r)r4ros#WJ&!!w, CH Jr>rHc30# UH oSSS2v M g7fNrr/)r1es r)r4rs8A$B$sc3># [URUURU5H4up#TRX#5(aMX!U/TRX254v M6 g7fr.)rr succrK)Cr2rBrFrs r)stemschordless_cycles..stemssPq 166!95zz!'')QZZ%5556s AA#A#c3X>^# UU4Sj[UTS55ShvN gN7f)Nc3T># UHupUTU/TRX!54v M g7fr.rJ)r1rBrrr2s r)r42chordless_cycles..stems..s)XBW$!!QAJJq$45BWs%(rH)r)rr2rs `r)rrs!X,qQRtUVBWX X Xs *(*c3H# UHn[U5S:dMUv M g7fr[r9r\s r)r4rsQ%Bc!fqj!!%Br`)rLrMrPrNrOrQrR to_undirectedrScopyrremove_edges_fromrsrrKrarpr:rrcrdrbrw_chordless_cycle_searchrh)rrWrrrrBrErXr2rAFudigonsseparaterr]rjFcFccBccS is_trianglerr=s` @@r)rrs7v 1   A @A A}}H"JNQUU[[]NNN>QUU[[]>>>LA$5  JJT155;;=T T OOEO * HHRR R &AeGUU[[]EAGBHHJG (DA1u++aVaV,<=) XBHHJW (DAAv f 1u a+ )  A#(UU[[]EA&(=bAJJq,t> >8NsA'O8,O#-)O8O&DO8A O8+AO8?O)O)$O8+O.,A:O8&O1=O1BO8O6 ?O8!O8&O8)O81O8c#H# [[5nUSnSXBS'USSHnXHnXG==S- ss'M M [XS5/nU(aUSn U H~nXFS:XdM Ub[U5U:dM!Xn XZ;a X&/-v M3Xn X[;aM>U HnXG==S- ss'M UR U5 UR [U 55 O7 UR 5 XR 5HnXG==S-ss'M U(aMgg7f)aPThe main loop for chordless cycle enumeration. This algorithm is strongly inspired by that of Dias et al [1]_. It has been modified in the following ways: 1. Recursion is avoided, per Python's limitations 2. The labeling function is not necessary, because the starting paths are chosen (and deleted from the host graph) to prevent multiple occurrences of the same path 3. The search is optionally bounded at a specified length 4. Support for directed graphs is provided by extending cycles along forward edges, and blocking nodes along forward and reverse edges 5. Support for multigraphs is provided by omitting digons from the set of forward edges Parameters ---------- F : _NeighborhoodCache A graph of forward edges to follow in constructing cycles B : _NeighborhoodCache A graph of blocking edges to prevent the production of chordless cycles path : list A cycle prefix. All cycles generated will begin with this prefix. length_bound : int A length bound. All cycles generated will have length at most length_bound. Yields ------ list of nodes Each cycle is represented by a list of nodes along the cycle. References ---------- .. [1] Efficient enumeration of chordless cycles E. Dias and D. Castonguay and H. Longo and W.A.R. Jradi https://arxiv.org/abs/1309.1051 rr7NrHr)rintrdr:rr) rrrrWrtargetrr2rrFwBws r)rrs^#G !WFGG !"XA J!OJ!G*  E RyAzQL$8CI nURX5(dMTR U/5 UR X5 M@ [ [U[[U5555m T HmURU U4SjU55n[R"U5n[UU 4SjS9nURU5n[U5S:dMe[UT RS9nUHnST U'/T USS&M T "XfU5nM T$) aFind simple cycles (elementary circuits) of a directed graph. A `simple cycle`, or `elementary circuit`, is a closed path where no node appears twice. Two elementary circuits are distinct if they are not cyclic permutations of each other. This version uses a recursive algorithm to build a list of cycles. You should probably use the iterator version called simple_cycles(). Warning: This recursive version uses lots of RAM! It appears in NetworkX for pedagogical value. Parameters ---------- G : NetworkX DiGraph A directed graph Returns ------- A list of cycles, where each cycle is represented by a list of nodes along the cycle. Example: >>> edges = [(0, 0), (0, 1), (0, 2), (1, 2), (2, 0), (2, 1), (2, 2)] >>> G = nx.DiGraph(edges) >>> nx.recursive_simple_cycles(G) [[0], [2], [0, 1, 2], [0, 2], [1, 2]] Notes ----- The implementation follows pp. 79-80 in [1]_. The time complexity is $O((n+e)(c+1))$ for $n$ nodes, $e$ edges and $c$ elementary circuits. References ---------- .. [1] Finding all the elementary circuits of a directed graph. D. B. Johnson, SIAM Journal on Computing 4, no. 1, 77-84, 1975. https://doi.org/10.1137/0204007 See Also -------- simple_cycles, cycle_basis c>TU(a6STU'TU(a&T"TUR55 TU(aM%ggg)z6Recursively unblock and remove nodes from B[thisnode].FN)r)thisnoder_unblockrs r)r)recursive_simple_cycles.._unblock/s? 8  %GH H+8*+H++ r*cX>SnT RU5 STU'X H>nXA:XaT RT SS5 SnM TU(aM,T"XAU5(dM<SnM@ U(a T"U5 O*X H"nUTU;dMTURU5 M$ T R5 U$)NFT)rr) r startnode componentrnextnoderrrcircuitrresults r)r(recursive_simple_cycles..circuit6s H !+H$ d1g&X&&8 ::!F ,  X %/1X;.hK&&x00   r*c3D># UHnTUTT:dMUv M g7fr.r/)r1r(orderingss r)r4*recursive_simple_cycles..\s"RqtHTNhqk4Qddqs  c.>[U4SjU55$)Nc3.># UH nTUv M g7fr.r/)r1nrs r)r4...`s4M"QXa["s)r)nsrs r))recursive_simple_cycles..`s4M"4M1Mr*keyr7FN)rboolrqrKrrsrzipranger:rbrQrar __getitem__)rr2rb strongcompmincomprrr(dummyrrrrrrrrs @@@@@@@@r)r r s!d,( D$GDA F  ::a   MM1#  MM! C5Q=)*H ::RqRR55h? j&MNJJw' y>A I8+?+?@I! % $ "I)>> G = nx.DiGraph([(0, 1), (0, 2), (1, 2)]) >>> nx.find_cycle(G, orientation="original") Traceback (most recent call last): ... networkx.exception.NetworkXNoCycle: No cycle found. >>> list(nx.find_cycle(G, orientation="ignore")) [(0, 1, 'forward'), (1, 2, 'forward'), (0, 2, 'reverse')] See Also -------- simple_cycles )Noriginalc USS$)NrHr/edges r)tailheadfind_cycle..tailheads 8Or*reversecUSUS4$)Nr7rr/rs r)rrs7DG# #r*ignorec2USS:Xa USUS4$USS$)Nrrr7rrHr/rs r)rrs,Bx9$AwQ''8Or*Nr7rrzNo cycle found.)rMr nbunch_iterrQedge_dfsrr IndexErrorrrhrrr: exceptionNetworkXNoCycle enumerate)rsource orientationrexploredr& final_node start_noderrseen active_nodes previous_headrtailhead popped_edge popped_head last_headis r)r r lsH ==??k-??   ! $    uH EJmmF+  ! |"|  KK{;D!$JD(T-B9&+iik '/{&;A&> $++K8$,U2Y$7$: 9,! LL # U#!   & $ M>> G = nx.Graph() >>> nx.add_cycle(G, [0, 1, 2, 3]) >>> nx.add_cycle(G, [0, 3, 4, 5]) >>> nx.minimum_cycle_basis(G) [[5, 4, 3, 0], [3, 2, 1, 0]] References: [1] Kavitha, Telikepalli, et al. "An O(m^2n) Algorithm for Minimum Cycle Basis of Graphs." http://link.springer.com/article/10.1007/s00453-007-9064-z [2] de Pina, J. 1995. Applications of shortest path methods. Ph.D. thesis, University of Amsterdam, Netherlands See Also -------- simple_cycles, cycle_basis c3Z># UH n[TRU5T5v M" g7fr.)_min_cycle_basisrb)r1r]rrs r)r4&minimum_cycle_basis..6s&U:TQ !**Q- 0 0:Ts(+)sumrQconnected_components)rrs``r)rr s*R U":Q:QRS:TU  r*c ^ /n[[R"USSS95nURU- UVVs1sHupEXT4iM snn- nUVs/sHow1PM nnU(aUR 5n [ X U5n UR U VVs/sHupEUPM snn5 UV ^ V s/sHsm [U 4SjU 55S-(aQT V s1sHoU ;dM U SSS2U ;dMU iM sn U V s1sHoT ;dM U SSS2T ;dMU iM sn -OT PMu nn n U(aMU$s snnfs snfs snnfs sn fs sn fs sn n f)NF)rdatac3P># UHoT;=(d USSS2T;v M g7frr/)r1rorths r)r4#_min_cycle_basis..Rs'G;aI04R4D0;s#&rHr)rqrQminimum_spanning_edgesrrr _min_cyclerr ) rrcb tree_edgesrBr2chordsrset_orthbase cycle_edgesrrs ` r)r r ;sX Bb//$UKLJ WWz ! $C aV $C CF$**646H* ||~ &1  -1-.! !G;GG!K!IDqTMQttWD5HDI"Kdtm1q2wd7J1dKL   !   (" I+%D+ . JK sMD4 D:D? ,'E E E .E 4E: E  E E  E Ec [R"5nURUSS9HHupEnXE4U;dXT4U;aURXES44US4U4/US9 M/URXE4US4US44/US9 MJ [RnUVs0sH oU"X8US4SS9_M n n[ XR S9n U S4n [R"X:U SS9n U Vs/sHoU;aUOUSPM n n[[U 55n[5nUHRnUU;aURU5 MUSSS 2U;aURUSSS 25 MAURU5 MT /nUHinUU;a$URU5 URU5 M-USSS 2U;dM;URUSSS 25 URUSSS 25 Mk U$s snfs snf) z Computes the minimum weight cycle in G, orthogonal to the vector orth as per [p. 338, 1] Use (u, 1) to indicate the lifted copy of u (denoted u' in paper). r7)rdefault) Gi_weightr)rrrrrNr)rQrSrradd_edges_fromshortest_path_lengthrr shortest_pathrqr rrrr)rrrGirBr2wtsplrliftrend min_path_imin_pathedgelistedgesetr min_edgelists r)rrYs BGGG3b 6T>aVt^   q6{aVQK8B  G   vAA'78B  G 4 ! !CMN OQs2A{C CQD O (( #E !*C!!"3{SJ0::z!!V1%zH:HX&'HeG  < NN1  ttW  NN1TrT7 # KKN L  <    " NN1  ttW    $B$ ( NN1TrT7 #  ? P;s G Gc[=p[RRRR n[RRRR nUHZnUS0n[R"X5H9upxn Xgn X:a M/XLa U S-Xh'MXLn X-S-U - n X:dM3U nX- nM; M\ U$)aReturns the girth of the graph. The girth of a graph is the length of its shortest cycle, or infinity if the graph is acyclic. The algorithm follows the description given on the Wikipedia page [1]_, and runs in time O(mn) on a graph with m edges and n nodes. Parameters ---------- G : NetworkX Graph Returns ------- int or math.inf Examples -------- All examples below (except P_5) can easily be checked using Wikipedia, which has a page for each of these famous graphs. >>> nx.girth(nx.chvatal_graph()) 4 >>> nx.girth(nx.tutte_graph()) 4 >>> nx.girth(nx.petersen_graph()) 5 >>> nx.girth(nx.heawood_graph()) 6 >>> nx.girth(nx.pappus_graph()) 6 >>> nx.girth(nx.path_graph(5)) inf References ---------- .. [1] `Wikipedia: Girth `_ rr7rH)rrQ algorithms traversalbreadth_first_search TREE_EDGE LEVEL_EDGEbfs_labeled_edges) rr depth_limit tree_edge level_edgerdepthrBr2labeldudeltalengths r)rrsTE ''<<FFI((==HHJ A//5KA%B!6+1u,>"E"$*K6 & Lr*r.)NN) r collectionsrr itertoolsrrmathrnetworkxrQnetworkx.utilsrr __all__ _dispatchabler r rUrVrrwrerfrrr r rr rrr/r*r)rAs -+8 Z \"J#!JZC=C=L/=d/=d   9 x: zORORdJ Z\"%j&#jZ\\~Z \"X&)'#!)X<2jZ \"=#!=r*