,Vh% UdZddlZddlZddlZddlZddlZddlZddlZddlm Z m Z ddl m Z m Z mZmZmZmZmZmZmZmZmZddl m ZddlmZmZddlmZmZmZmZgdZ d de!d hZ"Gd d Z#d edefdZ$dedefdZ%deee&dee&dee'de'de'dee&e'fdeee&e'ffdZ(deee&deededee&e'fde'f dZ) d|deededee&e'fdee'def dZ*de'de'de'de'de+f d Z,de'de'de'de'de+f d!Z-e,e-d"Z.d#e&de e'e'e'e'ge+ffd$Z/d%e'd&e'd'e'd(e'd)e'd*e'de!fd+Z0d%e'd&e'd'e'd(e'd)e'd*e'de!fd,Z1e0e1d-Z2Gd.d/e#Z3 d}deededee&e'fdee'd0ee'd1e'd2e&d3e&defd4Z4ejje4d5Z6ejje4d65Z7ejje4d75Z8ee'e'e'fZ9ee9eeefZ:ded8ee&e'fdeee'fd9eee'fd:ee'ee&fd)ed*ed3e de:fd;Z;ded8ee&e fdeee'fd9eee'fd:ee'ee&fd)ede+d3e ddfd?Z d~deeded8ee&e'fdDe d3e def dEZ? ddeededee&e'fdee'dDe d3e&defdFZ@dGee dHfdefdIZAdeee'dee'deee'fdJZBdKe'dLeee'deee'ddffdMZCdNZDdOe'dPe'dQee'dee'dRe'dSe'dTe'dUee'e fdVe'dWe'deee'dXee'dee'dYee'ee'fdZee'ee'fddf d[ZEdOe'dPe'dQee'dee'dRe'dSe'dTe'dUee'e fdVe'dWe'deee'dXee'dee'dYee'ee'fdZee'ee'fddf d\ZFdOe'dPe'dQee'dee'dRe'dSe'dTe'dUee'e fdVe'dWe'deee'dXee'dee'dYee'ee'fdZee'ee'fddf d]ZGd^ZHeHeIfdOe'dPe'dQee'dee'dRe'dSe'dTe'dUee'e fdVe'dWe'deee'dXee'dee'dYee'ee'fdZee'ee'fd_ee'e!fd`e ddf$daZJejdbZLejdcd2ee&e fdee ee'e!fffddZNdLeee'dHfdee dHffdeZOdeee'dfee&dHfdgee&deeee'eee'eee'ee'fffdhZPGdidje#ZQ d|deededee&e'fdee'dke def dlZRiZSeTd7dmD]ZUe*eSeU< eTdmdnD]ZUe6eSeU< eTdndoD]ZUe7eSeU< eTdodpD]ZUe8eSeU<  d|deededee&e'fdee'def dqZViZWeTd7drD]ZUe*eWeU< eTdrdsD]ZUeReWeU<  d|deededee&e'fdee'def dtZXeVeXe*e6e7e8e@e@e@eReRdu ZYee&efeZdv<dwe&dxeddfdyZ[dze&defd{Z\y)zSContains the path technology behind opt_einsum in addition to several path helpers.N)Counter defaultdict) AnyCallableDict FrozenSet GeneratorListOptionalSequenceSetTupleUnion)r)compute_size_by_dict flop_count)ArrayIndexTypePathSearchFunctionTypePathTypeTensorShapeType) optimal BranchBoundbranchgreedyautoauto_hq get_path_fnDynamicProgrammingdynamic_programminginfc neZdZdZdeededeeefddfdZ d deededeeefde ede f d Z y) PathOptimizeraBase class for different path optimizers to inherit from. Subclassed optimizers should define a call method with signature: ```python def __call__(self, inputs: List[ArrayIndexType], output: ArrayIndexType, size_dict: dict[str, int], memory_limit: int | None = None) -> list[tuple[int, ...]]: \"\"\" Parameters: inputs: The indices of each input array. outputs: The output indices size_dict: The size of each index memory_limit: If given, the maximum allowed memory. \"\"\" # ... compute path here ... return path ``` where `path` is a list of int-tuples specifying a contraction order. inputsoutput size_dictreturnNcj|||f}t|ds||_y||jk7r tdy)zUtility that stateful optimizers can use to ensure they are not called with different contractions across separate runs. _first_call_argszThe arguments specifying the contraction that this path optimizer instance was called with have changed - try creating a new instance.N)hasattrr( ValueError)selfr#r$r%argss @/home/dcms/DCMS/lib/python3.12/site-packages/opt_einsum/paths.py_check_args_against_first_callz,PathOptimizer._check_args_against_first_call5sI *t/0$(D ! T** *W + memory_limitctN)NotImplementedError)r+r#r$r%r0s r-__call__zPathOptimizer.__call__Hs "!r/r2) __name__ __module__ __qualname____doc__r rrstrintr.r rr4r/r-r"r" s(^$S>   0'+ "^$""S> " sm "  "r/r"ssa_pathr&c ttt|t|z dz}tt |}g}|}|D]w}t |Dcgc]}t j||c}}t|D]}|j||j||j||dz }y|D cgc] } t| c} Scc}wcc} w)zConvert a path with static single assignment ids to a path with recycled linear ids. Example: ```python ssa_to_linear([(0, 3), (2, 4), (1, 5)]) #> [(0, 3), (1, 2), (0, 1)] ``` ) summaplenlistrangesortedbisect bisect_leftreversedpopappendtuple) r<nidspathssasconsconjxs r- ssa_to_linearrTRs$ CX #h-/!3A uQx.C D C$?Qf((a0?@# A GGAJ  3 C q # #E!H ## @ $s C CrMc`ttt|t|z dz}tt |t j |}g}|D]T}|jtfd|Dt|dD]}|=jt|V|S)zConvert a path with recycled linear ids to a path with static single assignment ids. Exmaple: ```python linear_to_ssa([(0, 3), (1, 2), (0, 1)]) #> [(0, 3), (2, 4), (1, 5)] ``` r>c3(K|] }| ywr2r;).0id_ linear_to_ssas r- z linear_to_ssa..s@SmC0@T)reverse) r?r@rArBrC itertoolscountrIrJrDnext)rM num_inputsnew_idsr<rLrXrYs @r-rYrYsSd^$s4y014Jz*+Mooj)GH,@C@@A#t, #Cc" #T']+ , Or/r#r$ remainingirRr%c ||||}}||z}||z} tj|gt|j|||hz } || z} t |t | | z d|} | | fS)aECalculate the resulting indices and flops for a potential pairwise contraction - used in the recursive (optimal/branch) algorithms. Parameters: inputs: The indices of each tensor in this contraction, note this includes tensors unavailable to contract as static single assignment is used:> contracted tensors are not removed from the list. output: The set of output indices for the whole contraction. remaining: *The set of indices (corresponding to ``inputs``) of tensors still available to contract. i: Index of potential tensor to contract. j: Index of potential tensor to contract. size_dict: Size mapping of all the indices. Returns: k12: The resulting indices of the potential tensor. cost: Estimated flop count of operation. ) frozensetunionr@ __getitem__rbool) r#r$rbrcrRr%k1k2eithersharedkeepk12costs r-calc_k12_flopsrqs|2AYq B "WF "WF ??6 PC(:(:IA ttt|}t|dtdidtt t |fii i  fdd|t t t |dtdS)aComputes all possible pair contractions in a depth-first recursive manner, sieving results based on `memory_limit` and the best path found so far. Parameters: inputs: List of sets that represent the lhs side of the einsum subscript. output: Set that represents the rhs side of the overall einsum subscript. size_dict: Dictionary of index sizes. memory_limit: The maximum number of elements in a temporary array. Returns: path: The optimal contraction order within the memory limit constraint. Examples: ```python isets = [set('abd'), set('ac'), set('bdc')] oset = set('') idx_sizes = {'a': 1, 'b':2, 'c':3, 'd':4} optimal(isets, oset, idx_sizes, 5000) #> [(0, 2), (0, 1)] ``` flopsr r<c .t|dk(r | d<| d<ytj|dD]\}}||kDr||}}||||f} |\}}||z} | dk\r0t vr< |} | kDr1|t||z} | dkr| d<|t|fz d<t |||ffz||fz|||hz t|hz| y#t$rt ||||x\}}|<YwxYw#t$rt |x} |<YwxYw)Nr>rxr<rerMr#rbrx) rAr] combinationsKeyErrorrq_UNLIMITED_MEMrrvrJ)rMrbr#rxrcrRkeyroflops12 new_flopssize12_optimal_iterate best_flops best_ssa_pathr0 output_set result_cache size_cacher%s r-rz!optimal.._optimal_iterates y>Q "'Jw (,M* % **9a8# DAq1u!1!9fQi(C r+C0 W IJw//>1T'_F L( %(? S]_h(i iI :g#66.7 7+48E)M,.J\^L++Z"Z3uS[?Q;RZ[\ z2 33r/rxsizer best_sizec||f||fkSr2r;rxrrrs r-better_flops_firstr!s 4=J 2 22r/c||f||fkSr2r;rs r-better_size_firstr%s %=Iz2 22r/rxrr~ct|Sr2) _BETTER_FNSr~s r- get_better_fnr/s s r/rsize1size2rorjrkc||z |z S)zpThe default heuristic cost, corresponding to the total reduction in memory of performing a contraction. r;rrrrorjrks r-cost_memory_removedr6s E>E !!r/c@tjdd||z |z zS)zyLike memory-removed, but with a slight amount of noise that breaks ties and thus jumbles the contractions a bit. g?g{Gz?)randomgaussrs r-cost_memory_removed_jitterr=s# <<T "funu&< ==r/)memory-removedzmemory-removed-jitterc eZdZ ddeedededefdZedefdZ dd e e d e d e eefd eedef d Z y)rNnbranchcutoff_flops_factorminimizecost_fnc ||dkrtd|d||_||_||_tj |||_t||_tdtdd|_ td|_ y)aExplores possible pair contractions in a depth-first recursive manner like the `optimal` approach, but with extra heuristic early pruning of branches as well sieving by `memory_limit` and the best path found so far. Parameters: nbranch: How many branches to explore at each contraction step. If None, explore all possible branches. If an integer, branch into this many paths at each step. Defaults to None. cutoff_flops_factor: If at any point, a path is doing this much worse than the best path found so far was, terminate it. The larger this is made, the more paths will be fully explored and the slower the algorithm. Defaults to 4. minimize: Whether to optimize the path with regard primarily to the total estimated flop-count, or the size of the largest intermediate. The option not chosen will still be used as a secondary criterion. cost_fn: A function that returns a heuristic 'cost' of a potential contraction with which to sort candidates. Should have signature `cost_fn(size12, size1, size2, k12, k1, k2)`. Nr>z6The number of branches must be at least one, `nbranch=z`.r rctdS)Nr )rr;r/r-z&BranchBound.__init__..os 5<r/) r*rrr _COST_FNSgetrrbetterrbestr best_progress)r+rrrrs r-__init__zBranchBound.__init__Ks~4  Wq[UV]U^^`ab b #6   %MM'7; #H- .3ElE%L$Q /:;O/Pr/r&c2t|jdS)Nr<)rTr)r+s r-rMzBranchBound.pathqsTYYz233r/inputs_output_r%r0c D j|ttt|}t|Dcic]}|t |c} i  fdd|t t t|ddjScc}w)aParameters: inputs_: List of sets that represent the lhs side of the einsum subscript output_: Set that represents the rhs side of the overall einsum subscript size_dict: Dictionary of index sizes memory_limit: The maximum number of elements in a temporary array. Returns: path: The contraction order within the memory limit constraint. Examples: ```python isets = [set('abd'), set('ac'), set('bdc')] oset = set('') idx_sizes = {'a': 1, 'b':2, 'c':3, 'd':4} optimal(isets, oset, idx_sizes, 5000) #> [(0, 2), (0, 1)] c tdk(r.jd<jd<jd<ydttdttdtdtd t f f d }g}t jd D]N\}}||kDr||}}||} } | j| r+|| | ||} | s9tj|| P|sUt jd D]<\}}||kDr||}}||} } || | ||} | s'tj|| >d } j| jkrp|rmtj|\} } }}\}}}||ffz|fz||hz thz|| | dz } j| jkr|rkyyyy)Nr>rrxr<rjrkrcrRr&c  ||f\}} |} |z}t|}j ||j dj dsy|j t kr|j t <n)|jj t zkDrytvrT|kDrO t z}|j dkr+|j d<tfzj d<y | |} } j|| | |||} | |||||f|fS#t$rt ||x\}}||f<YUwxYw#t$rt|x}|<YpwxYw)Nrxrr<) r|rqrmaxrrrrArr}rvrJr)rjrkrcrRrorrrnew_sizerrrprxr#r0r$rrMrbrr+rrr%s r-_assess_candidatezHBranchBound.__call__.._branch_iterate.._assess_candidatesu#/B#7LCT'_F"GO tV,{{9h '8JDIIV\L]^t11#f+>>6?D&&s6{3!9!9D._branch_iterates9~"$( &!%* '"(, *%' Gin' G)C.' GS' GUX' G]`' G' G' GTJ!..y!< :1q5aqAF1IB==$-b"a; NN:y9 :%229a@>DAq1u !1#AYq B 1"b!Q ?I z9= >B<<'2 +<*9>z9R61i6Aq3!Q )!SF?(Aq61c&k]B#! a<<'2 +<*+<*+P:QYZabcyyyMsB)Nrxrr2)r5r6r7r r:r9rpropertyrrMr rrr4r;r/r-rrJs"&#$' $Q#$Q!$Q $Q  $QL4h44'+ yn%y yS> y sm y  yr/rrrrrc6t||||}|||||S)N)rrrr)r) r#r$r%r0rrrr optimizers r-rrs,-@8]dI VVY ==r/)rrer>sizes footprintsdim_ref_countsc||z}||z} || z } ||z| |dzz| |dzz} |t| |||||| ||} ||} ||}| |kDr |||| f\}} }}| || f} | ||| fS)Nre)r)r$rrbrrrjrkrrltwoonerorpid1id2s r-_get_candidater s"WF r'C 3,C F?s^A%66 73PQAR;R SC S%(22    D B-C B-C SysB+CS c>D R r/k2squeuepush_allc  fd|D} |r| D]} tj|| ytj|t| y)Nc 3BK|]}t|ywr2)r) rWrkrrrrjr$rbrs r-rZz"_push_candidate..3s(vln. :~WY[]_fgvs)rrmin) r$rrbrrrjrrrrrrs `````` ` r-_push_candidater'sHwvruvJ# -I NN5) , - uc*o.r/ dim_to_keysdimsc6|D]}t||}|dkr)|dj||dj|?|dk(r)|dj||dj|m|dj||dj|y)Nr>rer)rAdiscardadd)rrrdimr^s r-_update_ref_countsr<s  'K$% A: 1  % %c * 1  % %c * aZ 1  ! !# & 1  % %c * 1  ! !# & 1  ! !# & 'r/cTtj|\}}}}||vs||vry||||fS)zFDefault contraction chooser that simply takes the minimum cost option.N)rr)rrbrprjrkros r-_simple_chooserrNs: e,D"b# b 1 R r/ choose_fnc,t|dk(rdgStj||}| t}d}nd}|Dcgc] }t |}}t |t j |z}i}t jt|} g} t|D]3\} } | |vr%| j|| | ft| || </| || <5tt} |D] } | |z D]}| |j| "dDcic]8}|| jDchc]\}}t||k\s|c}}|z :}}}}|D cic]} | t| |}} g}| jD]N\}}t!||j"}t|ddD]!\}}|d|zd}t%|||||||||| #P|rG|||}||\}}}}|j'|}|j'|}||z D]}| |j)|||z D]}| |j)|| j||f||vr | j||t| fn||z D]}| |j|t| ||<t+| ||||z zt||||<|}|Dchc]}| |D]}|}}}|j-||rt%||||||t/|||| |rG|jD cgc]\} } t| |z|| | f} } } t1j2| t1j4| \}!}}| rt1j4| \}!}}| jt7||t9||f||z|z}t||}t| }"t1j:| ||"|f\}!}}| r| Scc}wcc}}wcc}}}wcc} wcc}}wcc} } w) zThis is the core function for :func:`greedy` but produces a path with static single assignment ids rather than recycled linear ids. SSA ids are cheaper to work with and easier to reason about. r>)rNFT)rerrr)rArrrrf intersectionr]r^ enumeraterIr_rrritemsrrDrhrrHremoverrrBrheapifyrrr heappushpop)#r#r$rrrrrS fs_inputsrbssa_idsr<ssa_idr~rrr^keysrrrdim_keys dim_keys_listrcrj k2s_guessrQrprkrossa_id1ssa_id2r final_queuerssa_id12s# r-ssa_greedy_optimizerVs 6{av mmGW-G#  (..!1.I. v !7!7!C CF,.Iooc)n-G&(H +$  )  OOYs^V4 5!']IcN#IcN $c"K&< &C    % &&gm]b[%6%6%8O TCI!O88O8< O> PP #P8O>cj|tvrt||||d|St|||||}t|S)a9Finds the path by a three stage algorithm: 1. Eagerly compute Hadamard products. 2. Greedily compute contractions to maximize `removed_size` 3. Greedily compute outer products. This algorithm scales quadratically with respect to the maximum number of elements sharing a common dim. Parameters: inputs: List of sets that represent the lhs side of the einsum subscript output: Set that represents the rhs side of the overall einsum subscript size_dict: Dictionary of index sizes memory_limit: The maximum number of elements in a temporary array choose_fn: A function that chooses which contraction to perform from the queue cost_fn: A function that assigns a potential contraction a cost. Returns: path: The contraction order (a list of tuples of ints). Examples: ```python isets = [set('abd'), set('ac'), set('bdc')] oset = set('') idx_sizes = {'a': 1, 'b':2, 'c':3, 'd':4} greedy(isets, oset, idx_sizes) #> [(0, 2), (0, 1)] ``` r>)rr)rr)r}rrrT)r#r$r%r0rrr<s r-rrsAJ>)ffiqRYZZ"669gYbcH  ""r/tree.c\t|tk(rgS|g}g}g}t|dkDr|jd}|j ddt |Dcgc]}t|tk(s|c}D]:|dxxt fd|Dfz cc<|j |dd<|Dcgc]}t|tk7s|c}D]6}|dxxt|t|zfz cc<|j|8t|dkDr|Scc}wcc}w)a{Converts a contraction tree to a contraction path as it has to be returned by path optimizers. A contraction tree can either be an int (=no contraction) or a tuple containing the terms to be contracted. An arbitrary number (>= 1) of terms can be contracted at once. Note that contractions are commutative, e.g. (j, k, l) = (k, l, j). Note that in general, solutions are not unique. Parameters: c: Contraction tree Returns: path: Contraction path Examples: ```python _tree_to_sequence(((1,2),(0,(4,5,3)))) #> [(1, 2), (1, 2, 3), (0, 2), (0, 1)] ``` rrr;c3.K|] }|ks dywr>Nr;)rWqrcs r-rZz$_tree_to_sequence..4s/qQ/s )typer:rArHinsertrDr?rI)rctrPrRrci_tups ` r-_tree_to_sequencer s> DzS $vAA!A a&1* EE"I BA8qaC89 "A aDS/A//1 1D HHQqT"Xq ! "*+Ad5kS.@eA E aDSVc!f_& &D HHUO  a&1* H9BsD$/D$;D)D)cZg}ttt|}tj||z }t|dkDrt}|j g}t|dkDr~|j }|j ||||z}|D chc]} t||| zdkDs| } } |j| |j| t|dkDr~|j|t|dkDr|D cgc] } t| c} Scc} wcc} w)aFinds disconnected subgraphs in the given list of inputs. Inputs are connected if they share summation indices. Note: Disconnected subgraphs can be contracted independently before forming outer products. Parameters: inputs: List of sets that represent the lhs side of the einsum subscript output: Set that represents the rhs side of the overall einsum subscript Returns: subgraphs: List containing sets of indices for each subgraph Examples: ```python _find_disconnected_subgraphs([set("ab"), set("c"), set("ad")], set("bd")) #> [{0, 2}, {1}] _find_disconnected_subgraphs([set("ab"), set("c"), set("ad")], set("abd")) #> [{0}, {1}, {2}] ``` r) rrCrArfrgrHrextenddifference_updaterI) r#r$ subgraphs unused_inputsi_sumgrrRi_tmprrKrSs r-_find_disconnected_subgraphsr >s*Ic&k*+M OOV $v -E m q E    !!fqjA EE!HF1I%E)HqS1B-Ca-GHAH HHQK  + +A . !fqj  m q #, ,QIaL ,, I -sD#3D#D(rPseqcFdt|t|dddDS)zSelect elements of ``seq`` which are marked by the bitmap set ``s``. E.g.: >>> list(_bitmap_select(0b11010, ['A', 'B', 'C', 'D', 'E'])) ['B', 'D', 'E'] c32K|]\}}|dk(s |yw)1Nr;)rWrSbs r-rZz!_bitmap_select..ps >$!QQ#XA >s Nr>r)zipbin)rPr s r-_bitmap_selectrhs$ ?#c3q6%1R%=1 >>r/cx|||z z}|rtjt||}n t}||z }||z S)zoCalculates the effective outer indices of the intermediate tensor corresponding to the subgraph ``s``. )rfrgr) r all_tensorsrPr#i1_cut_i2_wo_output i1_union_i2ri_r i_contracts r- _dp_calc_legsrssF [1_Aoo~a89k$s*J  ##r/cost1cost2rcost_caps1s2xnrrr contract1 contract2c||zt||z}||krD||z}||vs |||dkr/t|| || | |}t||}| || kr ||| |ff||<yyyy)aPerforms the inner comparison of whether the two subgraphs (the bitmaps `s1` and `s2`) should be merged and added to the dynamic programming search. Will skip for a number of reasons: 1. If the number of operations to form `s = s1 | s2` including previous contractions is above the cost-cap. 2. If we've already found a better way of making `s`. 3. If the intermediate tensor corresponding to `s` is going to break the memory limit. r>N)rr)rrrr%rrrrrrr#rr0r r!rprPrcmems r-_dp_compare_flopsr$s8 5=/ YG GD x G B;$Aq/aa9LkZA&q)4C#sl':D9i"891(;*r/c||z}t|| || | |}t||}t|||}||kr#||vs |||dkr| || kr ||| |ff||<yyyy)zLike `_dp_compare_flops` but sieves the potential contraction based on the size of the intermediate tensor created, rather than the number of operations, and so calculates that first. r>N)rrrrrrr%rrrrrrr#rr0r r!rPrcr#rps r-_dp_compare_sizer's* RAaa1DkRA q) ,C ueS !D x B;$Aq/#sl':D9i"891(;*r/c||z}t|| || | |}t||}||z|z}||kr#||vs |||dkr| || kr ||| |ff||<yyyy)zLike ``_dp_compare_flops`` but sieves the potential contraction based on the total size of memory created, rather than the number of operations, and so calculates that first. r>Nrrr&s r-_dp_compare_writer*s* RAaa1DkRA q) ,C 5=3 D x B;$Aq/#sl':D9i"891(;*r/@factorcombinec||z}t|| || | |}t||}t||}||z||||zfz}||kr#||vs |||dkr| || kr ||| |ff||<yyyy)zLike ``_dp_compare_flops`` but sieves the potential contraction based on some combination of both the flops and size,. r>Nr))rrrr%rrrrrrr#rr0r r!r,r-rPrcr#frps r-_dp_compare_combor0s, RAaa1DkRA q) ,C[)4A 5=7Av|#45 5D x B;$Aq/#sl':D9i"891(;*r/z%(flops|size|write|combo|limit)-*(\d*)c|dk(rtdfS|dk(rtdfS|dk(rtdfSt|r |t dfSt j |}|td|d|j\}}|r t |nt}|dk(r+tjt|t t dfS|d k(r+tjt|t t dfStd|d) zThis works out what local scoring function to use for the dp algorithm as well as a `naive_scale` to account for the memory_limit checks. rxr>rwriter z!Couldn't parse `minimize` value: .combo)r,r-limit)r$r'r*callablerminimize_finder fullmatchr*groupsDEFAULT_COMBO_FACTOR functoolspartialr0r?r)rmatch custom_factorr,s r-_parse_minimizer@s  7 !## V "" W  !## ( u%%  % %h /E } (((1, 2), 3), 4) ``` c ||fSr2r;rSys r-rz#simple_tree_tuple..6s !Qr/)r<reduce)r s r-simple_tree_tuplerF-s   / 55r/all_inds ind_countsctfdt|D}g}g}g}t|D]W\}}||z } | s!t|dkDr|j|f.|j| |j| |k7r|fn|Y|||fS)aQTake `inputs` and parse for single term index operations, i.e. where an index appears on one tensor and nowhere else. If a term is completely reduced to a scalar in this way it can be removed to `inputs_done`. If only some indices can be summed then add a 'single term contraction' that will perform this summation. c3:K|]\}}|dk(s|ywrr;)rWrcrrHs r-rZz0_dp_parse_out_single_term_ops..Cs Qtq!jmq>PQsr)rfrrArI) r#rGrHi_single inputs_parsed inputs_doneinputs_contractionsrRrc i_reduceds ` r-_dp_parse_out_single_term_opsrP9sQy':QQH*,M$&K8:&!F1L A   t $   +  & &yA~t1 EF +': ::r/c jeZdZdZd dedeeefdeddfdZ dde e d e d e eefd e ede f d Zy)raOFinds the optimal path of pairwise contractions without intermediate outer products based a dynamic programming approach presented in Phys. Rev. E 90, 033315 (2014) (the corresponding preprint is publicly available at https://arxiv.org/abs/1304.6112). This method is especially well-suited in the area of tensor network states, where it usually outperforms all the other optimization strategies. This algorithm shows exponential scaling with the number of inputs in the worst case scenario (see example below). If the graph to be contracted consists of disconnected subgraphs, the algorithm scales linearly in the number of disconnected subgraphs and only exponentially with the number of inputs per subgraph. Parameters: minimize: What to minimize: - 'flops' - minimize the number of flops - 'size' - minimize the size of the largest intermediate - 'write' - minimize the size of all intermediate tensors - 'combo' - minimize `flops + alpha * write` summed over intermediates, a default ratio of alpha=64 is used, or it can be customized with `f'combo-{alpha}'` - 'limit' - minimize `max(flops, alpha * write)` summed over intermediates, a default ratio of alpha=64 is used, or it can be customized with `f'limit-{alpha}'` - callable - a custom local cost function cost_cap: How to implement cost-capping: - True - iteratively increase the cost-cap - False - implement no cost-cap at all - int - use explicit cost cap search_outer: In rare circumstances the optimal contraction may involve an outer product, this option allows searching such contractions but may well slow down the path finding considerably on all but very small graphs. rr search_outerr&Nc.||_||_||_yr2)rrRr)r+rrrRs r-rzDynamicProgramming.__init__ws  (  r/rr size_dict_ memory_limit_c /t|j\}}|jrdnd}tt j g||}t |} t| D cic]\} } | |  c} } /|D cgc]} t/fd| D} } t/fd|D}|jD cic]\} }| /vs /| |}} }tt|D cgc]} ||  }} |t| ztjtj|dz}t!| | |\} }}| st#t%|S|}dgt|z}|jrttt| g}n t'| |}dt| zdz }|D]\}dgdztt|dz D cgc]} ic} z}|D cic]} d| z| | d|| fc} |d<tjd d |D}tj(t+|| }|j,d urt/||z|}n&|j,d ur t1d }n |j,}t|dk(rd}n)t3t5t7|j8|d}t|ddk(rtdt|ddzD]}||} td|dzdzD]}!||!jD]k\}"\}#}$}%|||!z jD]I\}&\}'}(})|"|&zr|!||!z k7s|"|&ks|#|'z|z }*||*s/|#|'z}+||$|(|+|||"|&| ||| |*||%|)Km||kDrt|ddk(r t;d||z}t|ddk(rt=|dj?d\} },}-|jA|-|jAt/| |_tCtt||j8D cgc]} ||  }} t%|}.t#|.Scc} } wcc} wcc}} wcc} wcc} wcc} wcc} w)a2Parameters: inputs_: List of sets that represent the lhs side of the einsum subscript output_: Set that represents the rhs side of the overall einsum subscript size_dict_: Dictionary of index sizes memory_limit_: The maximum number of elements in a temporary array. Returns: path: The contraction order (a list of tuples of ints). Examples: ```python n_in = 3 # exponential scaling n_out = 2 # linear scaling s = dict() i_all = [] for _ in range(n_out): i = [set() for _ in range(n_in)] for j in range(n_in): for k in range(j+1, n_in): c = oe.get_symbol(len(s)) i[j].add(c) i[k].add(c) s[c] = 2 i_all.extend(i) o = DynamicProgramming() o(i_all, set(), s) #> [(1, 2), (0, 4), (1, 2), (0, 2), (0, 1)] ``` cy)NTr;rSs r-rz-DynamicProgramming.__call__..sr/c|Sr2r;rXs r-rz-DynamicProgramming.__call__..sQr/c3(K|] }| ywr2r;rWr symbol2ints r-rZz.DynamicProgramming.__call__..s5aJqM5r[c3(K|] }| ywr2r;r[s r-rZz.DynamicProgramming.__call__..s:Q:a=:r[r>Nrerc ||zSr2r;rCs r-rz-DynamicProgramming.__call__..s QUr/c3&K|] }d|z ywrr;)rWrRs r-rZz.DynamicProgramming.__call__..sq+ABBNAaD!''(:?Ahnn>N* :$:R )+Ra1q5jBG;=7f:L$7(44G'H682g (:,1,1,7,5,4,.,.,.,4,7,2,?,9,5,5)**** *Bz)AbE a&'WXX*H4Mae*/P$(" #7#: At[ ! ( ( 5 & - -.B1i.P QOG R\c456.::!  "! $! ! !!67 &&g<GbU>)HNJ! s0% Q:Q%> Q* Q*, Q0 Q5$Q:; Q?)rxTFr2)r5r6r7r8r9rrir:rr rrr rr4r;r/r-rrTs D!!%c :J!ae!rv!(, ^'n%^' ^'cN ^'  } ^'  ^'r/rkwargsc .tdi|}|||||S)Nr;)r)r#r$r%r0rtrs r-rrs"#,V,I VVY ==r/ cXtjt|t||||S)zuFinds the contraction path by automatically choosing the method based on how many input arguments there are. ) _AUTO_CHOICESrrAr)r#r$r%r0s r-rr3s&   S[& 1&&)\ ZZr/c\ddlm}tjt ||||||S)zFinds the contraction path by automatically choosing the method based on how many input arguments there are, but targeting a more generous amount of search time than ``'auto'``. r)random_greedy_128)opt_einsum.path_randomr_AUTO_HQ_CHOICESrrA)r#r$r%r0rs r-rrFs,9   F -> ?PY[g hhr/) rzauto-hqrz branch-allzbranch-2zbranch-1reager opportunisticdpzdynamic-programming _PATH_OPTIONSnamefnc`|tvrtd|d|t|j<y)zrs Y   ,iiii)?__ dE%L)/"/"d$H$$\X,! )C. !! cN!~! !  ! CH~ ! 9S>3 !H J )C. ! JN# J  JCH~ J  J&#' R4  R4 R4CH~R43- R4  R4p3c33#3#3RV33S3333QU3   sxc3(s>3>s>>RU>[^>ch>*7  d-dV#'! # >   >  >CH~ >3- > c] >  > > > > Y  vt 4 9  VQ / 9  VQ /sC}%nnnn\]  S>NC'(^S()  c#h'    </ / S>/NC'(/^S() / c#h' /  / n / % &/// /*'c3~../'c#h'' ' '$# D  D D S>D D  D  DV#'# )#  )# )#CH~)#3- )#  )#  )#)#X2 E#s(O2 2 j'-in)='-yQT~'-Z^_hil_mZn'-T?c?Ys^ 4?9S>SWY]C]9^? $ #: #: #:S#:Cy #:  #: #: #: S#X#: #:#: 3 #:S#:3-#:S%*_%#:S%*_%#:  !#:L: : :S:Cy :  : : : S#X: :: 3 :S:3-:S%*_%:S%*_%:  !:>: : :S:Cy :  : : : S#X: :: 3 :S:3-:S%*_%:S%*_%:  !:>&!5#: : :S:Cy :  : : : S#X: :: 3 :S:3-:S%*_%:S%*_%: #u* !:"#:$ %:B"**EFSJeCM2JuXuSRWZGX=X7YJJ< 68E#s(O4 6sCx 6; 3 ;,1#s(O;ITUXIY; 4 # eCj!14c5:o8N3O OP;6F'F'Z#' >  > >CH~>3- >  >  > q!AM! q!"A!M!" q! AM! q" AM! #' [   [  [CH~ [3- [  [ q!"A!Q" q".A-Q.#' i   i  iCH~ i3- i  i   . 4 tC//0 %3%$:%t%$3$#9$r/