Call-by-value, call-by-name and the vectorial behaviour of the algebraic lambda-calculus

We examine the relationship between the algebraic lambda-calculus, a fragment of the differential lambda-calculus and the linear-algebraic lambda-calculus, a candidate lambda-calculus for quantum computation. Both calculi are algebraic: each one is equipped with an additive and a scalar-multiplicative structure, and their set of terms is closed under linear combinations. However, the two languages were built using different approaches: the former is a call-by-name language whereas the latter is call-by-value; the former considers algebraic equalities whereas the latter approaches them through rewrite rules. In this paper, we analyse how these different approaches relate to one another. To this end, we propose four canonical languages based on each of the possible choices: call-by-name versus call-by-value, algebraic equality versus algebraic rewriting. We show that the various languages simulate one another. Due to subtle interaction between beta-reduction and algebraic rewriting, to make the languages consistent some additional hypotheses such as confluence or normalisation might be required. We carefully devise the required properties for each proof, making them general enough to be valid for any sub-language satisfying the corresponding properties.

💡 Research Summary

The paper investigates the relationship between two algebraic extensions of the λ‑calculus that have been proposed for different computational paradigms: the Algebraic λ‑Calculus, a fragment of the differential λ‑calculus that follows a call‑by‑name evaluation strategy and treats algebraic laws as equalities, and the Linear‑Algebraic λ‑Calculus, a candidate language for quantum computation that adopts a call‑by‑value strategy and implements algebraic laws through rewrite rules. Although both systems enrich the ordinary λ‑calculus with a linear structure (addition and scalar multiplication) and allow terms to be combined linearly, they were designed using distinct methodological choices.

To make the comparison systematic, the authors define four “canonical” languages that arise from the two binary design dimensions: (i) evaluation strategy (call‑by‑name vs. call‑by‑value) and (ii) treatment of algebraic laws (equational reasoning vs. rewriting). Each language is presented with a precise syntax, operational semantics, and a set of meta‑properties (confluence, strong normalisation, linearity preservation, etc.). The four languages are:

1. Call‑by‑name with algebraic equalities,
2. Call‑by‑name with algebraic rewrites,
3. Call‑by‑value with algebraic equalities,
4. Call‑by‑value with algebraic rewrites.

The core technical contribution is a series of simulation theorems showing that any of these languages can faithfully simulate any other. The authors construct explicit translations between terms and prove that reductions in the source language are mirrored by reductions in the target language, eventually reaching the same normal form (when it exists). The simulations are not trivial because β‑reduction and algebraic rewriting can interact in subtle ways. For instance, a term of the form (λx. α·x) (β·t + γ·s) may admit a β‑step before or after an algebraic rewrite, leading to different intermediate terms. To guarantee that the final results coincide, the paper identifies necessary additional hypotheses:

• Confluence of the algebraic rewrite system – ensures that different rewrite orders lead to a unique algebraic normal form.
• Strong normalisation – guarantees that rewrite sequences terminate, preventing infinite interleavings of β‑steps and algebraic reductions.
• Linearity preservation – requires that scalar multiplication and addition distribute over λ‑abstraction and application, so that algebraic manipulation commutes with β‑reduction.
• Compatibility (or commutation) between β‑reduction and algebraic steps – a form of Church‑Rosser property for the combined system.

Each simulation proof explicitly states which of these properties is required. For example, the simulation from call‑by‑value with rewrites to call‑by‑name with equalities needs strong normalisation of the rewrite system, while the reverse direction relies on confluence and linearity. The authors also discuss how weakening any of these assumptions can produce counter‑examples where the simulation fails, thereby clarifying the exact boundaries of the results.

Beyond the meta‑theoretical analysis, the paper explores the implications for quantum programming. The Linear‑Algebraic λ‑Calculus was introduced to model quantum superposition and linear operators; showing that it is simulation‑equivalent to a call‑by‑name, equality‑based system demonstrates that the choice of evaluation strategy does not affect expressive power, provided the algebraic layer satisfies the identified properties. Consequently, language designers can select the strategy that best matches implementation constraints (e.g., eager evaluation for quantum hardware) without sacrificing the underlying logical foundations.

In summary, the work provides a unified framework that reconciles the two main algebraic λ‑calculi, clarifies the role of evaluation strategy and algebraic treatment, and establishes robust simulation results under well‑specified meta‑properties. This contributes both to the theoretical understanding of linear‑algebraic extensions of λ‑calculus and to practical considerations in designing languages for quantum and other linear‑algebraic computations.