wg;-dZddlmZddlZddlmZddlm Z m Z m Z gdZ dZ e de d ejd Ze de d ejd Ze d ejdd ddZe de d ejdZe de d ejddd iidZe de d ejdZe de d ejddZy)aFunctions concerning tournament graphs. A `tournament graph`_ is a complete oriented graph. In other words, it is a directed graph in which there is exactly one directed edge joining each pair of distinct nodes. For each function in this module that accepts a graph as input, you must provide a tournament graph. The responsibility is on the caller to ensure that the graph is a tournament graph: >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 0)]) >>> nx.is_tournament(G) True To access the functions in this module, you must access them through the :mod:`networkx.tournament` module:: >>> nx.tournament.is_reachable(G, 0, 1) True .. _tournament graph: https://en.wikipedia.org/wiki/Tournament_%28graph_theory%29 ) combinationsN)is_simple_path)arbitrary_elementnot_implemented_forpy_random_state)hamiltonian_path is_reachableis_strongly_connected is_tournamentrandom_tournamentscore_sequencect|D]\}}||s|cS dzS#t$r}td|d}~wwxYw)aReturns the index of the first element in `iterable` that satisfies the given condition. If no such element is found (that is, when the iterable is exhausted), this returns the length of the iterable (that is, one greater than the last index of the iterable). `iterable` must not be empty. If `iterable` is empty, this function raises :exc:`ValueError`. ziterable must be non-emptyN) enumerate NameError ValueError)iterable conditionixerrs c/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/networkx/algorithms/tournament.pyindex_satisfyingr(sW(#1 Q<H@1u @56C?@s& A ;A undirected multigraphcttfdtdDxrtjdk(S)aReturns True if and only if `G` is a tournament. A tournament is a directed graph, with neither self-loops nor multi-edges, in which there is exactly one directed edge joining each pair of distinct nodes. Parameters ---------- G : NetworkX graph A directed graph representing a tournament. Returns ------- bool Whether the given graph is a tournament graph. Examples -------- >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 0)]) >>> nx.is_tournament(G) True Notes ----- Some definitions require a self-loop on each node, but that is not the convention used here. c3BK|]\}}||v||vz ywN.0uvGs r z is_tournament..es* E$!QQ!A$Y1!9 % Esr)allrnxnumber_of_selfloopsr$s`rr r Cs8D E,q!2D EE +  " "1 % *ctdk(rgStdk(r tgSttjt hz }t |fd}|j ||S)arReturns a Hamiltonian path in the given tournament graph. Each tournament has a Hamiltonian path. If furthermore, the tournament is strongly connected, then the returned Hamiltonian path is a Hamiltonian cycle (by joining the endpoints of the path). Parameters ---------- G : NetworkX graph A directed graph representing a tournament. Returns ------- path : list A list of nodes which form a Hamiltonian path in `G`. Examples -------- >>> G = nx.DiGraph([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]) >>> nx.is_tournament(G) True >>> nx.tournament.hamiltonian_path(G) [0, 1, 2, 3] Notes ----- This is a recursive implementation with an asymptotic running time of $O(n^2)$, ignoring multiplicative polylogarithmic factors, where $n$ is the number of nodes in the graph. rrc|vSrr)r"r$r#s rz"hamiltonian_path..s1 r+)lenrrsubgraphsetrinsert)r$hampathindexr#s` @rrrjsxF 1v{  1v{!!$%%!Aqzz#a&A3,78G W&= >E NN5! Nr+rT)graphs returns_graphcfdt||dz zdzD}tt|d}dt||D}tj|S)aReturns a random tournament graph on `n` nodes. Parameters ---------- n : int The number of nodes in the returned graph. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- G : DiGraph A tournament on `n` nodes, with exactly one directed edge joining each pair of distinct nodes. Notes ----- This algorithm adds, for each pair of distinct nodes, an edge with uniformly random orientation. In other words, `\binom{n}{2}` flips of an unbiased coin decide the orientations of the edges in the graph. c3>K|]}jywr)random)r!rseeds rr%z$random_tournament..s >qT[[] >srr&c3BK|]\\}}}|dkr||fn||fyw)g?Nr)r!r"r#rs rr%z$random_tournament..s+ Nyv1qq3waVQF * Ns)rangerzipr(DiGraph)nr:coinspairsedgess ` rr r sQ8 ?E1A;1*<$= >E q1 %E NCu>> G = nx.DiGraph([(1, 0), (1, 3), (0, 2), (0, 3), (2, 1), (3, 2)]) >>> nx.is_tournament(G) True >>> nx.tournament.score_sequence(G) [1, 1, 2, 2] c3&K|] \}}| ywrr)r!r#ds rr%z!score_sequence..s/1!/s)sorted out_degreer*s rr r s8 / / //r+r$weight)preserve_edge_attrscJtj|}||jz S)aReturns the tournament matrix for the given tournament graph. This function requires SciPy. The *tournament matrix* of a tournament graph with edge set *E* is the matrix *T* defined by .. math:: T_{i j} = \begin{cases} +1 & \text{if } (i, j) \in E \\ -1 & \text{if } (j, i) \in E \\ 0 & \text{if } i == j. \end{cases} An equivalent definition is `T = A - A^T`, where *A* is the adjacency matrix of the graph `G`. Parameters ---------- G : NetworkX graph A directed graph representing a tournament. Returns ------- SciPy sparse array The tournament matrix of the tournament graph `G`. Raises ------ ImportError If SciPy is not available. )r(adjacency_matrixT)r$As rtournament_matrixrOs"N AA qss7Nr+czd}dDcgc] }|| }}tfd|DScc}w)aDecides whether there is a path from `s` to `t` in the tournament. This function is more theoretically efficient than the reachability checks than the shortest path algorithms in :mod:`networkx.algorithms.shortest_paths`. The given graph **must** be a tournament, otherwise this function's behavior is undefined. Parameters ---------- G : NetworkX graph A directed graph representing a tournament. s : node A node in the graph. t : node A node in the graph. Returns ------- bool Whether there is a path from `s` to `t` in `G`. Examples -------- >>> G = nx.DiGraph([(1, 0), (1, 3), (1, 2), (2, 3), (2, 0), (3, 0)]) >>> nx.is_tournament(G) True >>> nx.tournament.is_reachable(G, 1, 3) True >>> nx.tournament.is_reachable(G, 3, 2) False Notes ----- Although this function is more theoretically efficient than the generic shortest path functions, a speedup requires the use of parallelism. Though it may in the future, the current implementation does not use parallelism, thus you may not see much of a speedup. This algorithm comes from [1]. References ---------- .. [1] Tantau, Till. "A note on the complexity of the reachability problem for tournaments." *Electronic Colloquium on Computational Complexity*. 2001. czDchc]'k(svstfdDs&)c}Scc}w)aKReturns the set of nodes at distance at most two from `v`. `G` must be a graph and `v` a node in that graph. The returned set includes the nodes at distance zero (that is, the node `v` itself), the nodes at distance one (that is, the out-neighbors of `v`), and the nodes at distance two. c3<K|]}t|gywr)is_path)r!zr$r#rs rr%z9is_reachable..two_neighborhood..Ks6XQRwq1a)7L6Xs)any)r$r#rs```rtwo_neighborhoodz&is_reachable..two_neighborhood@s@ AFa1Q4i36XVW6X3XA   s'88cHtfdtz DS)zDecides whether the given set of nodes is closed. A set *S* of nodes is *closed* if for each node *u* in the graph not in *S* and for each node *v* in *S*, there is an edge from *u* to *v*. c3:K|]}D] }||v ywrr)r!r"r#r$nodess rr%z2is_reachable..is_closed..Vs%DeD1!9D9Ds)r'r1)r$rYs``r is_closedzis_reachable..is_closedNsDc!funDDDr+c3JK|]}|xr |vxr|v ywrr)r!Sr$rZsts rr%zis_reachable..Ys,V1IaO=Q=1A:>Vs #r')r$r]r^rVr# neighborhoodsrZs``` @rr r sBt  E677%a+7M7 V V VV8s8 tournament_is_strongly_connected)namec,tfdDS)aDecides whether the given tournament is strongly connected. This function is more theoretically efficient than the :func:`~networkx.algorithms.components.is_strongly_connected` function. The given graph **must** be a tournament, otherwise this function's behavior is undefined. Parameters ---------- G : NetworkX graph A directed graph representing a tournament. Returns ------- bool Whether the tournament is strongly connected. Examples -------- >>> G = nx.DiGraph([(0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (3, 0)]) >>> nx.is_tournament(G) True >>> nx.tournament.is_strongly_connected(G) True >>> G.remove_edge(3, 0) >>> G.add_edge(0, 3) >>> nx.is_tournament(G) True >>> nx.tournament.is_strongly_connected(G) False Notes ----- Although this function is more theoretically efficient than the generic strong connectivity function, a speedup requires the use of parallelism. Though it may in the future, the current implementation does not use parallelism, thus you may not see much of a speedup. This algorithm comes from [1]. References ---------- .. [1] Tantau, Till. "A note on the complexity of the reachability problem for tournaments." *Electronic Colloquium on Computational Complexity*. 2001. c3FK|]}D]}t||ywr)r r s rr%z(is_strongly_connected..s';;A|Aq!$;$;s!r_r*s`rr r \sn ;a; ;;r+r)__doc__ itertoolsrnetworkxr( networkx.algorithms.simple_pathsrrSnetworkx.utilsrrr__all__r _dispatchabler rr r rOr r rr+rrls.#FRR @6\"\"!##!H\"\"*##*ZT23@\"\"0##08\"\"sXqM&:;%<##%P\"\"PW##PWf\"\"9:4<;##4