M. Ronan Sleep

Executing functional programs on a virtual tree of processors

A wide variety of computational models, including the lambda calculus, may be represented by a set of reduction rules which guide the (run-time) construction of a process tree. Even a single source of parallelism in an otherwise lazy evaluator may give rise to an exponential growth in the process tree, which must eventually overwhelm any finite architecture. We present a simple model for concurrently executing such process trees, which gives us a basis for matching the production of new tasks to the available resources. In addition, we present a generalised interpretation of a familiar topology suited to the support of large, perhaps irregular, virtual process trees on a much smaller physical network.

Dactl: An Experimental Graph Rewriting Language

Dactl is an experimental language programming language based on fine grain graph transformations. It was developed in the context of a large parallel reduction machine project. The design of the language is outlined, and examples given of its use both as a compiler target language and as a programming language. Dactl has a formal semantics and stable implementations on a number of platforms.

Director strings as combinators

A simple calculus (the Director String Calculus-DSC) for expressing abstractions is introduced, which captures the essence of the “long reach” combinators introduced by Turner. We present abstraction rules that preserve the applicative structure of the original lambda term, and that cannot increase the number of subterms in the translation. A translated lambda term can be reduced according to the evaluation rules of DSC. If this terminates with a DSC normal form, this can be translated into a lambda term using rules presented below. We call this process of abstracting a lambda term, reducing to normal form in the space of DSC terms, and translating back to a lambda term an implementation. We show that our implementation of the lambda calculus is correct: For lambda terms with a normal form that contains no lambdas (ground terms), the implementation is shown to yield a lambda calculus normal form. For lambda terms whose normal forms represent functions, it is shown that the implementation yields lambda terms that are beta-convertible in zero or more steps to the normal form of the original lambda term. In this sense, our implementation involves weak reduction according to Hindley et al. [9].

Comparing curried and uncurried rewriting

Abstract Currying is a transformation of term rewrite systems which may contain symbols of arbitrary arity into systems which contain only nullary symbols, together with a single binary symbol called application. We show that for all term rewrite systems (whether orthogonal or not) the following properties are preserved by this transformation: strong normalization, weak normalization, weak Church-Rosser, completeness, semi-completeness, and the non-convertibility of distinct normal forms. Under the condition of left-linearity we show preservation of the properties NF (if a term is reducible to a normal form,then its reducts are all reducible to the same normal form) and UN→ (a term is reducible to at most one normal form).We exhibit counterexamples to the preservation of NF and UN→ for non-left-linear systems.The results extend to partial currying(where some subset of the symbols are curried),and imply some modularity properties for unions of applicative systems.

Applicative caching: Programmer control of object sharing and lifetime in. distributed implementations of applicative languages

The “referential transparency” of applicative language expressions demands that all occurrences of an expression in a given context yield the same value. In principle, that value therefore needs to be computed only once. However, in recursive programming, a context usually unfolds dynamically, precluding textual recognition of multiple occurrences, so that such occurrences are recomputed. To remedy the lack, in applicative languages, of an ability to store and retrieve a computed value under programmer control, “caching functionals” are proposed which allow the programmer to selectively avoid recomputation without overt use of assignment. The uses and implementation of such mechanisms are discussed, including reasons and techniques for purging the underlying cache. Our approach is an extension of the early notion of “memo function”, enabling improved space utilization and a “building-block” approach.

Syntactic Definitions of Undefined: On Defining the Undefined

In the λ-calculus, there is a standard notion of what terms should be considered to be “undefined”: the unsolvable terms. There are various equivalent characterisations of this property of terms. We attempt to find a similar notion for orthogonal term rewrite systems. We find that in general the properties of terms analogous to the various characterisations of solvability differ.

Infinitary Lambda Calculi and Böhm Models

In a previous paper we have established the theory of transfinite reduction for orthogonal term rewriting systems. In this paper we perform the same task for the lambda calculus. This results in several new Bohm-like models of the lambda calculus, and new descriptions of existing models.

Infinitary rewriting: from syntax to semantics

Rewriting is the repeated transformation of a structured object according to a set of rules. This simple concept has turned out to have a rich variety of elaborations, giving rise to many different theoretical frameworks for reasoning about computation. Aside from its theoretical importance, rewriting has also been a significant influence on the design and implementation of real programming languages, most notably the functional and logic programming families of languages. For a theoretical perspective on the place of rewriting in Computer Science, see for example [14]. For a programming language perspective, see for example [16].

Lambda-Definable Term rewriting Systems

λ-definability of term rewriting systems has been an open question. Berarducci and Bohm show that canonical systems are translated into the λ-calculus. However, they do not present a theory which can formalize their translation. In this paper, we adapt Bohms separability theory for λ-definability. A term rewriting system version of separability, called separable systems, is proposed. Separable systems may includes multiple constructors in the left-hand sides, and canonical systems are a subclass of separable systems. An encoding technique of translating separable systems into the λ-calculus is presented.

Semagraph: the Theory and Practice of Term Graph Rewriting

Abstract Semagraph II is a working group (WG 6345) supported by the CEC basic research directorate. The main aim of Semagraph II has been to mature and promulgate the research results and prototypes developed during the Semagraph I Basic Research Action (BRA 3074). This note outlines the aims and achievements of Semagraph, and provides references to key results.