Denotational semantics as a foundation for cost recurrence extraction for functional languages

Abstract

A standard method for analyzing the asymptotic complexity of a program is to extract a recurrence that describes its cost in terms of the size of its input, and then to compute a closed-form upper bound on that recurrence. In practice there is rarely a formal argument that the recurrence is in fact an upper bound; indeed, there is usually no formal connection between the program and the recurrence at all. Here we develop a method for extracting recurrences from functional programs in a higher-order language with let-polymorphism that provably bound their operational cost. The method consists of two phases. In the first phase, a monadic translation is performed to extract a costannotated version of the original program. In the second phase, the extracted program is interpreted in a model. The key feature of this second phase is that different models describe different notions of size. This plays out specifically for values of inductive type, where different notions of size may be appropriate depending on the analysis, and for polymorphic functions, where we show that the notion of size for a polymorphic function can be described formally as the data that is common to the notions of size of its instances. We give several examples of different models that formally justify various informal extracta-recurrence-and-solve cost analyses to show the applicability of our approach.

Denotational recurrence extraction for amortized analysis

“…It includes some standard connectives of linear logic, such as positive/eager/multiplicative products (⊗ and 1), sums/coproducts (⊕), and functions (⊸), as well as negative/lazy/additive products (&). The language has two basic datatypes, natural numbers (N) and (eager) lists (List (A)), both with structural recursion (though we expect these techniques to extend to all strictly positive inductive types [8,9]).…”

“…The definition of slrec is similar; the new question that arises is that, because we have abstracted lists as their lengths, forgetting the elements, we do not have a value for the head of the list to supply to д (which, when we use this operation, will be the translation of the cons branch given to the λ C recursor). Here, we always supply ∞ as the head list element, which is sufficient when the analysis really does not require any information about the elements of the list (otherwise, one can make a model where lists are interpreted more precisely than as their lengths [8,9]).…”

“…It is these semantic recurrences that match the recurrences that arise from the typical "extract-and-solve" approach to analyzing program cost. Our previous work develops this methodology for functional programs with numbers and lists [10], inductive types with structural recursion [9], general recursion [22], and let-polymorphism [8].…”