Term Rewriting Systems play an important role in various areas, such as abstract data type specifications, implementations of functional programming languages and automated deduction. In this chapter we introduce several of the basic comcepts and facts for TRS's. Specifically, we discuss Abstract Reduction Systems

Orthogonal term rewriting systems (also known as regular systems) provide an elegant framework for programming in equational logic. O'Donnell showed that the parallel-outermost strategy, which replaces all outermost redexes in each step, is complete for such systems. Many of the reductions performed by this strategy could be wasteful in general. A lazy normalization algorithm that completely eliminated these wasteful reductions by reducing only "needed redexes" was later developed by Huet and Levy. However, this algorithm required the input programs to be restricted to the subclass of strongly sequential systems. This is because needed redexes do not exist for all orthogonal programs, and even when they do, they may not be computable. It is therefore quite natural to ask whether it is possible to devise a complete normalization algorithm for the entire class that minimizes (rather than eliminate) the wasteful reductions. In this paper we propose a solution to this problem using the concept of a necessary set of redexes. In such a set, at least one of the redexes must be reduced to normalize a term. We devise an algorithm to compute a necessary set for any term not in normal form and show that a strategy that repeatedly reduces all redexes in such a set is complete for orthogonal programs. We also show that our algorithm is "optimal" among all normalization algorithms that are based on left-hand sides alone. This means that our algorithm is lazy (like Huet-Levy's) on strongly sequential parts of a program and "relaxes laziness minimally" to handle the other parts and thus does not sacrifice generality for the sake of efficiency.

Pattern matching is an important operation used in many applications such as functional programming, rewriting and rule-based expert systems. By preprocessing the patterns into a DFA-like automaton, we can rapidly select the matching pattern(s) in a single scan of the relevant portions of the input term. This automaton is typically based on left-to-right traversal of the patterns. By adapting the traversal order to suit the set of input patterns, it is possible to considerably reduce the space and matching time requirements of the automaton.

This paper describes equals, a fast parallel implementation of a lazy functional language on a commercially available shared-memory parallel machine, the Sequent Symmetry. In contrast to previous implementations, we detect parallelism automatically using strictness analysis. Another important difference between equals and previous implementations is the use of reference counting for memory management, instead of garbage collection. Our implementation shows that reference counting leads to very good scalability, low memory requirements and improved locality. We compare our results with other sequential (SML/NJ) and parallel (h; Gi-machine and GAML) implementations of functional languages.

In [8], Thatte demonstrated the possibility of simulating an orthogonal TRS with a left-linear constructor system obtained from the original system via a simple transformation. The class of strongly sequential systems (SS) was defined in [3]. In [2], we have defined the class of constructor equivalent systems (CE) for which Thatte's transformation preserves strong sequentiality; in that same article, we prove that CE ae SS by showing that CE is a strict subset of the forward-branching class [7] which is itself a strict subset of SS [1]. In this article, we give a direct proof (i.e. a proof which does not involve the forward-branching class) of the inclusion CE ae SS. It uses parts of the proof given in [6] for deciding strong sequentiality.

An automaton with concurrency relations A is a labeled transition system with a collection of binary relations indicating when two actions in a given state of the automaton can occur independently of each other. The concurrency relations induce a natural equivalence relation for finite computation sequences. We investigate two graph-theoretic representations of the equivalence classes of computation sequences and obtain that under suitable assumptions on A they are isomorphic. Furthermore, the graphs are shown to carry a monoid operation reflecting precisely the composition of computations. This generalizes fundamental graph-theoretical representation results due to Mazurkiewicz in trace theory.

this paper, we provide a precise and formal characterizationof the loss of information that leads to this incompleteness. Specifically, we establish the following characterization theorem for Mycroft's strictness analysis method and a natural generalization of his method to non-flat domains called ee-analysis: Mycroft's method will deduce a strictness property for program P iff the property is independent of any constant appearing in any evaluation of P . To prove this, we specify a small set of equations called E-axioms, that capture the information loss in Mycroft's method and develop a new proof technique called E-rewriting. E-rewriting extends the standard notion of rewriting to permit the use of reductions using E-axioms interspersed with standard reduction steps. E-axioms are a syntactic characterization of information loss and E-rewriting provides an algorithm independent proof technique for characterizing the power of analysis methods. It can be used to answer questions on completeness and incompleteness of Mycroft's method on certain natural classes of programs. Finally, the techniques developed in this paper provide a general principle for establishing similar results for other analysis methods such as those based on abstract interpretation. As a demonstration of the generality of our technique, we give a characterization theorem for another variation of Mycroft's method called dd-analysis. Categories and Subject Descriptors: D.3.1 [Programming Languages]: Formal Definitions and Theory; D.3.2 [Programming Languages]: Language Classifications---applicative languages; D.3.4 [Programming Languages]: Processors---compilers ; optimization General Terms: Languages, Theory, Measurement Additional Key Words and Phrases: Program analysis, abstract interpretation, str...

We define the notion of transfinite term rewriting: rewriting in which terms may be infinitely large and rewrite sequences may be of any ordinal length. For orthogonal rewrite systems, some fundamental properties known in the finite case are extended to the transfinite case. Among these are the Parallel Moves lemma and the Unique Normal Form property. The transfinite Church-Rosser property (CR 1 ) fails in general, even for orthogonal systems, including such well-known systems as Combinatory Logic. Syntactic characterisations are given of some classes of orthogonal TRSs which do satisfy CR 1 . We also prove a weakening of CR 1 for all orthogonal systems, in which the property is only required to hold up to a certain equivalence relation on terms. Finally, we extend the theory of needed reduction from the finite to the transfinite case. The reduction strategy of needed reduction is normalising in the finite case, but not in the transfinite case. To obtain a normalising str...

In [KM91], Klop and Middeldorp conjectured that deciding strong sequentiality for orthogonal term rewriting systems is NP-Complete. This problem appeared as "Problem 8" in the list of open problems in rewriting published in [DJK91]. In this article we show that the problem is in co-NP. If, as we conjecture, the problem is also in NP , this reduces its chances of being NP-Complete.

Partial evaluation is greatly simplified if the target language is simple. In [SS90] we define an extremely simple language that is used as an intermediate language for equational programming [O'D85]. Although the intermediate language is a general graph manipulation language, we take advantage of the particular properties of programs generated from equational programs. For partial evaluation to be successful, we need both a set of transformations that preserve the semantics of the program and a strategy that tells us when to apply a particular transformation. The strategy includes termination criteria to avoid infinite computations. In this paper we concentrate on a set of transformations that preserve the semantics of the program. We also show a small example of how these transformations can be applied to a program in order to improve its execution speed. The strategy, however, is only sketchy at the present time. The complete strategy is left for a future paper. Furthermore, we do n...