+
    =åûjº  ã                   ó|   € ^ RI Ht ^ RIHtHt ^ RIHt ^ RIHu H	t	 ^ RIH
t
 ]3R lt]3R lt]
3R lt]3R	 ltR# )
é    )Úpartial)ÚchainÚminimize)ÚidentityN)Úyieldifyc                ó”   € V F;  p\        W4      '       g   K  W,          ! \        \        \        WR7      V 4      !  u # 	  V! V 4      # )a>  Apply functions onto recursive containers (tree).

Explanation
===========

join - a dictionary mapping container types to functions
  e.g. ``{list: minimize, tuple: chain}``

Keys are containers/iterables.  Values are functions [a] -> a.

Examples
========

>>> from sympy.strategies.tree import treeapply
>>> tree = [(3, 2), (4, 1)]
>>> treeapply(tree, {list: max, tuple: min})
2

>>> add = lambda *args: sum(args)
>>> def mul(*args):
...     total = 1
...     for arg in args:
...         total *= arg
...     return total
>>> treeapply(tree, {list: mul, tuple: add})
25
)ÚjoinÚleaf)Ú
isinstanceÚmapr   Ú	treeapply)Útreer	   r
   Útyps   &&& ÚQC:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\sympy\strategies\tree.pyr   r      sG   € ó8 ˆÜ�d× Ô Ø–9œc¤'¬)¸$Ô"JØ"&ó(ñ )ò )ñ ñ �‹:Ðó    c                ó^   € \        \        VR7      p\        V \        V\        \
        /3/ VB # )a   Execute a strategic tree.  Select alternatives greedily

Trees
-----

Nodes in a tree can be either

function - a leaf
list     - a selection among operations
tuple    - a sequence of chained operations

Textual examples
----------------

Text: Run f, then run g, e.g. ``lambda x: g(f(x))``
Code: ``(f, g)``

Text: Run either f or g, whichever minimizes the objective
Code: ``[f, g]``

Textx: Run either f or g, whichever is better, then run h
Code: ``([f, g], h)``

Text: Either expand then simplify or try factor then foosimp. Finally print
Code: ``([(expand, simplify), (factor, foosimp)], print)``

Objective
---------

"Better" is determined by the objective keyword.  This function makes
choices to minimize the objective.  It defaults to the identity.

Examples
========

>>> from sympy.strategies.tree import greedy
>>> inc    = lambda x: x + 1
>>> dec    = lambda x: x - 1
>>> double = lambda x: 2*x

>>> tree = [inc, (dec, double)] # either inc or dec-then-double
>>> fn = greedy(tree)
>>> fn(4)  # lowest value comes from the inc
5
>>> fn(1)  # lowest value comes from dec then double
0

This function selects between options in a tuple.  The result is chosen
that minimizes the objective function.

>>> fn = greedy(tree, objective=lambda x: -x)  # maximize
>>> fn(4)  # highest value comes from the dec then double
6
>>> fn(1)  # highest value comes from the inc
2

Greediness
----------

This is a greedy algorithm.  In the example:

    ([a, b], c)  # do either a or b, then do c

the choice between running ``a`` or ``b`` is made without foresight to c
)Ú	objective)r   r   r   ÚlistÚtupler   )r   r   ÚkwargsÚoptimizes   &&, r   Úgreedyr   +   s,   € ôD ”x¨9Ô5€HÜ�TœD (¬E´5Ð9ÑD¸VÑDÐDr   c                ón   € \        V \        \        P                  \        \        P
                  /VR7      # )as  Execute a strategic tree.  Return all possibilities.

Returns a lazy iterator of all possible results

Exhaustiveness
--------------

This is an exhaustive algorithm.  In the example

    ([a, b], [c, d])

All of the results from

    (a, c), (b, c), (a, d), (b, d)

are returned.  This can lead to combinatorial blowup.

See sympy.strategies.greedy for details on input
)r
   )r   r   ÚbranchÚ	multiplexr   r   )r   r
   s   &&r   Ú
allresultsr   q   s+   € ô( �TœD¤&×"2Ñ"2´E¼6¿<¹<ÐHØô ð  r   c                 ó   a aa€ VVV 3R  l# )c           	      óP   <€ \        \        \        S3/ SB ! V 4      4      SR 7      # ))Úkey)Úminr   r   )Úexprr   r   r   s   &€€€r   Ú<lambda>Úbrute.<locals>.<lambda>Š   s#   ø€ œœE¤*¨TÑ"<°VÒ"<¸TÓ"BÓCØ )õ+r   © )r   r   r   s   fflr   Úbruter%   ‰   s   ú€ ö+ð +r   )Ú	functoolsr   Úsympy.strategiesr   r   Úsympy.strategies.corer   Úsympy.strategies.branchÚ
strategiesr   r   r   r   r   r%   r$   r   r   Ú<module>r+      sC   ðÝ ß ,Ý *ß (Ð (Ý ,ð  (ô  ðF $ô CEðL #ô  ð0 #ö +r   