14 research outputs found
Extended Call-by-Push-Value: Reasoning About Effectful Programs and Evaluation Order
Traditionally, reasoning about programs under varying evaluation regimes (call-by-value, call-by-name etc.) was done at the meta-level, treating them as term rewriting systems. Levy’s call-by-push-value (CBPV) calculus provides a more powerful approach for reasoning, by treating CBPV terms as a common intermediate language which captures both call-by-value and call-by-name, and by allowing equational reasoning about changes to evaluation order between or within programs.
We extend CBPV to additionally deal with call-by-need, which is non-trivial because of shared reductions. This allows the equational reasoning to also support call-by-need. As an example, we then prove that call-by-need and call-by-name are equivalent if nontermination is the only side-effect in the source language.
We then show how to incorporate an effect system. This enables us to exploit static knowledge of the potential effects of a given expression to augment equational reasoning; thus a program fragment might be invariant under change of evaluation regime only because of knowledge of its effects
Useful Open Call-By-Need
This paper studies useful sharing, which is a sophisticated optimization for ?-calculi, in the context of call-by-need evaluation in presence of open terms. Useful sharing turns out to be harder in call-by-need than in call-by-name or call-by-value, because call-by-need evaluates inside environments, making it harder to specify when a substitution step is useful. We isolate the key involved concepts and prove the correctness and the completeness of useful sharing in this setting
Distilling Abstract Machines (Long Version)
It is well-known that many environment-based abstract machines can be seen as
strategies in lambda calculi with explicit substitutions (ES). Recently,
graphical syntaxes and linear logic led to the linear substitution calculus
(LSC), a new approach to ES that is halfway between big-step calculi and
traditional calculi with ES. This paper studies the relationship between the
LSC and environment-based abstract machines. While traditional calculi with ES
simulate abstract machines, the LSC rather distills them: some transitions are
simulated while others vanish, as they map to a notion of structural
congruence. 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. We show that such a pattern applies
uniformly in call-by-name, call-by-value, and call-by-need, catching many
machines in the literature. We start by distilling the KAM, the CEK, and the
ZINC, and then provide simplified versions of the SECD, the lazy KAM, and
Sestoft's machine. Along the way we also introduce some new machines with
global environments. Moreover, we show that distillation preserves the time
complexity of the executions, i.e. the LSC is a complexity-preserving
abstraction of abstract machines.Comment: 63 page
: De la réduction linéaire de tête à l'évaluation paresseuse
National audienceÀ partir de la réduction linéaire de tête, nous dérivons de manière systématique un calcul en appel par nécessité. L'introduction d'un calcul pour la réduction linéaire de tête, basée sur une analyse fine de la notion de radicaux premiers de Danos et Regnier, nous permet de construire pas à pas un lambda-calcul en appel par nécessité que l'on compare aux calculs présents dans la littérature
Node Replication: Theory And Practice
We define and study a term calculus implementing higher-order node
replication. It is used to specify two different (weak) evaluation strategies:
call-by-name and fully lazy call-by-need, that are shown to be observationally
equivalent by using type theoretical technical tools.Comment: 64 pages, submitted to LMC
A strong call-by-need calculus
We present a call-by-need -calculus that enables strong reduction
(that is, reduction inside the body of abstractions) and guarantees that
arguments are only evaluated if needed and at most once. This calculus uses
explicit substitutions and subsumes the existing strong-call-by-need strategy,
but allows for more reduction sequences, and often shorter ones, while
preserving the neededness. The calculus is shown to be normalizing in a strong
sense: Whenever a -term t admits a normal form n in the
-calculus, then any reduction sequence from t in the calculus
eventually reaches a representative of the normal form n. We also exhibit a
restriction of this calculus that has the diamond property and that only
performs reduction sequences of minimal length, which makes it systematically
better than the existing strategy. We have used the Abella proof assistant to
formalize part of this calculus, and discuss how this experiment affected its
design. In particular, it led us to derive a new description of call-by-need
reduction based on inductive rules
Node Replication: Theory And Practice
We define and study a term calculus implementing higher-order node
replication. It is used to specify two different (weak) evaluation strategies:
call-by-name and fully lazy call-by-need, that are shown to be observationally
equivalent by using type theoretical technical tools