+
    )ic4                        R t ^ RIt^ RIt^ RIHt ^ RIHtHt . ROt	 ! R R]P                  4      t]! R4      ]! R4      ]P                  R 4       4       4       t]P                  ]P                  3R	 l4       t]P                  R
 4       t]P                  R 4       tR tR tR tR]P                  3R lt]! R4      ]P                  ! RR7      R 4       4       tR# )z
Algorithms for chordal graphs.

A graph is chordal if every cycle of length at least 4 has a chord
(an edge joining two nodes not adjacent in the cycle).
https://en.wikipedia.org/wiki/Chordal_graph
N)connected_components)arbitrary_elementnot_implemented_forNetworkXTreewidthBoundExceededc                       ] tR t^tRtRtR# )r   zRException raised when a treewidth bound has been provided and it has
been exceeded N)__name__
__module____qualname____firstlineno____doc____static_attributes__r       Y/var/www/html/photoedit/myenv/lib/python3.14/site-packages/networkx/algorithms/chordal.pyr   r      s    r   directed
multigraphc                h    \        V P                  4      ^8:  d   R# \        \        V 4      4      ^ 8H  # )ul  Checks whether G is a chordal graph.

A graph is chordal if every cycle of length at least 4 has a chord
(an edge joining two nodes not adjacent in the cycle).

Parameters
----------
G : graph
  A NetworkX graph.

Returns
-------
chordal : bool
  True if G is a chordal graph and False otherwise.

Raises
------
NetworkXNotImplemented
    The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.

Examples
--------
>>> e = [
...     (1, 2),
...     (1, 3),
...     (2, 3),
...     (2, 4),
...     (3, 4),
...     (3, 5),
...     (3, 6),
...     (4, 5),
...     (4, 6),
...     (5, 6),
... ]
>>> G = nx.Graph(e)
>>> nx.is_chordal(G)
True

Notes
-----
The routine tries to go through every node following maximum cardinality
search. It returns False when it finds that the separator for any node
is not a clique.  Based on the algorithms in [1]_.

Self loops are ignored.

References
----------
.. [1] R. E. Tarjan and M. Yannakakis, Simple linear-time algorithms
   to test chordality of graphs, test acyclicity of hypergraphs, and
   selectively reduce acyclic hypergraphs, SIAM J. Comput., 13 (1984),
   pp. 566–579.
T)lennodes_find_chordality_breaker)Gs   &r   
is_chordalr      s.    r 177|q'*+q00r   c                .   \        V 4      '       g   \        P                  ! R4      h\        P                  ! V 4      pVP	                  W4       \        4       p\        WAV4      pV'       dG   Vw  rxp	VP                  V4       V F  p
W8w  g   K  VP	                  W4       K  	  \        WAV4      pKN  V'       d[   VP                  V4       W,           F=  p\        V\        W,          4      ,          4      ^8X  g   K+  VP                  V4        V# 	  V# )a!  Returns the set of induced nodes in the path from s to t.

Parameters
----------
G : graph
  A chordal NetworkX graph
s : node
    Source node to look for induced nodes
t : node
    Destination node to look for induced nodes
treewidth_bound: float
    Maximum treewidth acceptable for the graph H. The search
    for induced nodes will end as soon as the treewidth_bound is exceeded.

Returns
-------
induced_nodes : Set of nodes
    The set of induced nodes in the path from s to t in G

Raises
------
NetworkXError
    The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
    If the input graph is an instance of one of these classes, a
    :exc:`NetworkXError` is raised.
    The algorithm can only be applied to chordal graphs. If the input
    graph is found to be non-chordal, a :exc:`NetworkXError` is raised.

Examples
--------
>>> G = nx.Graph()
>>> G = nx.generators.classic.path_graph(10)
>>> induced_nodes = nx.find_induced_nodes(G, 1, 9, 2)
>>> sorted(induced_nodes)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Notes
-----
G must be a chordal graph and (s,t) an edge that is not in G.

If a treewidth_bound is provided, the search for induced nodes will end
as soon as the treewidth_bound is exceeded.

The algorithm is inspired by Algorithm 4 in [1]_.
A formal definition of induced node can also be found on that reference.

Self Loops are ignored

References
----------
.. [1] Learning Bounded Treewidth Bayesian Networks.
   Gal Elidan, Stephen Gould; JMLR, 9(Dec):2699--2731, 2008.
   http://jmlr.csail.mit.edu/papers/volume9/elidan08a/elidan08a.pdf
Input graph is not chordal.)
r   nxNetworkXErrorGraphadd_edgesetr   updateaddr   )r   sttreewidth_boundHinduced_nodestripletuvwns   &&&&       r   find_induced_nodesr+   \   s    p a==<==
AJJqEM&q_=G
	qW%Av

1   +1A!A=3qt9,-2!!!$	  r   c              #    a "   V 3R l\        S 4       4        EFf  pVP                  4       ^8X  dO   \        P                  ! V4      ^ 8  d   \        P                  ! R4      h\        VP                  4       4      x  Kg  \        VP                  4       4      p\        V4      pVP                  V4       V0pV0pV'       d   \        WV4      pVP                  V4       VP                  V4       \        VP                  V4      4      V,          pVP                  V4      p\        V4      '       d)   VP                  V4       We8  g   \        V4      x  TpK  \        P                  ! R4      h\        V4      x  EKi  	  R# 5i)a  Returns all maximal cliques of a chordal graph.

The algorithm breaks the graph in connected components and performs a
maximum cardinality search in each component to get the cliques.

Parameters
----------
G : graph
  A NetworkX graph

Yields
------
frozenset of nodes
    Maximal cliques, each of which is a frozenset of
    nodes in `G`. The order of cliques is arbitrary.

Raises
------
NetworkXError
    The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
    The algorithm can only be applied to chordal graphs. If the input
    graph is found to be non-chordal, a :exc:`NetworkXError` is raised.

Examples
--------
>>> e = [
...     (1, 2),
...     (1, 3),
...     (2, 3),
...     (2, 4),
...     (3, 4),
...     (3, 5),
...     (3, 6),
...     (4, 5),
...     (4, 6),
...     (5, 6),
...     (7, 8),
... ]
>>> G = nx.Graph(e)
>>> G.add_node(9)
>>> cliques = [c for c in chordal_graph_cliques(G)]
>>> cliques[0]
frozenset({1, 2, 3})
c              3   b   <"   T F$  pSP                  V4      P                  4       x  K&  	  R # 5iN)subgraphcopy).0cr   s   & r   	<genexpr>(chordal_graph_cliques.<locals>.<genexpr>   s'     D,Cqajjm  "",Cs   ,/r   N)r   number_of_nodesr   number_of_selfloopsr   	frozensetr   r   r   remove_max_cardinality_noder    	neighborsr/   _is_complete_graph)r   C
unnumberedr(   numberedclique_wanna_benew_clique_wanna_besgs   f       r   chordal_graph_cliquesrB      s6    \ E,@,CD!#%%a(1,&&'DEEAGGI&&QWWYJ!!$Aa sH cO)!B!!!$Q&)!++a.&9H&D#ZZ0%b))'++A..A'88&9O**+HIIO,,1 Es   B?FCFc                    \        V 4      '       g   \        P                  ! R4      hRp\        P                  ! V 4       F  p\	        V\        V4      4      pK  	  V^,
          # )a(  Returns the treewidth of the chordal graph G.

Parameters
----------
G : graph
  A NetworkX graph

Returns
-------
treewidth : int
    The size of the largest clique in the graph minus one.

Raises
------
NetworkXError
    The algorithm does not support DiGraph, MultiGraph and MultiDiGraph.
    The algorithm can only be applied to chordal graphs. If the input
    graph is found to be non-chordal, a :exc:`NetworkXError` is raised.

Examples
--------
>>> e = [
...     (1, 2),
...     (1, 3),
...     (2, 3),
...     (2, 4),
...     (3, 4),
...     (3, 5),
...     (3, 6),
...     (4, 5),
...     (4, 6),
...     (5, 6),
...     (7, 8),
... ]
>>> G = nx.Graph(e)
>>> G.add_node(9)
>>> nx.chordal_graph_treewidth(G)
3

References
----------
.. [1] https://en.wikipedia.org/wiki/Tree_decomposition#Treewidth
r   )r   r   r   rB   maxr   )r   
max_cliquecliques   &  r   chordal_graph_treewidthrH      sT    Z a==<==J**1-S[1
 .>r   c                    \         P                  ! V 4      ^ 8  d   \         P                  ! R4      hV P                  4       pV^8  d   R# V P	                  4       pW^,
          ,          ^,          pW#8H  # )z&Returns True if G is a complete graph.z'Self loop found in _is_complete_graph()T)r   r6   r   r5   number_of_edges)r   r*   e	max_edgess   &   r   r;   r;   +  se    	a 1$HII	A1u	A!e!I>r   c                    \        V 4      pV  FU  pV\        \        W,          P                  4       4      V.,           4      ,
          pV'       g   KD  W#P                  4       3u # 	  R# )z5Given a non-complete graph G, returns a missing edge.N)r   listkeyspop)r   r   r'   missings   &   r   _find_missing_edgerR   7  sL    FE#d1499;/1#5667{{}%% r   c                    RpV F8  p\        W,           Uu. uF  qUV9   g   K  VNK  	  up4      pWc8  g   K4  TpTpK:  	  X# u upi )zXReturns a the node in choices that has more connections in G
to nodes in wanna_connect.
rD   )r   )r   choiceswanna_connect
max_numberxynumbermax_cardinality_nodes   &&&     r   r9   r9   @  sS     J<Am);aa<=J#$ 	 
  	 =s
   A
A
c                    \        V 4      ^ 8X  d   \        P                  ! R4      h\        V 4      pVf   \	        V 4      pVP                  V4       V0pRpV'       d   \        WV4      pVP                  V4       VP                  V4       \        W,          4      V,          pV P                  V4      p\        V4      '       d7   \        V\        V4      4      pWR8  d   \        P                  ! RV 24      hK  \        V4      w  rWV
3# R# )a/  Given a graph G, starts a max cardinality search
(starting from s if s is given and from an arbitrary node otherwise)
trying to find a non-chordal cycle.

If it does find one, it returns (u,v,w) where u,v,w are the three
nodes that together with s are involved in the cycle.

It ignores any self loops.
zGraph has no nodes.ztreewidth_bound exceeded: rD   r   )r   r   NetworkXPointlessConceptr   r   r8   r9   r    r/   r;   rE   r   rR   )r   r!   r#   r=   r>   current_treewidthr(   r?   rA   r'   r)   s   &&&        r   r   r   M  s     1v{))*?@@QJya asH
!!:!Qad)h.ZZ(b!! #$5s?7K L 27701B0CD  3 (+FQ!9Ir   T)returns_graphc           	       a V P                  4       pV Uu/ uF  q"^ bK  	  pp\        P                  ! V4      '       d   W3# \        4       pVP	                  4        Uu/ uF  q"^ bK  	  upo\        VP	                  4       4      p\        \        VP	                  4       4      ^ R4       EF   p\        VV3R lR7      pVP                  V4       WcV&   . pV F  p	V P                  W4      '       d   VP                  V	4       K-  SV	,          p
V Uu. uF  pSV,          V
8  g   K  VNK  	  pp\        P                  ! VP                  WV	.,           4      W4      '       g   K  VP                  V	4       VP                  Wy34       K  	  V F  pSV;;,          ^,          uu&   K  	  EK  	  VP                  V4       W3# u upi u upi u upi )a  Return a copy of G completed to a chordal graph

Adds edges to a copy of G to create a chordal graph. A graph G=(V,E) is
called chordal if for each cycle with length bigger than 3, there exist
two non-adjacent nodes connected by an edge (called a chord).

Parameters
----------
G : NetworkX graph
    Undirected graph

Returns
-------
H : NetworkX graph
    The chordal enhancement of G
alpha : Dictionary
        The elimination ordering of nodes of G

Notes
-----
There are different approaches to calculate the chordal
enhancement of a graph. The algorithm used here is called
MCS-M and gives at least minimal (local) triangulation of graph. Note
that this triangulation is not necessarily a global minimum.

https://en.wikipedia.org/wiki/Chordal_graph

References
----------
.. [1] Berry, Anne & Blair, Jean & Heggernes, Pinar & Peyton, Barry. (2004)
       Maximum Cardinality Search for Computing Minimal Triangulations of
       Graphs.  Algorithmica. 39. 287-298. 10.1007/s00453-004-1084-3.

Examples
--------
>>> from networkx.algorithms.chordal import complete_to_chordal_graph
>>> G = nx.wheel_graph(10)
>>> H, alpha = complete_to_chordal_graph(G)
c                    < SV ,          # r.   r   )nodeweights   &r   <lambda>+complete_to_chordal_graph.<locals>.<lambda>  s	    6$<r   )keyrD   )r0   r   r   r   r   rN   ranger   rE   r8   has_edgeappendhas_pathr/   r    add_edges_from)r   r$   ra   alphachordsunnumbered_nodesizupdate_nodesrX   y_weightlower_nodesrb   s   &           @r   complete_to_chordal_graphrs   t  s   T 	
A!"#1WE#	}}QxUF"#''),)$Ag),FAGGI3qwwy>1b) &?@"a!Azz!##A& "!9%5%5T9PDD%5   ;;qzz+A*>?FF ''*JJv& " !D4LAL !' ** V8O9 $ -s   GGG&G)r   r+   rB   rH   r   rs   )r   sysnetworkxr   networkx.algorithms.componentsr   networkx.utilsr   r   __all__NetworkXExceptionr   _dispatchabler   maxsizer+   rB   rH   r;   rR   r9   r   rs   r   r   r   <module>r|      s     ? AR%9%9 
 Z \"81  # !81v 03 L L^ E- E-P 2 2j	&
  #' $N Z %E & !Er   