Abstract
Rewriting is a computational paradigm that specifies the actions, but not the control. We introduce a hierarchical structure representing, at a high level of abstraction, a form of control. Its application solves a specific problem arising in the design and implementation of inherently sequential, lazy, functional programming languages based on rewriting. For example, we show how to extend the expressive power of Log(F) and how to improve the efficiency of an implementation of BABEL. Our framework provides a notion of degree of parallelism of an operation and shows that the elements of a necessary set of redexes are related by an and-or relation. Both concepts find application in parallel implementations of rewriting. In an environment in which computations can be executed in parallel we are able to detect sequential com-putations in order to minimize overheads and/or optimize execution. Conversely, we are able to detect when inherently sequential computations can be executed in parallel without performing unnecessary rewrites.
Supported by the National Science Foundation Grant No. CCR-8908565.
This is a preview of subscription content, log in via an institution to check access.
Preview
Unable to display preview. Download preview PDF.
References
Sergio Antoy. Design strategies for rewrite rules. In S. Kaplan aand M. Okada, editor, CTRS'90, pages 333–341, Montreal, Canada, June 1990. Lect. Notes in Comp. Sci., Vol. 516.
Sergio Antoy. Non-determinism and lazy evaluation in logic programming. In T. P. Clement and K.-K. Lau, editors, LOPSTR'91, pages 318–331, Manchester, UK, July 1991. Springer-Verlag.
G. Boudol. Computational semantics of term rewriting systems. In Maurice Nivat and John C. Reynolds, editors, Algebraic methods in semantics, chapter 5. Cambridge University Press, Cambridge, UK, 1985.
L. G. Bouma and H. R. Walters. Implementing algebraic specifications. In J. A. Bergstra, J. Heering, and P. Klint, editors, Algebraic Specification, chapter 5. Addison-Wesley, Wokingham, England, 1989.
N. Dershowitz and J. Jouannaud. Rewrite systems. In J. van Leeuwen, editor, Handbook of Theoretical Computer Science B: Formal Methods and Semantics, chapter 6, pages 243–320. North Holland, Amsterdam, 1990.
J. Goguen, J. Meseguer, S. Leinwand, T. Winkler, and H. Aida. The rewrite rule machine project. Technical Report SRI-CSL-89-6, SRI International, Menlo Park, CA, 1989.
C. M. Hoffman and M. J. O'Donnell. Implementation of an interpreter for abstract equations. In 11th ACM Symposium on the Principle of Programming Languages, Salt Lake City, 1984.
Gérard Huet. Confluent reductions: Abstract properties and applications to termrewriting systems. JACM, 27:797–821, 1980.
Gérard Huet and Jean-Jacques Lévy. Call by need computations in non-ambiguous linear term rewriting systems. Technical Report 359, INRIA, Le Chesnay, France, 1979.
J. R. Kennaway. Sequential evaluation strategies for parallel-or and related reduction systems. Annals of Pure and Applied Logic, 43:31–56, 1989.
Claude Kirchner and Patrick Viry. Implementing parallel rewriting. In PLILP'90, pages 1–15, Linköping, Sweden, August 1990. Lect. Notes in Comp. Sci., Vol. 456.
Jan Willem Klop. Term rewriting systems. Technical Report CS-R9073, Stichting Mathematisch Centrum, Amsterdam, The Netherlands, 1990.
Jan Willem Klop and Aart Middledorp. Sequentiality in orthogonal term rewriting systems. Technical Report CS-R8932, Stichting Mathematisch Centrum, Amsterdam, The Netherlands, 1989.
H. Kuchen, R. Loogen, J. J. Moreno-Navarro, and M. RodrÃguez-Artalejo. Graphbased implementation of a functional language. In ESOP'90, pages 279–290, 1990. Lect. Notes in Comp. Sci., 432.
J. J. Moreno-Navarro, H. Kuchen, R. Loogen, and M. RodrÃguez-Artalejo. Lazy narrowing in a graph machine. In Conf. on Algebraic and Logic Progr., 1990. Lect. Notes in Comp. Sci., 463.
J. J. Moreno-Navarro and M. RodrÃguez-Artalejo. Logic programming with functions and predicates: The language BABEL. Journal of Logic Programming, 1992. (To appear).
Sanjai Narain. LOG(F): An optimal combination of logic programming, rewriting, and lazy evaluation. PhD thesis, University of California, Los Angeles, CA, 1988.
Sanjai Narain. Optimization by non-deterministic, lazy rewriting. In RTA'89, pages 326–342, Chapel Hill, NC, 1989. Lect. Notes in Comp. Sci., Vol. 355.
Sanjai Narain. Lazy evaluation in logic programming. In Third IEEE Conference on Computer Languages, pages 218–227, New Orleans, 1990.
Michael J. O'Donnell. Computing in systems described by equations. Springer-Verlag, 1977. Lect. Notes in Comp. Sci., Vol. 58.
Michael J. O'Donnell. Eguational Logic as a Programming Language. MIT Press, 1985.
R. C. Sekar and I. V. Ramakrishnan. Programming in equational logic: Beyond strong sequentiality. In Proceedings of the Fifth Annual IEEE Symposium on Logic in Computer Science, pages 230–241, Philadelphia, PA, June 1990.
Satish Thatte. A refinement of strong sequentiality for term rewriting with constructors. Information and Computation, 72:46–65, 1987.
Yonggong Yan. Building definitional trees. Master's project, Portland State University, Portland, OR, March 1992.
Author information
Authors and Affiliations
Editor information
Rights and permissions
Copyright information
© 1992 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Antoy, S. (1992). Definitional trees. In: Kirchner, H., Levi, G. (eds) Algebraic and Logic Programming. ALP 1992. Lecture Notes in Computer Science, vol 632. Springer, Berlin, Heidelberg. https://doi.org/10.1007/BFb0013825
Download citation
DOI: https://doi.org/10.1007/BFb0013825
Published:
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-55873-6
Online ISBN: 978-3-540-47302-2
eBook Packages: Springer Book Archive