PDF e-Pub

## Section: Research Program

### Cost Models and Abstract Machines for Functional Programs

In the proof normalization approach, computation is usually reformulated as the evaluation of functional programs, expressed as terms in a variation over the $\lambda$-calculus. Thanks to its higher-order nature, this approach provides very concise and abstract specifications. Its strength is however also its weakness: the abstraction from physical machines is pushed to a level where it is no longer clear how to measure the complexity of an algorithm.

Models like Turing machines or RAM rely on atomic computational steps and thus admit quite obvious cost models for time and space. The $\lambda$-calculus instead relies on a single non-atomic operation, $\beta$-reduction, for which costs in terms of time and space are far from evident.

Nonetheless, it turns out that the number of $\beta$-steps is a reasonable time cost model, i.e.,it is polynomially related to those of Turing machines and RAM. For the special case of weak evaluation (i.e., reducing only $\beta$-steps that are not under abstractions)—which is used to model functional programming languages—this is a relatively old result due to Blelloch and Greiner  [46] (1995). It is only very recently (2014) that the strong case—used in the implementation models of proof assistants—has been solved by Accattoli and Dal Lago [42].

With the recent recruitment of Accattoli, the team's research has expanded in this direction. The topics under investigations are:

1. Complexity of Abstract Machines. Bounding and comparing the overhead of different abstract machines for different evaluation schemas (weak/strong call-by-name/value/need $\lambda$-calculi) with respect to the cost model. The aim is the development of a complexity-aware theory of the implementation of functional programs.

2. Reasonable Space Cost Models. Essentially nothing is known about reasonable space cost models. It is known, however, that environment-based execution model—which are the mainstream technology for functional programs—do not provide an answer. We are exploring the use of the non-standard implementation models provided by Girard's Geometry of Interaction to address this question.