Fusion, one of the most useful transformation tactics for deriving efficient programs, is the process whereby separate pieces of programs are fused into a single one, leading to an efficient program with no intermediate data structures produced. In this paper, we report our on-going investigation on the design and implementation of an automatic transformation system HYLO which performs fusion transformation in a more systematic and more general way than any other systems. The distinguished point of our system is its calculational feature based on simple application of transformation laws rather than traditional search-based transformation. Keywords Program Transformation, Fusion, Constructive Algorithmics, Bird-Meertens Formalisms 1 INTRODUCTION Program transformation has been advocated as the linchpin of a programming paradigm in which the derivation of efficient programs from naive specification of problems is a formal and mechanically supported process [PP93]. It does not attempt ...

this paper, we shall formulate accumulations as higher order catamorphisms , and propose several general transformation rules for calculating accumulations (i.e., finding and manipulating accumulations) by calculation-based (rather than a search-based) program transformation methods. Some examples are given for illustration.

Program certification aims to provide explicit evidence that a program meets a specified level of safety. This evidence must be independently reproducible and verifiable. We have developed a system, based on theorem proving, that generates proofs that auto-generated aerospace code adheres to a number of safety policies. For certification purposes, these proofs need to be verified by a proof checker. Here, we describe and evaluate a semantic derivation verification approach to proof checking. The evaluation is based on 109 safety obligations that are attempted by EP and SPASS. Our system is able to verify 129 out of the 131 proofs found by the two provers. The majority of the proofs are checked completely in less than 15 seconds wall clock time. This shows that the proof checking task arising from a substantial prover application is practically tractable. 1

Program transformation is a technique for obtaining, starting from a program P, a semantically equivalent one, which is "better" than P with respect to a particular goal. Traditionally, the main goal of program transformation was obtaining more efficient programs, but, in general, this technique can be used to produce programs written in a syntactic form satisfying some properties. Program transformation techniques have been extensively studied in the framework of functional and logic languages, where they were applied mainly to obtain more efficient and readable programs. All these works are based on the Unfold/Fold program transformation method developed by Burstall and Darlington in the context of their recursive equational language. The use of Unfold /Fold based transformations for concurrent languages is a relevant issue that has not yet received an adequate attention. In fact the existing proposals of transformations of concurrent programs are not based on a general Unfold/Fold transformation theory. The aim of this paper is to define such a theory for the concurrent calculus CCS and to prove it correct. 1

The use of the program transformation methodology has been extensively studied in the framework of functional and logical languages. The aim of this paper is to evaluate the feasibility of a program transformation technique for concurrent programs, and in particular for CCS ones, with the aim of obtaining a program which has a "more manageable " syntactic form than the initial one, for example for proving properties of programs. In the paper we define a transformation methodology for CCS based on the "rules + strategies" approach. We first define a set of general "equivalence preserving" rules, which are a specialization, for CCS, of classical program transformation rules, such as Folding and Unfolding. Then we define a class of transformation rules specific for CCS. Finally, we give a strategy, using the defined rules, to transform, if possible, a CCS program into one whose operational semantics is a finite state transition system. The problem is significant, since most of the existing verification environments for CCS-like languages are based on an internal finite state representation of the program. We show that the set of programs for which our strategy succeeds properly contains the set of programs for which other existing methods succeed. 1

We provide a transformation strategy for primitive recursive program schemes which is based on the three transformation relations splitting, sharing, and tupling, and which is provably semantic preserving. The transformation strategy works "without eureka". We can prove that there are infinitely many nontrivial primitive recursive program schemes for which the resulting recursive program scheme is strictly more efficient than the original one.

We consider primitive recursive program schemes with parameters together with the callby -value computation rule. The schemes are finite systems of functions which are defined by primitive (or: structural) recursion; simultaneous recursion and nesting of function calls is allowed. We present a transformation strategy which replaces primitive recursion by iteration. The transformation strategy which is fully automatic, takes as input a primitive recursive program scheme M with parameters and it computes a program scheme M 0 as output. We prove that, for every argument tuple, M 0 is at least as (time) efficient as M . We also prove that there are infinitely many nontrivial primitive recursive program schemes M with parameters for which the transformation yields a program scheme M 0 such that there are infinitely many argument tuples for which M 0 is more efficient than M . Moreover, we provide an algorithm which decides for an arbitrary given primitive recursive program scheme M...

One problem of parallel computing is that parallel computers vary greatly in architecture so that a program written to run efficiently on a particular architecture, when porting to a different architecture, would often need to be changed and adapted substantially in order to run with reasonable performance on the target architecture. Porting with performance is, hence, labour-intensive and costly. A method of parallel programming using the Bird-Meertens Formalism where programs are formulated as compositions of (mainly) higher order functions on some data type in the data parallel functional style has been proposed as a solution. The library of (mainly) higher-order functions in which all communication and parallelism in a program is embedded could (it is argued) be implemented efficiently on different parallel architectures. This gives the advantage of portability between different architectures with reasonable and predictable performance without change in program source. ...