A Consistent Semantics of Self-adjusting Computation

107

The LF logical framework codifies a methodology for representing deductive systems, such as programming languages and logics, within a dependently typed λ-calculus. In this methodology, the syntactic and deductive apparatus of a system is encoded as the canonical forms of associated LF types; an encoding is correct (adequate) if and only if it defines a compositional bijection between the apparatus of the deductive system and the associated canonical forms. Given an adequate encoding, one may establish metatheoretic properties of a deductive system by reasoning about the associated LF representation. The Twelf implementation of the LF logical framework is a convenient and powerful tool for putting this methodology into practice. Twelf supports both the representation of a deductive system and the mechanical verification of proofs of metatheorems about it.The purpose of this paper is to provide an up-to-date overview of the LF λ-calculus, the LF methodology for adequate representation, and the Twelf methodology for mechanizing metatheory. We begin by defining a variant of the original LF language, called Canonical LF, in which only canonical forms (long βη-normal forms) are permitted. This variant is parameterized by a subordination relation, which enables modular reasoning about LF representations. We then give an adequate representation of a simply typed λ-calculus in Canonical LF, both to illustrate adequacy and to serve as an object of analysis. Using this representation, we formalize and verify the proofs of some metatheoretic results, including preservation, determinacy, and strengthening. Each example illustrates a significant aspect of using LF and Twelf for formalized metatheory.

Section: Applications Of Lf and Twelfmentioning

confidence: 99%

Mechanizing metatheory in a logical framework

Harper¹,

Licata²

2007

107

“…While not typically considered build systems, self-adjusting computation is a well-studied area, and in particular, the contrast between different formulations has been thoroughly investigated, for example, see Acar et al (2007). Self-adjusting computations can automatically adjust to an external change to their inputs.…”

Section: Self-adjusting Computationmentioning

confidence: 99%

“…First, to decide which files need to be rebuilt, it stores the dependency graph that is constructed during the previous build (instead of just file modification times or a linear chain). This idea has a long history, going back to incremental (Demers et al, 1981), adaptive (Acar et al, 2002), and self-adjusting computations -see Acar et al (2007) and Section 9. Second, instead of aborting and deferring the execution of tasks whose newly discovered dependencies have not yet been built (as EXCEL does), SHAKE suspends their execution until the dependencies are brought up to date.…”

mentioning

confidence: 99%

Build systems à la carte: Theory and practice

Mokhov

Mitchell²,

Jones

2020

Build systems are awesome, terrifying – and unloved. They are used by every developer around the world, but are rarely the object of study. In this paper, we offer a systematic, and executable, framework for developing and comparing build systems, viewing them as related points in a landscape rather than as isolated phenomena. By teasing apart existing build systems, we can recombine their components, allowing us to prototype new build systems with desired properties.

“…Although DDGs are general-purpose graphs, they are effective only for certain classes of data changes (Section 2). This paper presents a semantics for self-adjusting computation based on a memoizing change propagation technique that can dramatically improve reuse of computations; the paper is the journal version of a conference paper (Acar et al, 2007) published earlier. The semantics presented here established the foundation for follow-up work on self-adjusting computation and related topics.…”

Section: Self-adjusting Computationmentioning

confidence: 99%

A consistent semantics of self-adjusting computation

Acar¹,

Blume²,

Donham³

2013

Self Cite

This paper presents a semantics of self-adjusting computation and proves that the semantics are correct and consistent. The semantics integrate change propagation with the classic idea of memoization to enable reuse of computations under mutation to memory. During evaluation, reuse of a computation via memoization triggers a change propagation that adjusts the reused computation to reflect the mutated memory. Since the semantics integrate memoization and change-propagation, it involves both non-determinism (due to memoization) and mutation (due to change propagation). Our consistency theorem states that the non-determinism is not harmful: any two evaluations of the same program starting at the same state yield the same result. Our correctness theorem states that mutation is not harmful: self-adjusting programs are consistent with purely functional programming. We formalize the semantics and their meta-theory in the LF logical framework and machine check our proofs using Twelf. IntroductionMany applications operate on data that changes over time. Self-adjusting computation is a technique that enables program to respond to changes to their data (e.g., inputs/arguments, external state, or outcome of tests). Advances on self-adjusting computation show that it can speed up response times by orders of magnitude over recomputing from scratch, closely matching best-known (problem-specific) algorithms both in theory and in practice (e.g., [3]). More recent results show that the approach can even enable solving challenging open problems that have resisted traditional algorithmic approaches (e.g. [7,6]).Key to effectiveness of self-adjusting computation is a technique that integrates change propagation [4], and the classic idea of memoization [17]. Due to an interesting duality between memoization and change propagation, combining them turns out to be crucial for efficiency. This technique was first developed in two previously published conference papers. One paper focused on algorithmic, implementation, and experimental aspects (journal version [3]). The other formal *