Richard S. Bird. Addendum to "The promotion and accumulation strategies in transformational programming". ACM Transactions on Programming Languages and Systems, 7(3):490--492, July 1985.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....One of the most important techniques used to improve program performance involves incrementally updating results of computations as their parameters change rather than computing the results from scratch. This problem has received much attention in the transformational programming literature [7, 12, 35, 37, 45], where it is commonly known as finite differencing. However, general techniques of incremental computation have far broader application throughout software, e.g. loop optimizations in optimizing compilers [2, 3, 11, 14, 46] interactive systems like editors [6, 13, 43] and programming ....

....thus i 1 by i Gamma 1) b[i; j] b[i Gamma 1; j] Gamma c[i Gamma 1; j] c[i m; j] 12) In summary, only four Sigma operations are needed for each pixel, no matter how large m is. Thus the whole program takes only O(n ) time. 11 6. 3 Path Sequence Problem This example is taken from [7]. Given a directed acyclic graph, and a string whose elements are vertices in the graph, the problem is to compute the length of the longest subsequence in the string that forms a path in the graph. We focus on the second half where an exponential time recursive solution is improved (incorrectly ....

[Article contains additional citation context not shown here]

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, October 1984.

....general and systematic. Second, it stores only values that are necessary for the optimization; it also shows exactly when and where subproblems not in the original computation have to be included. Our method is based on a number of static analyses and transformations studied previously by others [6, 9, 21, 42, 47, 55, 56, 62] and ourselves [30, 37, 38, 39] and improves them. Each of the caching, incrementalization, and pruning steps is simple, automatable, and ecient and has been implemented in a prototype system, CACHET. The system has been used in optimizing many programs written as straightforward recursions, ....

.... arg aux info original program s running time optimized prog s running time Fibonacci function [45] O(2 ) O(n) binomial coecients [45] O(2 ) O(n k) longest common subsequence [15] matrix chain multiplication [15] string editing distance [52] O(3 dag path sequence [6] optimal polygon triangulation [15] optimal binary search tree [2] paragraph formatting [15] paragraph formatting 2 ) O(n width) 0 1 knapsack [15] a O(2 ) O(n weight) context free grammar parsing [2] p p a O(n (2 size 1) size) Figure 3: ....

[Article contains additional citation context not shown here]

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Trans. Program. Lang. Syst., 6(4):487-504, Oct. 1984.

....(4, 10) 5, 15) 6, 21) With the same trick, we can eliminate the other four. Consequently, the aggregate predicates can be expressed in the form of f (head) g (last) It should be noted that this preprocessing does not raise additional cost by using accumulation and fusion techniques [Bir84, Chi92]. Normalization of Composite Property Next, let us turn our attention to the composite property. With respect to it, we have the following Lemma holds. Lemma 2 (Normalization) Any composite predicate can be expressed in its canonical form, that is, the disjunction of a number of conjunction of ....

R. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

....program, the programmer is faced with a tension between correctness and efficiency. A program that is easy to understand and whose correctness is obvious to see often fails to be efficient, while a more efficient program often compromises clarity. Transformational programming [BD77, Fea87, Dar81, Bir84, Bir86, Bir87, Bac95] is a well known methodology to address this difficulty. In transformational programming, one does not attempt to produce directly a program that is correct, understandable and efficient, rather one initially concentrates on producing a program which is as clear and ....

....ignoring any question of efficiency. Having satisfied himself that he has a correct program he successively transforms it to more and more efficient versions using methods guaranteed to preserve the meaning of the program. Although quite a lot of creative, elegant and efficient algorithms [Bir84, Bir86, PP96] have been derived in this manner showing the impetus of the transformational approach to programming, there remain two major problems. 1 September 1999, METR 99 06 ffl Insightful rules for big step jumps can be difficult to find. While creative algorithms are interesting to ....

[Article contains additional citation context not shown here]

R. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

....with a list elimination approach by shortcut deforestation for polymorphically recursive workers in Section 7.1. Example 3. Consider the following specification of a function inits that returns the list of initial segments of its argument list e.g. inits [1. 4] 1] 1, 2] 1, 2,3] [1, 2,3,4]] inits : inits [ inits (x : xs) map (x : inits xs) By abstracting from the list constructors of the outer result list including map and using Theorem 3, inits can be replaced by: l = vanish ,rev,map (ln c a r m let f [ c n f (x : ....

....eliminate such substitution functions from top down tree transducer modules by introducing accumulating parameters. Their integration step could also be realized in the framework of our methodology, thus generalizing their accumulation technique to arbitrary functions that produce trees. Bird [4], Hu et al. 11] use calculational methods to derive accumulative programs in their setting higher order folds over algebraic data types from first order folds, such as transforming rev from the previous subsection into rev (which none of the other accumulation methods discussed here ....

R. Bird. The promotion and accumulation strategies in transformational programming. ACM Trans. on Prog. Lang. and Systems, 6:487--504, 1984.

....of the resulting algorithm. Equally or more important are the assurance of correctness for the algorithm and implementation developed and the ability to develop them easily and quickly. Much previous research has answered these questions positively for subclasses of problems, e.g. [4, 7, 8, 9, 10, 11, 13, 14, 16, 19, 30, 31, 34, 37]. This paper describes a method that uni es and generalizes existing classes of problems that can be solved systematically. Important and interesting questions in detail are: How are appropriate data structures determined In case multiple choices exist, how can they be compared Two fundamental ....

.... Examples original program s running time optimized prog s running time Fibonacci function [29] O(2 ) O(n) binomial coecients [29] O(2 ) O(n k) longest common subsequence [12] O(2 matrix chain multiplication [12] O(n 3 string editing distance [33] O(3 dag path sequence [8] O(2 optimal polygon triangulation [12] O(n 3 optimal binary search tree [1] O(n 3 paragraph formatting [12] O(n 2 paragraph formatting 2 [19] O(n 2 ) O(n width) 0 1 knapsack [12] O(2 ) O(n weight) context free grammar parsing [1] O(n (2 size 1) ....

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Trans. Program. Lang. Syst., 6(4):487-504, Oct. 1984.

....x i changed to a pair (x i , s i ) and reduce aggregate sum property to a transitive total order relation between the leftmost and rightmost elements of the concerned segment. It is worth noting that this preprocessing does not raise additional cost by using accumulation and fusion technique [Bir84]. With the same trick, the other four aggregate predicates can also be normalized into the primitive form. Accordingly, we further have the following selfevident lemma hold for the composite property. Lemma 2 (Disjunctive Normal Form) Any composite predicate can be expressed in its canonical ....

R. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

....performance degradation, especially with the increasingly large data sets that many applications are facing, yet methods for eliminating overlapping aggregate array redundancy have been lacking. Optimizations similar to incrementalization have been studied for various language features, e.g. [8, 16, 34, 52, 51, 53, 57, 58, 59, 71, 79], but no systematic technique handles aggregate computations on arrays. At the same time, many optimizations have been studied for arrays, e.g. 1, 2, 3, 4, 6, 22, 29, 31, 37, 41, 55, 56, 63, 69, 74] but none of them achieves incrementalization. This paper presents a method and algorithms for ....

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Trans. Program. Lang. Syst., 6(4):487-504, Oct. 1984.

.... = f apply law (3) map(f,map(g,xs) map(f g,xs) g tails( x] atten(map(tails (x: inits(xs) After several steps, we are still unable to fold as we encountered a slightly enlarged expression of the form atten(map(tails (x: inits(xs) As reported elsewhere [Bir84] and [HIT99] this calls for the use of an accumulation tactic which generalizes (x: to (w ) asegs (w,xs) atten(map(tails (w ) inits(xs) A subsequent fusion transformation obtains: asegs (w, x] tails(w [x] asegs (w,x:xs) tails(w [x] asegs (w [x] xs) In general, this ....

Richard S. Bird. The promotion and accumulation strategies in transformational programming. ACM Trans. on Programming Languages and Systems, 6(4):487-504, October 1984.

....We also show that the notion of downwards accumulation developed by Gibbons is subsumed by our notion of accumulation. 1 Introduction often called accumulators [20, 5, 15] In functional programming, the notion of accumulation is usually associated with the so called accumulation technique [8, 4, 18, 3], which transforms recursive definitions by the introduction of additional arguments over which intermediate results are computed. The accumulation technique is strongly connected with the familiar procedure of generalization for induction that arises in the field of theorem proving [7, 1, 26] A ....

.... X A) Examples of the use of these laws can be found in [29] 4 Accumulations Accumulations are recursive functions that keep intermediate results in additional parameters, known as accumulating parameters or accumulators, which are eventually used in later stages of the computation (see e.g. [4, 20, 5, 15]) In this section we define a generic operator that permits us to represent structural recursive accumulations on inductive types. The operator is obtained by a small modification in the definition of pfold. Let us start with an example of an accumulation. Consider the function that computes the ....

R.S. Bird. The Promotion and Accumulation Strategies in Transformational Programming. ACM Transactions on Programming Languages and Systems, 6(4), October 1984.

....guration is generated, and thus eciency is improved. By applying our proposed list introduction strategy we will mechanically derive a program which is similar to the accumulator program version of [StS94] Indeed, this strategy will allow us to realise the so called lter promotion described in [Bir84, Dar78], by which the safeness test is promoted into the generation process and the number of generated unsafe board con gurations is decreased. A similar e ect may also be achieved by the compiling control technique described in [BDK89] which works by transforming a given initial program into a new ....

.... of Cohen [Coh83] by which arrays whose dimensions depend on the size of the input are introduced, ii) the continuation based transformations of Wand [Wan80] whereby one exploits the power of higher order arguments which store sequences of function calls, iii) the accumulation technique of Bird [Bir84], which works by introducing variables to collect a number of previously computed values. All these techniques follow a schemata approach, by which program transformations are expressed as a catalogue of conditional equivalences between program schemata. In order to apply a transformation to a ....

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Toplas, 6(4):487{ 504, 1984.

....guration is generated, and thus, eciency is improved. By applying our proposed list introduction strategy we will mechanically derive a program which is similar to the accumulator program version of [StS94] Indeed, this strategy will allow us to realize the so called lter promotion described in [Bir84, Dar78], by which the safeness test is promoted into the generation process and the number of generated unsafe board con gurations is decreased. A similar e ect may also be achieved by the compiling control technique described in [BDK89] which works by transforming a given initial program into a new ....

.... of Cohen [Coh83] by which arrays whose dimensions depend on the size of the input are introduced, ii) the continuation based transformations of Wand [Wan80] whereby one exploits the power of higher order arguments which store sequences of function calls, iii) the accumulation technique of Bird [Bir84], which works by introducing variables to collect a number of previously computed values. All these techniques follow a schemata approach, by which program transformations are expressed as a catalog of conditional equivalences between program schemata. In order to apply a transformation to a ....

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Toplas, 6(4):487{ 504, 1984.

....of the speedup of the resulting algorithm. Equally or more important are the assurance of correctness for the algorithm and implementation developed and the ability to develop them easily and quickly. Much previous research has answered these questions positively for subclasses of problems, e.g. [10, 3, 27, 7, 24, 4, 12, 6, 29, 9, 25, 5, 14]. This paper describes a method that uni es and generalizes existing classes of problems that can be solved systematically. Important and interesting questions in detail are: How are appropriate data structures determined In case multiple choices exist, how can they be compared Two fundamental ....

.... optimized prog s running time Fibonacci function [23] O(2 n ) O(n) binomial coecients [23] O(2 n ) O(n k) longest common subsequence [8] O(2 n m ) O(n m) matrix chain multiplication [8] O(n 3 n ) O(n 3 ) string editing distance [26] O(3 n m ) O(n m) dag path sequence [4] O(2 n ) O(n 2 ) optimal polygon triangulation [8] O(n 3 n ) O(n 3 ) optimal binary search tree [1] O(n 3 n ) O(n 3 ) paragraph formatting [8] O(n 2 n ) O(n 2 ) paragraph formatting 2 [14] O(n 2 n ) O(n width) 0 1 knapsack [8] O(2 n ) O(n weight) ....

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Trans. Program. Lang. Syst., 6(4):487-504, Oct. 1984.

....function length which computes the number of elements of a set, and to denote the lter operator on set: p s produces a new set whose elements are all from the set s but satisfy the predicate p. The lter operator enjoys the lter map property (that is commonly used in program derivation e.g. Bir84] p ) x : x : p (x : 1) and the lter pipeline property: p ) q ) x: p x q x) 2) In addition, xs ys is true if xs is a sublist (i.e. subset) of ys, and false otherwise: ys = T rue (x : xs) ys = xs ys x 2 ys: So much for our speci cation ....

....the readers are familiar with the Haskell language [Bir98] in this paper. In addition, we say that our Haskell programs are pseudo in the sense that they include some additional notations for sets. 4 by using the known calculation techniques of fusion [Chi92] generalization (accumulation) Bir84, HIT99] base case lter promotion [Chi90] and tabulation [Bir80, CH95] Our derivation strategy is rather standard for program optimization and can be summarized as follows. First, we eliminate as much unnecessary intermediate data structures as possible by fusion of composition of recursive ....

[Article contains additional citation context not shown here]

R. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487-504, 1984.

....the Accumulation Promotion Theorems. 1 ] Deriving an accumulation for subs This derivation has been already given in Example 4.2. The result is as follows. subs xs = 1 5 2 ] F1 F2 xs ffl where 1 ( y = f[y]g 2 (x; p) y = p y [ y : 3 (p x) where F 1 = 1 and F 2 = a 2 I . [ 2 ] Manipulating (path ) ffi subs After obtaining the accumulation for subs, we step to derive an accumulation for the composition of the function path with the subs based on Theorem 5.1. Let k = path . We calculate 1 ; 2 from 1 ; 2 and k based on the 18 Zhenjiang HU, Hideya IWASAKI, Masato ....

....= x; p 0 ) y: p 0 y) if arc y x y 6= ffl then (y : 3 (p 0 x) else (p 0 x) ffi F 2 (kffi) Thus we get 2 defined as 2 (x; p) y = p y) h where h = if arc y x y 6= ffl then (y : 3 (p x) else (p x) Finally, according to Theorem 5. 1, we obtain ( path ) ffi subs) xs = [ 1 5 2 ]) xs ffl: 3 ] Promoting max ffi (length3) into the obtained accumulation We continue promoting max ffi length3 into the derived accumulation according to the Accumulation Promotion Theorems, as we did above. We omit the detail calculation but give the last result. psp xs = j 1 5 j 2 ] xs ....

) Bird, R. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems 6, 4 (1984), 487--504.

....another, making use of the previously computed output in computing a new output, instead of computing the new output from scratch. Incremental computation is a fundamental issue relevant throughout computer software, e.g. optimizing compilers [2,3,17,23,78] transformational program development [8,20,62,65,77], and interactive systems [5,6,10,22,33,41,71,72] Numerous techniques for incremental computation have been developed, e.g. 3,4,25,34 36,56,64,68,70,73,76,79,86] Strengthening invariants for incrementalization. We are engaged in an ambitious e ort to derive incremental extended programs ....

....enables further optimizations on the overall loop structure, as discussed in [47] 25 6. 2 Promotion and accumulation in transformational programming: path sequence problem This example was used by Bird to illustrate important program transformation strategies called promotion and accumulation [8]. Given a directed acyclic graph, and a string whose elements are vertices in the graph, the problem is to compute the length of the longest subsequence in the string that forms a path in the graph. We focus on the second half of the example, where an exponential time recursive solution is ....

[Article contains additional citation context not shown here]

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Trans. Program. Lang. Syst., 6(4):487-504, Oct. 1984.

....general and systematic. Second, it stores only values that are necessary for the optimization; it also shows exactly when and where subproblems not in the original computation have to be included. Our method is based on a number of static analyses and transformations studied previously by others [6, 9, 21, 42, 47, 55, 56, 61] and ourselves [30, 37, 38, 39] and improves them. Each of the caching, incrementalization, and pruning steps is simple, automatable, and ecient and has been implemented in a prototype system, CACHET. The system has been used in optimizing many programs written as straightforward recursions, ....

.... prog s running time Fibonacci function [45] O(2 n ) O(n) binomial coecients [45] O(2 n ) O(n k) longest common subsequence [15] p O(2 n m ) O(n m) matrix chain multiplication [15] p O(n 3 n ) O(n 3 ) string editing distance [52] O(3 n m ) O(n m) dag path sequence [6] p O(2 n ) O(n 2 ) optimal polygon triangulation [15] p O(n 3 n ) O(n 3 ) optimal binary search tree [2] p O(n 3 n ) O(n 3 ) paragraph formatting [15] p O(n 2 n ) O(n 2 ) paragraph formatting 2 p O(n 2 n ) O(n width) 0 1 knapsack [15] p a O(2 n ) O(n ....

[Article contains additional citation context not shown here]

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Trans. Program. Lang. Syst., 6(4):487-504, Oct. 1984.

....control technique one can improve generate and test programs by simulating a computation rule which selects test predicates as soon as the relevant data become available. A similar idea has also been investigated in the area of functional programming, within the so called lter promotion strategy [9, 46]. Some other transformation techniques for improving generate and test logic programs which are closely related to the compiling control technique and the lter promotion strategy, can be found in [23, 136] The problem of compiling a given computation rule C can be described as follows: given ....

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Toplas, 6(4):487504, 1984.

....93] and 3. the Finite Differencing technique [Paige Koenig 82] and compare them with the strategies we have considered above. For other methods, such as: i) combinatory techniques [Turner 79] ii) supercombinator methods [Hughes 82] iii) local recursions [Bird 84a] iv) promotion strategies [Bird 84b] v) lambda liftings [Johnsson 85] and vi) lambda hoistings [Takeichi 87] we suggest to look at the original papers. There are some other techniques which have been proposed in the literature for transforming functional and logic programs. They are related to higher order features, in the ....

Bird, R. S.: The Promotion and Accumulation Strategies in Transformational Programming. ACM Toplas 6 (4) (1984) 487--504

....to implement many optimization rules using this representation of queries. The second benefit is the equational theory of monads. Its axioms give us several powerful and general optimization rules. We illustrate these two points using the rules for vertical loop fusion [11] and filter promotion [4]. Other rules derived from the axioms of monads can be found in [7, 27] their implementation is just as simple. 5.1.1 Vertical Loop Fusion Vertical loop fusion[11] is closely related to the concept of pipelines and quantifier elimination. It is an optimization that combines two loops into one ....

....1 ; x; e 2 ) y; e 3 ) This rule is implemented directly in our system using the following trivial piece of ML codes: fun VerticalLoopFusion (ExtSet(E1, x, ExtSet(E2, y, E3) SOME(ExtSet(ExtSet(E1, x, E2) y, E3) j VerticalLoopFusion = NONE 24 5.1. 2 Filter Promotion Filter promotion [4] corresponds to the well known concept of moving test predicates closer to generators [24] It is closely related to the idea of pushing selections toward base tables in relational optimization [25] The optimization idea can be expressed in comprehension syntax as a rule that transform an ....

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transaction on Programming Languages and Systems, 6(4):487--504, October 1984. 40

.... = f apply law (4) map(f,map(g,xs) map(f ffi g,xs) g tails( x] flatten(map(tails ffi (x: inits(xs) After several steps, we are still unable to fold as we encountered a slightly enlarged expression of the form flatten(map(tails ffi (x: inits(xs) As reported elsewhere [Bir84] and [ f Please pass your reference in NGC g ) this calls for the use of an accumulation tactic to overcome the problem of meeting ever larger expressions during transformation. Specifically, we need to define: asegs (w,xs) flatten(map(tails ffi (w ) inits(xs) With a new generalised ....

Richard S. Bird. The promotion and accumulation strategies in transformational programming. ACM Trans. on Programming Languages and Systems, 6(4):487--504, October 1984.

....Some examples are given to explain our method. 1 Introduction Accumulations are operators on structured object that proceed their computation on each element of the object keeping some intermediate results. Accumulations have gained a wide interest in the design of both sequential programs [1, 2] and parallel programs [4] Especially in parallel programming, accumulations are considered as one of basic parallel operators [3] and a special hardware for scan accumulations has been installed in CM5 [5] recently. The purpose of this paper is to deal with the transformation on accumulations ....

....to formulate accumulations and the other is how to perform transformation on such accumulations. For the first problem, it has been suggested that an accumulation can be efficiently described by the parameter accumulation whereby a specification is generalized by the inclusion of an extra argument [1, 9, 10]. Because such parameter accumulations can be of any style, it follows that the promotion strategy for parameter accumulations seems difficult to find. To overcome this shortcoming, we make restriction on the style of parameter accumulations, requiring that parameter accumulations be specified by ....

[Article contains additional citation context not shown here]

R. Bird, The promotion and accumulation strategies in transformational programming, ACM Transactions on Programming Languages and Systems 6 (1984), no. 4, 487--504.

....we mean how many steps of unfolding are needed to find a suitable place for generalization, since a proper place usually comes out after several unfoldings. One general way, known as forcing generalization, is to do generalization in case folding cannot be done during unfold fold transformations[3, 6, 21, 22], although related studies remain in an ad hoc level. The other difficulty, surprisingly not yet receiving its worthy consideration, is how to manipulate accumulations. We believe this more important for the following reason. As we know, one advantage of functional programming is that it allows ....

....Note that we may have function f : 1 X which is defined over 1. For example, and e are such functions. In such case, we often regard f as a value with type X. In other words, we may use f to represent ( f when it is clear from the context. 3 Accumulations and Catamorphisms An accumulation[3] is a kind of computation which proceeds over an algebraic data structure while keeping some information in an accumulating parameter to be used as an intermediate result. We shall borrow the word accumulation to refer to the function which performs accumulating computation. As a simple ....

[Article contains additional citation context not shown here]

R. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

.... prune = pfold BA (T(alg s) That is, prune(empty; 0 prune(node(t; a; t 0 ) if a 2 then 0 else 1 count(t; count(t 0 ; 2 5 Accumulations Accumulations are functions that use an extra parameter to keep intermediate results to be used during the computation (see e.g. [4, 13, 14, 18]) In this section we build up a comonadic operator for a kind of downwards accumulations by adding some ingredients to the definition of pfold. For defining accumulations we can follow, essentially, the same two alternatives discussed before for functions with parameters. One is to define ....

....coinductive type. Other directions for future study are: ffl The search of more interesting cases of comonads that neatly interact with recursion. ffl The derivation of further laws for accumulations, for example, laws involving type functors. ffl The application of the accumulation strategy [4, 3] in connection with our notion of accumulation, and its comparasion with other approaches (like e.g. 18] ffl The combination of recursion with both monads and comonads. Acknowledgements I would like to thank the anonymous referees for helpful suggestions and comments. Diagrams were drawn ....

R.S. Bird. The Promotion and Accumulation Strategies in Transformational Programming. ACM Transactions on Programming Languages and Systems, 6(4), October 1984.

....by David Gries somewhere around 1982, was unfortunately done in complete ignorance of similar work at Eindhoven University and documented in [15] and various 2 privately circulated documents written by E. W. Dijkstra and his colleagues. At the same time I was aware of the work of Richard Bird [8, 9] on an alternative calculus for program construction. The latter work had, for me, a clearly recognisable connection with my own work in spite of the quite irrelevant fact that my implementation language was imperative whereas Bird s was recursively defined functions but I had no time to ....

R.S. Bird. The promotion and accumulation strategies in transformational programming. ACM. Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

....process in a unified framework. As a formal vehicle, the specification and verification system PVS [7] is utilized to integrate development steps and development methods from different existing transformational approaches (for example, PROSPECTRA [6] KIDS [9] CIP [1, 5, 8] Bird Meertens [2]) Integration comprises the formalization (that is, the implementation in the PVS specification language) the verification, and the correct application of the generic development steps to specific problems. Transformations of different kind and complexity have been integrated into this framework ....

Richard S. Bird. The Promotion and Accumulation Strategies in Transformational Programming. ACM - Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

....simply define paths F = unfold G for some suitable . Consider a substructure y of a data structure x. The substructure of paths F x that corresponds to y is not constructed from y alone; it depends also on the ancestors of y in x. Therefore, we have to use an extra accumulating parameter [3] to carry this contextual information about the ancestors. In fact, we will define paths F t = unfold G (t; id) where the extra accumulating parameter is a function of type P(A) P(A) Intuitively, this accumulating parameter is mapped over the paths: unfold G (t; f) L f (paths F t) ....

Richard S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, October 1984. See also [4].

....of the tree in some order. One example of a tree traversal is preorder traversal, in which every parent appears in the traversal before any of its children, and siblings appear in left to right order. For example, the preorder traversal of the tree 2 k 1 k 2 k 5 k 6 k 3 k 4 k 7 is the list [1,2,5,6,3,4,7]. Preorder traversal, postorder traversal (in which a parent appears after all its children) and inorder traversal (which only makes sense on binary trees, and in which a parent appears between its two children) are all examples of depth first traversals. They are easy to implement in a pure ....

....( concat In contrast, breadth first traversal goes against the structure of the tree. The breadth first traversal of a tree consists first of the root (the only element at depth 1) then of all the elements at depth 2, and so on. For example, the breadth first traversal of the tree above is [1,2,3,4,5,6,7]. It is not nearly so obvious how to implement breadth first traversal efficiently in a pure functional language. In particular, breadth first traversal is not a fold, because the traversal of a forest cannot be constructed from the traversals of the trees in that forest. The standard ....

[Article contains additional citation context not shown here]

Richard S. Bird. Addendum to "The promotion and accumulation strategies in transformational programming ". ACM Transactions on Programming Languages and Systems, 7(3):490--492, July 1985.

....of the tree in some order. One example of a tree traversal is preorder traversal, in which every parent appears in the traversal before any of its children, and siblings appear in left to right order. For example, the preorder traversal of the tree 2 k 1 k 2 k 5 k 6 k 3 k 4 k 7 is the list [1,2,5,6,3,4,7]. Preorder traversal, postorder traversal (in which a parent appears after all its children) and inorder traversal (which only makes sense on binary trees, and in which a parent appears between its two children) are all examples of depth first traversals. They are easy to implement in a pure ....

....( concat In contrast, breadth first traversal goes against the structure of the tree. The breadth first traversal of a tree consists first of the root (the only element at depth 1) then of all the elements at depth 2, and so on. For example, the breadth first traversal of the tree above is [1,2,3,4,5,6,7]. It is not nearly so obvious how to implement breadth first traversal efficiently in a pure functional language. In particular, breadth first traversal is not a fold, because the traversal of a forest cannot be constructed from the traversals of the trees in that forest. The standard ....

[Article contains additional citation context not shown here]

Richard S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, October 1984. See also [2].

.... b List a List b scanr f e [ e] scanr f e (a:x) f a (head x ) x where x = scanr f e x (Here, a:x is the non empty list with head a and tail x, and the function head satis es head (a:x) a. The notation is essentially that of Haskell [20] For example, scanr ( 0 [1,2,3] = 6,5,3,0] Here, is the addition operator passed as an argument, and [1,2,3] a list with three elements. Rightwards accumulation, of course, distributes information in the opposite direction: scanl : b a b) b List a List b scanl f e [ e] scanl f e (a:x) e : ....

....b List a List b scanr f e [ e] scanr f e (a:x) f a (head x ) x where x = scanr f e x (Here, a:x is the non empty list with head a and tail x, and the function head satis es head (a:x) a. The notation is essentially that of Haskell [20] For example, scanr ( 0 [1,2,3] [6,5,3,0] (Here, is the addition operator passed as an argument, and [1,2,3] a list with three elements. Rightwards accumulation, of course, distributes information in the opposite direction: scanl : b a b) b List a List b scanl f e [ e] scanl f e (a:x) e : scanl f (f e a) ....

[Article contains additional citation context not shown here]

Richard S. Bird. Addendum to \The promotion and accumulation strategies in transformational programming". ACM Transactions on Programming Languages and Systems, 7(3):490-492, July 1985.

.... b List a List b scanr f e [ e] scanr f e (a:x) f a (head x ) x where x = scanr f e x (Here, a:x is the non empty list with head a and tail x, and the function head satis es head (a:x) a. The notation is essentially that of Haskell [20] For example, scanr ( 0 [1,2,3] = 6,5,3,0] Here, is the addition operator passed as an argument, and [1,2,3] a list with three elements. Rightwards accumulation, of course, distributes information in the opposite direction: scanl : b a b) b List a List b scanl f e [ e] scanl f e (a:x) e : ....

....: x where x = scanr f e x (Here, a:x is the non empty list with head a and tail x, and the function head satis es head (a:x) a. The notation is essentially that of Haskell [20] For example, scanr ( 0 [1,2,3] 6,5,3,0] Here, is the addition operator passed as an argument, and [1,2,3] a list with three elements. Rightwards accumulation, of course, distributes information in the opposite direction: scanl : b a b) b List a List b scanl f e [ e] scanl f e (a:x) e : scanl f (f e a) x For example, scanl ( 0 [1,2,3] 0,1,3,6] To make the analogy with ....

[Article contains additional citation context not shown here]

Richard S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487-504, October 1984. See also [3].

....of this transformation schema. 1 Introduction In this introductory section, we give the definitions of the notions that are needed to prove the correctness of the transformation schemas in [3] The transformation schemas proved in this report are pre compilations of the accumulation strategy [2], of tupling generalization, which is a special case of structural generalization [4] of a combination of the previous two techniques, and of the first duality law of the fold operators in functional programming [1] For a detailed explanation of these transformation schemas and examples of the ....

R.S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems 6(4):487--504, 1984.

....Corollary 43 (Catamorphism Fusion) For all 2 fw; vg, U ffi ( V ] R ] U ffi V R ffi F:U 2 Fusion laws are important. In earlier publications [2, 21] we used the term promotion property, this term having been used by Bird to name a technique for improving the efficiency of programs [8] and which our notion captured and generalised. Maarten Fokkinga suggested the more descriptive term fusion property. Several valuable properties of catamorphisms are listed below. Theorem 44 (Monotonicity) R ] w ( S ] R w S 2 Theorem 45 (Domain Trading) For all monotypes A and specs R, ....

R.S. Bird. The promotion and accumulation strategies in transformational programming. ACM. Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

....programs into equivalent and more efficient ones. Our main concern in this paper is on transforming programs, in particular finding efficient programs. Many different tactics have been suggested for program transformation. Three of them should be mentioned here, as unfold fold[BrD77] accumulation[B84], and [B88] and promotion [W88] C90] and [B88] In the first section a problem will be defined and a program will be derived from its definition. In the second section the derived program is transformed to an efficient one via a series of steps. Finally, in the last section we talk about the ....

Bird R.S.: The promotion and Accumulation Strategies in Transformational Programming. ACM Transactions on Programming Languages and Systems, 6, 4, (1984).

.... 61, 58] by Dijkstra, Gries, and Reynolds [21, 35, 74, 36] on maintaining and strengthening loop invariants, by Boyle, Moore, Manna, and Waldinger on induction, generalization, and deductive synthesis [13, 53, 54] by Dershowitz on extension techniques [20] by Bird on promotion and accumulation [9, 10], by Broy, Bauer, Partsch, and others on transforming recursive functional programs in CIP [14, 7, 63] by Smith on finite differencing of functional programs in KIDS [79] as well as the work pioneered by Michie on memoization [55, 18, 39, 82] and by others on related techniques [15, 8, 64] The ....

....else if x = 2 then 2; 1 else let r 1 = fib 1 (x Gamma 1) in 1st(r 1 ) 1st(2nd(r 1 ) 1st(r 1 ) For input n, while the straightforward program takes O(2 n ) time, the optimized program takes only O(n) time. 3. 5 More examples Below are more examples taken from graph algorithms [9, 50], VLSI design [56, 44] image processing [88, 47] and string processing [68, 48] respectively. Each one is a nontrivial problem. Problem Straightforward Optimized dag path sequence problem O(2 n ) O(n 2 ) non restoring binary integer square root k 2 ; 2 i ; Gamma; 2; 2 local ....

[Article contains additional citation context not shown here]

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Trans. Program. Lang. Syst., 6(4):487--504, Oct. 1984.

.... p x = p x [x] 3) p Delta = Delta p (4) p Delta f = f Delta (p Delta f) 5) p q) p Delta q (6) Delta (p f; ffl ) Delta f Delta p (7) 3 3 Specification The top level specification considered is almost exactly (but for notation) that of [Bir84], that is: sort = head Delta ord Delta perms where ord is (as in [SdM92] ord = Delta Delta ( Theta #= Delta splits and the generators perms and splits defined by: perms Delta [ ffl = ffl perms Delta ( a] Delta ( afi) Delta splits) Delta perms afihu; vi ....

.... x (x ) tail (inits y) which doesn t lead directly to a homomorphism (in the third equation the result doesn t depend only on inits x and inits y but also on x) This kind of equation can be used to express functions in terms of homomorphisms, even if they are not, using accumulations ([Bir84, Bir88]) A homomorphism Hinits carrying on the x along with the desired result is defined as: Hinits [ h[ i Hinits [a] h[ a] a]i Hinits (x y) Hinits x Phi i Hinits y 4 with hix; xi Phi i hiy; yi = hix (x ) tail iy) x yi We then have the equations: ....

[Article contains additional citation context not shown here]

Richard S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, October 1984.

....Bool fsp vss least ys = #( ys isSublist ) vss) least Note that for ease of program manipulation, we use the shorten notation: # to denote function length, and p to denote f ilter p. The filter operator enjoys the filter element map property (that is commonly used in program derivation e.g. Bir84] p ) ffi ( x : 3) x : 3) ffi ( p ffi (x : and the filter pipeline property: p ) ffi (q ) x: p x q x) In addition, xs isSublist ys is true if xs is a sublist of ys, and false otherwise: isSublist ys = True (x : xs) isSublist ys = xs isSublist ys x elem ys ....

....can be reduced dramatically via program calculation. Specifically, we will derive an efficient program for finding frequent sets from the specification fs os vss least = fsp vss least) subs os) by using the known calculation techniques of fusion [Chi92] generalization (accumulation) Bir84, HIT99] base case filter promotion [Chi90] and tabulation [Bir80, CH95] 5 3.1 Fusion Fusion is used to merge two passes (from nested recursive calls) into a single one, by eliminating intermediate the data structure passing between the two passes. Notice that our fs has two passes, and the ....

[Article contains additional citation context not shown here]

R. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

....program, the programmer is faced with a tension between correctness and efficiency. A program that is easy to understand and whose correctness is obvious to see often fails to be efficient, while a more efficient program often compromises clarity . Transformational programming [BD77, Fea87, Dar81, Bir84, Bir86, Bir87, Bac95] is a well known methodology to address this difficulty. In transformational programming, one does not attempt to produce directly a program that is correct, understandable and efficient, rather one initially concentrates on producing a program which is as clear and ....

....ignoring any question of efficiency. Having satisfied himself that he has a correct program he successively transforms it to more and more efficient versions using methods guaranteed to preserve the meaning of the program. Although quite a lot of creative, elegant and efficient algorithms [Bir84, Bir86, PP96] have been derived in this manner showing the impetus of the transformational approach to programming, there remain two major problems. 1 September 1999, METR 99 06 A Case Study on a Modular Transformation Strategy 2 ffl Insightful rules for big step jumps can be difficult to ....

[Article contains additional citation context not shown here]

R. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

....severe performance degradation, especially with the increasingly large data sets that many applications are facing, yet methods for eliminating overlapping aggregate array redundancy have been lacking. Optimizations similar to incrementalization have been studied for various language features [7, 12, 28, 38, 39, 40, 43, 45, 44, 55, 63], but no systematic technique han dles aggregate computations on arrays. At the same time, many optimizations have been studied for arrays [1, 2, 3, 5, 24, 26, 31, 34, 42, 49, 54, 58] but none of them achieves incrementalization. This paper presents a method and algorithms for incrementalizing ....

R. S. Bird. The promotion and accumulation strategies in transformational programming. ACM Trans. Program. Lang. and Syst., 6(4):487--504, Oct. 1984.

....program derivations. Keywords: constructive set theory, program transformation, intensional semantics 2 Introduction This paper continues our study of the proof theory of certain elementary program derivations: those obtained by the techniques of transformational programming (e.g. BuD77] [Bir84] [Hen88] from functional programs. In our earlier work [Hen93] we concentrated exclusively on transformations over the natural numbers. In this paper we wish to extend this work towards algebraic types in general. These data types are, in their full generality, significantly more problematic than ....

....There we see hints and suggestions for the modification of the straightforward transformational tradition, motivated by the well known problems of unrestricted folding, which restrict the use of folding to circumstances in which well orderings play an explicit r le. The work of Bird (for example [Bir84]) is particularly noteworthy and our own remarks in [Hen87] are in this spirit too. The advice one obtains from these sources is that the calculus of transformations can be restricted, without prejudicing its expressibility, so that folding is only allowed on immediate predecessors in some ....

Bird, R., The promotion and accumulation strategies in transformational programming, ACM. Trans. Programming Languages and Systems, 6, pp 487-504, 1984.

....is the exploitation of the properties of a monoid. In literature, it can be found under the headings of recursion removal [Str71, WS73, AS78] or simplification [Par90] generalisation of output terms [Aub75] data structures representing continuations [Wan80] rebracketing [BW82] accumulation [Bir84a] lambda abstraction or higher order generalisation [Pet87, PS87] or even a novel implementation of lists [Hug86] It falls under the generalisation tactic in Feather s survey paper [Fea87] but is not mentioned explicitly there. I will start by showing the two famous examples of ....

....the equivalence of their different versions, Cooper derives a general theorem for proving the equivalence of certain computations. Cooper also gives the first formal treatment of inverting the order of evaluation [Boi92] for the factorial function. 7 Some descriptions by R. Bird and others In [Bir84a] the use of the accumulation strategy in transformational programming is described. Bird considers parameter accumulation to be one of the most important things to be taught in functional programming. In his notation, the conditions for applicability of parameter accumulation are given as ....

[Article contains additional citation context not shown here]

R.S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

.... Gries, and Reynolds [Dij76,Gri81,Rey81,Gri84] on maintaining and strengthening loop invariants, by Boyle, Moore, Manna, and Waldinger on induction, generalization, and deductive synthesis [BM79,MW80,MW93] by Dershowitz on extension techniques [Der83] by Bird on promotion and accumulation [Bir84,Bir85] by Broy, Bauer, Partsch, etc. on transforming recursive functional programs in CIP [Bro84,BMPP89, Par90] by Smith on finite differencing of functional programs in KIDS [Smi90,Smi91] as well as the work pioneered by Michie on memoization [Mic68,Bir80,Coh83,Web95] The most basic idea can ....

....approach, we even discover that an extra shift is done in [OLHA94] Thus, such systematic transformational approach is not only greatly desired for automating designs and guaranteeing correctness, but also also for helping reduce the cost. 5.4. 2 Path sequence problem This example is from [Bir84] Given a directed acyclic graph, and a string whose elements are vertices in the graph, the problem is to compute the length of the longest subsequence in the string that forms a path in the graph. We focus on the second half of the example, where an exponential time recursive solution is ....

[Article contains additional citation context not shown here]

Richard S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, October 1984.

No context found.

Richard S. Bird. Addendum to "The promotion and accumulation strategies in transformational programming". ACM Transactions on Programming Languages and Systems, 7(3):490--492, July 1985.

No context found.

Richard S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, October 1984. See also [3].

No context found.

R.S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

No context found.

R. Bird, "The Promotion and Accumulation Strategies in Transformational Programming", ACM Transactions on Programming Languages and Systems, vol. 6, no. 4, pages 487--504, 1984.

No context found.

R.S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

No context found.

R.S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487--504, 1984.

No context found.

R.S. Bird. The promotion and accumulation strategies in transformational programming. ACM Transactions on Programming Languages and Systems, 6(4):487-504, October 1984.

No context found.

Richard S. Bird. Addendum to "The promotion and accumulation strategies in transformational programming". ACM Transactions on Programming Languages and Systems, 7(3):490--492, July 1985.

First 50 documents  Next 50

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC