A Strong Distillery

Accattoli, Beniamino; Barenbaum, Pablo; Mazza, Damiano

doi:10.1007/978-3-319-26529-2_13

Cited by 14 publications

(20 citation statements)

References 28 publications

(44 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Other abstract machines for strong reduction have been studied too: de Carvalho [2009]; Ehrhard and Regnier [2006]; García-Pérez, Nogueira, and Moreno-Navarro [2013]. Accattoli and Guerrieri [2016] explore open call-by-value and Accattoli, Barenbaum, and Mazza [2015] study a (call-by-name) machine based on the linear substitution calculus for reduction to strong normal form. None of these mentioned works address however strong call-by-need.…”

Section: Related Workmentioning

confidence: 99%

Foundations of strong call by need

Balabonski

Barenbaum

Bonelli

et al. 2017

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

We present a call-by-need strategy for computing strong normal forms of open terms (reduction is admitted inside the body of abstractions and substitutions, and the terms may contain free variables), which guarantees that arguments are only evaluated when needed and at most once. The strategy is shown to be complete with respect to β-reduction to strong normal form. The proof of completeness relies on two key tools: (1) the definition of a strong call-by-need calculus where reduction may be performed inside any context, and (2) the use of non-idempotent intersection types. More precisely, terms admitting a β-normal form in pure lambda calculus are typable, typability implies (weak) normalisation in the strong call-by-need calculus, and weak normalisation in the strong call-by-need calculus implies normalisation in the strong call-by-need strategy. Our (strong) call-by-need strategy is also shown to be conservative over the standard (weak) call-by-need.[2002] have proposed a strong normalisation function N which they have proved to be correct, in the sense that N computes the normal form of strongly normalising, closed λ-terms. This function essentially consists in iterating the standard (weak) call-by-value (CBV) strategy on terms possibly containing free variables, Grégoire and Leroy [2002] refers to this variant of CBV as symbolic CBV.The starting point of this work is the observation that rather than iterating CBV, one should consider an appropriate notion of call-by-need (CBNd) that computes strong normal forms (of open terms). In this paper we replace symbolic CBV by symbolic CBNd, consisting in iterating the standard CBNd strategy on terms possibly containing free variables. Our strategy computes strong normal forms in which, in contrast to N , arguments are evaluated only if they are needed and, moreover, are evaluated at most once thus avoiding duplication of work. For example, the function N in Grégoire and Leroy [2002] computes the value of the argument (λz.z)(λz.z) in the λ-term (λx .λy.(λz.z)y)((λz.z)(λz.z)) even though this value is not required for the strong normal form of the whole term, whereas our strategy will not. Also, our strategy is normalising, i.e. it computes the normal form of weakly normalising terms, that is, of terms that admit a normal form but whose evaluation may diverge along some other strategies.Defining Strong Call-by-Need. Some of the subtleties involved in developing a theory of CBNd to strong normal form are illustrated next. In what follows, we write ⇝ for denoting the CBNd strategy to strong normal form devised in this paper and motivated below.Consider a term (λx .t )(id id), where id abbreviates the identity term λz.z and t is an arbitrary subterm (in Fig. 1, t is chosen to be λy.yxx). The first reduction step for a term of this shape is a common (weak) call-by-need step: the β-redex (λx .t )(id id) is turned into an explicit binding between the variable x and the argument id id in the expression t, which is often written let x = (id id) in t, or here t[x\id id], wher...

show abstract

Section: Related Workmentioning

confidence: 99%

Foundations of strong call by need

Balabonski

Barenbaum

Bonelli

et al. 2017

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

show abstract

“…Such a study leads to a new quantitative theory of abstract machines, where machines can be compared and the value of different design choices can be measured. The rest of the paper provides a gentle introduction to the basic concepts of the new complexity-aware theory of abstract machines being developed by the author in joint works [3,6,4,7,2] with Damiano Mazza, Pablo Barenbaum, and Claudio Sacerdoti Coen, and resting on tools and concepts developed beforehand in collaborations with Delia Kesner [9] and Ugo Dal Lago [8], as well as Kesner plus Eduardo Bonelli and Carlos Lombardi [5].…”

Section: Reasonablementioning

confidence: 99%

The Complexity of Abstract Machines

Accattoli

2017

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

The λ -calculus is a peculiar computational model whose definition does not come with a notion of machine. Unsurprisingly, implementations of the λ -calculus have been studied for decades. Abstract machines are implementations schema for fixed evaluation strategies that are a compromise between theory and practice: they are concrete enough to provide a notion of machine and abstract enough to avoid the many intricacies of actual implementations. There is an extensive literature about abstract machines for the λ -calculus, and yet-quite mysteriously-the efficiency of these machines with respect to the strategy that they implement has almost never been studied.This paper provides an unusual introduction to abstract machines, based on the complexity of their overhead with respect to the length of the implemented strategies. It is conceived to be a tutorial, focusing on the case study of implementing the weak head (call-by-name) strategy, and yet it is an original re-elaboration of known results. Moreover, some of the observation contained here never appeared in print before. Cost Models & Size-ExplosionThe λ -calculus is an undeniably elegant computational model. Its definition is given by three constructors and only one computational rule, and yet it is Turing-complete. A charming feature is that it does not rest on any notion of machine or automaton. The catch, however, is that its cost model are far from being evident. What should be taken as time and space measures for the λ -calculus? The natural answers are the number of computational steps (for time) and the maximum size of the terms involved in a computation (for space). Everyone having played with the λ -calculus would immediately point out a problem: the λ -calculus is a nondeterministic system where the number of steps depends much on the evaluation strategy, so much that some strategies may diverge when others provide a result (but fortunately the result, if any, does not depend on the strategy). While this is certainly an issue to address, it is not the serious one. The big deal is called size-explosion, and it affects all evaluation strategies. Size-Explosion.There are families of terms where the size of the n-th term is linear in n, evaluation takes a linear number of steps, but the size of the result is exponential in n. Therefore, the number of steps does not even account for the time to write down the result, and thus at first sight it does not look as a reasonable cost model. Let's see examples.The simplest one is a variation over the famous looping λ -term Ω := (λ x.xx)(λ x.xx) → β Ω → β . . .. In Ω there is an infinite sequence of duplications. In the first size-exploding family there is a sequence of n nested duplications. We define both the family {t n } n∈N of size-exploding terms and the family {u n } n∈N of results of the evaluation t 0 := y u 0 := y t n+1 := (λ x.xx)t n u n+1 := u n u nWe use |t| for the size of a term, i.e. the number of symbols to write it, and say that a term is neutral if it is normal and it is not an abstraction.

show abstract

“…Sands et al [33], and Danvy and Zerny [22] where however it has no impact on the complexity of the machines, as they deal with closed calculi. We discovered the relevance of this optimization in the open setting after our paper was submitted, in a joint work with Condoluci and Sacerdoti Coen [14], building on the present one, which is why we present it as an additional optimization.…”

Section: A Further Refinement: Renaming On βmentioning

confidence: 83%

“…The proof of Theorem 1 is a clean and abstract generalization of the concrete reasoning used in [12,10,2,3,14] for specific abstract machines and strategies, and it is a contribution of this work.…”

Section: Lemma 4 (One-step Simulationmentioning

confidence: 99%

Abstract machines for Open Call-by-Value

Accattoli

Guerrieri

2019

Science of Computer Programming

Self Cite

View full text Add to dashboard Cite

The theory of the call-by-value λ-calculus relies on weak evaluation and closed terms, that are natural hypotheses in the study of programming languages. To model proof assistants, however, strong evaluation and open terms are required. Open call-by-value is the intermediate setting of weak evaluation with (possibly) open terms, on top of which Grégoire and Leroy designed one of the abstract machines of Coq. This paper provides a theory of abstract machines for the fireball calculus, the simplest presentation of open callby-value. The literature contains machines that are either simple but inefficient, as they have an exponential overhead, or efficient but heavy, as they rely on a labeling of environments and a technical optimization. We introduce a machine that is simple and efficient: it does not use labels and it implements the fireball calculus within a bilinear overhead. Moreover, we provide a new fine understanding of how different optimizations impact on the complexity of the overhead, and evidence that the time cost model we work with is minimal.

show abstract

A Strong Distillery

Cited by 14 publications

References 28 publications

Foundations of strong call by need

Foundations of strong call by need

The Complexity of Abstract Machines

Abstract machines for Open Call-by-Value

Contact Info

Product

Resources

About