On Constructor Rewrite Systems and the Lambda-Calculus (Long Version)

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 each other with a linear overhead. In particular, weak call-by-value beta-reduction can be simulated by an orthogonal constructor term rewrite system in the same number of reduction steps. Conversely, each reduction in a term rewrite system can be simulated by a constant number of beta-reduction steps. This is relevant to implicit computational complexity, because the number of beta steps to normal form is polynomially related to the actual cost (that is, as performed on a Turing machine) of normalization, under weak call-by-value reduction. Orthogonal constructor term rewrite systems and lambda-calculus are thus both polynomially related to Turing machines, taking as notion of cost their natural parameters.

💡 Research Summary

The paper establishes a tight, linear‑overhead correspondence between orthogonal constructor term rewrite systems (CRS) and the weak call‑by‑value λ‑calculus. After motivating the need for cost‑preserving simulations in implicit computational complexity, the authors formalise both models. The λ‑calculus is equipped with weak call‑by‑value reduction (→ᵥ) and the unit‑cost model Timeᵥ that counts β‑steps. CRS are defined over a signature containing constructors and function symbols, with the usual orthogonal constraints (non‑overlapping left‑hand sides, each variable appears at most once) and a call‑by‑value evaluation strategy that only substitutes constructor terms for variables.

The first major contribution is an encoding of λ‑terms into CRS. For every abstraction λx.M a constructor c_{x,M} is introduced whose arity equals the number of free variables of the abstraction; applications are represented by a binary function symbol app. The translation