Denotational recurrence extraction for amortized analysis

@article{Cutler2020DenotationalRE,
  title={Denotational recurrence extraction for amortized analysis},
  author={Joseph W. Cutler and Daniel R. Licata and N. Danner},
  journal={Proceedings of the ACM on Programming Languages},
  year={2020},
  volume={4},
  pages={1 - 29}
}
A typical way of analyzing the time complexity of functional programs is to extract a recurrence expressing the running time of the program in terms of the size of its input, and then to solve the recurrence to obtain a big-O bound. For recurrence extraction to be compositional, it is also necessary to extract recurrences for the size of outputs of helper functions. Previous work has developed techniques for using logical relations to state a formal correctness theorem for a general recurrence… Expand
Denotational semantics as a foundation for cost recurrence extraction for functional languages
TLDR
A method for extracting recurrences from functional programs in a higher-order language with let-polymorphism that provably bound their operational cost is developed. Expand
Automatic amortized resource analysis with the Quantum physicist’s method
TLDR
This work uses the quantum physicist’s method of amortized resource analysis to extend the Automatic Amortized Resource Analysis type system, enabling the derivation of resource bounds based on tree depth and introduces remainder contexts, which aid bookkeeping in linear type systems. Expand
On continuation-passing transformations and expected cost analysis
We define a continuation-passing style (CPS) translation for a typed λ-calculus with probabilistic choice, unbounded recursion, and a tick operator — for modeling cost. The target language is aExpand
Reasoning about the garden of forking paths
TLDR
This work presents a novel and simple framework for formally reasoning about lazy computation costs based on a recent model of lazy evaluation: clairvoyant call-by-value, and shows that this monad can be effectively used to mechanically reason about the computational cost of lazy functional programs written in Coq. Expand

References

SHOWING 1-10 OF 55 REFERENCES
Denotational semantics as a foundation for cost recurrence extraction for functional languages
TLDR
A method for extracting recurrences from functional programs in a higher-order language with let-polymorphism that provably bound their operational cost is developed. Expand
Denotational cost semantics for functional languages with inductive types
TLDR
This work gives a formal account of the extraction of cost and size recurrences from higher-order functional programs over inductive datatypes, and proves by a logical relations argument thatRecurrences extracted by this process are upper bounds for evaluation cost. Expand
Recurrence extraction for functional programs through call-by-push-value
TLDR
A method that automatically extracts recurrences from the syntax of higher-order recursive functional programs, which are programs in a call-by-name language with recursion, explicitly compute the running time in terms of the size of the input. Expand
A static cost analysis for a higher-order language
TLDR
The proof of the Soundness Theorem is formalized in Coq, providing certified upper bounds on the cost of any expression in the target language. Expand
A denotational approach to measuring complexity in functional programs
TLDR
A compositional semantics for functional programs that allows us to analyze the time a program takes to run in terms of the number of times certain operations are required, and uniformly handles both higher-order types and lazy types. Expand
Upper and Lower Amortized Cost Bounds of Programs Expressed as Cost Relations
TLDR
A new analysis for computing upper and lower cost bounds of programs expressed as cost relations, which allows to reduce the inference of complex polynomial expressions to a set of linear problems that can be solved efficiently. Expand
On the Inference of Resource Usage Upper and Lower Bounds
TLDR
A novel approach to infer upper and lower bounds from cost relations, an extended form of standard recurrence equations that can be nondeterministic, contain inexact size constraints and have multiple arguments that increase and/or decrease. Expand
Type-Based Cost Analysis for Lazy Functional Languages
TLDR
A type-based analysis employing amortisation and cost effects to statically determine upper bounds on evaluation costs of lazily evaluated functional languages, such as Haskell is applied. Expand
TiML: a functional language for practical complexity analysis with invariants
TLDR
TiML, though lacking full automation and theoretical completeness, is versatile enough to verify worst-case and/or amortized complexities for algorithms and data structures like classic list operations, merge sort, Dijkstra's shortest-path algorithm, red-black trees, Braun trees, functional queues, and dynamic tables with bounds like m n logn. Expand
Non-linear reasoning for invariant synthesis
TLDR
An abstract domain for reasoning about non-linear arithmetic, a semantics-based method for extracting recurrence relations from loop bodies, and a recurrence solver that avoids closed forms that involve complex or irrational numbers are presented. Expand
...
1
2
3
4
5
...