Abstract. Dynamic programming is a classical programming technique, applicable in a wide variety of domains such as stochastic systems analysis, operations research, combinatorics of discrete structures, flow problems, parsing of ambiguous languages, and biosequence analysis. Little methodology has hitherto been available to guide the design of such algorithms. The matrix recurrences that typically describe a dynamic programming algorithm are difficult to construct, error-prone to implement, and, in nontrivial applications, almost impossible to debug completely. This article introduces a discipline designed to alleviate this problem. We describe an algebraic style of dynamic programming over sequence data. We define its formal framework, based on a combination of grammars and algebras, and including a formalization of Bellman’s Principle. We suggest a language used for algorithm design on a convenient level of abstraction. We outline three ways of implementing this language, including an embedding in a lazy functional language. The workings of the

BURS theory provides a powerful mechanism to efficiently generate pattern matches in a given expression tree. BURS, which stands for bottom-up rewrite system, is based on term rewrite systems, to which costs are added. We formalise the underlying theory, and derive an algorithm that computes all pattern matches. This algorithm terminates if the term rewrite system is finite. We couple this algorithm with the well-known search algorithm A* that carries out pattern selection. The search algorithm is directed by a cost heuristic that estimates the minimum cost of code that has yet to be generated. The advantage of using a search algorithm is that we need to compute only those costs that may be part of an optimal rewrite sequence (and not the costs of all possible rewrite sequences as in dynamic programming). A system that implements the algorithms presented in this work has been built.

Every interactive system requires a presentation mechanism, to show the user the data it handles. Often, the relationship between the data and its presentation is complex; further, it is often mediated by astyle mechanism, allowing the user or a designer to describe how the data should be displayed. It is a standing engineering challenge to develop a presentation model that is exible, handling many kinds of data and layout; powerful, giving the user extensive control over appearance; and e cient enough for interactive work. In this dissertation, we propose a model of presentation by tree transformation. Because information often has a hierarchical logical structure, trees are widely used to represent documents and other data. The layout or presentation of a document is also often modeled as a computation over a tree. But these trees are not generally identical. In other words, presentation can be seen as a mapping between trees. Casting it as a formal tree transformation o ers both expressive, compact style speci cations and e cient implementation. We present a general framework for presentation by tree transformation. It has been implemented as part of Ensemble, a software development environment and multimedia document system

Abstract. Dynamic programming is a classic programming technique, applicable in a wide variety of domains, like stochastic systems analysis, operations research, combinatorics of discrete structures, flow problems, parsing with ambiguous grammars, or biosequence analysis. Yet, no methodology is available for designing such algorithms. The matrix recurrences that typically describe a dynamic programming algorithm are difficult to construct, error-prone to implement, and almost impossible to debug. This article introduces an algebraic style of dynamic programming over sequence data. We define the formal framework including a formalization of Bellman’s principle, specify an executable specification language, and show how algorithm design decisions and tuning for efficiency can be described on a convenient level of abstraction.

Abstract. Algebraic dynamic programming is a new method for developing and reasoning about dynamic programming algorithms. In this approach, so-called yield grammars and evaluation algebras constitute abstract specifications of dynamic programming algorithms. We describe how this theory is put to practice by providing a specification language that can both be embedded in a lazy functional language, and translated into an imperative language. Parts of the analysis required for the latter translation also gives rise to source-to-source transformations that improve the asymptotic efficiency of the functional implementation. The multi-paradigm system resulting from this approach provides increased programming productivity and effective validation. 1

A system called BURS that is based on term rewrite systems and a search algorithm A* are combined to produce a code generator that generates optimal code. The theory underlying BURS is re-developed, formalised and explained in this work. The search algorithm uses a cost heuristic that is derived from the term rewrite system to direct the search. The advantage of using a search algorithm is that we need to compute only those costs that may be part of an optimal rewrite sequence.

Abstract. Dynamic programming is a classic programming technique, applicable in a wide variety of domains, like stochastic systems analysis, operations research, combinatorics of discrete structures, flow problems, parsing ambiguous languages, or biosequence analysis. Yet, heretofore no methodology was available guiding the design of such algorithms. The matrix recurrences that typically describe a dynamic programming algorithm are difficult to construct, error-prone to implement, and almost impossible to debug. This article introduces an algebraic style of dynamic programming over sequence data. We define its formal framework including a formalization of Bellman’s principle. We suggest a language for algorithm design on a convenient level of abstraction. We outline three ways of implementation, including an embedding in a lazy functional language. The workings of the new method are illustrated by a series of examples from diverse areas of computer science.

This survey reports results on the ambiguity of finite tree automata, the valuedness of bottom-up finite state tree transducers and boundedness of cost automata.

Pagode is an advanced back-end generator that produces automatically a code generator from a specification of the processor. Such a specification is easy to derive from the various documents provided by the processor manufacturer, without requiring any additional code-generation expertise. This paper mainly focuses on the generic aspects of the Pagode system which is open enough to integrate the most powerful algorithms corresponding to the various subtasks of the code generation process. This approach has been validated by the production of a C-SPARC compiler in the framework of an industrial technology. Contents 1 Introduction 2 2 A generic back-end 3 3 Generic engines using the processor specification 4 3.1 The processor specification : : : : : : : : : : : : : : : : : : : : : : : : : : : : 4 3.2 A generic instruction selector : : : : : : : : : : : : : : : : : : : : : : : : : : : 7 3.3 A short example : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 7 3.4 The gen...