(Leftmost-Outermost) Beta Reduction is Invariant, Indeed

@article{Accattoli2016LeftmostOutermostBR,
  title={(Leftmost-Outermost) Beta Reduction is Invariant, Indeed},
  author={Beniamino Accattoli and Ugo Dal Lago},
  journal={Log. Methods Comput. Sci.},
  year={2016},
  volume={12}
}
Slot and van Emde Boas' weak invariance thesis states that reasonable machines can simulate each other within a polynomially overhead in time. Is lambda-calculus a reasonable machine? Is there a way to measure the computational complexity of a lambda-term? This paper presents the first complete positive answer to this long-standing problem. Moreover, our answer is completely machine-independent and based over a standard notion in the theory of lambda-calculus: the length of a leftmost-outermost… 

Figures from this paper

e strong invariance thesis for a λ-calculus
TLDR
The first proof of the strong invariance thesis for any kind of λ-calculus is proved, which enables results in the area of complexity theory, relying on both the simple measures and powerful verication techniques available for the authors' calculus.
The strong invariance thesis for a λ-calculus
TLDR
This talk will focus on an informal presentation of the interpretation strategies, introducing the first proof of the strong invariance thesis for any kind of λ-calculus, and hopes that this enables to formalise results in the area of complexity theory.
The weak call-by-value λ-calculus is reasonable for both time and space
TLDR
The proof for the weak call-by-value λ-calculus is the first proof of reasonability for a functional language based on natural measures and enables the formal verification of complexity-theoretic proofs concerning complexity classes, both on paper and in proof assistants.
Strong Call-by-Value is Reasonable, Implosively
TLDR
It is shown that also strong call-by-value evaluation is reasonable for time, via a new abstract machine realizing useful sharing and having a linear overhead, and a new mix of sharing techniques, which on some terms brings an exponential speed-up.
Strong Call by Value is Reasonable for Time
TLDR
This paper shows that a family of strong call-by-value strategies in the λ-calculus are reasonable for time, and is the first machine that implements a strong CbV strategy and simulates β-reduction with the overhead polynomial in the number of β-steps and in the size of the initial term.
The Useful MAM, a Reasonable Implementation of the Strong λ-Calculus
TLDR
This paper presents a new abstract machine for the strong $\lambda $$-calculus based on useful sharing, the Useful Milner Abstract Machine, and proves that it reasonably implements leftmost-outermost evaluation.
Towards the average-case analysis of substitution resolution in λ-calculus
TLDR
An effective hierarchy (Gn)n of regular tree grammars partitioning υ-normalisable terms into classes of terms normalising in n normal-order rewriting steps is established, and it is shown that for any fixed n ≥ 0, the probability that a uniformly random, conditioned on size, λυ-termπ�- normalises in nnormal-order tends to a computable limit as the term size tends to infinity.
A Mechanised Proof of the Time Invariance Thesis for the Weak Call-By-Value Lambda-Calculus
Maximilian Wuttke # Saarland University, Saarland Informatics Campus, Saarbrücken, Germany Abstract The weak call-by-value λ-calculus L and Turing machines can simulate each other with a polynomial
Linear Depth Increase of Lambda Terms in Leftmost-Outermost Beta-Reduction Rewrite Sequences
TLDR
The following property of leftmost-outermost $\beta$-reduction rewrite sequences in the Lambda Calculus is proved: for every lambda-term $t$ with depth $d$ it holds that in every step of a left most- outermost $\ beta$- reduction rewrite sequence starting on t the term depth increases by at most $d$, and hence the depth of the $n$-th reduct in such a rewrite sequence is bounded by d.
...
...

References

SHOWING 1-10 OF 53 REFERENCES
Beta reduction is invariant, indeed
TLDR
The main technical contribution of the paper is indeed the definition of useful reductions and the thorough analysis of their properties, and the first complete positive answer to this long-standing problem of λ-calculus.
Beta Reduction is Invariant, Indeed (Long Version)
TLDR
This paper presents the first complete positive answer to this long-standing problem, completely machine-independent and based over a standard notion in the theory of $\lambda$-calculus: the length of a leftmost-outermost derivation to normal form is an invariant cost model.
The weak lambda calculus as a reasonable machine
On Constructor Rewrite Systems and the Lambda-Calculus
We prove that orthogonal constructor term rewrite systems and lambda-calculus with weak (i.e., no reduction is allowed under the scope of a lambda-abstraction) call-by-value reduction can simulate
On the Invariance of the Unitary Cost Model for Head Reduction (Long Version)
TLDR
Invariance is proved by way of a linear calculus of explicit substitutions, which allows to nicely decompose any head reduction step in the lambda calculus into more elementary substitution steps, thus making the combinatorics of head-reduction easier to reason about.
Parallel beta reduction is not elementary recursive
TLDR
The computational paradigms of superposition of values and of higher-order sharing are identified, appealing to compelling analogies with quantum mechanics and SIMD-parallelism.
A logical account of pspace
TLDR
This work proposes a characterization of PSPACE by means of atype assignment for an extension of lambda calculus with a conditional construction and introduces a call-by-name evaluation machine in order to compute programs in polynomial space.
Distilling abstract machines
TLDR
The distillation process unveils that abstract machines in fact implement weak linear head reduction, a notion of evaluation having a central role in the theory of linear logic, and shows that the LSC is a complexity-preserving abstraction of abstract machines.
Maximal sharing in the Lambda calculus with letrec
TLDR
This work shows how a maximal degree of sharing can be obtained for programs expressed as terms in the lambda calculus with letrec, and introduces a notion of 'maximal compactness' for λletrec-terms among all terms with the same infinite unfolding.
...
...