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.

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.

Strongly sequential constructor systems admit a very efficient algorithm to compute normal forms. The class of forward-branching systems contains the class of strongly sequential constructor systems, and admits a similar reduction algorithm, but less efficient on the entire class of forward-branching systems. In this article, we present a new transformation which transforms any forward-branching system into a strongly sequential constructor one. We prove the correctness and completeness of the transformation algorithm, then that the new system is equivalent to the input system, with respect to the behavior and the semantics. As a programming language, it permits us to have a less restrictive syntax without compromise of semantics and efficiency.

Abstract. Kamperman and Walters proposed the notion of a simulation of one rewrite system by another one, whereby each term of the simulating rewrite system is related to a term in the original rewrite system. In this paper it is shown that if such a simulation is sound and complete and preserves termination, then the transformation of the original into the simulating rewrite system constitutes a correct step in the compilation of the original rewrite system. That is, the normal forms of a term in the original rewrite system can then be obtained by computing the normal forms of a related term in the simulating rewrite system. 1

A new compilation technique for left-linear term rewriting systems is presented, where rewrite rules are transformed into so-called minimal rewrite rules. These minimal rules have such a simple form that they can be viewed as instructions for an abstract rewriting machine (ARM).

Huet and Levy pioneered lazy sequential evaluation of equational programs based on the concepts of strong-sequentiality and needed redexes. Natural extensions of their strategy are not well-suited for parallel evaluation since they do not support independent searches for needed redexes along different paths in the input term. Furthermore, the size of compiled code can be exponential in program size. We therefore propose a different notion of sequentiality called path-sequentiality that overcomes these drawbacks and thus provides a natural framework for lazy parallel evaluation. We present a sound and complete algorithm for lazy parallel normalization of path-sequential systems. We show that our algorithm is optimal in the sense that its time complexity is bounded only by the time required to perform the needed reductions. The results presented in this paper are applicable to functional languages as well through the transformation of Laville.

Sekar and al. found an efficient parallel reduction strategy for the class of path sequential term rewriting systems, which follow the constructor discipline. In this article, we present an overview of a parallel reduction strategy for the extended class of nonconstructor path sequential systems. We then define formally this class and show some of its properties. Moreover, we give a transformation which transforms every forward branching system with a nonconstructor path sequential one. The size of the system increases only modestly over that of the original one in many practical situation. We give an algorithm for this transformation and we prove its correctness and completeness. The new system is then proved to be equivalent to the input system, with respect to the behavior and the semantics.

We define a lifting of the notion of transformation of term rewriting systems to arbitrary relational structures, that ties in with the simulation relations of concurrency theory. We illustrate the resulting concepts in an examination of Thatte's transformation of term rewriting systems. We refute an earlier claim that this transformation preserves confluence for weakly persistent systems. We conclude by proving the preservation of weak normalization, and of confluence in weakly normalizing systems and in nonoverlapping systems with linear subtemplates. 1

Strongly sequential systems, developed by Huet and Levy [HL79], has formed the basis of equational programming languages. Experience with such languages so far suggests that even complex equational programs are based only on strongly sequential systems with constructors.