Construction of List Homomorphisms by Tupling and Fusion

@inproceedings{Hu1996ConstructionOL,
  title={Construction of List Homomorphisms by Tupling and Fusion},
  author={Zhenjiang Hu and Hideya Iwasaki and Masato Takeichi},
  booktitle={MFCS},
  year={1996}
}
List homomorphisms are functions which can be efficiently computed in parallel since they ideally suit the divide- sand-conquer paradigm. However, some interesting functions, e.g., the maximum segment sum problem, are not list homomorphisms. In this paper, we propose a systematic way of embedding them into list homomorphisms so that parallel programs are derived. We show, with an example, how a simple, and “obviously” correct, but possibly inefficient solution to the problem can be successfully… 

Constructing List Homomorphisms from Proofs

TLDR
This paper proposes a new approach: to construct a possible candidate of the associative operator and, at the same time, to transform a proof that h is both a foldr and a foldl to a proofthat h is a list homomorphism.

Formal Derivation of Parallel Program for 2-Dimensional Maximum Segment Sum Problem

TLDR
It is shown how a straightforward, and“obviously” correct, but quite inefficient solution to the problem can be successfully turned into a semantically equivalent “almost list homomorphism” based on two transformations, namely tupling and fusion, which are defined according to the specific recursive structures of list homomorphicisms.

Cheap Tupling Transformation

TLDR
This paper proposes a cheap tupling based on the theory of constructive algorithmics, which not only can be successfully applied to improve a lot of interesting recursive functions but also can be implemented e ciently.

Cheap Tupling Transformation Zhenjiang

TLDR
This paper proposes a cheap tupling based on the theory of constructive algorithmics, which not only can be successfully applied to improve a lot of interesting recursive functions but also can be implemented eciently.

Tupling calculation eliminates multiple data traversals

TLDR
This work proposes a new method to expose recursive structures in recursive definitions and shows how this structural information can be explored for calculating out efficient programs by means of tupling.

Theory and applications of inverting functions as folds

Parallelization with Tree Skeletons

TLDR
This paper proposes two important transformations, the tree diffusion transformation and the tree context preservation transformation, which allow one to use familiar recursive definitions to develop his parallel programs, and shows how to derive associative operators that are required when using tree skeletons.

Catamorphism-based program transformations for non-strict functional languages

TLDR
The warm fusion method is implemented in the Glasgow Haskell Compiler, which has allowed practical feedback, and the problem of removing mutually recursive sets of polynomial datatypes is analysed in detail.

A calculational approach to program inversion

TLDR
A generalised theorem stating the conditions for the inverse of a partial function to be a hylomorphism is presented and proved and applied to many examples, including the classical problem of rebuilding a binary tree from its preorder and inorder traversals.

A Calculational Framework for Parallelization of Sequential Programs

TLDR
A calculational framework for deriving parallel divide-and-conquer programs from naive sequential ones is proposed and is not only helpful in design of parallel programs in general but also promising in construction of parallelization system.

References

SHOWING 1-10 OF 15 REFERENCES

Parallel Programming, List Homomorphisms and the Maximum Segment Sum Problem

TLDR
The main purpose is to show that an understanding of the homo-morphism lemma can be helpful in producing programs for problems which are \not quite" list homomorphisms themselves.

The Third Homomorphism Theorem

TLDR
The Third Homomorphism Theorem is formalize and prove, and it is used to improve an O ( n 2 ) sorting algorithm to O (n log n ).

Towards an automated tupling strategy

  • W. Chin
  • Computer Science
    PEPM '93
  • 1993
TLDR
This work extends that of a number of past techniques which have used dependency graphs of function calls for analysing redundancy patterns by using the use of appropriate call orderings based on recursion parameters to systematically search for eureka tuples in dependency graphs.

Shortcut deforestation in calculational form

TLDR
This work presents a simple algorithm for deforestation based on two fusion rules for hylomorphismj an expressive recursion pattern, and a generic notation for hyLomorphisms is introduced, where natural transformations are explicitly factored out, and it is used to represent programs.

Deriving structural hylomorphisms from recursive definitions

TLDR
This paper proposes an algorithm which can automatically turn all practical recursive definitions into structural hylomorphisms making program fusion be easily applied.

Safe fusion of functional expressions

TLDR
The deforestation technique is generalised to make it applicable to all first-order and higher-order functional programs, made possible by the adoption of a model for safe fusion which views each function as a producer and its parameters as consumers.

Calculating Recurrences Using the Bird-Meertens Formalism

TLDR
New operators for the theory of lists that compute generalized recurrences are built that have logarithmic parallel time complexity and are illustrated by deriving a parallel solution to the maximum segment sum problem.

Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire

TLDR
A calculus for lazy functional programming based on recursion operators associated with data type definitions is developed and it is shown that all example functions in Bird and Wadler's Introduction to Functional Programming can be expressed using these operators.

Architecture-independent parallel computation

TLDR
It is shown that the Bird-Meertens formalism is universal over all four architecture classes and that nontrivial restrictions of functional programming languages exist that can be efficiently executed on disparate architectures.

An introduction to the theory of lists

TLDR
In these lectures a notation and a calculus for specifying and manipulating computable functions over lists are introduced, used to derive efficient solutions for a number of problems, including problems in text processing.