Mirroring Call-by-Need, or Values Acting Silly

2024-02-19

International Conference on Formal Structures for Computation and Deduction

AI Summary

This paper addresses the compositional interaction of copying and erasing behaviors in λ-calculus, identifying a gap in understanding how inefficiencies in evaluation strategies arise from their interplay. Method: We introduce *call-by-silly*, a symmetrically degenerate evaluation strategy orthogonal to call-by-need, deliberately combining the redundant copying of call-by-name with the blind erasure of call-by-value. We formally define the call-by-silly calculus and—using rewriting theory and a tight multi-type system—rigorously prove its contextual equivalence to call-by-value. Moreover, we construct the first type system that precisely characterizes the length of longest reduction sequences. Contribution: Our work reveals that contextual equivalence is insensitive to operational inefficiencies; provides the first symmetric degenerate model exhibiting both worst-case copying and worst-case erasure; and achieves a decidable, type-based characterization of evaluation length—establishing a novel bridge between type-theoretic precision and quantitative operational semantics.

Technology Category

• Constraint Satisfaction and Optimization: Satisfiability Modulo Theories
• Knowledge Representation and Reasoning: Computational Complexity of Reasoning
• Search and Optimization: Evaluation and Analysis

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Search and Retrieval-Augmented AI: Web evaluation methodologies and metrics
• Security and Privacy: Large-scale security measurements

Abstract

Call-by-need evaluation for the lambda-calculus can be seen as merging the best of call-by-name and call-by-value, namely the wise erasing behaviour of the former and the wise duplicating behaviour of the latter. To better understand how duplication and erasure can be combined, we design a degenerated calculus, dubbed call-by-silly, that is symmetric to call-by-need in that it merges the worst of call-by-name and call-by-value, namely silly duplications by-name and silly erasures by-value. We validate the design of the call-by-silly calculus via rewriting properties and multi types. In particular, we mirror the main theorem about call-by-need -- that is, its operational equivalence with call-by-name -- showing that call-by-silly and call-by-value induce the same contextual equivalence. This fact shows the blindness with respect to efficiency of call-by-value contextual equivalence. We also define a call-by-silly strategy and measure its length via tight multi types. Lastly, we prove that the call-by-silly strategy computes evaluation sequences of maximal length in the calculus.

Problem

• Designing a degenerated calculus merging worst duplication and erasure behaviors
• Validating call-by-silly via rewriting properties and multi types analysis
• Proving call-by-silly produces maximal length evaluation sequences

Innovation

• Degenerated calculus merging worst duplication and erasure
• Validated via rewriting properties and multi types
• Strategy with maximal evaluation sequence length