3.1 The cost type

The recurrence language has a cost type $\textsf{C}$. As we discuss in Section 4, we can think of recurrence extraction as a monadic translation into the writer monad, where the “writing” action is to increment the cost component. Thus it suffices to ensure that $\textsf{C}$ is a monoid, though in our examples of models, it is usually interpreted as a set with more structure (e.g., the natural numbers adjoined with an “infinite” element).

3.2 The “missing” pieces from the source language

There are no suspension types, nor term constructors corresponding to $\mathtt{let}$, $\mathtt{map}$, or $\mathtt{mapv}$. We are primarily interested in the denotations of expressions in the recurrence language, not in carefully accounting for the cost of evaluating them. Of course, it is convenient to have the standard syntactic sugar $\textsf{let}\,{x_0=e_0,\dots,x_{n-1}=e_{n-1}}\,\textsf{in}\,{e}$ for ${e}\{e_0,\dots,e_{n-1}/x_0,\dots,x_{n-1}\}$. Because of the way in which the size order is axiomatized, this must be defined as a substitution, not as a $\beta$-expansion. Likewise, we still need a construct that witnesses functoriality of shape functors, but it suffices to do so with a metalanguage macro $F[(x:\rho).e',e]$ that is defined in Figure 12.

Fig. 12. The macro $F[\rho; y.e', e]$.

Fig. 13. The complexity and potential translation of types. Remember that although we have a grammar for structure functors F, they are actually just a subgrammar of the small types, so we do not require a separate translation function for them.

Fig. 14. Notation related to recurrence language expressions and recurrence extraction.

Fig. 15. The recurrence extraction function on source language terms. On the right-hand sides, $(c, p) = \|e\|$ and $(c_i, p_i) = \|e_i\|$ (note that $\|e\|$ is always a pair).

3.3 Datatype constructor, destructor, and fold

The constructor, destructor, and fold terms are similar to those in the source language, though here we use the more typical type for $\textsf{fold}_\delta$. Since type abstraction and application are explicit in the recurrence language, it may feel a bit awkward that $\beta$-reduction for types seems to change these constants; for example,$(\Lambda\alpha.\cdots\mathtt{fold_{\alpha\,list}}e'\mathtt{of}x.e\cdots)\sigma$ would convert to $\cdots\mathtt{fold_\alpha\,list}e'\mathtt{of}x.e\cdots$. The right way to think of this is that there is really a single constant $\textsf{fold}$ that maps inductive types to the corresponding operator—in effect, we write $\textsf{fold}_\delta$ for $\textsf{fold}\,\delta$, and so the substitution of a type for a type variable does not change the constant, but rather the argument to $\textsf{fold}$.

The choice as to whether to implement datatype-related constructs as term formers or as constants and whether they should be polymorphic or not is mostly a matter of convenience. The choice here meshes better with the definitions of environment models we use in Section 6, but using constants does little other than force us to insert some semantic functions into some definitions. However, one place where this is not quite the whole story is for $\textsf{fold}_\delta$, which one might be tempted to implement as a term constant of type $\forall{\vec{\alpha}\beta}.(F[\beta]\to\beta)\to\delta\to\beta$, where $\vec\alpha = \mathrm{ftv}(\delta)$. The typing we have chosen is equivalent with respect to any standard operational or denotational semantics. However, our denotational semantics will be non-standard, and the choice turns out to matter in the model construction of Section 7.4. There, we show how to identify type abstraction with size abstraction in a precise sense. Were we to use the polymorphic type for $\textsf{fold}_\delta$, then even when $\delta$ is monomorphic, $\textsf{fold}_\delta$ would still have polymorphic type (for the result), and that would force us to perform undesirable size abstraction on values of the monomorphic type.

3.4 The size order

The semantics of the recurrence language is described in terms of size orderings $\leq_\tau$ that is defined in Figure 11 for each type $\tau$ (although the rules only define a preorder, we will continue to refer to it as an order). The syntactic recurrence extracted from a program of type $\sigma$ has the type $\textsf{C}\times{\langle\langle\sigma\rangle\rangle}$. The intended interpretation of $\langle\langle\sigma\rangle\rangle$ is the set of sizes of source language values of type $\sigma$. We expect to be able to compare sizes, and that is the role of $\leq_\sigma$. Although $\leq_\textsf{C}$ is more appropriately thought of as an ordering on costs, general comments about $\leq$ apply equally to $\leq_\textsf{C}$, so we describe it as a size ordering as well to reduce verbosity.^{Footnote 3} The relation $\leq_\textsf{C}$ just requires that $\textsf{C}$ be a monoid (i.e., have an associative operation with an identity). In particular, there are no axioms governing 1 needed to prove the bounding theorem; it is not even necessary to require that $0\not=1$ or even $0\leq_\textsf{C} 1$.

Let us gain some intuition behind the axioms for $\leq_\sigma$. On the one hand, they are just directed versions of the standard call-by-name equational calculus that one might expect. In the proof of the Syntactic Bounding Theorem (Theorem 5), that is the role they play. But there is more going on here than that. The intended interpretation of the axioms is that the introduction-elimination round-trips that they describe provide a possibly less precise description of size than what is started with. It may help to analogize with abstract interpretation here: an introductory form serves as an abstraction, whereas an elimination form serves as a concretization. In practice, the interpretation of products, sums, and arrows do not perform any abstraction, and so in the models we present in Section 6, the corresponding axioms are witnessed by equality (e.g., for ($\beta_\times$), $[\![{e_i}]\!] = [\![{\pi_i ({e_0}{e_1})]\!]}$). That is not the case for datatypes and type quantification, so let us examine this in more detail.

Looking forward to definitions from Section 4, if $\sigma$ is a source language type, then $\langle\langle\sigma\rangle\rangle$ is the potential type corresponding to $\sigma$ and is intended to be interpreted as a set of sizes for $\sigma$ values. It happens that $\langle\langle{\mathtt{list}\sigma}\rangle\rangle = {\langle\langle\sigma\rangle\rangle}\mathtt{list}$, so a $\sigma\mathtt{list}$ value $vs = [v_0,\dots,v_{n-1}]$ is extracted as a list of $\langle\langle\sigma\rangle\rangle$ values, each of which represents the size of one of the $v_i$s. Hence, a great deal of information is preserved about the original source-language program. But frequently the interpretation (the denotational semantics of the recurrence language) abstracts away many of those details. For example, we might interpret ${\langle\langle\sigma\rangle\rangle}\mathtt{list}$ as $\mathbf{N}$ (the natural numbers), $\textsf{nil}$ as 0, and $\textsf{cons}$ as successor (with respect to its second argument), thereby yielding a semantics in which each list is interpreted as its length (we define two such “constructor-counting” models in Sections 7.2 and 7.3). Bearing in mind that ${\langle\langle\sigma\rangle\rangle}\textsf{list} = \mu t.F$ with $F = \textsf{unit}+{{\langle\langle\sigma\rangle\rangle}\times{t}}$, the interpretation of $F[{\langle\langle\sigma\rangle\rangle}\textsf{list}]$ must be $[\![\textsf{unit}]\!] + ([\![{\langle\langle\sigma\rangle\rangle}]\!]\times\mathbf{N})$. Let us assume that $+$ and $\times$ are given their usual interpretations (though as we will see in Section 7, that is often not sufficient). For brevity, we will write $\textsf{c}$ and $\textsf{d}$ for $\textsf{c}_{{\langle\langle\sigma\rangle\rangle}\textsf{list}}$ and $\textsf{d}_{{\langle\langle\sigma\rangle\rangle}\textsf{list}}$. Thus, $\textsf{c}(y, n) = 1+n$ represents the size of a source-language list that is built using $\mathtt{c}_{\sigma\textsf{list}}$ when applied to a head of size y (which is irrelevant) and a tail of size n. The question is, what should the value of $\textsf{d}(1+n)$ be? It ought to somehow describe all possible pairs that are mapped to $1+n$ by $\textsf{c}$. Ignoring the possibility that it is an element of $[\![\textsf{unit}]\!]{}$ (which seems obviously wrong), and assuming the $\mathbf{N}$-component ought to be n, no one pair $(y', n)\in[\![{\langle\langle\sigma\rangle\rangle}]\!]\times\mathbf{N}$ seems to do the job. However, if we assume the existence of an maximum element $\infty$ of $[\![{\langle\langle\sigma\rangle\rangle}]\!]{}$, then $(\infty, n)$ is an upper bound on all pairs (y’, n) such that $\textsf{c}(y', n) = 1+n$, and so it seem reasonable to set $\textsf{d}(1+n) = (\infty, n)$. But in this case, the round trip is not an identity because $\textsf{d}(\textsf{c}(y, n)) = (\infty, n) \geq (y, n)$, and so $\beta_{\delta}$ and $\beta_{\delta\textsf{fold}}$ are not witnessed by equality.

Turning to type quantification, the standard interpretation of $\forall\alpha\sigma$ is $\prod_{U\in\mathbf{U}}[\![{\sigma}]\!]{\{\alpha\mapsto U\}}$ for a suitable index set $\mathbf{U}$ (in the setting of predicative polymorphism, this does not pose any foundational difficulties), and the interpretation of a polymoprhic program is the $\mathbf{U}$-indexed tuple of all of its instances. Let ${\lambda{xs}.{e}}\mathbin: {{\alpha}\textsf{list}\rightarrow{\rho}}$ be a polymorphic program in the source language. The recurrence extracted from it essentially has the form ${\Lambda\alpha.{{\lambda{xs}.{E}}}} \mathbin:\forall\alpha.{{\alpha\textsf{list}}\rightarrow{\textsf{C}\times{\langle\langle\rho\rangle\rangle}}}$. Let us consider a denotational semantics in which $[\![{\sigma\textsf{list}}]\!]{} =\mathbf{N}\times\mathbf{N}$, where (k, n) describes a $\sigma\textsf{list}$ value with maximum component size k and length n (this is a variant of the semantics in Section 7.3). We are then in the conceptually unfortunate situation that the analysis of this polymorphic recurrence depends on its instances, which are defined in terms of not only the list length, but also the sizes of the list values. Parametricity tells us that the list value sizes are irrelevant, but our model fails to convey that. Instead, we really want to interpret the type of the recurrence as $\mathbf{N}\to([\![\textsf{C}]\!]\times[\![{\langle\langle\rho\rangle\rangle}]\!])$, where the domain corresponds to list length. This is a non-standard interpretation of quantified types, and so the interpretations of quantifier introduction and elimination will also be non-standard. In our approach to solving this problem, those interpretations in turn depend on the existence of a Galois connection between $\mathbf{N}$ and $\mathbf{N}\times\mathbf{N}$, for example mapping the length n (quantified type) to $(\infty, n)$ (an upper bound on instances), and we might map (k, n) (instance type) to n. The round trip for type quantification corresponds to $(k, n)\mapsto n \mapsto (\infty, n)$, and hence $(\beta_\forall)$ is not witnessed by equality (we deploy the usual conjugation with these two functions in order to propogate the inequality to function types while respecting contravariance). We describe an instance of this sort of model construction in Section 7.4, although there we are not able to eliminate the $\mathbf{U}$-indexed product, and so the type of the recurrence is interpreted by $\prod_{U\in\mathbf{U}}\mathbf{N}\to([\![\textsf{C}]\!]{}\times[\![{\langle\langle\rho\rangle\rangle}]\!]{})$.

6.1 Models of the recurrence language

We start by defining the notions of type frame and applicative structure for the recurrence language.

Definition A type frame is specified by the following data:

• • A set $\mathbf{U}_{sm}$ of small semantic types and a set $\mathbf{U}_{lg}$ of large semantic types with $\mathbf{U}_{sm}\subseteq\mathbf{U}_{lg}$;

• • Distinguished semantic types $U_\textsf{C}, U_{\textsf{unit}}\in\mathbf{U}_{sm}$;

• • Functions $\mathrel{\underline{\times}}:\mathbf{U}_{sm}\times\mathbf{U}_{sm}\to\mathbf{U}_{sm}$, $\mathrel{\underline{+}}:\mathbf{U}_{sm}\times\mathbf{U}_{sm}\to\mathbf{U}_{sm}$, $\mathrel{\underline{\mathord\to}}:\mathbf{U}_{sm}\times\mathbf{U}_{sm}\to\mathbf{U}_{sm}$, and $\mathord{\underline{\smash\mu}}:(\mathbf{U}_{sm}\to\mathbf{U}_{sm})\rightharpoonup\mathbf{U}_{sm}$; and

• • A function $\mathord{\underline{\forall}} : (\mathbf{U}_{sm}\to\mathbf{U}_{lg})\rightharpoonup\mathbf{U}_{lg}$.

Let TyVar be the set of type variables and let $\eta : \mathrm{TyVar}\to \mathbf{U}_{sm}$. The denotation of $\tau$ with respect to $\eta$, $[\![\tau]\!]\eta$, is given in Figure 18.

Fig. 18. The denotation (partial) function of types and type schemes into a type frame.

Definition A type frame is a type model if for all F and $\eta$, ${\lambda\hskip-.32em\lambda} V.[\![ F]\!]{{\eta}{t}\mapsto{V}}\in\mathrm{Dom}\;\mathord{\underline{\smash\mu}}$ and for all $\tau$ and all $\eta$, ${\lambda\hskip-.32em\lambda} U.[\![\tau]\!]{{\eta}\{\alpha\mapsto U\}}\in\mathrm{Dom}\;\mathord{\underline{\forall}}$ (and hence $[\![\tau]\!]\eta$ is defined for all $\tau$ and $\eta$).

Definition An applicative structure is specified by the following data:

• • A type model $(\mathbf{U}_{sm}, \mathbf{U}_{lg})$.

• • For each $U\in\mathbf{U}_{lg}$, a preordered set $(D^U,\leq_U)$.

• • For each $\Phi\in\mathrm{Dom}\;\mathord{\underline{\smash\mu}}$ and $U, V\in\mathbf{U}_{sm}$, a function $\Phi_{U,V}:(D^U\to D^V)\to(D^{\Phi\,U}\to D^{\Phi\,V})$.

• • Distinguished elements $0,1\in D^{U_\textsf{C}}$ and an associative function $+:D^{U_\textsf{C}}\to D^{U_\textsf{C}}$ such that 0 is a right- and left identity for $+$.

• • A distinguished element $*\in D^{U_\textsf{unit}}$

• • For each $U, V\in \mathbf{U}_{sm}$, functions

  
  such that $\underline{App}\circ\mathbin\circ\underline{Abs} \geq \mathop{\mathrm{id}}\nolimits$. Note that $\underline{Abs}$ is a partial function.

• • For each $U_0, U_1\in\mathbf{U}_{sm}$, functions

  \[D^{U_0}\times D^{U_1} \xrightarrow{\underline{Pair}U_0,U_1} D^{U_0\mathrel{\underline{\times}} U_1}\xrightarrow{\underline{Proj}{U_0,U_1}^i} D^{U_i}\]
  such that $\underline{Proj}^i(\underline{Pair}(a_0, a_1)) \geq a_i$.

• • For each $U_0$, $U_1$, $V\in\mathbf{U}_{sm}$, functions

  \[D^{U_i} \xrightarrow{\underline{\mathrm{Inj}}^{i}[U_0, U_1]^i} D^{U_0\mathrel{\underline{+}} U_1}\xrightarrow{\underline{\mathrm{Pair}}U_0, U_1, V} (D^{U_0}\to V)\times (D^{U_1}\to V)\to D^V\]
  such that $(\underline{\mathrm{Case}}\mathbin\circ\underline{\mathrm{Inj}}^i)\,a\,(f_0, f_1)\geq f_i\,a$. We often write $\underline{\mathrm{Case}}(a, f_0, f_1)$ for $\underline{\mathrm{Case}}\,a\,(f_0, f_1)$.

• • For each $\Phi\in\mathrm{Dom}\;\mathord{\underline{\smash\mu}}$, functions

  \[D^{\Phi(\mathord{\underline{\smash\mu}}\,\Phi)} \xrightarrow{\underline{\mathrm{C}}_\Phi}D^{\mathord{\underline{\smash\mu}}\,\Phi} \xrightarrow{\underline{\mathrm{D}}_\Phi}D^{\Phi(\mathord{\underline{\smash\mu}}\,\Phi)}\]
  such that $\underline{\mathrm{D}}\mathbin\circ\underline{\mathrm{C}}\geq\mathop{\mathrm{id}}\nolimits$.

• • For each $\Phi\in\mathrm{Dom}\;\mathord{\underline{\smash\mu}}$ and $U\in\mathbf{U}_{sm}$, functions $\underline{\mathrm{Fold}}_{\Phi,U} : (D^{\Phi\,U}\to D^U) \to (D^{\mathord{\underline{\smash\mu}}\,\Phi}\to D^U)$ such that $(\underline{\mathrm{Fold}}_{\Phi,U}\,f)\mathbin\circ \underline{\mathrm{C}}_{\Phi}\geq f\mathbin\circ (\Phi_{\mathord{\underline{\smash\mu}}\,\Phi,U}(\underline{\mathrm{Fold}}_{\Phi,U}\,f))$.

• • For each $\Phi\in \mathrm{Dom}\;\forall$, functions

  
  such that $\underline{\mathrm{TyApp}}\mathbin\circ\underline{\mathrm{TyAbs}})\geq \mathop{\mathrm{id}}\nolimits$. Note that $\underline{\mathrm{TyAbs}}$ is a partial function.

Remember that when we write, e.g., $D^U\to D^V$, we mean the monotone functions from $D^U$ to $D^V$, and hence all of the semantic functions that make up the data of an applicative structure are monotone.

We write ${\mathbf{U}} = (\mathbf{U}_{sm},\mathbf{U}_{lg},\{D^U\}{U\in\mathbf{U}_{lg}})$ for a typical applicative structure, or just ${\mathbf{U}} = \{D^U\}{U\in\mathbf{U}_{lg}}$ when $\mathbf{U}_{lg}$ is clear from context. For a context $\Gamma$ define $\mathrm{tyvar}(\Gamma) = \{\alpha\mid\alpha \mathrm{occurs in ftv}(\Gamma(x))\mathrm{for some}x$. Define a $\Gamma$-environment to be a map $\eta$ such that

• • $\eta(\alpha)\in\mathbf{U}_{sm}$ for $\alpha\in\mathrm{tyvar}(\Gamma)$; and

• • $\eta(x)\in D^{[\![{\Gamma(x)}]\!]\eta}$ for $x\in\mathrm{Dom}\;\Gamma$.

For an applicative structure and environment $\eta$, define a partial denotation function $[\![{\Gamma \vdash e : \tau}]\!]\eta$ as in Figure 19. The only way in which $[\![\cdot]\!]\cdot$ may fail to be total is if the arguments to $\underline{\mathrm{Abs}}$ or $\underline{\mathrm{TyAbs}}$ are not in the corresponding domains (because we start with a type model, we know that $\mathord{\underline{\smash\mu}}$ and $\mathord{\underline{\forall}}$ are only applied to functions in their domains).

Fig. 19. The denotation (partial) function into an applicative structure. For constructors and destructors, assume $\delta = \mu t F$ and $\mathop{\mathrm{fv}}\nolimits(\delta) = \{\alpha_0,\dots,\alpha_{n-1}\}$, and define $\eta^* = \eta\{\vec\alpha\mapsto\vec U\}$.

Fig. 20. The monomorphic tree copy function and its extracted recurrence.

Definition Let ${\mathbf{U}}$ be an applicative structure.

1. 1. ${\mathbf{U}}$ is a premodel if

2. − Whenever $\Gamma \vdash e: \tau$ and $\eta$ is a $\Gamma$-environment, $[\![{\Gamma\vdash e:\tau}]\!]\eta$ is defined and an element of $D^{[\![{\tau}]\!]{\eta}}$; and

3. − Whenever ${\Gamma,y\mathbin:\rho}\vdash{e'}:{\sigma}$ and $\Gamma\vdash{e}:{{F}[{\rho}]}$ and $\eta$ is a $\Gamma$-environment,

   \[[\![{F[(y:\rho).{e'},e]}]\!]\eta\leq_{[\![\sigma]\!]\eta}({\lambda\hskip-.32em\lambda} V.[\![ F]\!] {\eta\{t\mapsto V\}})_{[\![\rho]\!]\eta,[\![\sigma]\!]\eta}({\lambda\hskip-.32em\lambda} a.[\![{e'}]\!]{\eta\{y\mapsto a\}})([\![ e]\!] \eta).\]

4. 2. ${\mathbf{U}}$ is a model if ${\mathbf{U}}$ is a premodel and whenever ${\Gamma}\vdash {e}\leq_{\tau} {e'}$, and $\eta$ is a $\Gamma$-environment, $[\![{\Gamma \vdash e : \tau}]\!]\eta \leq_{[\![\tau]\!]\eta}[\![{\Gamma \vdash {e'}:\sigma}]\!]\eta$.

The indirection of interpreting syntactic types by semantic types, and then interpreting terms of a given syntactic type as elements of a domain associated to the corresponding semantic type is necessary, especially in our setting of nonstandard models. This makes is much easier (seemingly, possible) to define things like the $\mathord{\underline{\smash\mu}}$ operator. Without the indirection, we would have to define $\mathord{\underline{\smash\mu}}$ on (functions on) a collection of domains, some of which represent syntactic types. That ends up being very difficult to do. For example, we might have to first define a notion of polynomial function on the semantic domains in order to define the domain of $\mathord{\underline{\smash\mu}}$, and then somehow identify each semantic polynomial function with a structure functor. But doing so gets us into problems with unique representation; e.g., there may be multiple structure functors corresponding to the same semantic polynomial. And with nonstandard models, we seem to have even more troubles because we end up trying to define the interpretations of inductive types simultaneously with the $\mathord{\underline{\smash\mu}}$ function. But first interpreting the syntactic types by semantic types gives us a way around these problems because (if we wish) we can define the semantic types to be closely tied to the syntactic types. That is exactly what we do for the standard type frame, so we can essentially define $\mathord{\underline{\smash\mu}}$ syntactically, and then choose a domain corresponding to $\mu t F$ (which is a semantic type as well as a syntactic one) after having defined $\mathord{\underline{\smash\mu}}$.

1. 1. $[\![{\tau\sigma\mapsto\alpha}]\!]\eta =[\![\tau]\!]\eta\{\alpha\mapsto {[\![\sigma]\!]\eta}\}$. If $\alpha\notin\mathrm{ftv}(\tau)$ then for all U, $[\![\tau]\!]\eta = [\![\tau]\!]\eta\{\alpha\mapsto U\}$ and for all term variables x and all a, $[\![\tau]\!]\eta = [\![\tau]\!]\eta \{x\mapsto a\}$.

2. 2. $[\![ e\{{e'}/ x\}]\!]\eta =[\![ e]\!] \eta \{x\mapsto {[\![{e'}]\!] \eta}\}$. If $x\notin\mathop{\mathrm{fv}}\nolimits(e)$, then for all a, $[\![ e]\!] \eta = [\![ e]\!]\eta\{ x\mapsto a\}$.

3. 3. If $a\leq a'$, then $[\![ e]\!] \eta\{ x\mapsto a\} \leq [\![ e]\!] \eta\{ x\mapsto {a'}\}$; in other words, ${\lambda\hskip-.32em\lambda} a.[\![ e]\!] \eta \{x \mapsto a\}$ is monotone.

One might hope that a model of the fragment of the recurrence language that omits $\textsf{fold}_\delta$ can be extended to one that does, but in our setting this does not quite hold. Since we only have directed versions of the usual equalities, initial algebras for structure functors may not exist. And even if they do, they are not necessarily what we want. For clarity, in this discussion, we will write syntactic types for semantic types. The point behind different semantics is to abstract inductive values to some notion of size, and when this abstraction is non-trivial, $D^{\mu t.F}$ and $D^{F[{\mu t.F}]}$ are probably not isomorphic. Instead of the usual initial algebra for interpreting $\mu t.F$, we typically want an algebra $\underline{\mathrm{C}}_{F} : D^{F[\mu t.F]}\to D^{\mu t F}$ such that for any other algebra $s : D^{F[\sigma]}\to D^\sigma$, there is a function $\underline{\mathrm{Fold}}_{F,\sigma}\,s$ that makes the diagram

commute, where $\underline{\mathrm{Map}}_F$ is a semantic function that corresponds to the $F[\cdot,\cdot]$ macro. Relative to the usual definition of initial algebra, this requirement is weak, in that we ask only for existence of a $\underline{\mathrm{Fold}}{}$ function making the diagram commute ($\beta$ reduction) and not the uniqueness of $\underline{\mathrm{Fold}}{}$ ($\eta$/induction), and it is lax, in that we ask that $\beta$-reduction holds only as an inequality, rather than an equality.

Nonetheless, under assumptions that turn out to be relatively easy to ensure, we can define $\underline{\mathrm{Fold}}_{\Phi,U}$. Given a subset $X\subseteq A$ of a preordered set A, we say that $a\in A$ is a least upper bound of X, written $a = \bigvee X$, if for all $x\in X$, $x\leq a$, and if $b\in A$ satisfies the condition that for all $x\in X$, $x\leq b$, then $a\leq b$. When A is preordered, $\bigvee X$ may not exist, and when it does, it need not be unique. If A is a partial order (i.e., $a\leq b\leq a$ implies that $a=b$), then $\bigvee X$ is unique when it exists, and we say that A is a complete upper semi-lattice if A is a partial order and $\bigvee X$ exists for every $X\subseteq A$. Though this seems like a very strong condition, in practice it is easy to ensure.

In a model in which every $D^U$ is a complete upper semi-lattice, we would like to define

\[\underline{\mathrm{Fold}}_{\Phi,U}\,s\,x =\bigvee\{s\bigl(\Phi_{\mathord{\underline{\smash\mu}}\,\Phi,U}(\underline{\mathrm{Fold}}_{\Phi,U} s)\,z\bigr)\}{z\in D^{\Phi(\mathord{\underline{\smash\mu}}\,\Phi)}, {\underline{\mathrm{C}}_{\Phi}\,z \leq x}}.\tag{std-fold}\]

A priori, this definition may not be well founded, but in fact it is, as shown in the next proposition.

1. 1. For all s, $\underline{\mathrm{Fold}}_{\Phi,U}\,s$ is total and monotone.

2. 2. $\underline{\mathrm{Fold}}_{\Phi,U}$ is total and monotone.

The proof of Proposition 3, and hence the interpretation of $\textsf{fold}_\delta$, may seem a bit heavy-handed, making use of general least fixed point theorems and even iterating into the transfinite. As we noted earlier, we are in a setting in which we do not have (and do not want) initial algebras, but must nonetheless show an initiality-like property of a given algebra. Accordingly, we would expect to use technology at least as strong as that needed for typical initial algebra existence theorems. The canonical such theorem (e.g., as described by Aczel Reference Aczel1988, Thm. 7.6) verifies that the least fixed point of a set-continuous operator is an initial algebra, and the verification consists of constructing the equivalent of $\underline{\mathrm{Fold}}\,s$ by induction on the (ordinal-indexed) construction of the least fixed point.

The reader may have noticed that an alternative possible definition for $\underline{\mathrm{Fold}}$ is

\[\underline{\mathrm{Fold}}\,s\,x= s(\Phi(\underline{\mathrm{Fold}}\,s)(\underline{\mathrm{D}}\,x))\]

and Proposition 3 would still hold. This fact witnesses that the initiality condition for $\underline{\mathrm{C}}_{\Phi} : D^{\Phi(\mathord{\underline{\smash\mu}}\,\Phi)}\to D^{\mathord{\underline{\smash\mu}}\,\Phi}$ is weak, in that functions to other algebras are not unique. In practice, this alternative definition yields far worse bounds for extracted recurrences, because we end up defining $\underline{\mathrm{D}}_{\Phi}\,x = \bigvee\{z\}{\underline{\mathrm{C}}_{\Phi}(z)\leq x}$ and so $\underline{\mathrm{Fold}}\,s\,x= s(\Phi(\underline{\mathrm{Fold}}\,s)(\bigvee\{z\}{\underline{\mathrm{C}}_{\Phi}(z)\leq x}))$. Monotonicity of f only allows us to conclude that $f(\bigvee X) \geq\bigvee\{f(x)\}{x\in X}$, but this putative definition for $\underline{\mathrm{Fold}}\,s$ exposes a case in which this inequality is strict.

6.2 The standard type frame

Our last step in our general discussion of models is to define the type frame upon which all of our examples will be based. It gives us enough data to provide a standard definition of the functions $\Phi_{U,V}$, which in turn lets us use (std-fold) to define $\underline{\mathrm{Fold}}$ and so for most of our examples, it will suffice to define $\underline{\mathrm{C}}_{\Phi}$ (because we will set $\underline{\mathrm{D}}_{\Phi} = \bigvee\{z\}{\underline{\mathrm{C}}_{\Phi}(z)\leq x}$). Our examples are all based on variations of the standard type frame, which is defined as follows:

• • $\mathbf{U}_{sm}$ is the set of closed types and $\mathbf{U}_{lg}$ the set of closed type schemes of the recurrence language.

• • $\mathrel{\underline{\mathord\to}}$, $\mathrel{\underline{\times}}$, and $\mathrel{\underline{+}}$ are the standard type constructors; e.g., $\sigma_0\mathrel{\underline{+}}\sigma_1 = {\sigma_0}+{\sigma_1}$.

• • $\mathrm{Dom}\;\mathord{\underline{\smash\mu}} = \{{\lambda\hskip-.32em\lambda}\sigma.F[\sigma]\}{\mathop{\mathrm{fv}}\nolimits(F) \subseteq \{t\}}$ and $\mathord{\underline{\smash\mu}}({\lambda\hskip-.32em\lambda}\sigma.F[\sigma]) = \mu t F$ (we call a structure functor F with $\mathop{\mathrm{fv}}\nolimits(F)\subseteq\{t\}$ closed).

• • $\mathrm{Dom}\;\mathord{\underline{\forall}} = \{{\lambda\hskip-.32em\lambda}\sigma.\tau'\{\sigma/\alpha\}\}{\mathop{\mathrm{fv}}\nolimits(\tau)=\{\alpha\}}$ and $\mathord{\underline{\forall}}({\lambda\hskip-.32em\lambda}\sigma.\tau\{\sigma/\alpha\}) = \forall\alpha.\tau$.

It is straightforward to show that if ${\lambda\hskip-.32em\lambda}\sigma.F[\sigma] ={\lambda\hskip-.32em\lambda}\sigma.F'[\sigma]$, then $F = F'$, and if ${\lambda\hskip-.32em\lambda}\sigma.\tau\sigma\mapsto\alpha = {\lambda\hskip-.32em\lambda}\sigma.{\tau'}\{\sigma/\alpha\}$, then $\tau = \tau'$, so $\mathord{\underline{\smash\mu}}$ and $\mathord{\underline{\forall}}$ are well defined. It should be clear and occasionally helpful to observe that for any $\tau$ and environment $\eta =\{\alpha_0\mapsto{\sigma_0},\dots,{\alpha_{n-1}}\mapsto{\sigma_{n-1}}\}$, $[\![\tau]\!]\eta = \tau\{\vec{\sigma}/\vec{\alpha}\}$. For models based on the standard type frame and any closed structure functor F, we will usually write F in place of ${\lambda\hskip-.32em\lambda}\sigma.F[\sigma]$ in subscripts for readability.

For any applicative structure based on (an extension of) the standard type frame, define $F_{\rho,\sigma} : (D^\rho\to D^\sigma)\to(D^{F[\rho]}\to D^{F[\sigma]})$ for each closed structure functor F and closed $\rho$ and $\sigma$ by

\[\begin{aligned}[t]t_{\rho,\sigma}\,g\,x &= g\,x \\(\sigma_0)_{\rho,\sigma}\,g\,x &= x \\\end{aligned}\qquad\begin{aligned}[t]({F_0}+{F_1})_{\rho,\sigma}\,g\,x &= \underline{\mathrm{Case}}(x, {\lambda\hskip-.32em\lambda} y.\underline{\mathrm{Inj}}^0((F_0)_{\rho,\sigma}\,g\,y),{\lambda\hskip-.32em\lambda} y.\underline{\mathrm{Inj}}^1((F_1)_{\rho,\sigma}\,g\,y)) \\({F_0}\times{F_1})_{\rho,\sigma}\,g\,x &= \underline{\mathrm{Pair}}((F_0)_{\rho,\sigma}\,g\,(\underline{\mathrm{Proj}}^0 x),(F_1)_{\rho,\sigma}\,g\,(\underline{\mathrm{Proj}}^1 x)),\\({\sigma_0}\to{F})_{\rho,\sigma}\,g\,x &= {\lambda\hskip-.32em\lambda} y.F_{\rho,\sigma}\,g\,(x\,y)\end{aligned}\]

Lemma 7. If ${\mathbf{U}}$ is an applicative structure based on an extension of the standard type frame that is a model for the fragment of the recurrence language that omits $\textsf{fold}_\delta$, ${\Gamma,y\mathbin:\rho}\vdash{e'}:{\sigma}$, $\Gamma\vdash e: {F[\rho]}$, and $\eta$ is a $\Gamma$-environment, then

\[ [\![{F [(\rho:y).{e'}, e]}]\!]\eta = ([\![ F]\!]\eta)_{[\![\rho]\!]\eta,[\![\sigma]\!]\eta}\,({\lambda\hskip-.32em\lambda} a.[\![{e'}]\!]\eta\{y\mapsto a\} )\,([\![ e]\!] \eta).\]

Combining Proposition 3 with Lemma 7, we conclude that to define a model of the recurrence language, it suffices to define an extension of the standard type frame and the following applicative structure data:

• • The sets $D^\tau$, along with an argument that $D^\tau$ is a complete upper semi-lattice;

• • The semantic functions for arrow, product, and sum types;

• • $\underline{\mathrm{C}}_{F}$ for each structure functor F.

From this data, we can define $\underline{\mathrm{D}}_F(x) = \bigvee\{z\}{\underline{\mathrm{C}}_{F}\leq x}$, $F_{\rho,\sigma}$ as just given, and $\underline{\mathrm{Fold}}_{F,\sigma}$ by (std-fold). Of course, there are models that are not constructed this way; Section 7.5 gives an example that is useful for extracting recurrences for lower bounds.

6.3 Syntactic sugar

We now introduce some syntactic sugar that will make our discussion of recurrences somewhat more pleasant. To simplify the discussion, we restrict the details to the source language type $\sigma\mathtt{tree}$ and its recurrence language potential $\sigma\mathtt{tree}$, but we will use analogous notation for other datatypes such as $\mathtt{nat}$ and $\alpha\mathtt{list}$ in our examples. Many of our source-language functions are really structural folds over some standard datatype—that is, the step function is a $\mathtt{case}$ expression where the argument for each branch is really the argument to one of the datatype constructors. Accordingly, we introduce notation for such $\mathtt{fold}$ expressions: for $y\notin\mathop{\mathrm{fv}}\nolimits(e_\mathtt{emp})\cup\mathop{\mathrm{fv}}\nolimits(e_\mathtt{node})$,

\[\mathtt{fold}_{\sigma\mathtt{tree}} e \mathtt{of emp}\Rightarrow {e_\mathtt{emp}}|\mathtt{node}\Rightarrow {(x, r_0, r_1).e_\mathtt{node}}\]

is syntactic sugar for

\[\mathtt{fold}_{\sigma \mathtt{tree}} e \mathtt{of} w.{\mathtt{case} w \mathtt{of} y.{e_\mathtt{emp}}; y.{e_\mathtt{emp}; {y.e_\mathtt{node}} {\pi_0 y, \pi_1 y, \pi_2 y} {x, r_0, r_1}}}.\]

We introduce a similar notation in the recurrence language:

\[\mathtt{fold}_{\sigma \mathtt{tree}} e \mathtt{of} \{\textsf{emp}\Rightarrow e_\textsf{emp}|\textsf{node}\Rightarrow (x, r_0, r_1).e_\textsf{node}\}\]

is syntactic sugar for

\[\mathtt{fold}_{\sigma \mathtt{tree}} e {(w : {F_{\sigma\mathtt{tree}}}[\rho]).} {{(\textsf{Case} w \textsf{of}y.{e_\textsf{emp}};y.{{e_{\textsf{node}}} {\pi_0 y, \pi_1 y, \pi_2 y}/{x, r_0, r_1}})}}\]

where w and y are fresh variables.

It would be nice to establish an identity of the form $\|{\mathtt{fold}_{\sigma\mathtt{tree}}\dotsb}\| = \textsf{fold}_{\sigma\textsf{tree}}\dotsb$, but the size-order axioms, which give us only inequalities, are too weak. However, the models that we will consider validate many equations, so we can set out a nice relationship. In the following proposition, we say “in the semantics, $e = e'$” to mean that for any $\eta$, $[\![ e]\!]\eta = [\![ {e'}]\!] \eta$:

• • In the semantics: if $\|{{e'}}\|_c = 0$, then $\|e\{e'/x\}\| = {\|e\|} {{\|e'\|}_p}/x$; and

• • In the semantics: $c+_c {\textsf{case} e \textsf{of} \{x.e_i\}}_{i=0,1} = \textsf{case} e \textsf{of}\{x.c+_{c}e_{i}\}_{i=0,1}$.

If $\Gamma\vdash\textsf{fold}_{\sigma\textsf{tree}} e \textsf{of\,emp}\Rightarrow {e_\mathtt{emp}}|\textsf{node}\Rightarrow(x,r_{0},r_{1}).e_{\textsf{node}}:\rho$, then in the semantics,

\begin{multline*}\|\mathtt{fold}_{\sigma\mathtt{tree}} e \textsf{of\,emp}\Rightarrow\,e_{\textsf{emp}}|\textsf{node}\Rightarrow(x,r_{0},r_{1}).e_{\textsf{node}}\|=c+_{c}\textsf{fold}_{\sigma\mathtt{tree}}p\textsf{of} \{\textsf{emp}\Rightarrow1+_{c}\|E_{\textsf{emp}}\| |\textsf{node}\Rightarrow(x,r_{0},r_{1}).1+_{c} \|E_{\textsf{node}}\|\}\end{multline*}

where $(c, p) = \|e\|$.

While the models that we discuss in subsequent sections satisfy the hypotheses of Proposition 5, they are not necessarily satisfied in an arbitrary model. That requires additional axioms that correspond roughly to $\eta$ axioms.

7.1 The standard model

For the standard model, we first extend the standard type frame by including the constant $\bot$ in $\mathbf{U}_{sm}$. A semantic type (scheme) is proper if it has no occurrences of $\bot$. The proper semantic types (type schemes) correspond exactly to the closed syntactic types (type schemes). In the definitions of $\mathord{\underline{\smash\mu}}$ and $\mathord{\underline{\forall}}$, we take F and $\tau$ to be proper. We define the sets $A^\sigma$ by induction on $\sigma$ as follows:^{Footnote 5}

• • $A^\textsf{C} = \mathbf{N}$, the natural numbers.

• • $A^\bot = \emptyset$.

• • $A^{\textsf{unit}} = \{*\}$, some one-element set.

• • $A^{{\sigma_0}\to{\sigma_1}} = (A^{\sigma_1})^{A^{\sigma_0}}$, the set of functions from $A^{\sigma_0}$ to $A^{\sigma_1}$.

• • $A^{{\sigma_0}\times{\sigma_1}} = A^{\sigma_0}\times A^{\sigma_1}$, where $\times$ is the standard set-theoretic product.

• • $A^{{\sigma_0}+{\sigma_1}} = A^{\sigma_0}\sqcup A^{\sigma_1}$, where $\sqcup$ is the standard set-theoretic disjoint union.

• • $A^{\mu t.F} = \bigcup_i A^{({\lambda\hskip-.32em\lambda} V.[\![ F]\!] {\{t\mapsto V\}})^i\bot}$.

• • $A^{\forall\alpha\tau} = \prod_{\sigma\in\mathbf{U}_{sm}} A^{\tau\{\sigma/\alpha\}}$.

Define $a\leq_{A^\sigma} b$ iff $a=b$, and let the semantic functions for arrows, products, and sums be the identity functions. The definitions of $\underline{\mathrm{C}}_{F}$, $\underline{\mathrm{D}}_F$, and $\underline{\mathrm{Fold}}_{F,\sigma}$ are based on the standard initial-algebra semantics. Note that we cannot use (std-fold) because the $A^\sigma$ are not complete upper semi-lattices, and hence the hypotheses of Proposition 3 do not hold, and hence $\beta_{\delta\textsf{fold}}$ must be verified directly.

At first blush, this model is not particularly interesting. There is no abstraction of values to sizes and the “order” on costs is the identity, so the recurrences extracted from source language programs describe the exact cost of those programs in terms of the argument values. However, this is a standard model of (predicative) polymorphism, and so we can hope that parametricity may have some interesting consequences. Free theorems (Wadler Reference Wadler1989) have been used to obtain relative cost information, and we discuss this further in Section 9. Here, we apply parametricity to the recurrence language and sketch the argument that if $g: {\alpha\mathtt{list}}\rightarrow{\alpha\mathtt{list}}$, then the cost of g(xs) depends only on the length of xs (the same can be said for the length of g(xs), but this follows from parametricity applied to the source language). For any $\rho$, let us define $T_\rho(xs) =(([\![{\|g\|}]\!]{}\,\langle\langle\rho\rangle\rangle)_p(xs))_c$, the exact cost of evaluating g(xs) (since $\|\cdot\|$ is a monadic translation and the interpretation of inductive types is the standard one, syntactic values of list type in the source language are isomorphic to the semantic values in the model). The goal is to show that if $xs : \rho\mathtt{list}$ and $ys : \sigma\mathtt{list}$ are of the same length, then $T_\rho(xs) =T_\sigma(ys)$. To do so, we apply parametricity to ${\lambda\hskip-.32em\lambda} \rho.{\lambda\hskip-.32em\lambda} xs.T_\rho(xs) \in A^{\forall \rho.\rho\mathtt{list} \to \textsf{C}}$. We take the relational interpretation of $\textsf{C}$ to be equality (so the cost constants 0 and $+$ preserve the relation). Expanding the definition of parametricity, this means that for any $\rho$ and $\sigma$ and relation $R \subseteq A^{\langle\langle\rho\rangle\rangle}\times A^{\langle\langle\sigma\rangle\rangle}$, for any $xs \in A^{{\langle\langle\rho\rangle\rangle}\textsf{list}}$ and $ys \in A^{\langle\langle\sigma\rangle\rangle\textsf{list}}$, if $R\textsf{list}\subseteq A^{{\langle\langle\rho\rangle\rangle}\textsf{list}}\times A^{\langle\langle\sigma\rangle\rangle\textsf{list}}$ holds for xs and ys, then the relational interpretation of $\textsf{C}$ holds for $T_\rho(xs)$ and $T_\sigma(ys)$. Since the relational interpretation of the cost type is equality, this would give the result, so it suffices to show that there is an R such that $(R\textsf{list})(xs,ys)$ holds whenever xs and ys have the same length. However, the standard relational lifting $R\textsf{list}$ holds whenever xs and ys have the same length and $xs_i$ is related to $ys_i$ by R, so taking R to be the total relation achieves this. We conclude that if xs and ys have the same length, then the cost of g(xs) and g(ys) is the same.

7.2 Constructor size and height

We now describe a model in which a value v of inductive type $\delta$ is interpreted either by the number of $\delta$ constructors in v (constructor size) or by the maximum nesting depth of $\delta$-constructors in v (constructor height), so that it reflects common size abstractions such as list length, tree size, and tree height. For example, in this model, the interpretation of the recurrence extracted from a function with domain $\sigma\textsf{list}$ describes the cost in terms of the length of the argument list. For concreteness we will define the constructor size model. For the interpretation of the types, we will need two versions of the natural numbers: $\mathbf{N}_0^\infty = \{0,1,\dots,\infty\}$ for costs, and $\mathbf{N}_1^\infty = \{1,2,\dots,\infty\}$ for sizes of inductive values, which must be at least 1 because every value contains at least one constructor. $\mathbf{N}_i^\infty$ is ordered by $x\leq_{\mathbf{N}_i^\infty} y$ if $y=\infty$ or $x\leq_\mathbf{N} y$. The presence of $\infty$ may be perplexing, since all programs in the source language terminate. However, it is not always possible to give a finite upper bound on cost or potential in terms of the potential of the argument, because the notion of potential used in this model may not identify all possible sources of recursive calls. For example, consider the function $\mathtt{sumtree}$ defined in Figure 22 that sums the nodes of a $\mathtt{nat tree}$. The cost and size of $\mathtt{sumtree}\,t$ depend on the size of t and the sizes of its labels, whereas in this model, the potential of t only tells us the former. Since $\mathtt{sumtree}$ is definable in our source language, its recurrence can be extracted, and hence must have a meaning in this model; the only sensible interpretation is one that maps every tree size to the trivial upper bound of $\infty$ for both cost and potential.

Fig. 21. Binary search tree membership and its extracted recurrence.

Fig. 22. A function that sums the nodes of a $\mathtt{nat tree}$.

We start by extending the standard type frame with additional small types $\mathbf{N}_0,\mathbf{N}_1\in\mathbf{U}_{sm}$. Then we define the sets $V^\tau$, observing that each $V^\tau$ is a complete upper semi-lattice. This allows us to construct a model by just defining $\underline{\mathrm{C}}_{F}$. The sets $V^\tau$ are defined as follows:

• • $V^{\mathbf{N}_i} = \mathbf{N}_i^\infty$.

• • $V^\textsf{C} = \mathbf{N}_0^\infty$ with the standard interpretations for $\underline{0}$ and $\underline{+}$, where $x\mathbin{\underline{+}}\infty =\infty\mathbin{\underline{+}}x = \infty$.

• • $V^\textsf{unit} = \{*\}$.

• • $V^{{\sigma_0}\to{\sigma_1}} =$ the set of monotone functions from $V^{\sigma_0}$ to $V^{\sigma_1}$ with the usual pointwise order, taking $\underline{Abs}$ and $\underline{App}$ to be the identity functions.

• • $V^{{\sigma_0}\times{\sigma_1}} =V^{\sigma_0}\times V^{\sigma_1}$ with the usual component-wise order, taking $\underline{\mathrm{Pair}}$ and $\underline{\mathrm{Proj}}$ to be the standard pairing and projection functions.

• • $V^{{\sigma_0}+{\sigma_1}} =\mathcal{O}(V^{\sigma_0}\sqcup V^{\sigma_1})$, which we define in Section 7.2.1.

• • $V^{\mu t F} = \mathbf{N}_1^\infty$. We define $\underline{\mathrm{C}}_{F}$ in Section 7.2.2 (recall that we write $\underline{\mathrm{C}}_{F}$ for $\underline{\mathrm{C}}_{{\lambda\hskip-.32em\lambda} V.[\![ F]\!] \{V/t\}}$, etc., and that we can define $\underline{\mathrm{D}}_F$ and $\underline{\mathrm{Fold}}_{F,\sigma}$ from it).

• • $V^{\forall\alpha.\tau} =\prod_{\sigma\in\mathbf{U}_{sm}}V^{\tau\{\sigma\alpha\}}$, with the pointwise order, taking $\underline{TyAbs}$ and $\underline{TyApp}$ to be the identity functions.

Once we define the interpretation of sums and datatypes, it is straightforward to verify that this is a model.

7.2.1 Interpretation of sums

As we observed, we need to ensure that all the sets $V^\sigma$ are complete upper semi-lattices. Preserving the complete upper semi-lattice property is straightforward for all type constructors except sum. We could take the usual disjoint sum along with a new infinite element $\infty$ that is a common upper bound of elements on both sides, but that ends up leading to very weak bounds in practice. For example, recall that $\underline{\mathrm{D}}_{\sigma\textsf{list}}(2)$ should tell us about the data that can be used to construct a list of size $\leq 2$ (which is a $\textsf{cons}$ list, because we count the number of $\textsf{c}_{\sigma\textsf{list}}$ constructors, so $\textsf{nil}$ has size 1). If we were to interpret sums as just proposed, both $\underline{\mathrm{Inj}}^0(*)$ and $\underline{\mathrm{Inj}}^1(a, 0)$ are such values, and their least upper bound would be $\infty$. It is not hard to parlay this into an argument that if $\mathtt{tail} = \lambda{xs}.{\mathtt{case}{xs} \mathtt{of} {x}.{\mathtt{nil}}; {x}.{\pi_1 x}}$ is the usual tail function on $\sigma\mathtt{tree}$, then the recurrence extracted from $\mathtt{tail}$ gives a bound of $\infty$ for all lists of length $>1$. While correct, this is hardly satisfying!

Instead, we take inspiration from abstract interpretation (Cousot & Cousot Reference Cousot and Cousot1977): we will define $\underline{\mathrm{D}}_F(n)$ to be the set of values x such that $\underline{\mathrm{C}}_{F}(x)\leq n$. We can arrange this for the typical cases of interest (i.e., finitary inductive datatypes such as lists and trees) by defining $V^{{\sigma_0}+{\sigma_1}}$ to be the downward closed subsets of $V^{\sigma_0}\sqcup V^{\sigma_1}$. We could arrange this for all inductive datatypes if we were to do something similar in the interpretation of arrows and products, but that entails some additional notational cost in reasoning about extracted recurrences while providing no benefits for the examples that we present. We start with some standard order-theoretic and set-theoretic definitions:

• • For any partially ordered set A, the order ideal of A is

  \[\mathcal{O}(A) =_{df}\{X\subseteq A\}{\text{$x\in X$ and $y\leq x$}\Rightarrow y\in X}.\]
  $\mathcal{O}(A)$ is partially ordered by set inclusion and is a complete upper semi-lattice; concretely, if $X\subseteq\mathcal{O}(A)$, then $\bigvee X = \bigcup X$.

• • For any $X\subseteq A$, $X\subseteq A,\downarrow^{A} X= \{x\in A\}|{\exists y\in X.x\leq y}\in\mathcal{O}(A)$ and for $a\in A$, $\downarrow^{A} a = \downarrow^{\{a\}}$ (we drop the superscript when it is clear from context).

• • For any $f : A \to B$ and $X\subseteq A$, $f[X] = \{f(x)\}{x\in X}$.

• • If $X_0$ and $X_1$ are partially ordered sets, $X_0\sqcup X_1$ is the usual disjoint union with injection functions $\mathrm{in}^{i}:X_i\to X_0\sqcup X_1$ partially ordered by $x\leq y$ iff $x = \mathrm{in}^{i}(x')$, $y = \mathrm{in}^{i}(y')$, and $x'\leq_{X_i} y'$.

For the interpretation of sums, we define $V^{{\sigma_0}+{\sigma_1}} =\mathcal{O}(V^{\sigma_0}\sqcup V^{\sigma_1})$ with the semantic functions defined by

\begin{align*}\underline{\mathrm{Inj}}^i(x) &= \mathrm{in}^{i}[\downarrow^{V}{^{\sigma_i}} x] = [\downarrow^{V}{^{\sigma_0}}\sqcup V^{\sigma_1}](\mathrm{in}^{i}(x)) \\\underline{\mathrm{Case}}(X_0\sqcup X_1, f_0, f_1) &= \bigvee f_0[X_0] \vee \bigvee f_1[X_1]\end{align*}

Lemma 8 $\underline{\mathrm{Case}}(\underline{\mathrm{Inj}}^i(x), f_0, f_1) \geq f_i(x)$.

Proof.

\begin{align*}\underline{\mathrm{Case}}(\underline{\mathrm{Inj}}^i(x), f_0, f_1) &= \underline{\mathrm{Case}}(\mathrm{in}^{i}[\downarrow x]\sqcup\emptyset, f_0, f_1) \\ &= \bigvee f_i[\downarrow x] \vee \bigvee f_{1-i}[\emptyset] \\ &= \bigvee f_i[\downarrow x] \\ &\geq f_i(x) & & (x\in\downarrow x).\end{align*}

Note that $\mathcal{O} A$ is a monad on the category of partially ordered sets and monotone functions, with unit $A \to \mathcal{O} A$ given by $\downarrow^A$, and multiplication $\mathcal{O} {\mathcal{O} A} \to\mathcal{O} A$ given by union, and it plays the role of a powerset monad on posets (the ordinary powerset operation, without the additional downward closure requirement, does not have a monotone function $A \to \mathcal{P}(A)$, because $x \leq_A y$ does not imply that $\{x\}\subseteq\{y\}$. When a partially ordered set is a complete upper semilattice (i.e. supports the maximum operation that we use to interpret the recursor), it is an algebra for this monad, i.e. there is a monotone function $\mathcal{O} A \to A$, satisfying some equations. Thus, another way of understanding these models is that, for functions and products, we build algebras $\bigvee_{A\to B} : \mathcal{O}(A \to B) \to (A \to B)$ and $\bigvee_{A\times B} : \mathcal{O}(A \times B) \to A \times B$ from algebra structures $\bigvee_{A} : \mathcal{O} A\to A$ and $\bigvee_B : \mathcal{O} B \to B$, but for sums, we use the free algebra $\mathcal{O}(A + B)$, with $\bigvee_{\mathcal{O}(A + B)} :\mathcal{O}{\mathcal{O} (A + B)} \to \mathcal{O}{(A+B)}$ given by union.

7.2.2 Semantic functions for inductive datatypes

We define $\underline{\mathrm{C}}_{F}$ by first defining a function $\underline{\mathrm{size}}_{F} : V^{[F {\mu t.F}]}\to \mathbf{N}_0^\infty$. For $\delta = \mu t F$, a semantic value of type ${F[{\mu t.F}]}$ represents the data from which a value of type $\delta$ is constructed, but with the inductive substructures replaced by their sizes, and $\underline{\mathrm{size}}_{F}$ returns the size of the inductive value constructed from that data.

\[\begin{aligned}[t]\underline{\mathrm{size}}_{t}(n) &= n \\\underline{\mathrm{size}}_{\sigma}(x) &= 0\end{aligned}\qquad\begin{aligned}[t]\underline{\mathrm{size}}_{{F_0}+{F_1}}{}(X_0\sqcup X_1) &= \bigvee\underline{\mathrm{size}}_{F_0}[X_0]\vee\bigvee\underline{\mathrm{size}}_{F_1}[X_1] \\\underline{\mathrm{size}}_{{F_0}\times{F_1}}(a_0, a_1) &= \underline{\mathrm{size}}_{F_0}{}(a_0) + \underline{\mathrm{size}}_{F_1}(a_1) \\\underline{\mathrm{size}}_{{\sigma}\to{F}}(g) &= \sum\{\underline{\mathrm{size}}_{F}(g\,x)\}{x\in V^\sigma}\end{aligned}\]

For the constructor height model, define a function $\underline{\mathrm{height}} F$ analogously, replacing the sums in the product and arrow shapes with maximums. The semantic constructor and destructor are then defined by

\[\underline{\mathrm{C}}_{F}(a) = 1 + \underline{\mathrm{size}}_{F}(a)\qquad\underline{\mathrm{D}}_F(n) = \bigvee\{a\}{\underline{\mathrm{C}}_{F}\,a \leq n}.\]

To use (std-fold), it suffices to verify the conditions of Proposition 3, which is trivial, so we have

\[\underline{\mathrm{Fold}}_{F,\sigma}\,s\,x =\bigvee\{s\bigl(F_{\delta,\sigma}(\underline{\mathrm{Fold}}_{F,\sigma}\,s)z\bigr)\} {1 + \underline{\mathrm{size}}_{F}(z) \leq x}.\]

7.2.3 Examples: lists and trees

Referring to Figure 10,

It is not hard to see that $[\![{\_\vdash t {\sigma\textsf{tree}}}]\!]{} = 2n + 1$, where n is the usual size of t (i.e., $[\![{\_\vdash t {\sigma\textsf{tree}}}]\!]{}$ is the number of internal and external nodes of t). Since this is linear in the usual notion of size of a tree, it suffices for showing that the recurrences that we extract have the expected O-behavior.

Destructors exhibit the desired behavior; consider $\sigma\textsf{list}$ again:

\begin{align*}\underline{\mathrm{D}}_{F_{\sigma\textsf{list}}}(x) &= \begin{cases} \{*\}\sqcup\emptyset,&x=1 \\ \{*\}\sqcup\{(a, x')\} {a\in V^\sigma, 1+x'\leq x},&2\leq x \leq \infty \end{cases} \\ &= \{*\}\sqcup (V^\sigma\times \downarrow^{\mathbf{N}_1^\infty}(x-1))\end{align*}

where we define $\downarrow^{\mathbf{N}_1^\infty}0 = \emptyset$. In other words, a list of size 1 must be $\mathtt{nil}$ and a list of length at most x is either $\mathtt{nil}$ or $\mathtt{cons}(x, xs)$, where xs has length at most $x-1$. Remember that $V^{F {[\sigma\textsf{list}]}} =\mathcal{O}(\{*\}\sqcup (V^\sigma\times\mathbf{N}_1^\infty))$, so if $\mathrm{in}^{l}(a, x)\in X\in V^{F{[\sigma\textsf{list}]}}$, then $x\geq 1$; that is why $\underline{\mathrm{D}}_{F_{\sigma\textsf{list}}}(1)\not=\{*\}\sqcup X$ with $X\not=\emptyset$. For $\sigma\textsf{tree}$, the result is equally pleasant:

\[\underline{\mathrm{D}}-{F_{\sigma\textsf{tree}}}(x) =\begin{cases}\{*\}\sqcup\emptyset,&x=1 \\\{*\}\sqcup\{(a, x_0, x_1)\} {a\in V^\sigma, 1+x_0+x_1\leq x},&2\leq x \leq \infty\end{cases}\]

Finally, we observe the following simple forms for the denotation of recurrences over lists and trees:

Proposition 7.

1. 1. If $f\,n=[\![\textsf{fold}_{\sigma\textsf{list}}y\textsf{of}\{\textsf{nil}\Rightarrow e_{\textsf{nil}}|\textsf{cons}\Rightarrow(x,r).e_{\textsf{cons}}\}]\!]\eta\{y\mapsto n\}$, then in the constructor size and height models,

   \begin{align*}f\,1 &= [\![{e_\textsf{nil}}]\!]\eta \\f\,n &= [\![{e_\textsf{nil}}]\!]\eta \vee \bigvee\{[\![{e_\textsf{cons}}]\!] \eta \{x, r\mapsto \infty^\sigma, f\,n' \}| \}|{n' < n} \\ &= [\![{e_\textsf{nil}}]\!]\eta \vee [\![{e_\textsf{cons}}]\!] \eta \{x, r\mapsto \infty^\sigma, f(n-1)\} & & (n > 1).\end{align*}
   The second form for $f\,n$, $n>1$, follows from monotonicity of the denotation function.

2. 2. If $f\,n=[\![\textsf{fold}_{\sigma\textsf{tree}}y\textsf{of}\{\textsf{emp}\Rightarrow e_{\textsf{emp}}|\textsf{node}\Rightarrow(x,r_0,r_1).e_{\textsf{node}}\}]\!]\eta\{y\mapsto n\}$, then in the constructor size model,

   \begin{align*}f\,1 &= [\![{e_\textsf{emp}}]\!]\eta \\f\,n &= [\![{e_\textsf{emp}}]\!]\eta \vee \bigvee\{[\![{e_\textsf{node}}]\!] \eta \{x, r_0, r_1\mapsto \infty^\sigma, f\,n_0, f\,n_1 \} \}{n_0+n_1 < n} & & (n > 1).\end{align*}
   In the constructor height model, replace $n_0+n_1 < n$ with $n_0\vee n_1 < n$.

Proof. The verification is a moderately tedious calculation; here, it is for (2) with $n>1$. Let

Observe that $f = \underline{\mathrm{Fold}}\,s$ and let us write $\underline{\mathrm{Map}}$ for $([\![{F_{\sigma\textsf{tree}}}]\!]{\eta})_{[\![{\sigma\textsf{tree}}]\!]\eta,[\![\rho]\!]\eta}$. By definition, we have $ f{\mkern 1mu} n = \bigvee \{ s(\underline {{\rm{Map}}} {\mkern 1mu} f{\mkern 1mu} (Z \sqcup X))|\underline {\rm{C}} (Z \sqcup X) \le n\} $. By monotonicity, we need only consider $Z = \{*\}$, and by definition of $\underline{\mathrm{C}}$, we need only consider nonempty sets X such that $(\underline{~}, n_0, n_1)\in X$ implies $n_0+n_1 < n$, so

Let us write the last equation as

First, let us show that for any X such that $(\underline{~},n_0,n_1)\in X\Rightarrow n_0+n_1 < n$, $A_X\subseteq\downarrow B$, from which we conclude that $\bigvee A_X\leq\bigvee B$, and hence $L\leq R$. For any such X, take $(b, k_0, k_1)$ such that there is $(a, n_0, n_1)\in X$ with $(b, k_0, k_1)\leq (a, f\,n_0, f\,n_1) \leq(\infty,f\,n_0, f\,n_1)$. By Proposition 6, $[\![{e_\textsf{node}}]\!]{\eta\{x,r_0,r_1\mapsto b,k_0,k_1\}} \leq[\![{e_\textsf{node}}]\!]{\eta\{x,r_0,r_1\mapsto\infty,f\,n_0,f\,n_1\}}$. Since $(b, k_0, k_1)$ was chosen arbitrarily, $A_X\subseteq\downarrow B$, as needed. To show that $R\leq L$, suppose that $n_0+n_1<n$. Then $[\![{e_\textsf{node}}]\!]{\eta\{x,r_0,r_1\mapsto\infty,f\,n_0,f\,n_1\}} \in A_{\downarrow(\infty,n_0, n_1)}$, from which $R\leq L$ follows. ■

Although we will primarily use Proposition 7, it may be instructive to work through an example of explicitly constructing $\underline{\mathrm{Fold}}_{F,\rho}$ from the proof of Proposition 3. Consider $F = \textsf{unit} +t$ (the structure functor for $\textsf{nat}$) and set $s(x) = \underline{\mathrm{Case}}(x, {\lambda\hskip-.32em\lambda} u.1, {\lambda\hskip-.32em\lambda} u.1+x)$. s might be the step function for the recurrence that describes the cost of the copy function on $\mathtt{nat}$. Define Q as in the proof of Lemma 3. In this setting, the bottom element at which we start iterating Q is the function that is constantly 0. Set $f_0 = Q\,\bot$ and $f_{n+1} = Q\,f_n$. Just as in the calculation of $\underline{\mathrm{D}}_{F_{\sigma\textsf{list}}}$,

\[\underline{\mathrm{D}}{F_\textsf{nat}}(x) =\begin{cases}\{*\}\sqcup\emptyset,&x=1 \\\{*\}\sqcup\{x'\}{1+x'\leq x},&2\leq x\end{cases}\]

and so a bit more calculation shows that

\[f_k(n) =\begin{cases}n,& n\leq k+1 \\k+1,& n>k+1.\end{cases}\]

It is not hard to see that $f_{\omega(n)} = n$ is a fixed point of Q, so we conclude that $[\![\mathsf{fold_{nat}}x \mathsf{of} \{Z\Rightarrow 1\mid\mathsf{S}\Rightarrow r.\mathsf{S}r\}]\!]{{x\mapsto n}} = n$.

Of course, this is precisely what we expect, though for readers familiar with how a typical recursive function on numbers is defined by successive approximations, the route may feel a bit different. Usually when defining a recursive function on numbers, one takes the flat order and starts with the everywhere-undefined function. For a typical total function, the kth approximation is a partial function that is defined and correct on some initial segment of the natural numbers and undefined elsewhere. Here we take the (more-or-less) standard order and start with a function that is everywhere an unlikely bound (namely, 0). Each successive approximation yields a function with more likely bounds, terminating with a (hopefully low but) correct bound. In the case of a partial recursive function, the “bad” case is that the function is not defined for some numbers (the value of the approximants never gets above $\bot$). In our setting, the “bad” case is that the bound is infinite (the value of the approximants never stops growing). The reader may wish to compare this with the use of $\mathbf{N}_0^\infty$ by Rosendahl (Reference Rosendahl1989), where $\infty$ corresponds to the bottom element in the usual CPO semantics for fixpoints. We return to this in Section 8 when we discuss general recursion.

7.2.4 Example: tree copy

For a first “sanity check,” let us analyze the tree copy function that is defined in Figure 20. We will also describe some of the main features in the analysis that are typical of all of our examples. The first is that a source language program $e = \lambda{x,y,z}{e'}$ extracts to a recurrence of the form $(0, \lambda x.(0, \lambda y.(0, \lambda z.\|e'\|)))$. However, we are really only interested in $\|e'\|$ as a function of the potentials x, y, and z. Accordingly, when analyzing a program such as e, we focus on the recurrence language program $\lambda{x,y,z}{\|e'\|}$. Here, this means we will analyze the (denotation of the) recurrence $\textsf{copy}_{\sigma\textsf{tree}}$ that is also shown in Figure 20. Second, we shall use Proposition 5 freely as though it is a theorem about the syntax when we write our examples. Third, in our examples, we typically use the identifier r in syntactic recurrences for a recursive call to the computation of a complexity, and hence $r_p$ and $r_c$ correspond to recursive calls that compute potential and cost, respectively. Finally, we remind the reader that our goal is to show that the semantic recurrences are essentially the same as those that we expect to arise from an informal analysis, and so we make no attempt to solve them.

The analysis for $\mathtt{copy}_{\sigma\mathtt{tree}}$ proceeds as follows. Define $T(n) = ([\![{\textsf{copy}_{\sigma\textsf{tree}}}]\!]{}(n))_c$. Following the definition of the denotation function and using Proposition 7 and facts about $\vee$ and $\bigvee$ in the semantics, we have

\[T(1) = 1\qquad\begin{aligned}[t]T(n) &= 1 \vee \bigvee\{1 + T(n_0) + T(n_1)\}{n_0+n_1<n} \\ &= \bigvee\{1 + T(n_0) + T(n_1)\}{n_0+n_1<n}\end{aligned}\]

and we obtain a similar recurrence for $S(n) = ([\![{\textsf{copy}_{\sigma\textsf{tree}}}]\!]{}(n))_p$. We observe that these are precisely the expected recurrences from an informal analysis which, if one is careful, must consider all possible combinations of subtree sizes when computing the cost or size of the result when the argument tree has size n.

7.2.5 Example: binary search tree membership

For an interesting example, let us consider membership testing in $\sigma$-labeled binary search trees. First, we define the type

\[\mathtt{order} = {\mathtt{unit}+\mathtt{unit}}+\mathtt{unit}\]

and write $\mathtt{case}\,e\,\mathtt{of}\,\mathtt{LT}.{e_0}; \mathtt{EQ}.{e_1};\mathtt{GT}.{e_2}$ for $\mathtt{case}^\mathtt{order}\,e\,\mathtt{of}\,x.e_0; x.e_1; x.e_2$, and we assume comparable notation in the recurrence language. The membership test function is given in Figure 21.

Let us consider an informal analysis of $\mathtt{mem}$, which is somewhat simpler to describe in reference to the $\mathtt{member}$ function of Figure 8(a). Let T(h) be the number of calls to $\mathtt{member}$ in terms of the height of t. We would probably argue that $T(1) = 1$ and for $h>1$,

\[T(h) \leq \underbrace{1}_{\text{the call to $\mathtt{member}$}} +\underbrace{\bigvee\{0, T(h_0), T(h_1)\}}_{\text{cost of a $\mathtt{case}$ isbounded by the costs of its branches}},\]

where $h_0, h_1 < h$. But since the only information we have is that $t_0$ and $t_1$ are subtrees of some tree t of height h, what we must really mean is that

$T(h) \le 1 + \bigvee \{ 0,T({h_0}),T({h_1})|{h_0} \vee {h_1} < h\} ,$

so this is the recurrence we expect to see in a formal analysis.

Taking the same approach as in the previous section, we analyze the recurrence $\textsf{mem}$ given in Figure 21, this time considering its denotation in the constructor height model. The extracted recurrence makes explicit the dependence of the complexity of $\mathtt{mem}$ on the complexity of the comparison function cmp. Of course, a typical analysis will make assumptions about this complexity. The most common such (and the one we implicitly made in our informal analysis) is that the cost of the comparison function is independent of the size of its arguments, which we can model here by assuming that $(cmp(x,y))_c$ for all x and y (more precisely, we only analyze $[\![{\textsf{mem}}]\!]{}\,cmp$ under the assumption that cmp satisfies this condition). Define $T(h) = ([\![{\textsf{mem}}]\!]\,cmp\,h\,x)_c$ and assume that $cmp(x, \infty) = A\sqcup B\sqcup C$. Then making use of Proposition 7,

Again, we have essentially the same recurrence as given by the informal analysis. The last inequality is valid because A, B, and C are all subsets of $\{*\}$, and hence are either $\emptyset$ or $\{*\}$ itself, and we take advantage of the fact that $\bigvee\!\emptyset = 0$. The comparison with $\infty$ might be a bit perturbing. In this model, the labels do not contribute to the potential of a tree. Since the comparison in the recurrence arises from the comparison of x with an arbitrary node label y, the best we can say about the potential of y is that it is at most $\infty$. For another perspective, keep in mind that cmp is monotone, so unless it is a particularly odd function, $cmp(x,\infty) = \{*\}\sqcup\{*\}\sqcup\{*\}$, which forces the recurrence to take all possible outcomes into account. This is precisely what we would expect in an informal analysis.

7.3 Counting all constructors

The cost of some functions cannot be usefully described in terms of the “usual” notion of size captured by the model $\mathbf{V}$ of the previous section. For example, to usefully analyze the $\mathtt{sumtree}$ function of Figure 22, we need a model in which the size of a $\textsf{nat tree}$ value measures both the number of $\textsf{nat tree}$ constructors and the number of $\textsf{nat}$ constructors. In this section, we give an example of how to construct such a model. In it, a value v of inductive type is interpreted by a function $\phi$ such that $\phi(\delta)$ is the size of the largest maximal subtree of v that contains only $\delta$-constructors. For $v : \textsf{nat tree}$, this means that $[\![ v]\!] {}(\textsf{nat tree})$ is the usual size of v, $[\![ v]\!] {}(\textsf{nat})$ is the maximum label size of v, and $[\![ v]\!] {}(\delta) = 0$ for $\delta\notin\{\textsf{nat tree},\textsf{nat}\}$.

Because we want to distinguish between constructors for different inductive types, it is convenient to use the following alternative grammar for types and structure functors, which just spells out the closed-type production for structure functors:

\[\begin{aligned}\sigma &::= \alpha \mid \textsf{C} \mid \textsf{unit} \mid \sigma+\sigma \mid \sigma\times\sigma \mid \sigma\to\sigma \mid \mu t F \\F &::= t \mid \alpha \mid \textsf{C} \mid \textsf{unit} \mid \mu t F \mid F + F \mid F \times F \mid \sigma \to F.\end{aligned}\tag{$*$}\]

The content of the next proposition is just that the grammar ($*$) defines the same words as that of Figure 9.

The type frame is the same as for the constructor-counting model of Section 7.2; for the current model, we write $W^\sigma$ for the interpretation of $\sigma$. Except for inductive types, the clauses for $W^\sigma$ are the same as those for $V^\sigma$ from Section 7.2. Set $\mathcal D = \{\mu t F\}{\text{{F} closed}}$ and

• • $W^{\mu t F} = \{\phi \in D \to \mathbf{N}_0^\infty\} {\phi(\mu t F) \geq 1, \delta\text{not a syntactic subtype of F}\Rightarrow \phi(\delta) = 0}$.

To define $\underline{\mathrm{C}}_{F}$ and $\underline{\mathrm{D}}_{F}$, we define $\underline{\mathrm{size}}_{F,\delta} : W^{F[\delta]}\to (\mathcal D\to\mathbf{N}_0^\infty)$ similarly to the previous section. The additional subscript enables us to track which datatype is the “main” datatype, as the counting is different for products for the main datatype and others. The definition is as follows:

\[\begin{aligned}[t]\underline{\mathrm{size}}_{t,\delta}(\phi) &= \phi \\\underline{\mathrm{size}}_{\textsf{C},\delta}(x) &= {\lambda\hskip-.32em\lambda}\delta.0 \\\underline{\mathrm{size}}_{\textsf{unit},\delta}(*) &= {\lambda\hskip-.32em\lambda}\delta.0 \\\underline{\mathrm{size}}_{\mu t F,\delta}(\phi) &= \phi\end{aligned}\;\;\;\begin{aligned}[t]\!\!\!\!\underline{\mathrm{size}}_{{F_0}+{F_1},\delta}(X_0\sqcup X_1) &= \bigvee\underline{\mathrm{size}}_{F_0,\delta}[X_0] \vee \bigvee\underline{\mathrm{size}}_{F_1,\delta}[X_1] \\\underline{\mathrm{size}}_{{F_0}\times{F_1},\delta}(x_0, x_1) &= {\lambda\hskip-.32em\lambda}\delta'. \begin{cases} \underline{\mathrm{size}}_{F_0,\delta}(x_0)(\delta') + \underline{\mathrm{size}}_{F_1,\delta}(x_1)(\delta'), &\delta' = \delta \\ \underline{\mathrm{size}}_{F_0,\delta}(x_0)(\delta') \vee \underline{\mathrm{size}}_{F_1,\delta}(x_1)(\delta'), &\delta' \not= \delta \\ \end{cases} \\\underline{\mathrm{size}}_{\sigma\to F,\delta}(f) &= {\lambda\hskip-.32em\lambda}\delta'. \begin{cases} \sum\{\underline{\mathrm{size}}_{F,\delta}(f\,x)(\delta')\}{x\in D^\sigma}, &\delta' = \delta \\ \bigvee\{\underline{\mathrm{size}}_{F,\delta}(f\,x)(\delta')\}{x\in D^\sigma}, &\delta' \not= \delta \\ \end{cases}\end{aligned}\]

Set

\[\underline{\mathrm{C}}_{F}(a) = {\lambda\hskip-.32em\lambda}\delta. \chi_F(\delta) + \underline{\mathrm{size}}_{F,\mu t F}(a)(\delta)\qquad\underline{\mathrm{D}}_{F}(\phi) = \bigvee\{a\}{\underline{\mathrm{C}}_{F}(a)\leq\phi}\]

where $\chi_F(\delta) = 1$ if $\delta=\mu t F$, $\chi_F(\delta) = 0$ otherwise. Notice that for $\delta = \mu t F$, $\underline{\mathrm{C}}_{F}(a)(\delta) =1 + \underline{\mathrm{size}}_{F,\delta}(a)(\delta) \geq 1$, so $\underline{\mathrm{C}}_{F}(a)\in W^\delta$. $\textsf{fold}_\delta$ is interpreted by (std-fold) as usual.

7.3.1 Example: the potential of ${\textsf{nat tree}}$

Although we could prove a general theorem to show that $\underline{\mathrm{size}}_{F,\delta}$ encapsulates the description given above, seeing the details of the specific case of $\textsf{nat tree}$ is more illuminating. To start, some notation is helpful: set $\phi^\textsf{nat}_n\in W^\textsf{nat}$ and $\phi^{\textsf{nat tree}}_{n,k}\in W^{\textsf{nat tree}}$ to be the functions

\[\begin{aligned}[t]\phi^\textsf{nat}_n(\textsf{nat}) &= n \\\phi^\textsf{nat}_n(\underline{~}) &= 0\end{aligned}\qquad\begin{aligned}[t]\phi^{\textsf{nat tree}}_{n,k}(\textsf{nat}) &= n \\\phi^{\textsf{nat tree}}_{n,k}({\textsf{nat tree}}) &= k \\\phi^{\textsf{nat tree}}_{n,k}(\underline{~}) &= 0\end{aligned}\]

First we start with a useful lemma:

Lemma 9 $[\![ \textsf{S}]\!] {}(\phi) = \chi_{F_\textsf{nat}} + \phi$, and in particular, $[\![\textsf{S}]\!]{}(\phi^\textsf{nat}_k) = \phi^\textsf{nat}_{k+1}$.

Proof.

\begin{multline*}[\![{\textsf{S}}]\!]{}(\phi) = \chi_{F_\textsf{nat}} + \underline{\mathrm{size}}_{F_\textsf{nat},\textsf{nat}}(\underline{\mathrm{Inj}}^1(\phi)) = \chi_{F_\textsf{nat}} + \underline{\mathrm{size}}_{F_\textsf{nat},\textsf{nat}}(\emptyset\sqcup\downarrow\phi) = \\ \chi_{F_\textsf{nat}} + \left(\bigvee\underline{\mathrm{size}}_{t,\textsf{nat}}[\downarrow\phi]\right) = \chi_{F_\textsf{nat}} + \left(\bigvee(\downarrow\phi)\right) = \chi_{F_\textsf{nat}} + \phi.\end{multline*}

■

Now set $\textsf{n} = \textsf{S}(\dotsc(\textsf{S}\,\textsf{Z})\dotsc) \mathbin:\textsf{nat}$ (n $\textsf{S}$s). We will show that $[\![{\textsf{n}}]\!]{} = \phi^\textsf{nat}_{n+1}$ by induction on n. For $n=0$,

\begin{multline*}[\![{\textsf{0}}]\!]{} = \underline{\mathrm{C}}_{F_\textsf{nat}}(\underline{\mathrm{Inj}}^0 *) = \underline{\mathrm{C}}_{F_\textsf{nat}}(\{*\}\sqcup\emptyset) = \\ \chi_{F_\textsf{nat}} + \underline{\mathrm{size}}_{F_\textsf{nat},\textsf{nat}}(\{*\}\sqcup\emptyset) = \chi_{F_\textsf{nat}} + ({\lambda\hskip-.32em\lambda}\delta.0) = \chi_{F_\textsf{nat}} = \phi^\textsf{nat}_1.\end{multline*}

And for $n\geq 0$, we use Lemma 9 to show that

\[[\![{\textsf{n+1}}]\!]{} = ([\![{\textsf{S}}]\!]{}\,[\![{\textsf{n}}]\!]{}) = [\![{\textsf{S}}]\!]{}(\phi^\textsf{nat}_{n+1}) = \phi^\textsf{nat}_{n + 2}.\]

Now let us consider closed $\textsf{nat tree}$ expressions built up using only $\textsf{nat tree}$ and $\textsf{nat}$ constructors—i.e., $\textsf{nat}$-labeled binary trees. We show that if t is such a tree, then $[\![{t}]\!]{} = \phi^{\textsf{nat tree}}_{m,k}$, where $m =\bigvee\{1+n\}{\text{{n} a label in {t}}}$ and k is the number of ${\textsf{nat tree}}$ constructors in t. In the following calculations, we will save a bit of space by writing $\underline{\mathrm{size}}_{F}$ for $\underline{\mathrm{size}}_{F,\textsf{nat tree}}$. For $\textsf{emp}$, the argument is essentially the same as for the analysis of $[\![{\textsf{0}}]\!]{}$, noting that $\bigvee\{1+n\mid\,n\,\text{a label in} \textsf{emp}\}=\bigvee\emptyset=0 $ For the inductive step, assume that $[\![{t_i}]\!]{} = \phi^{\textsf{nat tree}}_{n_i,k_i}$, so our goal is to show that $[\![{\textsf{node}(\textsf{n}, t_0, t_1)}]\!]{} =\phi^{\textsf{nat tree}}_{(n+1)\vee n_0\vee n_1,1+k_0+k_1}$:

\begin{align*}[\![{\textsf{node}(\textsf{n}, t_0, t_1)}]\!]{} &= \underline{\mathrm{C}}_{F_{\textsf{nat tree}}}(\underline{\mathrm{Inj}}^1( [\![{\textsf{n}}]\!]{}, [\![{t_0}]\!]{}, [\![{t_1}]\!]{})) \\ &= \underline{\mathrm{C}}_{F_{\textsf{nat tree}}}( \emptyset\sqcup\downarrow(\phi^\textsf{nat}_{n+1}, \phi^{\textsf{nat tree}}_{n_0,k_0}, \phi^{\textsf{nat tree}}_{n_1,k_1})) \\ &= \chi_{F_{\textsf{nat tree}}} + \underline{\mathrm{size}}_{F_{\textsf{nat tree}}}( \emptyset\sqcup\downarrow(\phi^\textsf{nat}_{n+1}, \phi^{\textsf{nat tree}}_{n_0,k_0}, \phi^{\textsf{nat tree}}_{n_1,k_1})) \\ &= \chi_{F_{\textsf{nat tree}}} + \bigvee\underline{\mathrm{size}}_{\textsf{nat}\times{t\times t}}[ \downarrow(\phi^\textsf{nat}_{n+1}, \phi^{\textsf{nat tree}}_{n_0,k_0}, \phi^{\textsf{nat tree}}_{n_1,k_1}) ].\end{align*}

If $(\phi',\phi_0',\phi_1')\in\downarrow(\phi^\textsf{nat}_{n+1}, \phi^{\textsf{nat tree}}_{n_0,k_0}, \phi^{\textsf{nat tree}}_{n_1,k_1})$, then

\begin{align*}\underline{\mathrm{size}}_{{\textsf{nat}\times{t\times t}}}(\phi',\phi_0',\phi_1')(\delta) &= \begin{cases} \underline{\mathrm{size}}_{\textsf{nat}}(\phi')(\delta) + \underline{\mathrm{size}}_{t}(\phi_0')(\delta) + \underline{\mathrm{size}}_{t}(\phi_1')(\delta), &\delta={\textsf{nat tree}} \\ \underline{\mathrm{size}}_{\textsf{nat}}(\phi')(\delta) \vee \underline{\mathrm{size}}_{t}(\phi_0')(\delta) \vee \underline{\mathrm{size}}_{t}(\phi_1')(\delta), &\delta\not={\textsf{nat tree}} \end{cases} \\ &= \begin{cases} \phi'({\textsf{nat tree}}) + \phi_0'({\textsf{nat tree}}) + \phi_1'({\textsf{nat tree}}), &\delta = {\textsf{nat tree}} \\ \phi'(\delta) \vee \phi_0'(\delta) \vee \phi_1'(\delta), &\delta \not= {\textsf{nat tree}} \end{cases}\end{align*}

and hence the computation of $[\![{\textsf{node}(\textsf{n}, t_0, t_1)}]\!]{}(\delta)$ proceeds as

\begin{align*}{} &= \begin{cases} 1 + \bigvee \Biggl\{ \begin{aligned} &\phi'({\textsf{nat tree}}) + \phi_0'({\textsf{nat tree}}) + \phi_1'({\textsf{nat tree}})\mid \\ &\qquad{(\phi',\phi_0',\phi_1')\in\downarrow(\phi^\textsf{nat}_{n+1},\phi^{\textsf{nat tree}}_{n_0,k_0},\phi^{\textsf{nat tree}}_{n_1,k_1})} \end{aligned} \Biggr\}, &\delta = {\textsf{nat tree}} \\ \bigvee \Biggl\{ \begin{aligned} &\phi'(\delta) \vee \phi_0'(\delta) \vee \phi_1'(\delta)\mid \\ &{(\phi',\phi_0',\phi_1')\in\downarrow(\phi^\textsf{nat}_{n+1},\phi^{\textsf{nat tree}}_{n_0,k_0},\phi^{\textsf{nat tree}}_{n_1,k_1})} \end{aligned} \Biggr\}, &\delta \not= {\textsf{nat tree}} \end{cases} \\ &= \begin{cases} 1 + k_0 + k_1,&\delta = {\textsf{nat tree}} \\ (n+1) \vee n_0 \vee n_1,&\delta = \textsf{nat} \\ 0,&\text{otherwise} \end{cases} \\ &= \phi^{\textsf{nat tree}}_{(n+1)\vee n_0 \vee n_1, 1 + k_0 + k_1}(\delta).\end{align*}

We have simplified descriptions of recurrences that are analogous to those of Proposition 7:

Proposition 9

1. 1. If $f\phi=[\![\mathsf{fold_{nat}}x \mathsf{of} \{\mathsf{Z}\Rightarrow e_Z|\mathsf{S}\Rightarrow r.e_{\mathsf{S}}\}]\!]\eta\{x\mapsto\phi\}$, then

   \[f\,\phi^\mathsf{nat}_1 = [\![{e_\mathsf{Z}}]\!]\eta\qquad\begin{aligned}[t]f\,\phi^\mathsf{nat}_n &= [\![{e_\mathsf{Z}}]\!]\eta \vee \bigvee \{[\![ e_{\mathsf{S}}]\!] \eta\{r\mapsto\phi^{\mathsf{nat}}_{j}\}|j<n\} \\ &= [\![{e_\mathsf{Z}}]\!]\eta \vee [\![{e_\mathsf{S}}]\!] \eta\vee[\![ e_{\mathsf{S}}]\!] \eta\{r\mapsto\phi^{\mathsf{nat}}_{n-1}\} & & (n>1)\end{aligned}\]

2. 2. If $f\,\phi =[\![\mathsf{fold_{nat tree}}x \mathsf{of} \{\mathsf{emp}\Rightarrow e_{\mathsf{emp}}|\mathsf{node}\Rightarrow(x,r_0,r_1).e_{\mathsf{node}}\}]\!]\eta\{x\mapsto\phi\}$, then

   \begin{align*}f\,\phi^{\mathsf{nat tree}}_{n,1} &= [\![{e_\mathsf{emp}}]\!]\eta \\f\,\phi^{\mathsf{nat tree}}_{n,k} &= [\![{e_\mathsf{emp}}]\!]{\eta} \vee \bigvee\!\! { [\![{e_\mathsf{node}}]\!] \eta{ \{x,r_0,r_1\mapsto \phi^\mathsf{nat}_{n'},f\,\phi^{{\mathsf{nat tree}}}_{n_0,k_0}, f\,\phi^{{\mathsf{nat tree}}}_{n_1,k_1}\}} } { n'\vee n_0\vee n_1\leq n, 1 + k_0 + k_1 \leq k } & & \!\!\!(n>1)\end{align*}

7.3.2 Example: summing the nodes of a $\mathtt{nat tree}$

Let us use this model to analyze the function $\mathtt{sumtree} : \mathtt{nat tree}\rightarrow\mathtt{nat}$ that sums the nodes of a $\mathtt{nat tree}$. Its definition is given in Figure 22, along the relevant extracted recurrences. An informal analysis might proceed as follows. Because the cost of $\mathtt{sumtree}$ depends on both the cost and size of the result of $\mathtt{plus}$ as well as the size of the results of the recursive calls, we must extract recurrences for all of these. If $S_\mathtt{plus}(m, n)$ and $T_\mathtt{plus}(m, n)$ are the size of the result and the cost of $\mathtt{plus}(\underline{m-1}, \underline{n-1})$, respectively (recall from Figure 4 that $\underline{n}$ is the source language numeral for n), then an informal analysis yields the recurrences

\[\begin{aligned}[t]S_\mathtt{plus}(1, n) &= n \\S_\mathtt{plus}(m, n) &= 1 + S_\mathtt{plus}(m-1, n)\end{aligned}\qquad\begin{aligned}[t]T_\mathtt{plus}(1, n) &= 1 \\T_\mathtt{plus}(m, n) &= 1 + T_\mathtt{plus}(m-1, n).\end{aligned}\]

Similarly, if $S_\mathtt{st}(n, k)$ and $T_\mathtt{st}(n, k)$ are the size of the result and the cost of $\mathtt{sumtree}(t)$ when t has maximum label size n and size k, we end up with the recurrences

\begin{align*}S_\mathtt{st}(n, 1) &= 1 \\S_\mathtt{st}(n, k) &= \bigvee \{S_\mathtt{plus}(n, S_\mathtt{plus}(S_\mathtt{st}(n, k_0), S_\mathtt{st}(n, k_1)))\} {k_0+k_1 < k}\end{align*}

and

\begin{align*}T_\mathtt{st}(n, 1) &= 1 \\T_\mathtt{st}(n, k) &= \begin{aligned}[t] \bigvee \{ &T_\mathtt{st}(n, k_0) + T_\mathtt{st}(n, k_1) + T_\mathtt{plus}(S_\mathtt{st}(n, k_0), S_\mathtt{st}(n, k_1)) + \\ &\qquad T_\mathtt{plus}(n, S_\mathtt{plus}(S_\mathtt{st}(n, k_0), S_\mathtt{st}(n, k_1))) \mid k_0 + k_1 < k \}. \end{aligned}\end{align*}

To solve these recurrences, one would first use any standard technique to conclude that $S_\mathtt{plus}(m, n) = m+n-1$ and $T_\mathtt{plus}(m, n) = m$ to simplify the recurrence clauses for $S_\mathtt{st}$ and $T_\mathtt{st}$, then establish bounds on the latter by induction. However, the solution of the recurrences is not our focus here, but rather the justified extraction of them.

Now let us turn to our formal analysis. Set $\tilde S_\textsf{plus}(\phi,\phi') = ([\![{\textsf{plus}}]\!]{}\,\phi\,\phi')_p$. Then making use of Proposition 9, $\tilde S_\textsf{plus}(\phi^\textsf{nat}_1,\phi') = \phi'$ and for $m>1$,

\begin{align*}\tilde S_\textsf{plus}(\phi^\textsf{nat}_m,\phi') &= \phi' \vee [\![{\textsf{S}(r_p)}]\!] {\{r\mapsto {[\![{\textsf{plus}}]\!]{}\,\phi^\textsf{nat}_{m-1}\,\phi'}\}} \\ &= \phi' \vee (\chi_{F_\textsf{nat}} + {{[\![{\textsf{plus}}]\!]{}\,\phi^\textsf{nat}_{m-1}\,\phi'}}) & & \text{(Proposition 9)} \\ &= \phi' \vee (\chi_{F_\textsf{nat}} + \tilde S_\textsf{plus}(\phi^\textsf{nat}_{m-1},\phi'))\end{align*}

This recursive description of $\tilde S_\textsf{plus}$ is sufficient to prove that $\tilde S_\textsf{plus}(\phi^\textsf{nat}_m,\phi') \geq \phi'$, and so we can conclude the reasoning with

\[\tilde S_\textsf{plus}(\phi^\textsf{nat}_m,\phi') =\chi_{F_\textsf{nat}} + \tilde S_\textsf{plus}(\phi^\textsf{nat}_{m-1},\phi')\]

and so in particular

\[\tilde S_\textsf{plus}(\phi^\textsf{nat}_1,\phi^\textsf{nat}_n) = \phi^\textsf{nat}_n\qquad\tilde S_\textsf{plus}(\phi^\textsf{nat}_m,\phi^\textsf{nat}_n) =\chi_{F_\textsf{nat}} + \tilde S_\textsf{plus}(\phi^\textsf{nat}_{m-1},\phi^\textsf{nat}_n),\]

recurrences that are equivalent to those derived informally. The analysis of $\tilde T_\textsf{plus}(\phi,\phi') = ([\![{\textsf{plus}}]\!]{}\,\phi\,\phi')_c$ is similar and results in the recurrence

\[\tilde T_\textsf{plus}(\phi^\textsf{nat}_1,\phi^\textsf{nat}_n) = 1\qquad\tilde T_\textsf{plus}(\phi^\textsf{nat}_m,\phi^\textsf{nat}_n) =1 + \tilde T_\textsf{plus}(\phi^\textsf{nat}_{m-1},\phi^\textsf{nat}_n).\]

Now set $\tilde S_\textsf{st}(\phi) = ([\![{\textsf{sumtree}}]\!]{}\,\phi)_p$. Making use of Proposition 9, $\tilde S_\textsf{st}(\phi^{\textsf{nat tree}}_{1,k}) = \phi^\textsf{nat}_1$ and for $k>1$,

\begin{align*}\tilde S_\mathsf{st}(\phi^{\mathsf{nat tree}}_{n,k}) &= \phi^\mathsf{nat}_1 \vee \bigvee \begin{aligned}[t] & \{([\![\mathsf{plus} x(\mathsf{plus r_{0_{p}}r_{1_{p}}})]\!]\{x,r_{i}\mapsto\phi^{\mathsf{nat}}_{n'},[\![\mathsf{suntree}]\!]\phi^{\mathsf{nat tree}}_{n_i,k_i}\})_p\\ & \qquad \mid n'\vee n_0 \vee n_1 \leq n, k_0+k_1 < k \bigr\} \end{aligned} \\ &= \phi^\mathsf{nat}_1 \vee \bigvee \begin{aligned}[t] & \bigl\{ ([\![{\mathsf{plus}}]\!]{}\,\phi^\mathsf{nat}_{n'}( [\![{\mathsf{plus}}]\!]{}\,(\tilde S_\mathsf{st}(\phi^{\mathsf{nat tree}}_{n_0,k_0}))\, (\tilde S_\mathsf{st}(\phi^{\mathsf{nat tree}}_{n_1,k_1})) )_{p})_{p} \\ & \qquad \mid n'\vee n_0 \vee n_1 \leq n, k_0+k_1 < k \bigr\} \end{aligned} \\ &= \phi^\mathsf{nat}_1 \vee \bigvee \begin{aligned}[t] & \bigl\{ \tilde S_\mathsf{plus}( \phi^\mathsf{nat}_{n'}, \tilde S_\mathsf{plus}( \tilde S_\mathsf{st}(\phi^{\mathsf{nat tree}}_{n_0,k_0}), \tilde S_\mathsf{st}(\phi^{\mathsf{nat tree}}_{n_1,k_1}) ) ) \\ & \qquad \mid n'\vee n_0 \vee n_1 \leq n, k_0+k_1 < k \bigr\} \end{aligned} \end{align*}

Since $\phi^\textsf{nat}_1$ is the bottom element of $W^\textsf{nat}$ and we can prove from this recurrence that $\tilde S_\textsf{st}(\phi^{\textsf{nat tree}}_{n,k})$ is monotone with respect to n, we can conclude this reasoning with

\[\tilde S_\textsf{st}(\phi^{\textsf{nat tree}}_{n,k}) =\bigvee\{ \tilde S_\textsf{plus}( \phi^\textsf{nat}_{n}, \tilde S_\textsf{plus}( \tilde S_\textsf{st}(\phi^{\textsf{nat tree}}_{n,k_0}), \tilde S_\textsf{st}(\phi^{\textsf{nat tree}}_{n,k_1}) ) )\}{k_0+k_1 < k},\]

which is analogous to the recurrence we derived informally. The analysis of $\tilde T_\textsf{st}(\phi^{\textsf{nat tree}}_{n,k}) =([\![{\textsf{sumtree}}]\!]{}\,\phi^{\textsf{nat tree}}_{n,k})_c$ is similar and leads to

As a final note, in order to obtain the desired final form, we sometimes had to do some reasoning about the function on the basis of its recurrence, such as proving that the function is monotone. In fact, such reasoning is almost always required in the informal analysis as well, even though we typically gloss over such points when analyzing algorithms.

In may be helpful to contrast this analysis with the interpretation of $\textsf{plus}$ and $\textsf{sumtree}$ in the model of Section 7.2. Since $\textsf{nat}$ values involve no other datatype constructors, the interpretation of $\textsf{plus}$ is essentially just the same, only requiring less notation to write down. However, the cost component of $[\![{\textsf{sumtree}}]\!]{\{n/ t\}}$ is less helpful. Because the model of Section 7.2 only accounts for the tree constructors, it does not account for the sizes of the node labels, and so this computation includes the cost component of $[\![{\textsf{plus}\,x\,({\textsf{plus}\,{r_{0_{p}}}\,{r_{1_{p}}}})_p}]\!] {{{\infty,\ldots/}{x,r_0, r_1}}}$ and this will result in a bound of $\infty$ (cf. to the occurrence of $\infty$ in the analysis of $\mathtt{mem}$ in the previous section, which did no harm there). This is correct as a bound. It reflects a cost analysis in which we have decided that we are counting each recursive call as a computation step, but then analyze a program in which data values whose size we ignore is the source of some recursive calls. However, this rather poor choice of size for this particular context yields a very weak bound, and so shows more generally that the choice of model does really matter.

7.4 Size abstraction and polymorphism: merging the constructor-counting models

Let us make a couple of observations about the previous two sections. It seems at least intuitive that counting only the main constructors is a more abstract notion of size than counting all constructors. And it also seems that even if we are working in the model of Section 7.3, if we have a polymorphic function in hand, it ought to be analyzable by just counting main constructors. This leads to the idea that if we have a model in hand (such as counting all constructors), then at least in some cases, it ought to be possible to interpret polymorphic recurrences so that the potentials arise from a more abstract notion of size than that given by the model. We give an example of how that might be done now.

Definition Suppose ${\mathbf{U}} = (\mathbf{U}_{sm}, \mathbf{U}_{lg}, \{D^\sigma\})$ and ${\mathbf{U}}' = (\mathbf{U}_{sm}, \mathbf{U}_{lg},\{D'\}^\sigma)$ are two models of the recurrence language, both based on the (same extension of the) standard type frame. We say that ${\mathbf{U}}'$ is an abstraction of ${\mathbf{U}}$, or ${\mathbf{U}}$ is a concretization of ${\mathbf{U}}'$, if for every $\sigma\in\mathbf{U}_{sm}$ there are functions

such that for all $\sigma$, $\mathrm{conc}_\sigma$ is monotone, $\mathrm{conc}_\sigma\mathbin\circ\mathrm{abs}_\sigma\geq\mathop{\mathrm{id}}\nolimits_{D^\sigma}$ and $\mathrm{abs}_\sigma\mathbin\circ\mathrm{conc}_\sigma = \mathop{\mathrm{id}}\nolimits_{D'^\sigma}$.

Definition Suppose ${\mathbf{U}}' = (\mathbf{U}_{sm}, \mathbf{U}_{lg}, \{D'\}^\sigma)$ is an abstraction of ${\mathbf{U}} = (\mathbf{U}_{sm}, \mathbf{U}_{lg}, \{D^\sigma\})$. The polymorphic abstraction of ${\mathbf{U}}$ relative to ${\mathbf{U}}'$ is the model ${\mathbf{U}}\to{\mathbf{U}}' = (\mathbf{U}_{sm}, \mathbf{U}_{lg}, \{B^\sigma\})$ that is defined as follows:

• • For $\sigma\in\mathbf{U}_{sm}$, $B^\sigma = D^\sigma$, with the semantic functions for small types taken from ${\mathbf{U}}$.

• • For $\tau\in\mathbf{U}_{lg}\setminus\mathbf{U}_{sm}$, $B^\tau = {D'}^\tau$, where:

• • If $\rho$ is quantifier-free and $\mathop{\mathrm{fv}}\nolimits(\rho)\subseteq\{\alpha\}$, then

  

• • If $\tau$ is not quantifier-free and $\mathop{\mathrm{fv}}\nolimits(\tau)\subseteq\{\alpha\}$, then we take $\underline{TyAbs}_{\lambda\hskip-.32em\lambda\sigma.\tau\{\sigma/\alpha\}} =\underline{TyAbs}_{\lambda\hskip-.32em\lambda\sigma.\tau\{\sigma/\alpha\}}^{{\mathbf{U}}'}$ and $\underline{TyAbs}_{\lambda\hskip-.32em\lambda\sigma.\tau\{\sigma/\alpha\}} =\underline{TyAbs}_{\lambda\hskip-.32em\lambda}\sigma.\tau\{\sigma/\alpha\}^{{\mathbf{U}}'}$.

Proof. The only nontrivial verification is that when $\rho$ is quantifier-free and $\mathop{\mathrm{fv}}\nolimits(\rho)\subseteq\{\alpha\}$, $\underline{\mathrm{TyApp}}_{\lambda\hskip-.32em\lambda\sigma.\rho\{\sigma/\alpha\}}( \underline{TyAbs}_{\lambda\hskip-.32em\lambda\sigma.\rho\{\sigma/\alpha\}}\,f )\geq f$:

As an example, we define abstraction and concretization functions in Figure 23 that show that the main constructor counting model $\mathbf{V}$ from Section 7.2 is an abstraction of the all-constructor counting model $\mathbf{W}$ from Section 7.3.

Fig. 23. Abstraction and concretization functions that relate the all-constructor (concrete) and main-constructor (abstract) models.

The definition of the abstraction and concretization functions in Figure 23 looks fairly canonical, so a natural question is whether for any two models of the recurrence language one can extend given functions on the interpretations of base types to all small types. In fact these definitions are an instance of a general pattern, but to state the pattern we will need a few definitions. A 2-category is a generalization of a category with a notion of morphism-between-morphism: if X and Y are objects, and $f,g : X\longrightarrow Y$ are morphisms, then we will write $f\le_{\mathcal{C}} g : X \longrightarrow Y$ for a 2-cell from f to g. We will mainly consider the 2-category $\mathbf{Preorder}$, whose objects X,Y are preordered sets, whose morphisms $f : X\longrightarrow Y$ are monotone functions, and whose 2-cells $f \le g :X \longrightarrow Y$ are bounds $\forall x:X. f(x) \le_Y g(x)$. We will also need $\mathbf{Preorder}^{op}$ (the 1-cell dual of $\mathbf{Preorder}$): the objects are again preorders, a 1-cell $X\longrightarrow_{\mathbf{Preorder}^{op}} Y$ in $\mathbf{Preorder}^{op}$ is a 1-cell in $Y \longrightarrow_{\mathbf{Preorder}} X$, i.e. a monotone function $Y \to X$, but the 2-cells $f \le_{Preorder^{op}} g :X \longrightarrow_{Preorder^{op}} Y$ are still the 2-cells $f\le_{\mathbf{Preorder}} g : Y \longrightarrow_{\mathbf{Preorder}} X$, i.e. $\forall y:Y. f(y) \le_X g(y)$. A standard construction is to take the cartesian product of two 2-categories, where the objects, 1-cells, and 2-cells are given pointwise; in particular we will consider $\mathbf{Preorder} \times \mathbf{Preorder}$ and $\mathbf{Preorder}^{op}\times \mathbf{Preorder}$. A 2-functor $F : \mathcal{C} \to\mathcal{D}$ between 2-categories acts on objects, 1-cells (preserving identity and composition either strictly or up to 2-cell isomorphism), and 2-cells. For example, a (strict) 2-functor $F : \mathbf{Preorder}\to \mathbf{Preorder}$ consists of (0) for each preorder X, a preorder F(X); (1) for each monotone function $f : X \to Y$, a monotone function $F(f) : F(X) \to F(Y)$ such that $F(id) = id$ and $F(g \circ f)= F(g) \circ F(f)$; (2) if $\forall x:X. f(x) \le_Y g(x)$ then $\forall w:F(X). F(f) w \le_{F(Y)} F(g) w$. I.e. F sends preorders to preorders and monotone functions to monotone functions, in such a way that if g bounds f then F(g) bounds F(f).

An abstract interpretation in the sense above is often called a Galois insertion, which is a reflection in $\mathbf{Preorder}$: a (strict) reflection of A into C consists of a pair of 1-cells $\mathrm{abs} \dashv \mathrm{conc}$ where $\mathrm{abs} : C \to A$ and $\mathrm{conc} : A \to C$, with an equality $\mathrm{abs} \circ \mathrm{conc} = id_A$ and a 2-cell $id_C \le_C \mathrm{conc} \circ \mathrm{abs}$. A standard observation is that any 2-functor $F : \mathcal{C} \to \mathcal{D}$ preserves reflections (this is used, for example, in domain theory Smyth & Plotkin Reference Smyth and Plotkin1982): if $\mathrm{abs} \dashv \mathrm{conc}$ is a reflection then $F(\mathrm{abs}) \dashv F(\mathrm{conc})$ is a reflection between F(C) and F(A). Applying F to the equality $\mathrm{abs} \circ \mathrm{conc} = id_A$ and using strict preservation of identity and composition gives $F(\mathrm{abs})\circ F(\mathrm{conc}) = id_{F(A)}$, and using the action on 2-cells of F on $id_C \le_C \mathrm{conc} \circ \mathrm{abs}$ (and again preservation of identity and composition) gives $id_{F(C)} \le_{F(C)} F(\mathrm{conc}) \circ F(\mathrm{abs})$.

This all means that we can lift the abstraction and concretization from base types to any type constructor that extends to a 2-functor. The product of preorders $X \times Y$ is the action on objects of a functor $\mathbf{Preorder} \times \mathbf{Preorder} \to\mathbf{Preorder}$, where the action on maps $f_0 : X_0 \to X_0'$ and $g: X_1 \to X_1'$ is given by

\[f_0 \times f_1 : X_0 \times X_1 \to X_0' \times X_1' := z \mapsto \langle f_0 (\pi_0 z), f_1(\pi_1 z) \rangle\]

This acts on 2-cells (preserves bounds) because pairing and application are monotone operations. To show that it preserves composition, we need a full $\beta$-reduction equation and to show that it preserves identity, we also need the corresponding $\eta$/surjective pairing equation. However, these are true for the standard cartesian product of preorders. A reflection in $\mathbf{Preorder} \times \mathbf{Preorder}$ is a pair of reflections for each component. Unwinding these definitions gives the definitions of $\mathrm{abs}_{\sigma_0 \times \sigma_1}$ and $\mathrm{conc}_{\sigma_0 \times \sigma_1}$ in Figure 23.

The case of sums is more interesting. The standard coproduct of preorders $X + Y$ is the disjoint union $X \sqcup Y$ ordered as defined above. This extends to a 2-functor $\mathbf{Preorder} \times\mathbf{Preorder} \to \mathbf{Preorder}$ with $f_0 + f_1$ defined via case-analysis. This is bound-preserving because the branches of a case-analysis (on the standard coproduct in preorders) are a monotone position and preserves identity/composition if we have $\beta\eta$ equations for case-analysis, which $X+Y$ does.

In the models under consideration, we do not define $D^{\sigma_0+\sigma_1}$ to be $D^{\sigma_0} + D^{\sigma_1}$, but $\mathcal{O}{(D^{\sigma_0} + D^{\sigma_1})}$. However, it is also the case that $\mathcal{O}$ is a 2-functor $\mathbf{Preorder} \to\mathbf{Preorder}$: $\mathcal{O}{f} : \mathcal{O}{X} \to \mathcal{O}{Y}$ is $\downarrow \{ f(x) : x \in X \}$, which preserves bounds and identities and compositions. The composition of 2-functors is again a 2-functor, so $\mathcal{O}{(- + -)} : \mathbf{Preorder} \times \mathbf{Preorder} \to\mathbf{Preorder}$ is as well, and unwinding definitions gives $\mathrm{abs}_{\sigma_0+\sigma_1}$ and $\mathrm{conc}_{\sigma_0+\sigma_1}$ from Figure 23.

For functions, the preorder of pointwise-ordered monotone maps $X \to Y$ extends to a mixed-variance 2-functor $\mathbf{Preorder}^{op} \times\mathbf{Preorder} \to \mathbf{Preorder}$, with functorial action given by pre- and post-composition. Moreover, a reflection $\mathrm{abs} \dashv\mathrm{conc}$ in $\mathbf{Preorder}$ is a reflection $\mathrm{conc} \dashv \mathrm{abs}$ in $\mathbf{Preorder}^{op}$ with the roles of concretization and abstraction exchanged. This unpacks to the definitions of $\mathrm{abs}_{\rho \to \sigma}$ and $\mathrm{conc}_{\rho \to \sigma}$ in Figure 23, where abstraction precomposes with concretization, and vice versa.

Thus, while our general definition of model does not require types to be interpreted as 2-functors—for example, being a model does not require the $\eta$ law for pairs that ensures preservation of identities—a number of more specific models will have this form, and thus admit the same definition of relativized model, given abstraction and concretization for base/inductive types. For example, we may freely apply $\mathord{}$ in the interpretation of any type constructor, e.g., defining $D^{\sigma_0\times\sigma_1}$ to be $\mathcal{O}{(D^{\sigma_0} \times D^{\sigma_1})}$ for more precision.

7.4.1 Example: list reverse

To get a sense of how polymorphic abstraction behaves, let us analyze the polymorphic linear-time list reverse function given in Figure 24 in the model $\mathbf{W}\to\mathbf{V}$. We choose this model because on the one hand $\mathbf{W}$ provides enough information for analyzing monomorphic functions like $\mathtt{sumtree}$ that depend on more than just the usual notion of size, yet we still want to analyze a polymorphic function like list reversal in terms of list length, ignoring any information about the elements of the argument list. Since polymorphism in the source language arises only via let-bindings, the recurrence for $\textsf{rev}'$ that is given is the recurrence that is substituted for for $\textsf{rev}'$ according to the definition of extraction for $\mathtt{let}$-expressions. A typical informal analysis of $\mathtt{rev}$ would really analyze $\mathtt{rev}'$ and might define S(n, m) and T(n, m) to be the size and cost of $\mathtt{rev}'\,xs\,ys$ when xs and ys have length n and m, respectively. One would then observe that S and T satisfy the recurrences

\[\begin{aligned}[t]S(1, m) &= m \\S(n, m) &= S(n-1, m+1)\end{aligned}\qquad\begin{aligned}[t]T(1, m) &= 1 \\T(n, m) &= 1 + T(n-1, m)\end{aligned}\]

from which one establishes the O(n) bound on cost.

Fig. 24. Linear-time list reversal and its extracted recurrences.

Just as with our other models, to analyze $\textsf{rev}$, we must consider its instantiation at some arbitrary small type $\sigma$. In the model $\mathbf{W}$, this would entail understanding how to compute $\underline{\mathrm{Fold}}^\mathbf{W}\,s\,\phi$ for arbitrary $\phi$, which would be defined in terms of all $\phi'\leq\phi$. The key point of $\mathbf{W}\to\mathbf{V}$ is that while we cannot avoid considering the instantiation of $\textsf{rev}$ at arbitrary $\sigma$, we only need to know how to compute $\underline{\mathrm{Fold}}^\mathbf{W}\,s\,\phi$ for those $\phi$ that are the concretizations of values in $V^{\sigma\textsf{list}}$. To see this, let us define $\phi^{\sigma\textsf{list}}_n = \mathrm{conc}_{\sigma\textsf{list}}(n)$—observe that $\phi^{\sigma\textsf{list}}_n$ maps $\sigma\textsf{list}$ to n and all other datatypes to $\infty$—and then compute $\textsf{rev}'$, where we write $f_\sigma\,\phi$ for $[\![\textsf{fold}_{\sigma\textsf{list}} xs \textsf{of} \{\textsf{nil}\Rightarrow\cdots|\textsf{cons}\Rightarrow\cdots\}]\!]\eta\{xs\mapsto\phi\}$:

When restricted to concretizations of abstract values, $\underline{\mathrm{Fold}}^\mathbf{W}$ is straightforward to compute.

Proposition 13. If $f\,n = [\![\textsf{fold}_{\sigma\textsf{list}}y \textsf{of}\{\textsf{nil}\Rightarrow e_{nil}|\textsf{cons}\Rightarrow(x,r).e_{\textsf{cons}}\}]\!]\eta\{y\mapsto\phi^{\sigma\textsf{list}}_{n}\}^{\mathbf{W}}$, then

\begin{align*}f\,1 &= [\![{e_\textsf{nil}}]\!]\eta \\f\,n &= [\![{e_\textsf{nil}}]\!]\eta \vee [\![{e_\textsf{cons}}]\!] {\eta \{x, r\mapsto \infty^\sigma, f(n-1) \} } & & (n > 1).\end{align*}

With this in mind, set $\tilde S(n, m) = \mathrm{abs}( (f_\sigma\,\phi^{\sigma\textsf{list}}_n )_p\,\phi^{\sigma\textsf{list}}_m)_p$. Our goal is to write a recurrence for $\tilde S(n, m)$. We start with

\begin{align*}\tilde S(1, m) &= \mathrm{abs}((f_\sigma\,\phi^{\sigma\textsf{list}}_1)_p\,\phi^{\sigma\textsf{list}}_m)_p \\ &=\mathrm{abs}(([\![(1,\lambda zs.(0,zs))]\!])_p\phi^{\sigma\textsf{list}}_m)_p &= \mathrm{abs}({\lambda\hskip-.32em\lambda}\phi.(0, \phi)\,\phi^{\sigma\textsf{list}}_m)_p \\ &= \mathrm{abs}(0,\phi^{\sigma\textsf{list}}_m)_p \\ &= \mathrm{abs}(\phi^{\sigma\textsf{list}}_m) \\ &= m.\end{align*}

To compute $\tilde S(n, m)$ for $n>1$, we first compute

Analysis of cost proceeds in a similar manner. We have again extracted the recurrences we expect from an informal analysis, but instead of those recurrences being in terms of arbitrary values in $W^{\sigma\textsf{list}}$, they are in terms of the length of the argument list.

Stepping back a bit, recall from Section 7.1 that we can apply parametricity to the standard model to reason about the cost of $\mathtt{rev}\,xs$, which seems comparable to what we have just done. But there is a difference. The result from parametricity tells us that the cost of the result is determined by the length of the argument, but it does not tell us how to compute the former in terms of the latter. What we have done here is to formally justify the recurrence that does just that.

7.5 Lower bounds and an application to map fusion

So far, we have focused on extracting recurrences for upper bounds. However, the syntactic bounding theorem is agnostic with respect to the actual interpretation of the size order. We take advantage of this to derive recurrences for upper and lower bounds in the main constructor counting model of Section 7.2. Let us consider the $\mathtt{map}$ function given in Figure 25. By reasoning that is by now hopefully somewhat mundane, if we set $T_{\mathtt{map}\,f}(n) = ([\![{\textsf{map}}]\!]{}\,f\,n)_c$, then we obtain the recurrence

\[T_{\mathtt{map}\,f}(1) = 1\qquad T_{\mathtt{map}\,f}(n) = 1 + (f\,\infty)_c + T_{\mathtt{map}\,f}(n-1).\]

Solving this recurrence yields an upper bound of $T_{\mathtt{map}\,f}(n) = n(1 + (f\,\infty)_c)$. Now let us apply this to the two sides of the usual map fusion law

\[\mathtt{map}\,f\,(\mathtt{map}\,g\,xs) = \mathtt{map}\,(f\mathbin\circ g)\,xs.\]

We hope to show that the right-hand side is less costly than the left. Working through the recurrence extractions, we conclude that the cost of the left-hand side is bounded by $T_{\mathtt{map}\,f\mathbin\circ\mathtt{map}\,g}(n) = 2n(1 + (g\,\infty)_c + (f\,\infty)_c)$, whereas the right-hand side is bounded by $T_{\mathtt{map}(f\mathbin\circ g)}(n) = n(1 + (g\,\infty)_c + (f(g\,\infty)_p)_c)$. Even under the assumption that the costs of f and g are independent of their arguments does not result in the desired conclusion, because we only know that these recurrences yield upper bounds, and the fact that one upper bound is larger than another tells us nothing about the actual costs. What we would like to know is that these recurrences are tight, and for that we need lower bounds as well.

Fig. 25. List map and its extracted recurrence.

As we already mentioned, as long as we have a model of the recurrence language in which the interpretation of the size order satisfies the axioms of Figure 11, the bounding theorem holds. So to obtain lower bounds, we would want a model in which the order on the interpretation of $\textsf{C}$ is the reverse of the usual order. That means we would have two models in hand, one that gives us upper bounds and one that gives us lower bounds; we would then have to ensure that the recurrences in each model can be sensibly compared. As it turns out, we can arrange that by using the model in Section 7.2 because the interpretations of the types are all complete upper semi-lattices. We take advantage of the fact that a complete upper semi-lattice is in fact a complete lattice, where greatest lower bounds are defined by $\bigwedge X = \bigvee\{x\}{\forall y\in X: x\leq y}$. This permits us to define the dual interpretation of the model $(\mathbf{U}_{sm},\mathbf{U}_{lg},\{V^\sigma\}{\sigma})$ to be $(\mathbf{U}_{sm},\mathbf{U}_{lg},\{(V^*)^\sigma\}{\sigma})$, where $(V^*)^\sigma = (V^\sigma, \leq^*_\sigma)$ and $x\leq^*_\sigma y$ iff $y\leq_\sigma x$. Because all of the size-order axioms except $\beta_{\delta}$ and $\beta_{\delta\textsf{fold}}$ are witnessed by identities in $\mathbf{V}$ (i.e., the left- and right-hand sides of the axioms have the same denotation), we can take the semantic functions in $\mathbf{V}^*$ not related to datatypes to be those of $\mathbf{V}$. For datatype-related functions, it is unnecessary to change either $\underline{\mathrm{size}}_{F}$ or $\underline{\mathrm{C}}_{F}$; the only change needed is that we define

\[\underline{\mathrm{D}}_{F}^*(n) = \bigwedge\{a\}{\underline{\mathrm{C}}_{F}(a)\geq n}.\]

We can verify that $\beta_{\delta}$ holds by observing that

\[\underline{\mathrm{D}}_{F}^*(\underline{\mathrm{C}}_{F}(a)) = \bigwedge\{a'\}{\underline{\mathrm{C}}_{F}(a')\geq \underline{\mathrm{C}}_{F}(a)} \leq a\]

and hence $\underline{\mathrm{D}}_{F}^*(\underline{\mathrm{C}}_{F}(a)) \geq^* a$ as required. Of course, the value of the destructor is different in this model, but not by much; a routine calculation shows that

\[\underline{\mathrm{D}}_{F_{\sigma\textsf{list}}}(x) = \emptyset\sqcup(\{\bot_\sigma\}\times\downarrow[\mathbf{N}_1^\infty](x-1));\]

compare this to the calculation in Section 7.2.

We likewise can define the semantic fold function in this model by

\begin{align*}\underline{\mathrm{Fold}}_{F}^*\,s\,x &= \bigwedge\{s(\underline{\mathrm{Map}}(\underline{\mathrm{Fold}}\,s)\,z)\}{\underline{\mathrm{C}}_{F} z\geq x}\end{align*}

Similar to the computation of $\underline{\mathrm{D}}_{F}$, we have an analogue of Proposition 7: if $f\,n = [\![\textsf{fold}_{\sigma\textsf{list}}y \textsf{of} \{\textsf{nil}\Rightarrow e_{\textsf{nil}}\mid\textsf{cons}\Rightarrow(x,r).e_{\textsf{cons}}\}]\!]\eta\{y\mapsto n\}$, then

\begin{align*}f\,1 &= \bot_\sigma \\f\,n &= [\![{e_\textsf{cons}}]\!]\eta{\{x,r\mapsto\bot_\sigma,f(n-1)\}}.\end{align*}

Returning to our discussion of comparing the costs of $\mathtt{map}\,f \mathbin\circ \mathtt{map}\,g$ and $\mathtt{map}({}f\mathbin\circ g)$, we now conclude that $T^\ell_{\mathtt{map}\,f\mathbin\circ\,\mathtt{map}\,g}(n) = 2n(1+(g\,\bot)_c + ({}f\,\bot)_c)$ is a lower bound on the cost of $\mathtt{map}\,f\mathbin\circ\mathtt{map}\,g$, so to show that $\mathtt{map}\,({}f\mathbin\circ g)$ is the more efficient alternative, it suffices to show that

\[n(1 + (g\infty)_c + ({}f(g\,\infty)_p)_c)\leq_\textsf{C}2n(1+(g\,\bot)_c + ({}f\,\bot)_c),\]

which is trivial when the costs of f and g are independent of their arguments.