Explaining the lazy Krivine machine using explicit substitution and addresses

Lang, Frédéric

doi:10.1007/s10990-007-9013-1

Cited by 8 publications

(6 citation statements)

References 22 publications

(31 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The λ [lvτ ⋆] -calculus. Since the call-by-need evaluation strategy imposes to share the evaluation of arguments across all the places where thay are need, abstract machines implementing it require a form of global memory [65,14,46,1]. In order to obtain such an abstract machine from the λ lv -calculus, Ariola et al first define the λ [lvτ ⋆] -calculus, which is reformulation of the former using explicit environments.…”

Section: 2mentioning

confidence: 99%

A constructive proof of dependent choice in classical arithmetic via memoization

Miquey¹

2019

Preprint

View full text Add to dashboard Cite

In a recent paper [29], Herbelin developed dPA ω , a calculus in which constructive proofs for the axioms of countable and dependent choices could be derived via the memoization of choice functions. However, the property of normalization (and therefore the one of soundness) was only conjectured. The difficulty for the proof of normalization is due to the simultaneous presence of dependent types (for the constructive part of the choice), of control operators (for classical logic), of coinductive objects (to encode functions of type N → A into streams (a0, a1, . . .)) and of lazy evaluation with sharing (for memoizing these coinductive objects).Elaborating on previous works, we introduce in this paper a variant of dPA ω presented as a sequent calculus. On the one hand, we take advantage of a variant of Krivine classical realizability that we developed to prove the normalization of classical call-by-need [55]. On the other hand, we benefit from dL tp , a classical sequent calculus with dependent types in which type safety is ensured by using delimited continuations together with a syntactic restriction [54]. By combining the techniques developed in these papers, we manage to define a realizability interpretation à la Krivine of our calculus that allows us to prove normalization and soundness. This paper goes over the whole process, starting from Herbelin's calculus dPA ω until our introduction of its sequent calculus counterpart dLPA ω .

show abstract

Section: 2mentioning

confidence: 99%

A constructive proof of dependent choice in classical arithmetic via memoization

Miquey¹

2019

Preprint

View full text Add to dashboard Cite

show abstract

“…Such a structure resemble to a tree whose nodes are decorated by terms, as opposed to a machinery allowing sharing (like ours) whose underlying structure is broadly a directed acyclic graph. See for instance [24] for a Krivine abstract machine with sharing.…”

Section: Explicit Environmentsmentioning

confidence: 99%

Realizability Interpretation and Normalization of Typed Call-by-Need $$\lambda $$-calculus with Control

Miquey

Herbelin

2018

Lecture Notes in Computer Science

View full text Add to dashboard Cite

We define a variant of Krivine realizability where realizers are pairs of a term and a substitution. This variant allows us to prove the normalization of a simply-typed call-by-need λ-calculus with control due to Ariola et al. Indeed, in such call-by-need calculus, substitutions have to be delayed until knowing if an argument is really needed. We then extend the proof to a call-by-need λ-calculus equipped with a type system equivalent to classical second-order predicate logic, representing one step towards proving the normalization of the call-by-need classical second-order arithmetic introduced by the second author to provide a proof-as-program interpretation of the axiom of dependent choice. The call-by-need evaluation strategyThe call-by-need evaluation strategy of the λ-calculus evaluates arguments of functions only when needed, and, when needed, shares their evaluations across all places where the argument is required. The call-by-need evaluation is at the heart of a functional programming language such as Haskell. It has in common with the call-by-value evaluation strategy that all places where a same argument is used share the same value. Nevertheless, it observationally behaves like the callby-name evaluation strategy (for the pure λ-calculus), in the sense that a given computation eventually evaluates to a value if and only if it evaluates to the same value (up to inner reduction) along the call-by-name evaluation. In particular, in a setting with non-terminating computations, it is not observationally equivalent to the call-by-value evaluation. Indeed, if the evaluation of a useless argument loops in the call-by-value evaluation, the whole computation loops, which is not the case of call-by-name and call-by-need evaluations.These three evaluation strategies can be turned into equational theories. For call-by-name and call-by-value, this was done by Plotkin through continuationpassing-style (CPS) semantics characterizing these theories [34]. For the call-byneed evaluation strategy, a specific equational theory reflecting the intensional behavior of the strategy into a semantics was proposed independently by Ariola and Felleisen [1], and by Maraist, Odersky and Wadler [26]. A continuationpassing-style semantics was proposed in the 90s by Okasaki, Lee and Tarditi [30]. However, this semantics does not ensure normalization of simply-typed call-byneed evaluation, as shown in [2], thus failing to ensure a property which holds in the simply-typed call-by-name and call-by-value cases.Continuation-passing-style semantics de facto gives a semantics to the extension of λ-calculus with control operators 6 . In particular, even though call-byname and call-by-need are observationally equivalent on pure λ-calculus, their different intentional behaviors induce different CPS semantics, leading to different observational behaviors when control operators are considered. On the other hand, the semantics of calculi with control can also be reconstructed from an analysis of the duality between programs and their evaluation c...

show abstract

“…Instead, lazy evaluation strategies require abstract machines with a global environment [3,33]. Such machines demand in particular to explicitly handle addresses (as in the Lazy Krivine [21]) or a renaming process (as in the Milner Abstract Machine [2]).…”

Section: Introductionmentioning

confidence: 99%

A calculus of expandable stores

Herbelin

Miquey

2020

Proceedings of the 35th Annual ACM/IEEE Symposium on Logic in Computer Science

View full text Add to dashboard Cite

The call-by-need evaluation strategy for the λ-calculus is an evaluation strategy that lazily evaluates arguments only if needed, and if so, shares computations across all places where it is needed. To implement this evaluation strategy, abstract machines require some form of global environment. While abstract machines usually lead to a better understanding of the flow of control during the execution, facilitating in particular the definition of continuation-passing style translations, the case of machines with global environments turns out to be much more subtle. The main purpose of this paper is to understand how to type a continuation-and-environment-passing style translation, that is to say how to soundly translate in continuationpassing style a calculus with global environment. To this end, we introduce F ϒ , a generic calculus to define the target of such translations. In particular, F ϒ features a data type for typed stores and a mechanism of explicit coercions witnessing store extensions along environment-passing style translations. On the logical side, this broadly amounts to a Kripke forcing-like translation mixed with a negative translation (for the continuation-passing part). Since F ϒ allows for the definition of such translations for different source calculi (call-by-need, call-by-name, call-by-value) with different type systems (simple types, system F), we claim that it precisely captures the computational content of continuationand-environment-passing style translations.

show abstract

Explaining the lazy Krivine machine using explicit substitution and addresses

Cited by 8 publications

References 22 publications

A constructive proof of dependent choice in classical arithmetic via memoization

A constructive proof of dependent choice in classical arithmetic via memoization

Realizability Interpretation and Normalization of Typed Call-by-Need $$\lambda $$-calculus with Control

A calculus of expandable stores

Contact Info

Product

Resources

About