Two decades of automatic amortized resource analysis

@article{Hoffmann2022TwoDO,
  title={Two decades of automatic amortized resource analysis},
  author={Jan Hoffmann and Steffen Jost},
  journal={Mathematical Structures in Computer Science},
  year={2022},
  volume={32},
  pages={729 - 759},
  url={https://api.semanticscholar.org/CorpusID:247510990}
}
An overview of automatic amortized resource analysis (AARA), a technique for inferring symbolic resource bounds for programs at compile time, and local inference rules, which reduce bound inference to numeric optimization.
View on Cambridge Press
cambridge.org
9 Citations
Background Citations
1
Methods Citations
1

9 Citations

A Reusable Machine-Calculus for Automated Resource Analyses

This work implemented type inference constraint generation for the authors' calculus, accompanied with an elaboration of bounds for iterators on algebraic datatypes, for minimal ML-style programming languages with Call-by-Value and Call-By-Push-Value semantics.

Automatic Linear Resource Bound Analysis for Rust via Prophecy Potentials

This article presents RaRust, a type-based linear resource-bound analysis for well-typed Rust programs, and proposes Resource-Aware Borrow Calculus (RABC) as a variant of recently proposed Low-Level Borrow Calculus (LLBC).

A Calculus for Amortized Expected Runtimes

We develop a weakest-precondition-style calculus à la Dijkstra for reasoning about amortized expected runtimes of randomized algorithms with access to dynamic memory — the aert calculus. Our calculus…

Synthesis of Sound and Precise Storage Cost Bounds via Unsound Resource Analysis and Max-SMT

The solution consists in using an off-the-shelf static resource analysis to synthesize storage bounds which take into account the dynamicity implicit to the cost model, and then computing corrections to recover soundness in the bounds by using a new Max-SMT based approach.

Amortized Analysis via Coalgebra

This work develops the alternative perspective that amortized analysis is naturally viewed coalgebraically in a category of cost algebras, where a morphism of coalgebras serves as a first-class generalization of potential function suitable for integrating cost and behavior.

Flexible Type-Based Resource Estimation in Quantum Circuit Description Languages

A type system for the Quipper language designed to derive upper bounds on the size of the circuits produced by the typed program, which is empirically evaluated through the QuRA tool, showing that, in many cases, inferring tight bounds is possible in a fully automatic way.

Tachis: Higher-Order Separation Logic with Credits for Expected Costs

Tachis, a higher-order separation logic to reason about the expected cost of probabilistic programs, is presented, inspired by the uses of time credits for reasoning about the running time of deterministic programs, and a novel notion of probabilistic cost credit is introduced.

Polynomial Time and Dependent Types

    R. Atkey
    Computer Science, Mathematics
    Proc. ACM Program. Lang.
  • 2024
This paper explores two systems for capturing polynomial time: one system that disallows construction of iterable data, and one, based on the LFPL system of Martin Hofmann, that controls construction via a payment method that is extended to full dependent types via Quantitative Type Theory.

Error Credits: Resourceful Reasoning about Error Bounds for Higher-Order Probabilistic Programs

Eris is presented, a higher-order separation logic for proving error probability bounds for probabilistic programs written in an expressive higher-order language and introduces error credits, a separation logic resource that tracks an upper bound on the probability that a program returns an erroneous result.

71 References

Automated amortised analysis

The main result is the formal soundness proof of the proposed analysis for a functional language, based on the manual amortised complexity analysis, that automatically infers formally guaranteed upper bounds on the use of compositional quantitative resources.

Amortized Resource Analysis with Polynomial Potential

This work extends a type system that uses a potential-based amortized analysis to infer bounds on the resource consumption of (first-order) functional programs to polynomial resource bounds, which can obtain good bounds on heap-space, stack-space and time usage.

Exponential Automatic Amortized Resource Analysis

A general methodology for AARA is presented that is instantiated to the polynomial version, the exponential version, and a combined system with potential functions that are formed by products of Stirling numbers and binomial coefficients.

Automatic amortised analysis of dynamic memory allocation for lazy functional programs

This paper describes the first successful attempt to define an automatic, type-based static analysis of resource bounds for lazy functional programs by capturing the costs of unevaluated expressions in type annotations and amortising the payment of these costs using a notion of lazy potential.

Amortised Resource Analysis for Lazy Functional Programs

This thesis describes the first successful attempt to define an automatic, type-based static analysis of resource bounds for lazy functional programs by capturing the costs of unevaluated expressions in type annotations and amortising the payment of these costs using a notion of lazy potential.

Amortized Resource Analysis with Polymorphic Recursion and Partial Big-Step Operational Semantics

The soundness of the inference is proved with respect to a novel operational semantics for partial evaluations to show that the inferred bounds hold for terminating as well as non-terminating computations and that run-time bounds also establish the termination of programs.

Efficient Type-Checking for Amortised Heap-Space Analysis

An extension of this type system consisting of more general subtyping and sharing relations that allows to type more examples is presented and it is proved soundness and completeness of the type checking algorithm and its efficiency is shown.

Type-Based Cost Analysis for Lazy Functional Languages

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.

Arrays and References in Resource Aware ML

A technique to accurately perform static prediction of resource usage for ML-like functional programs with references and arrays is introduced and the soundness of the analysis is proved introducing a potential-annotated memory typing, which gathers all unique locations reachable from a reference.

Static determination of quantitative resource usage for higher-order programs

A new automatic static analysis for determining upper-bound functions on the use of quantitative resources for strict, higher-order, polymorphic, recursive programs dealing with possibly-aliased data is described, using a type-based approach.
...