Chains with Multiple Recursion

This section contains an alternative algorithm to compute cost structures of chains that can also be ap-plied to chains with multiple recursion. The main idea is to extend the algorithm for phases (Section6.5) to include the cost of the chain or chains that appear after the given phase.

We consider a general algorithm for chains that start with multiple phases first. Non-multiple iterative phases represent a particular case of this general approach. Letch=ph·CHandph=M(c₁∨ · · · ∨c_n)^+/ω or ph=M(c₁∨ · · · ∨c_n)⁺, we start from valid cost structures 〈E_ci,IC_ci,FC_ci(x x⁰)〉 for each c_i and valid cost structures〈E_ch0,IC_ch0,FC_ch0(x y)〉for eachch⁰∈CH.

Remark6.42. Let T ∈ ¹C[ch]ºf c be an arbitrary evaluation. Eachc_i is evaluated#c_i:=|CEinst(T,c_i)|

times (see Definition6.7) and〈E_cij,IC_cij,FC_cij(a_cija⁰_c

ij)〉represents the cost structure instance of the j-th CE evaluation ofc_i for 1≤ j ≤#c_i. Similarly,#ch⁰=|maxCH(T,ch⁰)|is the number of maximal evalu-ation trees of chain ch⁰ in T (see Theorem 6.8) and 〈E_ch0j,IC_ch0j,FC_ch0j(a_ch0jb_ch0j)〉 is the cost structure instance of the j-th maximal evaluation tree ofch⁰for1≤ j≤#ch⁰. The following cost structure can be evaluated toCost(T).

* n

P

i=1

#c_i

P

j=1

E_cij+ P

ch⁰∈CH

#ch⁰

P

j=1

E_ch0j,









n

S

i=1

#c_i

S

j=1

(IC_cij)∪ S

ch⁰∈CH

#ch⁰

S

j=1

(IC_ch0j)







 ,









n

S

i=1

#c_i

S

j=1

FC_cij(ac_ija⁰_c

ij)

∪

S

ch⁰∈CH

#ch⁰

S

j=1

FC_ch0j(a_ch0jb_ch0j)







 +

This remark is a direct result of Theorem6.8and Definitions 6.7and6.6. As in the case for phases, this cost structure has to be transformed to remove the sums over unknowns. For the main cost expressions and non-final constraints, this can be done using the same approach as with phases (see Sections 6.5 and6.5.1). Sum variables can also be defined for the intermediate variables of the chainsch⁰∈CHand the transformations are also valid for the constraints originated inch⁰. Algorithm2now receives a tuple that also containsIC_ch0 for eachch⁰∈CHand the returned constraint set isIC_chinstead ofIC_ph. The rest is not modified.

The shape of Algorithm3also remains largely the same. In addition to the final constraint sets of the CEs of the phase, it receives the final constraint sets of eachch⁰∈CHand generates the corresponding pending sets Psums^ch0 and Pms^ch0. The algorithm has access to the chains insideCH and its summaries so they can be used by the strategies. Finally, the returned constraint sets are the constraint sets of the complete chainch, not only of the phaseph.

Next, the strategies for phases are adapted to deal with constraints in these new pending sets and to generate constraints that depend only on the initial input and output initial values (x_sy_s) of the chain.

6.7. Chains with Multiple Recursion 99

Table 6.3.: Classification conditions for Inductive Sum Strategy in multiple chains: Ac_e∈phor ach⁰∈C H named B can be classified into a class with respect to a candidate cd(x y) if its condition is satisfied.

Class Condition when./is≤ Condition when./is≥

Cnt (P

iv⁰./kl⁰k)∈Psums^B∧ kl⁰k./cd(x y)−

#calls(B)

P

k=1

cd(xky_k)≥0 Dc 0≤dc_B(x)≤cd(x y)−

#calls(B)

P

k=1

cd(xky_k) dc_B(x)≥cd(x y)−

#calls(B)

P

k=1

cd(x_ky_k) Ic ic_B(x)≥

#calls(B)

P

k=1

cd(x_ky_k)−cd(x y) 0≤ic_B(x)≤

#calls(B)

P

k=1

cd(x_ky_k)−cd(x y)

Inductive Sum Strategy for Multiple Chains

This strategy follows the same scheme of the original Inductive Sum strategy and is valid for chains of the form ch = ph · CH where ph = M(c₁ ∨ · · ·c_n)⁺, that is, it is not applicable for phases that might diverge. In this case, the CEs in the phase can have multiple recursive calls c_i:C(x :y) =ϕc_i,b₀,C(x₁:y₁),b₁,C(x₂:y₂),· · ·,C(x_n:y_n),b_n. The function #calls(c_i) denotes the number of recursive calls of c_i and C(x_k : y_k) is the k-th recursive call for 1 ≤ k ≤ #calls(i). For chains ch⁰ ∈ CH, we define #calls(ch⁰) := 0 and ϕ_ch⁰ := summary(ch⁰) so cost equations c_i ∈ ph and chainsch⁰∈CHcan be treated uniformly.

Given a constraintP

iv./klk ∈Psums^AwhereAis ac_i ∈phor a chainch⁰∈CH, the strategy generates a candidatecd(x y)such that:

ϕA⇒ klk./cd(x y)−

#calls(A)

X

k=1

cd(x_ky_k)≥0

This is a direct generalization of the condition used for linear phases. Note that if Ais a chain ch⁰,

#calls(A)is zero and the condition isϕA⇒(klk./cd(x y)≥0).

Once a candidate has been generated, the CEsc_e ∈ph and the chainsch⁰ ∈CHhave to be classified according to their behavior with respect to the candidate. This strategy has the same classes as before but the conditions have been generalized for CEs with multiple recursive calls and for chains.

LetBbe ac_e∈phor ach⁰∈CH, Table6.3contains the classes and their conditions. The classesCnt,Dc andIc also define the expressionscnt_B := P

smiv⁰, iv_dc

B:=kdc_B(x)k and iv_ic

B :=kic_B(x)k respectively.

Note that whenBis a chain, the expressioncd(x y)−P_#calls(B)

k=1 cd(x_ky_k)simply corresponds tocd(x y).

Theorem 6.43. If everyc_e∈phand everych⁰∈CHis classified intoCnt,IcorDcwith respect to a candidate cd(x y), the following constraints are valid:

X

B∈Cnt

cnt_B./iv_cd+−iv_cd−+X

B∈Ic

smiv_icB−X

B∈Dc

smiv_dcB iv_cd+./kcd(xsy_s)k iv_cd−!./k−cd(x_sy_s)k Finally, the strategy adds the constraintsiv_ic

B ./ kic_B(x)k andiv_dc

B ./ kdc_B(x)k to the corresponding pending setsPsums^Bfor eachB∈IcandB∈Dc.

Table 6.4.:Classification conditions for Inductive Sum Strategy wit Resets in multiple chains: A c_e ∈ ph or ach⁰∈ C HnamedBcan be classified into a class with respect to a candidatecd(x y)if its condition is satisfied.

Class Condition

CntR (P

iv⁰≤ kl⁰k)∈Psums^B∧ kl⁰k ≤ kcd(x)k −^#calls(B)P

k=1

kcd(xk)k

DcR 0≤ kcd(x)k −^#calls(B)P

k=1

kcd(x_k)k IcR icr_B(x)≥

#calls(B)

P

k=1

kcd(x_k)k − kcd(x)k

Inductive Sum Strategy with Resets for Multiple Chains

As in the linear case, Inductive Sum Strategy with Resets can be applied to chains with multiple phases that might diverge, that is, chains of the formch:=ph·CHwhereph:=M(c₁∨· · ·c_n)^+/ωand it generates only upper bound constraints.

The candidates are generated using the condition of class CntR(see Table 6.4) and only depend on the input variables cd(x). The strategy considers the classes CntR, DcR, and IcR from Table 6.4. In the case of multiple recursion, the conditions from the Inductive Sum Strategy cannot be reused. The conditions for this strategy have to always consider the positive part of the candidates (kcd(x)k) not only forCntRbut also forDcRandIcR. This is necessary for the soundness of the strategy. Given these conditions, resets become a special case of IcR and thus no distinct class Rstis considered. It is also worth noting that the condition for the DcRis trivial for chains ch⁰ ∈ CH because the right-hand side kcd(x)k−P_#calls(ch⁰₎

k=1 kcd(x_k)k=kcd(x)kis always positive. Consequently, the strategy can always classify chains intoDcRwhere they are ignored.

Theorem 6.44. If every c_e ∈phand everych⁰∈CHis classified into CntR,DcR, andIcRwith respect to a candidatecd(x), the following constraints are valid:

X

B∈CntR

cntr_B≤iv_cd+ X

B∈IcR

smiv_icrB iv_cd ≤ kcd(x_s)k

For each B∈IcR, the strategy adds the constraintiv_icrB ≤ kicr(x)ktoPsums^B.

Basic Product Strategy

The basic product strategy does not require any changes, it can be directly applied to constraints from pending sets of chains.

Max-Min Strategy for Multiple Chains

This strategy requires no changes in the candidate generation and in the constraint generation. Theo-rems6.33and6.34are also valid for constraintsiv≥ klk ∈Pms^ch0 andiv≤ klk ∈Pms^ch0 and for phases with multiple recursion. However, the classification differs. In this strategy, the chains ch⁰ ∈ CH do not need to be classified and the classification conditions are given in Table6.5. Instead of considering the sum of the values of the candidate in all the recursive calls, these conditions consider these values independently.

6.7. Chains with Multiple Recursion 101

Example 6.45. Let us consider Program4(in Page11) and its chainM(4^c∨5^c)⁺{(3^c)}. Its cost relations are in Figure 5.4 and they have been strengthened in Example 5.66 (in Page 74). For simplicity, we omit the superscript of the CEs and we assume the cost structures of its components have been already computed. The cost structure of(3)is empty, and the cost structures for4and5are〈iv₁+1,;,{iv₁=t1}〉

and 〈1,;,;〉 respectively (t1= l1is the cost of the call to append[(2)⁺(1)]). The simplified constraint sets are:

CE/Chain Constraint set

4 {t =1+t1+t2,t2≥0,t1≥1,t =l}

5 {t =1+t1+t2,t1≥0,t2≥0,l=t2+1,t1=0} (3) {t =l=0}

The initial pending sets arePsums⁴ ={iv_{i t}

4 ≤1,iv_{i t}

4 ≥1,iv₁ ≤ kt1k,iv₁ ≥ kt1k}andPsums⁵ ={iv_{i t}

5 ≤ 1,iv_{i t}

5≥1}. The cost structure computation is as follows:

1. Consider iv_{i t}

4 ≤ 1∈ Psums⁴. The algorithm applies the Inductive Sum Strategy and generates a candidate t. The classification isCnt:={4,5}and Dc:={(3)} withdc₍₃₎:=0 and the generated constraints aresmiv_{i t}

4+smiv_{i t}

5≤iv_cd+−iv_cd−,iv_cd+≤ ktk, andiv_cd−≥ k−tkwhich can be simplified tosmiv_{i t}

4+smiv_{i t}

5≤ ktk.

2. The processing ofiv_{i t4}≥1 is symmetric and its generated (and simplified) constraint issmiv_{i t4}+ smiv_{i t}

5≥ ktk.

3. The Inductive Sum Strategy fails to generate a candidate foriv₁≤ kt1k. Instead, the Basic Product Strategy can be applied and it generates smiv₁ ≤ smiv_{i t4}· dive1. The variable smiv_{i t4} has already been bounded soiv_{i t}

4≤1does not need to be added to the pending sets. The constraintiv₁≤ kt1k is added toPms⁴.

4. Consider iv₁ ≤ kt1k ∈ Pms⁴. The algorithm applies the Max-Min strategy and it generates the candidate t (t ≥ t1). Both CEs 4 and 5 can be classified in Dc and the generated constraint is dive1≤t.

5. Finally, foriv₁≥ kt1k ∈Psums⁴no non-trivial constraint can be obtained.

The resulting cost structure is:

smiv₁+smiv_{i t}

4+smiv_{i t}

5, {smiv₁≤smiv_{i t}

4· dive1}, {dive1≤t,smiv_{i t}

4+smiv_{i t}

5=ktk}

which represents an upper bound(1+t)·t and a lower bound oft. Note that the lower bound is precise for the given cost model. It corresponds to the case where the input argumentt is a degenerate tree and appendis always called withl1=Nil.

Linear Phases as a Special Case

The approach for chains with multiple recursion can also be applied for chains ch:=ph·ch⁰. It corre-sponds to having a setCHwith only one elementch⁰(see Corollary6.9).

The only particularity is that in such a chain, we know that#ch⁰=1and consequently for intermediate variables fromch, we havesmiv=dive=bivc. Therefore, theBasic Product strategycan be simplified for those cases. LetP

iv≤ klk ∈Psums^ch0, the modified strategy generates the constraintP

smiv≤ dive⁰and addsiv⁰≤ klk toPms^ch0 whereiv⁰is a fresh intermediate variable. Similarly, letP

iv≥ klk ∈Psums^ch0, it generates the constraintP

smiv≥ bivc⁰and addsiv⁰≥ klktoPms^ch0.

Table 6.5.:Classification conditions for Max-Min strategy in multiple chains: Ac_ecan be classified into the classesDc,IcorRstwith respect to a candidatecd(x)if its conditions are satisfied.

Class Condition when./is≤ Condition when./is≥ Dc

#calls(ce)

V

k=1

0≤dc_B(x)≤cd(x)−cd(x_k) ^#calls(cV ^e)

k=1

dc_B(x)≥cd(x)−cd(x_k) Ic

#calls(c_e)

V

k=1

ic_B(x)≥cd(x_k)−cd(x)

#calls(c_e)

V

k=1

0≤ic_B(x)≤cd(x_k)−cd(x) Rst

#calls(c_e)

V

k=1

cd(xk)./krst_B(x)k

Example 6.46. This approach obtains bounds for Program16. Consider the chain (3)⁺(2.1). The cost structures for CE 3 and chain (2.1) are 〈1,;,;〉 and 〈iv₁,;,{iv₁ = kbk}〉 respectively. The main cost expression is smiv_{i t}

3+smiv₁ and the initial pending sets are Psums^(2.1) = {iv₁ ≤ kbk,iv₁ ≥ kbk} and Psums³={iv_{i t3}≤1,iv_{i t3}≥1}. The cost structure computation is as follows:

1. First, the constraints iv_{i t3} ≤1and iv_{i t3} ≥1can be processed by the Inductive Sum Strategy. The generated (simplified) constraints aresmiv_{i t}

3≤ kakandsmiv_{i t}

3≥ kak.

2. Next, the constraintiv₁ ≤ kbk ∈Psums^(2.1) is selected. The Inductive Sum strategy generates the candidate b. The classification is Cnt := {(2.1)} and Ic := {3} with ic₃ := kak. The generated (simplified) constraints aresmiv₁≤iv₂+smiv_ic

3andiv₂≤ kbk. The constraintiv_ic

3≤ kakis added to the pending setPsums³. The treatment ofiv₁≥ kbk ∈Psums^(2.1)is symmetric.

3. The constraint iv_ic

3 ≤ kak ∈ Psums³ can be processed using the Basic Product strategy, which generatessmiv_ic

3≤smiv_{i t}

3· diveic₃, followed by the Max-Min strategy which generatesdiveic₃≤ kak.

This is enough to obtain an upper bound. The cost structure at this point is:

* smiv_{i t}

3+smiv₁,

§ smiv₁=iv₂+smiv_ic

3

smiv_ic

3≤smiv_{i t}

3· dive_ic3 ª

,





 smiv_{i t}

3=kak, iv₂=kbk, diveic₃≤ kak





 +

and the corresponding upper bound iskak+kbk+ (kak²). 4. Alternatively, the constraintsiv_ic

3≤ kakandiv_ic

3≥ kakcan also be processed using the Triangular Sum strategy withq=1. The resulting (simplified) cost structure is:

* smiv_{i t}

3+smiv₁,











smiv₁=iv₂+smiv_ic

3

smiv_ic

3=iv_p1+¹₂iv_p2−¹₂iv_{i ts} iv_p1=iv_ini·iv_{i ts}

iv_p2=smiv_{i t}

3·iv_{i ts} iv_{i ts}=smiv_{i t}

3









 ,





 smiv_{i t}

3=kak, iv₂=kbk, iv_ini=kak





 +

which represents the precise cost (upper and lower bound)kak+kbk+ (kak²/2+kak/2)

This approach can obtain bounds for programs where the approach based on composing the cost structures of the individual phases fails. This is because using this approach, the strategies for Sum and Max variables are used to infer non-linear size relations whereas the compositional approach relies on linear summaries that cannot capture such size relations. That is precisely the case with Program16.

However, this alternative does not solve all the limitations of the analysis with respect to non-linear size relations and it presents other disadvantages. Namely, this approach is less modular. Instead of

6.7. Chains with Multiple Recursion 103

computing a cost structure for the phase once, a computation has to be done for each chain that starts with such phase. In addition, it is harder to generate good candidates for the Inductive Sum strategy and obtain expressions that depend on the output as well. That is, it is harder to obtain amortized bounds using this approach.

A more detailed account of the limitations of the current analysis with respect to non-linear size relations is given in Chapter10.

Im Dokument Cost Analysis of Programs Based on the Refinement of Cost Relations (Seite 115-120)