i SrSSKrSSKrSSKrSSKrSSKJrJrJr SSK r SSK J r /SQr SS\"S51r"S S \5rS rS rS rSrS8SjrSrSr\\S.rSrSrSr\\S.r"SS\5rS8Sjr\R@"\SS9r!\R@"\SS9r"\R@"\SS9r#Sr$Sr%Sr&Sr'S9S jr(S:S!jr)S"r*S#r+S$r,S%r-S&r.S'r/S(r0S)r1"S*S+\5r2S8S,jr30r4\5"SS-5Hr6\\4\6'M \5"S-S.5Hr6\!\4\6'M \5"S.S/5Hr6\"\4\6'M \5"S/S05Hr6\#\4\6'M S8S1jr70r8\5"SS25Hr6\\8\6'M \5"S2S35Hr6\3\8\6'M S8S4jr9\7\9\\!\"\#\)\)\)\3\3S5. r:S6r;S7rnUR [ U4SjU555 UHnTUS===S-sss&M M@ U$)z Convert a path with static single assignment ids to a path with recycled linear ids. For example:: >>> ssa_to_linear([(0, 3), (2, 4), (1, 5)]) [(0, 3), (1, 2), (0, 1)] r)dtypec3@># UHn[TU5v M g7fr$)int).0ssa_ididss r ssa_to_linear..JsAv#c&k**N)nparangemaxmapint32appendtuple)ssa_pathpathssa_idsr5r6s @r ssa_to_linearrD?sq ))ACX.//rxx @C D EAAABF LA L Kr"cf^[[[U55[U5- S-n[[ U55m[ R "U5n/nUHUnUR[U4SjU555 [USS9HnTU M TR[U55 MW U$)z Convert a path with recycled linear ids to a path with static single assignment ids. For example:: >>> linear_to_ssa([(0, 3), (1, 2), (0, 1)]) [(0, 3), (2, 4), (1, 5)] rc3.># UH nTUv M g7fr$r/)r4id_ linear_to_ssas rr7 linear_to_ssa..]s@CSmC0CT)reverse) sumr=lenlistrange itertoolscountr?r@sortednext)rB num_inputsnew_idsrAr6rGrHs @rrHrHPsSd^$s4y014Jz*+Mooj)GH@C@@A#t,Cc"-T']+  Or"c XXpvXg-nXg-n [R"U/[URX#U1- 5Q76n X-n [R "XU - SU5n X4$)ay Calculate the resulting indices and flops for a potential pairwise contraction - used in the recursive (optimal/branch) algorithms. Parameters ---------- inputs : tuple[frozenset[str]] The indices of each tensor in this contraction, note this includes tensors unavaiable to contract as static single assignment is used -> contracted tensors are not removed from the list. output : frozenset[str] The set of output indices for the whole contraction. remaining : frozenset[int] The set of indices (corresponding to ``inputs``) of tensors still available to contract. i : int Index of potential tensor to contract. j : int Index of potential tensor to contract. size_dict dict[str, int] Size mapping of all the indices. Returns ------- k12 : frozenset The resulting indices of the potential tensor. cost : int Estimated flop count of operation. ) frozensetunionr= __getitem__r flop_count) rr remainingijrk1k2eithersharedkeepk12costs rcalc_k12_flopsrfdsk<Y  WF WF ??6 PC(:(:IA>> 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)] r)flopsrAc >>[U5S:Xa UT S'UT S'g[R"US5HupEXE:aXTpTX$X%4nTUupxX8-n U T S:aM+T [ ;a>TUn U T :a2U[X!TT5-n U T S:aU T S'U[U54-T S'MsT "XU44-X'4-XU1- [U51-U S9 M g![a [ UTXUT5=upxTU'Nf=f![a [ R"UT5=n TU'Nf=f)NrrmrArWrBrr\rm) rMrP combinationsKeyErrorrf_UNLIMITED_MEMrcompute_size_by_dictrkr@)rBr\rrmr]r^keyrdflops12 new_flopssize12_optimal_iteratebestr&r result_cache size_cachers rrx!optimal.._optimal_iterates y>Q !DM#D  **9a8DAu19fi(C n+C0  IDM)>1\'_F L( %(?SY[d(e eI 4=0(1W +/53C2F+FZ( $a&"3$*W$4'0q6'9S[M'I#, .=9  n3A&&R[`acl3mm |C0 n \/6/K/KCQZ/[[FZ_\s$C )C3 C0/C03&DDr/rrorA)r@r=rXfloatrOrMsetrD)rrrr&rxryrzr{s ```@@@@rrrs>3y&) *F v F5\eCK6H0I/L MDJL*.*.X"Vs5V;M7NVWX j) **r"cX4X#4:$r$r/rmsize best_flops best_sizes rbetter_flops_firstrs =J2 22r"cX4X24:$r$r/rs rbetter_size_firstrs =I2 22r"rmrc[U$r$) _BETTER_FNSrts r get_better_fnrs s r"cX- U- $)zhThe default heuristic cost, corresponding to the total reduction in memory of performing a contraction. r/rwsize1size2rdr_r`s rcost_memory_removedrs >E !!r"c@[R"SS5X- U- -$)zqLike memory-removed, but with a slight amount of noise that breaks ties and thus jumbles the contractions a bit. g?g{Gz?)randomgaussrs rcost_memory_removed_jitterrs! <<T "fnu&< ==r")memory-removedzmemory-removed-jitterc<\rSrSrSrSSjr\S5rS SjrSr g) r iaw Explores 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. Returns the lowest cost path. This algorithm still scales factorially with respect to the elements in the list ``input_sets`` if ``nbranch`` is not set, but it scales exponentially like ``nbranch**len(input_sets)`` otherwise. Parameters ---------- nbranch : None or int, optional 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 : float, optional 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 : {'flops', 'size'}, optional 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 : callable, optional 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)``. NcXlX lX0l[R XD5Ul[ U5Ul[S5[S5S.Ul [S5Ul g)Nrrc[S5$)Nr)r}r/r"r&BranchBound.__init__..?sur") nbranchcutoff_flops_factorminimize _COST_FNSgetcost_fnrbetterr}ryr best_progress)rrrrrs r__init__BranchBound.__init__7sP #6   }}W6 #H- #ElE%LA ()=>r"c2[URS5$)NrA)rDry)rs rrBBranchBound.pathAsTYYz233r"c V^^^^^^^TRUTT5 [[[U55n[T5mUVs0sHoU[R "UT5_M snm0mUUUUUUU4SjmT"SU[ [[U555SSS9 TR$s snf)a^ Parameters ---------- input_sets : list List of sets that represent the lhs side of the einsum subscript output_set : set Set that represents the rhs side of the overall einsum subscript idx_dict : dictionary Dictionary of index sizes memory_limit : int The maximum number of elements in a temporary array Returns ------- path : list The contraction order within the memory limit constraint. Examples -------- >>> 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 x>^^^^^[T5S:Xa.TTRS'TTRS'TTRS'gUUUUUUUUUUU4 Sjn/n[R"TS5HUupxXx:aXpTUTUpU R U 5(aM-U"XXx5n U (dM?[ R "Xk5 MW U(dX[R"TS5H=upxXx:aXpTUTUpU"XXx5n U (dM'[ R "Xk5 M? Sn TRbU TR:awU(ao[ R"U5u pnupxnT"TXx44-TU4-TXx1- [T51-UUS9 U S- n TRbU TR:a U(aMmgggg) NrrrmrAc $> TX4upETUnT U-n[ TU5nTR XxTR STR S5(dgUTR[T 5:aUTR[T 5'O*UTRTR[T 5-:agT[;aVUT:aPT [T TTT5-nUTR S:a+UTR S'T[T54-TR S'gTT UTT UpTRXiXX5n XXxX#4U4$![a [T TTX#T5=upETX4'GNVf=f![a [R"UT5=nTU'GN}f=f)NrmrrA)rqrfrrsr<rryrrMrrrrkr@r)r_r`r]r^rdrurwrvnew_sizerrrermrr&rrBr\rzrrr{rs r_assess_candidateHBranchBound.__call__.._branch_iterate.._assess_candidateqsu#/#7LC\'_F"GO tV,{{9 '8JDIIV\L]^^t11#f+>>6?D&&s6{3!9!9D._branch_iteratehs9~"$( &!%* '"(, *%' G' GTJ!..y!<5qF1IB==$$-ba; 9NN:9=%229a@DAu 1#AYq  1"! ?I yz= AB<<'2 +<*9>z9R616A3TaVJ%6'-'7+4v+=#f+*N&/%- / a<<'2 +<**+<*+P:QYZabcyywUs!B&)ryrrrrrr)Nrmrr$) r)r*r+r,r-rpropertyrBr'r.r/r"rr r s&6?44{r"r c *[S0UD6nU"XX#5$Nr/)r )rrrr&optimizer_kwargs optimizers rr r s/./I VY ==r")rrWcXV-nXV-n X- n X-XS--XS--n U"[R"X5X5X6XU5n X%n X&nX:aXnX]4up]pnXU 4n XXk4$)NrW)rrs)rsizesr\ footprintsdim_ref_countsr_r`rratwoonerdreid1id2s r_get_candidaters WF 'C ,C ?sA%66 73PQAR;R SC 7//;Z^Z^]`fh iD -C -C yB+ c>D R r"c ^^^^^^^ U UUUUUU4SjU5n U(a U Hn [R"X{5 M g[R"U[U 55 g)Nc 3H># UHn[TTTTTTUT5v M g7fr$)r) r4r`rrrr_rr\rs rr7"_push_candidate..s-vruln. :~WY[]_fggrus")rrmin) rrr\rrr_k2squeuepush_allrrrs `````` ` r_push_candidaters>vvruvJ#I NN5 ,$ uc*o.r"c@UHn[X5nUS::a*USRU5 USRU5 M@US:Xa*USRU5 USRU5 MpUSRU5 USRU5 M g)NrrWr)rMdiscardadd) dim_to_keysrdimsdimrQs r_update_ref_countsrsK$% A: 1  % %c * 1  % %c * aZ 1  ! !# & 1  % %c * 1  ! !# & 1  ! !# &r"cR[R"U5up#pEX1;dXA;agX#XE4$)zKDefault contraction chooser that simply takes the minimum cost option. N)rr)rr\rer_r`rds r_simple_chooserrs0 e,Db b1 R r"c|^ ^[U5S:XaS/$[RXD5nUc [nSnOSn[ [ [ U55n[ U5[ R"U6-n0n[R"[U55n/n[U5H2upX;a$URXjU 45 [U5Xj'M.XU 'M4 [[5mUH"n X- Hn TU RU 5 M M$ SV ^ s0sH*m T [U 4SjTR!555U- _M, n n UV s0sHo["R$"X5_M nn /nTR!5HKun n['UUR(S9n[USS 5HunnUSU-Sn[+XXnU UUXU5 M! MM U(GaTU"X5nUcMUunnnnUR-U5nUR-U5nUU- Hn TU R/U5 M UU- Hn TU R/U5 M URUU45 UU;a URUU[U545 O UU- Hn TU RU5 M [U5UU'[1TU UUU- -5 ["R$"UU5UU'Un[U4S jU55nUR3U5 U(a[+XXnU UUXU5 U(aGMTUR!5V V s/sH up["R$"X-U5X4PM" nn n [4R6"U5 [4R8"U5unnnU(a[4R8"U5unnnUR[;UU5[=UU545 UU-U-n["R$"UU5n[U5n>"UUUU45unnnU(aMU$s sn fs sn fs sn n f) z This 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)rWrc3N># UHup[U5T:dMUv M g7fr$)rM)r4rkeysrQs rr7&ssa_greedy_optimize..-s"R(;93s4yE?Q33(;s% %rrc3@># UHnTUHo"v M M g7fr$r/)r4rr`rs rr7rVs>[-=r"-="r9) rMrrrrNr=rX intersectionrPrQ enumerater?rSrr~ritemsrrsrRrZrpopremoverrrheapifyrrr< heappushpop)rrr choose_fnrrr\rCrAr5rtrrQrrrrr]r_rconrer`rdssa_id1ssa_id2rssa_id12rs ` @rssa_greedy_optimizers   6{awmmG-G#  #i( )F v !7!7!@ @FIooc&k*GH (    OOY^V4 5!']IN#cN )c"K>> B  F9.RTVY[`ls t9 %>bkapapar sarR]RUg**3<? MarE s MM%]]5)NAw u-7BWg.GW0EFGBw& ++C7=**5432GH7B % Ow VT ts1P. P39'P8c ZU[;a [XX#SUS9$[XX%US9n[U5$)a% Finds 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 List of sets that represent the lhs side of the einsum subscript output : set Set that represents the rhs side of the overall einsum subscript size_dict : dictionary Dictionary of index sizes memory_limit : int The maximum number of elements in a temporary array choose_fn : callable, optional A function that chooses which contraction to perform from the queu cost_fn : callable, optional A function that assigns a potential contraction a cost. Returns ------- path : list The contraction order (a list of tuples of ints). Examples -------- >>> 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)rrr rrD)rrrr&rrrAs rr r js9N>)fiqRYZZ"69YbcH  ""r"c^[U5[:Xa/$U/n/n/n[U5S:GaURS5nUR S[ 55 [ UVs/sHn[U5[:XdMUPM sn5H<mUS==[U4SjU554- ss'UR USST5 M> UVs/sHn[U5[:wdMUPM snH7mUS==[U5[U5-4- ss'URT5 M9 [U5S:aGMU$s snfs snf)aZ 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 : tuple or int Contraction tree Returns ------- path : list[set[int]] Contraction path Examples -------- >>> _tree_to_sequence(((1,2),(0,(4,5,3)))) [(1, 2), (1, 2, 3), (0, 2), (0, 1)] rrc36># UHoT:dM Sv M g7frNr/)r4qr]s rr7$_tree_to_sequence..s/AqQAs  ) typer3rMrinsertr@rRrLr?)ctsr^r]s `r_tree_to_sequencersH Aw#~ A A A a&1* EE"I EGA8AqaCA89A aDS/A//2 2D HHQqT"Xq !:1Q$q'S.!Q1A aDSVc!f_' 'D HHQK2 a&1* H92s"E=EE)Ec6/n[[[U555n[R"U6U- n[U5S:a[5nUR 5/n[U5S:aUR 5nUR U5 X@U-nUV s1sHn [XU -5S:dMU iM n n UR U 5 URU 5 [U5S:aMURU5 [U5S:aMU$s sn f)a Finds 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[set] List of sets that represent the lhs side of the einsum subscript output : set Set that represents the rhs side of the overall einsum subscript Returns ------- subgraphs : list[set[int]] List containing sets of indices for each subgraph Examples -------- >>> _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) r~rOrMrYrrextenddifference_updater?) rr subgraphs unused_inputsi_sumgrr^i_tmprns r_find_disconnected_subgraphsrs6Ic&k*+M IIv  'E m q E    !!fqjA EE!H1I%E)HMqS1B-Ca-GMAH HHQK  + +A . !fqj  m q   Is D7DcFS[U[U5SSS255$)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'] c3:# UHupUS:XdM Uv M g7f)1Nr/)r4xbs rr7!_bitmap_select.. s >1$!Q#XAA1s  Nrr)zipbin)rseqs r_bitmap_selectr s$ ?#c3q6%1R%=1 >>r"c|XU- -nU(a[R"[Xc56nO [5nXG- nXX- $)zgCalculates the effective outer indices of the intermediate tensor corresponding to the subgraph ``s``. )r~rYr ) r all_tensorsrri1_cut_i2_wo_output i1_union_i2ri_r i_contracts r _dp_calc_legsr s> 1_Aii23e$*J  ##r"cX-[R"X#5-nX::aOXV-nUU;d XUS:a9[XUXU5n[R"UU5nU bUU ::a UXU44UU'gggg)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. rN)rrsr)cost1cost2rrcost_caps1s2xnrrrrr&cntrct1cntrct2rerr]mems r_dp_compare_flopsrs =777 O OD  G B;$Aq/aakZA..q)>> tuple_nest([1, 2, 3, 4]) (((1, 2), 3), 4) cX4$r$r/rys rr#simple_tree_tuple..Js!r") functoolsreduce)r s rsimple_tree_tupler)Cs   / 55r"c,[U5VVs1sHup4X$S:XdMUiM nnn///pn[U5HNupX5- n U (dURU 45 M$URU 5 URX:waU 4OU 5 MP XgU4$s snnf)aATake ``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. r)rr?) rall_inds ind_countsr]ri_single inputs_parsed inputs_doneinputs_contractionsr^ i_reduceds r_dp_parse_out_single_term_opsr2Ms(1H1daZ]a5G1HH68"b 3M&!L    u %   +  & & uA F" ': ::Is BBc,\rSrSrSrSSjrSSjrSrg) ridaU Finds 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 publically 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 : {'flops', 'size'}, optional Whether to find the contraction that minimizes the number of operations or the size of the largest intermediate tensor. cost_cap : {True, False, int}, optional 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 : bool, optional 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. cXl[[S.URUlX0lSSS.URUlX lg)NrcU$r$r/rs rr-DynamicProgramming.__init__..sQr"cg)NTr/r6s rrr7sDr")FT)rrr!_check_contraction search_outer _check_outerr)rrrr:s rrDynamicProgramming.__init__sV! &$#  --# )      ! r"Nc^^%^&[[R"/TQUP765n[U5n[ U5VVs0sHupxX_M snnm&TV s/sHn [ U&4SjU 55PM sn m[ U&4SjU55nUR 5VV s0sHupUT&;dM T&UU _M nnn [[U55Vs/sHosUPM nn[TXe5umn m%T(d[[U 55$U n S/[U 5-n UR(a[ [[T555/nO [TU5nS[T5-S- nUGHvnS/S-[[U5S- 5Vs/sH n[5PM sn-n[UU%4SjU55US'[ R""SSU55n[ R$"['UT56nUR(S La[*R,"UU-U5nO'UR(S La [/S 5nO UR(n[1[3[5UR6U55S5n[US 5S :XGa[S[US5S-5HnUUn[SUS-S-5HnUUR 5HununnnUUU- R 5HkununnnUU-(aMUUU- :wdUU:dM'UU-U- n UR9U 5(dMGUU-n!UR;UUU!UUUUUUUTU UUU5 Mm M M M UU-n[US 5S :XaGM[=US R?55S un n"n#U RAU#5 U RA[*R,"X55 GMy [C[[U 55U R6S9Vs/sHnXPM n n[U 5n$[U$5$s snnfs sn fs sn nfs snfs snfs snf)a| Parameters ---------- inputs : list List of sets that represent the lhs side of the einsum subscript output : set Set that represents the rhs side of the overall einsum subscript size_dict : dictionary Dictionary of index sizes memory_limit : int The maximum number of elements in a temporary array Returns ------- path : list The contraction order (a list of tuples of ints). Examples -------- >>> 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)] c3.># UH nTUv M g7fr$r/r4r symbol2ints rr7.DynamicProgramming.__call__..s/QjmQrJc3.># UH nTUv M g7fr$r/r?s rr7rAs3FqZ]FrJrNrWc3D># UHnSU-TUSTU44v M g7f)rrNr/)r4r^rr0s rr7rAs.[YZTUQA7J17M(NOYZs c X-$r$r/r$s rr-DynamicProgramming.__call__..saer"c3,# UH nSU-v M g7frr/)r4r^s rr7rAs5Haa1fasTFrrrr)"rrPchainr@rr~rrOrMr2rr)r:rdictrr'r(rYr rrrsr}r<rr=rZr;r9rNvaluesr?rR)'rrrrr&r,r+r^rr]vr/subgraph_contractionssubgraph_contractions_sizerrrr subgraph_indsrcost_incrementrrmri1rrri2rrrrre contractiontreer0r@s' ` @@rr'DynamicProgramming.__call__s"JY__=f=f=> $(1':;':tqad':; 9?@A#/Q//@3F332;//2CW2C$!qJ%Z]A%2C W+0Y+@A+@aq\+@ A3PQWYa3n0 0$%6{%CD D!,&'S3{+;%;"   U3v;/01I4VVDI CK'1, A eCFQJ.?@.?df.?@@A[YZ[[AaD  !35Ha5HIA  II~a'@AM}}$"77 8NPYZ%' <== S)>)> %N!OQRSNae*/q#ad)a-0A1B#1a1fqj189! 4B 4UG<=a!eHNNAh! s)P5P; Q. QQQ Q)r9r;rrr:)rmTFr$)r)r*r+r,r-rr'r.r/r"rrrds>!$G'r"rc *[S0UD6nU"XX#5$r)r)rrrr&kwargsrs rrr s",V,I VY ==r" cZ[U5n[RU[5"XX#5$)zmFinds the contraction path by automatically choosing the method based on how many input arguments there are. )rM _AUTO_CHOICESrr )rrrr&Ns rr r 0s' F A   Q ' PPr"c\SSKJn [U5n[R XT5"XX#5$)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) path_randomrarM_AUTO_HQ_CHOICESr)rrrr&rar]s rr r ?s( / F A    5fi ^^r") r zauto-hqrz branch-allzbranch-2zbranch-1r eager opportunisticdpzdynamic-programmingczU[;a[SRU55eU[UR5'g)zAAdd path finding function ``fn`` as an option with ``name``. z#Path optimizer '{}' already exists.N) _PATH_OPTIONSrqformatlower)namefns rregister_path_fnrmYs3 }<CCDIJJ"$M$**,r"c U[;a6[SRU[[R 5555e[U$)zBGet the correct path finding function from str ``path_type``. z4Path optimizer '{}' not found, valid options are {}.)rhrqrir~r) path_types rrrbsG %MTT s=--/023 3  ##r"r$)Nr)NNr)=r-r'rrPr collectionsrrrnumpyr:r__all__r}rrobjectrrDrHrfrkrrrrrrrrr r partial branch_allbranch_2branch_1rrrrrr rrr rrr!r)r2rrr\rOr]r rcr rhrmrr/r"rrys6  99  dE%L)%"F%"P"(&RLT+t33   ">*7  e-eP>   vt 4   VQ /   VQ / / 'k\+#\7 t-`? $ 6, 6 6;.y'y'x>  q!AM!  q!A!M!  q!AM!  q"AM! Q q!A!Q  q"A-Q _   .  %$r"