+ j'zRt^RIt^RIt^RIHt^RIt^RIHt^RI H t ^RI H t H t HtHt^RIHt.ROt]!^4]P&!RRR7R R R/R ll44t]!^4]P&!RRR7R R R/R ll44t]t]t]!^4]P&!RRR7R!R R/R ll44t]!^4]P&!RRR7R R R/R ll44t]!^4]P&!RRR7R!R R/Rll44t]!^4]P&!RRR7R!R R/Rll44t]!^4]P&!RRR7R"R R/Rll44t]!^4]P&!RRR7R!R R/Rll44tRt]!^4]P&!RRR7R#R R/Rll44t]!^4]P&!RRR7R#R R/Rll44t ]!^4]P&!RRR7R!R R/Rll44t!]!^4]P&!RRR7R!R R/Rll44t"]!^4]P&!RRR7R!R R/Rll44t#]!^4]P&!RRR7R!R R/Rll44t$]!^4]P&!RRR7R$R R/Rll44t%]!^4]P&!RR7R$Rl44t&]!^4]P&!RRR7R#R R/Rll44t']!R4]P&!RRR7R!Rl44t(R#)%z Generators for random graphs. N) defaultdict)py_random_state)check_create_using)complete_graph empty_graph path_graph star_graph)degree_sequence_treeT)graphs returns_graph create_usingcZV'd\PM\Pp\WCRVR7pV^8:gV^8d\P!WW#VR7#\ WR7p\ P!RV, 4pV'd^pRp W8d\ P!RVP4, 4p V ^,\W, 4,p W8dW8dW, p V^,pKW8gKwVPW4K^pRp W8d\ P!RVP4, 4p V ^,\W, 4,p W8dW8dW, p V^,pKW8gKwVPW4KV#)u5Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph or a binomial graph. Parameters ---------- n : int The number of nodes. p : float Probability for edge creation. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. directed : bool, optional (default=False) If True, this function returns a directed graph. create_using : Graph constructor, optional (default=nx.Graph or nx.DiGraph) Graph type to create. If graph instance, then cleared before populated. Multigraph types are not supported and raise a ``NetworkXError``. By default NetworkX Graph or DiGraph are used depending on `directed`. Notes ----- The $G_{n,p}$ graph algorithm chooses each of the $[n (n - 1)] / 2$ (undirected) or $n (n - 1)$ (directed) possible edges with probability $p$. This algorithm [1]_ runs in $O(n + m)$ time, where `m` is the expected number of edges, which equals $p n (n - 1) / 2$. This should be faster than :func:`gnp_random_graph` when $p$ is small and the expected number of edges is small (that is, the graph is sparse). See Also -------- gnp_random_graph References ---------- .. [1] Vladimir Batagelj and Ulrik Brandes, "Efficient generation of large random networks", Phys. Rev. E, 71, 036113, 2005. Fdirected multigraphdefault)seedrr r g?) nxDiGraphGraphrgnp_random_graphrmathlograndomintadd_edge) nprrr rGlpvwlrs &&&&$ b/home/luca/screen-checking/.venv/lib/python3.14/site-packages/networkx/generators/random_graphs.pyfast_gnp_random_graphr&)sDT%bjj"((G%E7L Ava"" t\   A1A #' B  e# -.BABG $A&QUEEu 1  A A % XXcDKKM) * ECL fAAA 5 JJq  HcV'd\PM\Pp\WCRVR7pV^8d \ WR7#\P !WR7pV^8:dV#V'd\ PM\ PpV!\V4^4F*pVP4V8gKVP!V!K, V#)u`Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph or a binomial graph. The $G_{n,p}$ model chooses each of the possible edges with probability $p$. Parameters ---------- n : int The number of nodes. p : float Probability for edge creation. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. directed : bool, optional (default=False) If True, this function returns a directed graph. create_using : Graph constructor, optional (default=nx.Graph or nx.DiGraph) Graph type to create. If graph instance, then cleared before populated. Multigraph types are not supported and raise a ``NetworkXError``. By default NetworkX Graph or DiGraph are used depending on `directed`. See Also -------- fast_gnp_random_graph Notes ----- This algorithm [2]_ runs in $O(n^2)$ time. For sparse graphs (that is, for small values of $p$), :func:`fast_gnp_random_graph` is a faster algorithm. :func:`binomial_graph` and :func:`erdos_renyi_graph` are aliases for :func:`gnp_random_graph`. >>> nx.binomial_graph is nx.gnp_random_graph True >>> nx.erdos_renyi_graph is nx.gnp_random_graph True References ---------- .. [1] P. Erdős and A. Rényi, On Random Graphs, Publ. Math. 6, 290 (1959). .. [2] E. N. Gilbert, Random Graphs, Ann. Math. Stat., 30, 1141 (1959). Frr) rrrrrr itertools permutations combinationsrangerr) rrrrr rr edgetooles &&&&$ r%rrzs\%bjj"((G%E7L Ava;; q4AAv)1y%%y7M7MH eAh " ;;=1  JJN# Hr'c\VRRR7pW^, ,^,pW8d \W4#\W4pV^8XdV#^p^p^p^p VPWH, 4W, 8d#VP Wg4V ^, p W8XdV#V^, pV^, pWp8XgK_V^, pV^,pKs)aReturns a $G_{n,m}$ random graph. In the $G_{n,m}$ model, a graph is chosen uniformly at random from the set of all graphs with $n$ nodes and $m$ edges. This algorithm should be faster than :func:`gnm_random_graph` for dense graphs. Parameters ---------- n : int The number of nodes. m : int The number of edges. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. See Also -------- gnm_random_graph Notes ----- Algorithm by Keith M. Briggs Mar 31, 2006. Inspired by Knuth's Algorithm S (Selection sampling technique), in section 3.4.2 of [1]_. References ---------- .. [1] Donald E. Knuth, The Art of Computer Programming, Volume 2/Seminumerical algorithms, Third Edition, Addison-Wesley, 1997. Frr)rrr randranger) rmrr mmaxr ur"tks &&&$ r%dense_gnm_random_graphr7sN&lUuUL A;! Dya..A$AAv A A A A  >>$( #ae + JJq  FAv Q Q 6 FAAAr'c:V'd\PM\Pp\WCRVR7pV^8Xd\P!WR7#V'dW^, ,MW^, ,R, pW8d \ WR7#\P!WR7p\ V4p^p W8d^VPV4p VPV4p W8XgVPW4'dKGVPW4V ^,p KcV#)auReturns a $G_{n,m}$ random graph. In the $G_{n,m}$ model, a graph is chosen uniformly at random from the set of all graphs with $n$ nodes and $m$ edges. This algorithm should be faster than :func:`dense_gnm_random_graph` for sparse graphs. Parameters ---------- n : int The number of nodes. m : int The number of edges. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. directed : bool, optional (default=False) If True return a directed graph create_using : Graph constructor, optional (default=nx.Graph or nx.DiGraph) Graph type to create. If graph instance, then cleared before populated. Multigraph types are not supported and raise a ``NetworkXError``. By default NetworkX Graph or DiGraph are used depending on `directed`. See also -------- dense_gnm_random_graph Frrg@) rrrrrrlistchoicehas_edger) rr2rrr r max_edgesr nlist edge_countr4r"s &&&&$ r%gnm_random_graphr?s@%bjj"((G%E7L Av~~a;;'U Qa%[3->I~a;; q4A GEJ . KK  KK  6QZZ%%  JJq #aJ Hr'c\VRRR7pW8d\P!R4hW8Xd\P!W4#\ W4p\ VP 44pTp\^V^,^,4FJpWxRV^V,p \\V44F!p VPWz,W,4K# KL \ VP44p V FwrVP4V8gKVPV4pW8XgVPW4'd3VPV4pVPV 4V^, 8gKMK|VPW4K V#)u9Returns a Newman–Watts–Strogatz small-world graph. Parameters ---------- n : int The number of nodes. k : int Each node is joined with its `k` nearest neighbors in a ring topology. p : float The probability of adding a new edge for each edge. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. Notes ----- First create a ring over $n$ nodes [1]_. Then each node in the ring is connected with its $k$ nearest neighbors (or $k - 1$ neighbors if $k$ is odd). Then shortcuts are created by adding new edges as follows: for each edge $(u, v)$ in the underlying "$n$-ring with $k$ nearest neighbors" with probability $p$ add a new edge $(u, w)$ with randomly-chosen existing node $w$. In contrast with :func:`watts_strogatz_graph`, no edges are removed. See Also -------- watts_strogatz_graph References ---------- .. [1] M. E. J. Newman and D. J. Watts, Renormalization group analysis of the small-world network model, Physics Letters A, 263, 341, 1999. https://doi.org/10.1016/S0375-9601(99)00757-4 Fr0z"k>=n, choose smaller k or larger nN)rr NetworkXErrorrrr9nodesr,lenredgesrr:r;degree)rr6rrr r r=fromvjtovir.r4r"r#s&&&&$ r%newman_watts_strogatz_graphrJ9s8T&lUuULuCDD v  11A$A OE E 1a1fqj !Bi%!*$s5z"A JJux (#" QWWYA ;;=1  E"A&AJJq,,KK&88A;!a%' 1  Hr'c6\VRRR7pW8d\P!R4hW8Xd\P!W4pV#\P!WR7p\ \ V44p\ ^V^,^,4F+pWgRV^V,pVP\Wh44K- \ ^V^,^,4FpWgRV^V,p\Wh4FwrVP4V8gKVPV4p W8XgVPW4'd3VPV4p VPV 4V^, 8gKMK|VPW4VPW4K K V#)uReturns a Watts–Strogatz small-world graph. Parameters ---------- n : int The number of nodes k : int Each node is joined with its `k` nearest neighbors in a ring topology. p : float The probability of rewiring each edge seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. See Also -------- newman_watts_strogatz_graph connected_watts_strogatz_graph Notes ----- First create a ring over $n$ nodes [1]_. Then each node in the ring is joined to its $k$ nearest neighbors (or $k - 1$ neighbors if $k$ is odd). Then shortcuts are created by replacing some edges as follows: for each edge $(u, v)$ in the underlying "$n$-ring with $k$ nearest neighbors" with probability $p$ replace it with a new edge $(u, w)$ with uniformly random choice of existing node $w$. In contrast with :func:`newman_watts_strogatz_graph`, the random rewiring does not increase the number of edges. The rewired graph is not guaranteed to be connected as in :func:`connected_watts_strogatz_graph`. References ---------- .. [1] Duncan J. Watts and Steven H. Strogatz, Collective dynamics of small-world networks, Nature, 393, pp. 440--442, 1998. Fr0z!k>n, choose smaller k or larger nrN)rrrArrr9r,add_edges_fromziprr:r;rE remove_edger) rr6rrr r rBrGtargetsr4r"r#s &&&&$ r%watts_strogatz_graphrPsTZ&lUuULuBCC v   a . q4A qNE 1a1fqj !)eAaj( U,-" 1a1fqj !)eAaj('DA{{}q KK&f 1 0 0 E*Axx{a!e+MM!'JJq$(" Hr'c \V4F1p\WW$VR7p\P!V4'gK/Vu# \P!R4h)uReturns a connected Watts–Strogatz small-world graph. Attempts to generate a connected graph by repeated generation of Watts–Strogatz small-world graphs. An exception is raised if the maximum number of tries is exceeded. Parameters ---------- n : int The number of nodes k : int Each node is joined with its `k` nearest neighbors in a ring topology. p : float The probability of rewiring each edge tries : int Number of attempts to generate a connected graph. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. Notes ----- First create a ring over $n$ nodes [1]_. Then each node in the ring is joined to its $k$ nearest neighbors (or $k - 1$ neighbors if $k$ is odd). Then shortcuts are created by replacing some edges as follows: for each edge $(u, v)$ in the underlying "$n$-ring with $k$ nearest neighbors" with probability $p$ replace it with a new edge $(u, w)$ with uniformly random choice of existing node $w$. The entire process is repeated until a connected graph results. See Also -------- newman_watts_strogatz_graph watts_strogatz_graph References ---------- .. [1] Duncan J. Watts and Steven H. Strogatz, Collective dynamics of small-world networks, Nature, 393, pp. 440--442, 1998. rz Maximum number of tries exceeded)r,rPr is_connectedrA)rr6rtriesrr rIr s&&&&&$ r%connected_watts_strogatz_graphrTsI`5\ q\ J ??1  H   = >>r'craaaa\VRRR7pSS,^,^8wd\P!R4h^Su;8:dS8gM\P!R4h\P!SVR7pS^8XdV#RoVVVV3RlpV!4pVf V!4pK VP V4V#)aReturns a random $d$-regular graph on $n$ nodes. A regular graph is a graph where each node has the same number of neighbors. The resulting graph has no self-loops or parallel edges. Parameters ---------- d : int The degree of each node. n : integer The number of nodes. The value of $n \times d$ must be even. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. Notes ----- The nodes are numbered from $0$ to $n - 1$. Kim and Vu's paper [2]_ shows that this algorithm samples in an asymptotically uniform way from the space of random graphs when $d = O(n^{1 / 3 - \epsilon})$. Raises ------ NetworkXError If $n \times d$ is odd or $d$ is greater than or equal to $n$. References ---------- .. [1] A. Steger and N. Wormald, Generating random regular graphs quickly, Probability and Computing 8 (1999), 377-396, 1999. https://doi.org/10.1017/S0963548399003867 .. [2] Jeong Han Kim and Van H. Vu, Generating random regular graphs, Proceedings of the thirty-fifth ACM symposium on Theory of computing, San Diego, CA, USA, pp 213--222, 2003. http://portal.acm.org/citation.cfm?id=780542.780576 Fr0zn * d must be evenz+the 0 <= d < n inequality must be satisfiedrcxV'gR#VF)pVF pW#8XdKW#8dY2r2W#3V9gKR# K+ R#)TF)rDpotential_edgess1s2s&& r% _suitable'random_regular_graph.._suitableIsD!B%8785(&"r'c<\4p\\S 44S ,pV'd\R4pS P V4\ V4p\ W34FWwrEWE8dYTrTWE8wdWE3V9dVPWE34K/W$;;,^, uu&W%;;,^, uu&KY S !W4'gR#VP4UUUu.uFwrg\V4FpVNK K ppppKV#uupppi)c^#)rWrWr'r%=random_regular_graph.._try_creation..cs!r'N) setr9r,rshuffleiterrMadditems) rDstubsrXstubiterrYrZnode potential_r[drrs r% _try_creation+random_regular_graph.._try_creation\sU1X"))4O LL E{Hh178"!6IIrh'#'1,'#'1,'2U44(7'<'<'>'>ODy)A)'> E  s!D)rrrArrL)rlrrr r rmrDr[sfff$ @r%random_regular_graphro sb&lUuUL A{a344 :A:LMM q|4AAv&@ OE -U Hr'c\4p\V4V8d%VPV4pVPV4K4V#)zReturn m unique elements from seq. This differs from random.sample which can return repeated elements if seq holds repeated elements. Note: rng is a random.Random or numpy.random.RandomState instance. )rbrCr:re)seqr2rngrOxs&&& r%_random_subsetrts4eG g,  JJsO A Nr'c\VRRR7pV^8gW8d\P!RV RV 24hVf \W4pMM\ V4V8g\ V4V8d\P!RV RV R24hVP 4pVP 4UUUu.uFwr\V4FqpNK K pppp\ V4p V X8de\WV4p VP\V .V,V 44VPV 4VPV .V,4V ^, p KkV#uupppi)uReturns a random graph using Barabási–Albert preferential attachment A graph of $n$ nodes is grown by attaching new nodes each with $m$ edges that are preferentially attached to existing nodes with high degree. Parameters ---------- n : int Number of nodes m : int Number of edges to attach from a new node to existing nodes seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. initial_graph : Graph or None (default) Initial network for Barabási–Albert algorithm. It should be a connected graph for most use cases. A copy of `initial_graph` is used. If None, starts from a star graph on (m+1) nodes. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. Returns ------- G : Graph Raises ------ NetworkXError If `m` does not satisfy ``1 <= m < n``, or the initial graph number of nodes m0 does not satisfy ``m <= m0 <= n``. References ---------- .. [1] A. L. Barabási and R. Albert "Emergence of scaling in random networks", Science 286, pp 509-512, 1999. Fr0u;Barabási–Albert network must have m >= 1 and m < n, m = , n = u1Barabási–Albert initial graph needs between m=z and n= nodes) rrrArrCcopyrEr,rtrLrMextend) rr2r initial_graphr r rlrkrepeated_nodessourcerOs &&&&$ r%barabasi_albert_graphr}s=R&lUuUL1uI!FSTRU V   q ' }  !S%7!%;""CA3gaSPVW     %&HHJAJDAa1aaJNA VF 1*!D9 fX\734g&vhl+!  HBs)Ec\VRRR7pV^8gW8d\P!RV RV 24hV^8gW 8d\P!RV RV 24hV^8gV^8d\P!RV 24hV^8Xd\WWFR7#V^8Xd\WWFR7#Vf\ \ W4V4pM_\ V4\ W48g\ V4V8d'\P!R\ W4 R V R 24hVP4p\V4pVP4UU U u.uFwr \V 4FqNK K p p pp \ V4p V X8dVP4V8dTp MTp \WV4pVP\V .V ,V44V PV4V PV .V ,4V ^, p KV#uup p pi) uReturns a random graph using dual Barabási–Albert preferential attachment A graph of $n$ nodes is grown by attaching new nodes each with either $m_1$ edges (with probability $p$) or $m_2$ edges (with probability $1-p$) that are preferentially attached to existing nodes with high degree. Parameters ---------- n : int Number of nodes m1 : int Number of edges to link each new node to existing nodes with probability $p$ m2 : int Number of edges to link each new node to existing nodes with probability $1-p$ p : float The probability of attaching $m_1$ edges (as opposed to $m_2$ edges) seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. initial_graph : Graph or None (default) Initial network for Barabási–Albert algorithm. A copy of `initial_graph` is used. It should be connected for most use cases. If None, starts from a star graph on max(m1, m2) + 1 nodes. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. Returns ------- G : Graph Raises ------ NetworkXError If `m1` and `m2` do not satisfy ``1 <= m1,m2 < n``, or `p` does not satisfy ``0 <= p <= 1``, or the initial graph number of nodes m0 does not satisfy m1, m2 <= m0 <= n. References ---------- .. [1] N. Moshiri "The dual-Barabasi-Albert model", arXiv:1810.10538. Fr0u;Dual Barabási–Albert must have m1 >= 1 and m1 < n, m1 = rvu;Dual Barabási–Albert must have m2 >= 1 and m2 < n, m2 = u;Dual Barabási–Albert network must have 0 <= p <= 1, p = ruABarabási–Albert initial graph must have between max(m1, m2) = z and n = rw)rrrAr}rmaxrCrxr9rEr,rrtrLrMry)rm1m2rrrzr r rOrlrkr{r|r2s&&&&&&$ r%dual_barabasi_albert_graphrs`&lUuUL AvI"VTUSV W   AvI"VTUSV W   1uAI! M   Av$QDLL a$QDLL s2{L 1 } B +s=/AA/E""!!$R YqcA     1gG$%HHJAJDAa1aaJNA VF 1* ;;=1 AA!D9 fX\734g&vhl+!  H)BsG<c\VRRR7pV^8gW8dRV RV 2p\P!V4hW#,^8dRV RV 2p\P!V4h\W4p.pVP \ V44Tp W8EdVP 4p \V4^, p \V4V ,^, p W8EdGVP4W, 8:Ed+VP4U Uu.uFwrW8gK V NK pp p\ V4FpVPV4p\VV,4pVPV4TPVU u.uF qV9gK V NK up 4pVPVV4VPV4VPV4VPV4V 8XdVPV4VPV4V 8XgKVV9gKVPV4K EKY*u;8:dW#,8EdMEMWP4u;8:d V 8EdMEMVP4U Uu.uFwr^Tu;8d V 8gKMKV NK pp p\ V4EFDpVPV4p\VV,4pVPV4pVPV4TPVU u.uF qV9gK V NK up 4pVPVV4VPVV4VPV4VPV4VPV4^8XdVV9dVPV4VV9d.VPV4V 8XdVPV4EKEKVPV4^8XgEK3VPV4EKG EKX\!WV4pVP#\%V .V,V44VP V4VP V .V^,,4V ^, p EKV#uupp iuup iuupp iuup i)uReturns an extended Barabási–Albert model graph. An extended Barabási–Albert model graph is a random graph constructed using preferential attachment. The extended model allows new edges, rewired edges or new nodes. Based on the probabilities $p$ and $q$ with $p + q < 1$, the growing behavior of the graph is determined as: 1) With $p$ probability, $m$ new edges are added to the graph, starting from randomly chosen existing nodes and attached preferentially at the other end. 2) With $q$ probability, $m$ existing edges are rewired by randomly choosing an edge and rewiring one end to a preferentially chosen node. 3) With $(1 - p - q)$ probability, $m$ new nodes are added to the graph with edges attached preferentially. When $p = q = 0$, the model behaves just like the Barabási–Alber model. Parameters ---------- n : int Number of nodes m : int Number of edges with which a new node attaches to existing nodes p : float Probability value for adding an edge between existing nodes. p + q < 1 q : float Probability value of rewiring of existing edges. p + q < 1 seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. Returns ------- G : Graph Raises ------ NetworkXError If `m` does not satisfy ``1 <= m < n`` or ``1 >= p + q`` References ---------- .. [1] Albert, R., & Barabási, A. L. (2000) Topology of evolving networks: local events and universality Physical review letters, 85(24), 5234. Fr0z7Extended Barabasi-Albert network needs m>=1 and mQbb NR1X;;~6$(( #4  ''1 KK"7V"7BEU;URR"7V  8Y/&,,X6%,,Y788H%6"))(388I&-7IU >Ub>Ub NV1X{{>2!4M  ;;y1  & KK"7O"7BY;NRR"7O  dH- 4+&,,X6%,,Y788H%*x>/I"))(3.xx *m;&--i8<xx *a/&--i8CL%%:tDG  S(a9 : " ( ( 1 ! ( ((q1u)= > MH H]SW(WPs6 QQ/Q <Q *QQQ2Q% ?Q% c\VRRR7pV^8gW8d\P!RV RV 24hV^8gV^8d\P!RV 24h\W4p\ V4pTpWp8EdE\ WaV4pVP 4p VPWy4VPV 4^p W8dVP4V8dVPV 4U u.uF&p VPW{4'dKW8wgK$V NK( p p V 'd?VPV 4p VPW{4VPV 4V ^,p KVP 4p VPWy4VPV 4V ^,p KVPV.V,4V^, pEKKV#uup i)urHolme and Kim algorithm for growing graphs with powerlaw degree distribution and approximate average clustering. Parameters ---------- n : int the number of nodes m : int the number of random edges to add for each new node p : float, Probability of adding a triangle after adding a random edge seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. Notes ----- The average clustering has a hard time getting above a certain cutoff that depends on `m`. This cutoff is often quite low. The transitivity (fraction of triangles to possible triangles) seems to decrease with network size. It is essentially the Barabási–Albert (BA) growth model with an extra step that each random edge is followed by a chance of making an edge to one of its neighbors too (and thus a triangle). This algorithm improves on BA in the sense that it enables a higher average clustering to be attained if desired. It seems possible to have a disconnected graph with this algorithm since the initial `m` nodes may not be all linked to a new node on the first iteration like the BA model. Raises ------ NetworkXError If `m` does not satisfy ``1 <= m <= n`` or `p` does not satisfy ``0 <= p <= 1``. References ---------- .. [1] P. Holme and B. J. Kim, "Growing scale-free networks with tunable clustering", Phys. Rev. E, 65, 026107, 2002. Fr0z'NetworkXError must have m>1 and m`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. Raises ------ NetworkXError If `p1` or `p2` parameters are >= 1 because the while loops would never finish. Fr0c3*"TF q^8xK R#5i)NrW).0rs& r% 'random_lobster_graph..os $8a68sTz6Probability values for `p1` and `p2` must both be < 1.g?) rabsanyrrArrrr,r) rp1p2rr llenL current_nodecat_nodes &&&&$ r%random_lobster_graphrKsD&lUuUL Wc"g s $B8 $sss $B8 $$$WXX q4;;= 1$s* +D4&A!8L 4[kkmb A L JJq '#H++-"$!  82 Hr'c \VRRR7p\^V4p.p.p^pVFwrxp \W,4p VPW, 4\P !\ WzWPR7VR7p VPV 4Wg, p\PPW;4pK \\V4^, 4Fp \WL,4p \WL^,,4pW\,p^pVV8gK?VPV 4pVPV4pVV8XgVPVV4'dKLVPVV4V^,pKi V#)aReturns a random shell graph for the constructor given. Parameters ---------- constructor : list of three-tuples Represents the parameters for a shell, starting at the center shell. Each element of the list must be of the form `(n, m, d)`, where `n` is the number of nodes in the shell, `m` is the number of edges in the shell, and `d` is the ratio of inter-shell (next) edges to intra-shell edges. If `d` is zero, there will be no intra-shell edges, and if `d` is one there will be all possible intra-shell edges. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. Graph instances are not supported. Multigraph and directed types are not supported and raise a ``NetworkXError``. Examples -------- >>> constructor = [(10, 20, 0.8), (20, 40, 0.8)] >>> G = nx.random_shell_graph(constructor) Fr0)rr ) first_label)rrrrrconvert_node_labels_to_integersr? __class__ operatorsunionr,rCr9r:r;r) constructorrr r glist intra_edgesnnodesrr2rl inter_edgesgginlist1nlist2 total_edgesr>r4r"s&&$ r%random_shell_graphrs;8&lUuULA|$A EK Fa!%j 1?+  . . Q$[[ Q   Q  LL  q $CJN#eieFm$!o  ;& F#A F#AAvAq)) 1a '!^ $ Hr'cR\VRRR7p\WW#R7p\WT4pV#)aReturns a tree with a power law degree distribution. Parameters ---------- n : int The number of nodes. gamma : float Exponent of the power law. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. tries : int Number of attempts to adjust the sequence to make it a tree. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. Raises ------ NetworkXError If no valid sequence is found within the maximum number of attempts. Notes ----- A trial power law degree sequence is chosen and then elements are swapped with new elements from a powerlaw distribution until the sequence makes a tree (by checking, for example, that the number of edges is one smaller than the number of nodes). Fr0)gammarrS)rrandom_powerlaw_tree_sequencer )rrrrSr rqr s&&&&$ r%random_powerlaw_treers.D&lUuUL 'T OCS/A Hr')r c H\PPWVR7pVUu.uF"p\V\ \ V4^44NK$ pp\PPW1VR7pVUu.uF"p\V\ \ V4^44NK$ ppVF[p\PP V4wrV 'dVu#VP^V^, 4p VP4Wj&K] \P!RV R24huupiuupi)aReturns a degree sequence for a tree with a power law distribution. Parameters ---------- n : int, The number of nodes. gamma : float Exponent of the power law. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. tries : int Number of attempts to adjust the sequence to make it a tree. Raises ------ NetworkXError If no valid sequence is found within the maximum number of attempts. Notes ----- A trial power law degree sequence is chosen and then elements are swapped with new elements from a power law distribution until the sequence makes a tree (by checking, for example, that the number of edges is one smaller than the number of nodes). )exponentrzExceeded max (z%) attempts for a valid tree sequence.) rutilspowerlaw_sequenceminrroundis_valid_tree_degree_sequencerandintrrA) rrrrSzszseqswaprkvalidindexs &&&& r%rrs@ ""14"@A./ 0aC3uQx# $aD 0 ""5t"DA./ 0aC3uQx# $aD 0 8899$? K QA&hhj    DE  1 1s (D5(Dcaa \VRRR7pVf ^RIo VV 3Rlp\P!VR7pVP \ V44^^rvW`8d\ P!^VP4, 4)pS!W`, Wp, ^4V8:dV^,V^,rvK`\ P!W!W`, Wp, V4,4pVPV^, V^, 4KV#)uReturns an random graph based on the specified kernel. The algorithm chooses each of the $[n(n-1)]/2$ possible edges with probability specified by a kernel $\kappa(x,y)$ [1]_. The kernel $\kappa(x,y)$ must be a symmetric (in $x,y$), non-negative, bounded function. Parameters ---------- n : int The number of nodes kernel_integral : function Function that returns the definite integral of the kernel $\kappa(x,y)$, $F(y,a,b) := \int_a^b \kappa(x,y)dx$ kernel_root: function (optional) Function that returns the root $b$ of the equation $F(y,a,b) = r$. If None, the root is found using :func:`scipy.optimize.brentq` (this requires SciPy). seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. Notes ----- The kernel is specified through its definite integral which must be provided as one of the arguments. If the integral and root of the kernel integral can be found in $O(1)$ time then this algorithm runs in time $O(n+m)$ where m is the expected number of edges [2]_. The nodes are set to integers from $0$ to $n-1$. Examples -------- Generate an Erdős–Rényi random graph $G(n,c/n)$, with kernel $\kappa(x,y)=c$ where $c$ is the mean expected degree. >>> def integral(u, w, z): ... return c * (z - w) >>> def root(u, w, r): ... return r / c + w >>> c = 1 >>> graph = nx.random_kernel_graph(1000, integral, root) See Also -------- gnp_random_graph expected_degree_graph References ---------- .. [1] Bollobás, Béla, Janson, S. and Riordan, O. "The phase transition in inhomogeneous random graphs", *Random Structures Algorithms*, 31, 3--122, 2007. .. [2] Hagberg A, Lemons N (2015), "Fast Generation of Sparse Random Kernel Graphs". PLoS ONE 10(9): e0135177, 2015. doi:10.1371/journal.pone.0135177 Fr0NcV<aaaVVVV3RlpSPPVS^4#)c&<S!SSV4S, #NrW)bakernel_integralrys&r% my_function=random_kernel_graph..kernel_root..my_functionfs&q!Q/!33r')optimizebrentq)rrrrrspsfff r% kernel_root(random_kernel_graph..kernel_rootes( 4 4;;%%k1a8 8r'r) rscipyrradd_nodes_fromr,rrrceilr) rrrrr graphrIrGrrs &f&&$ @r%random_kernel_graphrsD&lUuUL 9 NN 5E q" % XXa$++-' ( ( 15!% +q 0q5!a%q !k!%::;A NN1q5!a% ( Lr'rchaaaaVP4pVPV3RlVP44.p\\ S44oVP 4F=wooVP S4VPVVV3Rl\ S444K? VPV4V#)uxReturn a `k`-lift of a graph using random permutations. The resulting graph ``H`` has `k` copies of each node from `G`. For each edge ``(u, v)`` in `G`, a random permutation is used to connect the ``i``-th copy of ``u`` to the permuted ``i``-th copy of ``v`` in ``H``. Parameters ---------- G : Graph, DiGraph, MultiGraph, or MultiDiGraph The base graph to lift. Any standard NetworkX graph type is supported. k : int The lift parameter. Each node in `G` is expanded to `k` copies. seed : int, RandomState, or None (default: None) Seed for the random number generator (used for permutation generation). This ensures reproducibility. See :ref:`Randomness`. Returns ------- H : Graph, DiGraph, MultiGraph, or MultiDiGraph The resulting `k`-lifted graph. The returned type matches the input graph type. Notes ----- Given a base graph `G` and a lift parameter `k`, this function performs a `k`-lift as follows: - For each node ``v`` in `G`, it creates `k` copies: ``(v, 0), ..., (v, k - 1)``. - For each edge ``(u, v)`` in `G`, a random permutation ``σ`` is applied to determine new edges: if ``σ(i) = j``, then ``((u, i), (v, j))`` is added to ``H``. The permutation is simulated by creating a shuffled list ``permutation`` of values 0 to ``k - 1``. Each ``i``-th copy of ``u`` is then connected to the ``permutation[i]``-th copy of ``v``. This operation is often used in the construction of expander graphs [1]_. If the base graph is a decent expander (i.e., has a good spectral gap-the difference between the two largest eigenvalues (in absolute value) of its adjacency matrix), then its `k`-lifts are also expanders, with the spectral gap preserved (or slightly reduced and stabilizing for larger `k` [3]_) with high probability, while producing a larger graph of the same degree. For arbitrary input graphs, the lifted graph may be disconnected. Disconnected lifts occur more often when the base graph is a poor expander. Since enforcing connectivity in such cases is unlikely to produce a good expander, this implementation returns the lift directly, even if it is disconnected. Users who require connected results may wrap this function with retries until a connected lift is found. This implementation supports all standard NetworkX graph types. While expander graphs are most commonly studied as degree-regular undirected simple graphs/multigraphs, the `k`-lift operation itself is well-defined and can also be beneficial for directed [4]_ and non-regular [5]_ graphs. References ---------- .. [1] Y. Bilu and N. Linial, "Lifts, Discrepancy and Nearly Optimal Spectral Gap." *Combinatorica*, 26(5), pp. 495–519, 2006, https://www.cs.huji.ac.il/~nati/PAPERS/raman_lift.pdf .. [2] A. Valadarsky, G. Shahaf, M. Dinitz and M. Schapira, "Xpander: Towards Optimal-Performance Datacenters.", In *Proceedings of the 12th International Conference on Emerging Networking Experiments and Technologies (CoNEXT)*, 2016, https://dl.acm.org/doi/pdf/10.1145/2999572.2999580 .. [3] N. Agarwal, K. Chandrasekaran, A. Kolla and V. Madan, "On the Expansion of Group-Based Lifts.", arXiv preprint arXiv:1311.3268v2, 2016, http://arxiv.org/abs/1311.3268v2 .. [4] P. Chebolu and A. Frieze, "Hamilton Cycles in Random Lifts of Directed Graphs.", Department of Mathematics, Carnegie Mellon University, 2007, https://www.math.cmu.edu/~af1p/Texfiles/LiftHamDir.pdf .. [5] S. Hoory, "On the Girth of Graph Lifts." arXiv:2401.01238v1, 2024, https://arxiv.org/pdf/2401.01238 Examples -------- >>> G = nx.complete_graph(4) # 3-regular, connected graph >>> H = nx.random_k_lift(G, 4, seed=42) # 4-lift of G >>> H.number_of_nodes() 16 c3N<"TFp\S4Fq!V3xK K R#5ir)r,)rr"rIr6s& r%r random_k_lift..s?WeAhVhVWs"%c3B<"TFpSV3SSV,33xK R#5irrW)rrI permutationr4r"s& r%rrs#EHqq!fq+a.12Hs) rrrBr9r,rDrcryrL)r r6rHrDrr4r"s&f& @@@r% random_k_liftrxsd A?QWW?? EuQx.K 1 [! EE!HEEU Hr')r&rr7r?erdos_renyi_graphbinomial_graphrJrPrTror}rrrrrrrrr)NFr)dN)NN)Nr))__doc__r)r collectionsrnetworkxrnetworkx.utilsr utils.miscrclassicrrrr degree_seqr __all__ _dispatchabler&rrrr7r?rJrPrTrortr}rrrrrrrrrrWr'r%rs  #*+HH, 0T2L 4L 3L ^T2; d; 3; ~"$T2<D<3<~T24 d4 34 nT2F DF 3F RT2K TK 3K \T23?RV3?33?lT2s $s 3s l T2G tG 3G TT2d AEd 3d NT2a $a 3a HT2X tX 3X vT22 t2 32 jT2: t: 3: zT2$ 4$ 3$ N00fT2TEIT3TnT2] 3] r'