Modelo del guión para el simulacro

We have investigated the main computational properties ofµ-normal forms regarding root-normaliza- tion and normalization. We proved that, for left-linear TRSsR and canonical replacement maps µ ∈

CMR:

1. theµ-normal forms are strongly root-stable. This refines a previous result that identified such

µ-normal forms as root-stable terms [Luc98a]. Indeed, this fact can be viewed now as a consequence

of the results established in this paper.

2. the confluence of a (left-linear) TRS does not ensure the unicity of theµ-normal forms of a term t, but it does ensure that the maximal replacing context of suchµ-normal forms is unique.

3. (unrestricted) reducts of µ-normal forms are µ-normal forms, and the maximal replacing context of aµ-normal form remains unchanged under further (unrestricted) reductions.

We have formalized the notion of context-sensitive rewriting strategy. We have investigated the def- inition, properties, and use of context-sensitive rewriting strategies (or µ-strategies, for a given re- placement map µ). The effective definition of µ-normalizing µ-strategies relies on the notions of

root-normalization, and root-neededness [Mid97] and its decidable approximations [Luc98b]. This

provides a measure for the efficiency of context-sensitive strategies, by taking the theory of root-needed reductions as a reference. We have proven that, whenever µ ∈ CM_R, every orthogonal TRSR ad- mits a one-stepµ-normalizing strategy. Moreover, for almost orthogonal NV-sequential TRSs, such

strategies can be effectively given. We have also shown that the restricted parallel outermostµ-strategy isµ-normalizing for every orthogonal TRS R (whenever µ ∈ CM_R).

Finally, we have shown how to useµ-normalizing strategies for defining efficient normalizing and infinitary normalizing strategies. These results can be summarized as follows: (1) each left-linear, confluent, TRSR which has a µ-normalizing µ-strategy (in particular µ-terminating TRSs) admits a (one-step) normalizing strategy (whereµ ∈ CMRis assumed), and (2) every left-linear,µ-normalizing TRSR which admits a µ-normalizing strategy also admits an infinitary normalizing strategy. In both cases, optimality of the underlyingµ-strategy is also inherited by the induced normalizing or infinitary normalizing strategy.

The theory is applied to define (infinitary) normalizing strategies for TRSs which do not admit a (infinitary) normalizing strategy based on the usual techniques for doing so. We also apply the theory to the analysis of computational properties of the evaluation strategies used inOBJorELAN. We believe that our work makes a contribution to the practical use and understanding of these languages.

We conclude by summarizing a number of results presented in the paper which complement or improve some results of the standard theory of rewriting:

1. We refine Middeldorp’s result: “every non-root-stable term has a root-needed redex” by con- sideringµcan

R -replacing redexes. This means that cs-restrictions provide a first, simple, and correct bound to root-neededness.

2. Since nv-sequential indices have been proved to be (currently) the best decidable approximation to root-neededness (see [Luc98b]), we are able to refine this result by taking into accountµcan

R -replacing

nv-indices which suffice for approximating root-needed redexes (without losing any nv-index).

3. We have demonstrated that, wheneverµ ∈ CM_R, left-linearµ-terminating TRSs are infinitary normalizing.

4. We have shown that the use of computational restrictions of rewriting such as CSR can be helpful for defining normalizing strategies. Moreover, we have presented two complementary approaches to achieve this: (1) the analysis of termination of the computational restriction (that, for CSR, is formally analogous to the standard case, see [Zan97] for an abstract description), and (2) the definition of “good” strategies for the computational restriction (which, for CSR, we have based on the notions of root- normalization and root-neededness). We believe this is an interesting link between the two approaches (and theoretical fields) which has probably not yet been sufficiently explored.

The problem of implementing computational systems based on rewriting redexes pointed by strong indices was considered in [Dur94, HL79, O’Do95, Str89]. Unfortunately, no comparable effort has been devoted to nv-indices. In practice, strong index reduction strategies are not implemented by means of -reduction, i.e., -reduction is not used for identifying redexes that should be reduced at each computation step. Instead, there are two main approaches. The first one is to describe a class of TRSs for which the calculus of strong indices is very simple; for instance, in weakly orthogonal, left-normal TRSs (i.e., TRSs where the function and constant symbols occur to the left of variables in all left-hand sides [BN98]), the leftmost-outermost redex of any term is addressed by a strong index [O’Do85, Toy92]. The second approach is to provide an adequate data structure which is able to combine the pattern matching operation with the search for a strong index, thus finding not only a redex within a term but more precisely a redex addressed by a strong index (e.g., matching dags [HL79], index trees [Dur94, Str89], or even definitional trees [Ant92] for constructor systems [HLM98]). As for future work, we plan to systematically adapt these methods to ease the specification and implementation of context-sensitive rewriting strategies in our setting.

ACKNOWLEDGMENTS

I thank Mar´ıa Alpuente, Bernhard Gramlich, and Aart Middeldorp for their comments on preliminary versions of this paper. I also thank the anonymous referees for their helpful remarks.

REFERENCES

[AG00] Arts, T., and Giesl, J. (2000), Termination of term rewriting using dependency pairs, Theoret. Comput. Sci. 236, 133–178.

[AM96] Antoy, S., and Middeldorp, A. (1996), A sequential reduction strategy, Theoret. Comput. Sci. 165, 75–95. [AN80] Arnold, A., and Nivat, M. (1980), The metric space of infinite trees: Algebraic and topological properties, Fund.

Inform. 4, 445–476.

[Ant92] Antoy, S. (1992), Definitional trees, in “Proc. of 3rd International Conference on Algebraic and Logic Program- ming, ALP’92” (H. Kirchner and G. Levi, Eds.), Lecture Notes in Computer Science, Vol. 632, pp. 143–157, Springer-Verlag, Berlin.

[BCDK+00] Borovansk´y, P., Cirtea, H., Dubois, H., Kirchner, C., Kirchner, H., Moreau, P.-E., Ringeissen, C., and Vittek, M. (2000),ELANUser Manual (version 3.4).

[BEGK+87] Barendregt, H. P., van Eekelen, M. C. J. D., Glauert, J. R. W., Kennaway, J. R., Plasmeijer, M. J., and Sleep, M. R. (1987), Term graph rewriting, in “Proc. of 2nd Conference on Parallel Architectures and Languages Europe, PARLE’87” (J. W. de Bakker, A. J. Nijman, and P. C. Treleaven, Eds.), Lecture Notes in Computer Science, Vol. 259, pp. 141–158, Springer-Verlag, Berlin.

[BFR00] Borralleras, C., Ferreira, M. C. F., and Rubio, A. (2000), Complete monotonic semantic path ordering, in “Proc. of 17th International Conference on Automated Deduction, CADE’00” (D. A. McAllester, Ed.), Lecture Notes in Computer Science, Vol. 1831, pp. 346–364, Springer-Verlag, Berlin.

[BKK98] Borovansk´y, P., Kirchner, C., and Kirchner, H. (1998), A functional view of rewriting and strategies for a semantics ofELAN, in “Proc. of 3rd Fuji International Symposium on Functional and Logic Programming, FLOPS’98” (M. Sato and Y. Toyama, Eds.), pp. 143–166, World Scientific, Singapore.

[BKKMR98] Borovansk´y, P., Kirchner, C., Kirchner, H., Moreau, P.-E., and Ringeissen, C. (1998), An overview ofELAN,

in “Proc. of 2nd International Workshop on Rewriting Logic and its Applications, WRLA’98” (C. Kirchner and

H. Kirchner, Eds.), Electronic Notes in Computer Science, Vol. 15, pp. 1–16.

[BLR02] Borralleras, C., Lucas, S., and Rubio, A. (2002), Recursive path orderings can be context-sensitive, in “Proc. of 18th International Conference on Automated Deduction, CADE’02” (A. Voronkov, Ed.), Lecture Notes in Artificial Intelligence, Vol. 2392, pp. 314–331, Springer-Verlag, Berlin.

[BN98] Baader, F., and Nipkow, T. (1998), “Term Rewriting and All That,” Cambridge University Press, Cambridge, UK. [Bur91] Burn, G. L. (1991) “Lazy Functional Languages: Abstract Interpretation and Compilation,” Pitman, London and

MIT Press, Cambridge, MA.

[CELM96] Claver, M., Eker, S., Lincoln, P., and Meseguer, J. (1996), Principles of maude, in “Proc. 1st International Workshop on Rewriting Logic and its Applications,” Electronic Notes in Theoretical Computer Science, Elsevier Sciences, Amsterdam.

[CG99] Corradini, A., and Gadducci, F. (1998), Rational term rewriting, in “Proc. of 1st International Conference on Foundations of Software Science and Computation Structures, FOSSACS’98” (M. Nivat, Ed.), Lecture Notes in Computer Science, Vol. 1378, pp. 156–171, Springer-Verlag, Berlin.

[Com00] Comon, H. (2000), Sequentiality, monadic second-order logic and tree automata, Inform. and Comput. 157, 25–51.

[Cor93] Corradini, A. (1993), Term rewriting in C T_, in “Proc. of 1st International Joint Conference CAAP/FASE on Theory and Practice of Software Development, TAPSOFT’93” (M.-C. Gaudel and J.-P. Jouannaud, Eds.), Lecture Notes in Computer Science, Vol. 668, pp. 468–484, Springer-Verlag, Berlin.

[CP85] Clack, C., and Peyton-Jones, S. L. (1985), Strictness analysis—A practical approach, in “Functional Programming and Computer Architecture” (J.-P. Jouannaud, Ed.), Lecture Notes in Computer Science, Vol. 201, pp. 35–39, Springer-Verlag, Berlin.

[Der87] Dershowitz, N. (1987), Termination of rewriting, J. Symbol. Comput. 3, 69–115.

[DJ90] Dershowitz, N., and Jouannaud, J.-P. (1990), Rewrite systems, in “Handbook of Theoretical Computer Science” (J. van Leeuwen, Ed.), Vol. B: Formal Models and Semantics, pp. 243–320, Elsevier, Amsterdam and MIT Press, Cambridge, MA.

[DKP91] Dershowitz, N., Kaplan, S., and Plaisted, D. (1991), Rewrite, rewrite, rewrite, rewrite, rewrite, Theoret. Comput.

Sci. 83, 71–96.

[DM97] Durand, I., and Middeldorp, A. (1997), Decidable call by need computations in term rewriting (Extended Abstract),

in “Proc. of 14th International Conference on Automated Deduction, CADE’97” (W. McCune, Ed.), Lecture Notes

in Artificial Intelligence, Vol. 1249, pp. 4–18, Springer-Verlag, Berlin.

[Dur94] Durand, I. (1994), Bounded, strongly sequential and forward-branching term rewriting systems, J. Symbol. Com-

put. 18, 319–352.

[Eke98] Eker, S. (1998), Term rewriting with operator evaluation strategies, in “Proc. of 2nd International Workshop on Rewriting Logic and its Applications, WRLA’98” (C. Kirchner and H. Kirchner, Eds.), Electronic Notes in Computer Science, Vol. 15, pp. 1–20.

[ENPS92] van Eekelen, M. C. J. D., N¨ocker, E. G. J. M. H., Plasmeijer, M. J., and Smetsers, J. E. W. (1991), “Concurrent Clean, Language Manual-Version 0.8,” Technical Report 92-18, University of Nijmegen.

[FGJM85] Futatsugi, K., Goguen, J., Jouannaud, J.-P., and Meseguer, J. (1985), Principles of OBJ2, in “Conference Record of the 12th Annual ACM Symposium on Principles of Programming Languages, POPL’85,” pp. 52–66, Assoc. Comput. Mach. Press, New York.

[FH88] Field, A. J., and Harrison, P. G. (1988), “Functional Programming,” Addison-Wesley, Reading, MA.

[FKW00] Fokkink, W., Kamperman, J., and Walters, P. (2000), Lazy rewriting on eager machinery, ACM Trans. Program.

Languages Systems 22(1), 45–86.

[FN97] Futatsugi, K., and Nakagawa, A. (1997), An overview ofCAFEspecification environment—An algebraic ap- proach for creating, verifying, and maintaining formal specification over networks, in “Proc. of 1st International Conference on Formal Engineering Methods.”

[FW76] Friedman, D. P., and Wise, D. S. (1976), CONS should not evaluate its arguments, in “Automata, Languages and Programming” (S. Michaelson and R. Milner, Eds.), pp. 257–284, Edinburgh University Press.

[FR99] Ferreira, M. C. F., and Ribeiro, A. L. (1999), Context-sensitive AC-rewriting, in “Proc. of 10th International Conference on Rewriting Techniques and Applications, RTA’99” (P. Narendran and M. Rusinowitch, Eds.), Lecture Notes in Computer Science, Vol. 1631, pp. 286–300, Springer-Verlag, Berlin.

[GL02] Gramlich, B., and Lucas, S. (to appear), Modular termination of context-sensitive rewriting, in “Proc. of 4th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming, PPDP’02” (C. Kirchner, Ed.), Assoc. Comput. Mach., New York.

[GM99] Giesl, J., and Middeldorp, A. (1999), Transforming context-sensitive rewrite systems, in “Proc. of 10th Inter- national Conference on Rewriting Techniques and Applications, RTA’99” (P. Narendran and M. Rusinowitch, Eds.), Lecture Notes in Computer Science, Vol. 1631, pp. 271–285, Springer-Verlag, Berlin.

[GM02] Giesl, J., and Middeldorp, A. (2002), “Transformation Techniques for Context-Sensitive Rewrite Systems,” Technical Report AIB-2002–02, Department of Computer Science, RWTH Aachen.

[Gra02] Gramlich, B. (2002), personal communication.

[GWMFJ00] Goguen, J. A., Winkler, T., Meseguer, J., Futatsugi, K., and Jouannaud, J.-P. (2000), Introducing OBJ, in “Software Engineering with OBJ: Algebraic specification in action” (J. Goguen and G. Malcolm, Eds.), Kluwer, New York. [GWMFJ93] Goguen, J. A., Winkler, T., Meseguer, J., Futatsugi, K., and Jouannaud, J.-P. (1993), Introducing OBJ∗,

in “Applications of Algebraic Specifications Using OBJ” (D. Coleman, R. Gallimore, and J. Goguen, Eds.).

[HL79] Huet, G., and L´evy, J. J. (1979), “Call by Need Computations in Nonambiguous Linear Term Rewriting Systems,” Technical Report 359, IRIA Laboria, LeChesnay, France.

[HL91] Huet, G., and L´evy, J. J. (1991), Computations in orthogonal term rewriting systems, in “Computational Logic: Essays in Honour of J. Alan Robinson” (J. L. Lassez and G. Plotkin, Eds.), pp. 395–414 and 415–443, MIT Press, Cambridge, MA.

[HLM98] Hanus, M., Lucas, S., and Middeldorp, A. (1998), Strongly sequential and inductively sequential term rewriting systems, Inform. Process. Lett. 67(1), 1–8.

[HM76] Henderson, P., and Morris, J., Jr. (1976), A lazy evaluator, in “Conference record of the 3rd ACM Symposium on Principles of Programming Languages, POPL’76,” pp. 95–103, Assoc. Comput. Mach., New York. [HPF99] Hudak, P., Peterson, J., and Fasel, J.H. (1999) “A Gentle Introduction to Haskell 98,” Yale University, Department

of Computer Science Technical Report, YALEU.

[HPW92] Hudak, P., Peyton-Jones, S. J., and Wadler, P. (1992), Report on the Functional Programming Language Haskell: A non-strict, purely functional language, Sigplan Notices 27(5), 1–164.

[Hue80] Huet, G. (1980), Confluent reductions: Abstract properties and applications to term rewriting systems, J. Assoc.

Comput. Mach. 27, 797–821.

[Jac96] Jacquemard, F. (1996), Decidable approximations to term rewriting systems, in “Proc. of 7th International Con- ference on Rewriting Techniques and Applications, RTA’96” (H. Ganzinger, Ed.), Lecture Notes in Cumputer Science, Vol. 1103, pp. 362–376, Springer-Verlag, Berlin.

[Jon92] Jones, M. P. (1992), “Introduction to Gofer 2.20,” Oxford Programming Research Group.

[JS94] Jouannaud, J. P., and Sadfi, W. (1995), Strong sequentiality of left-linear overlapping rewrite systems, in “Proc. of Workshop on Conditional Term Rewriting Systems, CTRS’94” (N. Dershowitz and N. Lindenstrauss, Eds.), Lecture Notes in Cumputer Science, Vol. 968, pp. 235–246, Springer-Verlag, Berlin.

[Ken89] Kennaway, R. (1989), Sequential evaluation strategies for parallel-or and related reduction systems, J. Pure Appl.

Algebra 43, 31–56.

[Ken94] Kennaway, R. (1994), A conflict between Call-By-Need computation and parallelism, in “Proc. of 4th Workshop on Conditional Term Rewriting Systems, CTRS’94” (N. Dershowitz and N. Lindenstrauss, Eds.), Lecture Notes in Computer Science, Vol. 968, pp. 247–261, Springer-Verlag, Berlin.

[KKV95] Kirchner, C., Kirchner, H., and Vittek, M. (1995), Designing constraint logic programming languages using com- putational systems, in “Principles and Practice of Constraint Programming” (P. van Hentenryck and S. Saraswat, Eds.), MIT Press, Cambridge, MA.

[Klo92] Klop, J. W. (1992), Term rewriting systems, in “Handbook of Logic in Computer Science” (S. Abramsky, D. M. Gabbay, and T. S. E. Maibaum, Eds.), Vol. 2, pp. 1–116, Oxford University Press, London.

[KKSV95] Kennaway, R., Klop, J. W., Sleep, M. R., and de Vries, F.-J. (1995), Transfinite reductions in orthogonal term rewriting systems, Inform. and Comput. 119, 18–38.

[KM91] Klop, J. W., and Middeldorp, A. (1991), Sequentiality in orthogonal term rewriting systems, J. Symbol. Comput. 12, 161–195.

[KW95] Kamperman, J. F. Th, and Walters, H. R. (1995), Lazy rewriting and eager machinery, in “Proc. of the 6th International Conference on Rewriting Techniques and Applications, RTA’95” (J. Hsiang, Ed.), Lecture Notes in Cumputer Science, Vol. 914, pp. 147–162, Springer-Verlag, Berlin.

[Luc96] Lucas, S. (1996), Termination of context-sensitive rewriting by rewriting, in “Proc. of 23rd. International Collo- quium on Automata, Languages and Programming, ICALP’96” (F. Meyer auf der Heide and B. Monien, Eds.), Lecture Notes in Cumputer Science, Vol. 1099, pp. 122–133, Springer-Verlag, Berlin.

[Luc98a] Lucas, S. (1998), Context-sensitive computations in functional and functional logic programs, J. Funct. Logic

Programming 1998(1), 1–61.

[Luc98b] Lucas, S. (1998), Root-neededness and approximations of neededness, Inform. Process. Lett. 67(5), 245–254. [Luc01a] Lucas, S. (2001), Termination of on-demand rewriting and termination of OBJ programs, in “Proc. of 3rd In-

ternational Conference on Principles and Practice of Declarative Programming, PPDP’01,” pp. 82–93, Assoc. Comput. Mach., New York.

[Luc01b] Lucas, S. (2001), Termination of rewriting with strategy annotations, in “Proc. of 8th International Conference on Logic for Programming, Artificial Intelligence and Reasoning, LPAR’01” (R. Nieuwenhuis and A. Voronkov, Eds.), Lecture Notes in Artificial Intelligence, Vol. 2250, pp. 669–684, Springer-Verlag, Berlin.

[Luc01c] Lucas, S. (2001), Transfinite rewriting semantics for term rewriting systems, in “Proc. of 12th International Conference on Rewriting Techniques and Applications, RTA’01” (A. Middeldorp, Ed.), Lecture Notes in Computer Science, Vol. 2051, pp. 216–230, Springer-Verlag, Berlin.

[Luc02a] Lucas, S. (2002), “Lazy Rewriting and Context-Sensitive Rewriting,” Electronic Notes in Theoretical Computer Science, Vol. 64, Elsevier, Amsterdam.

[Luc02b] Lucas, S. (2002), “MU-TERMVersion 1.0. User’s Manual,” Technical Report DSIC-II/01/02, DSIC, Universidad Polit´ecnica de Valencia.

[Luc02c] Lucas, S. (2002), Termination of (Canonical) Context-Sensitive Rewriting, in “Proc. of 13th International Con- ference on Rewriting Techniques and Applications, RTA’02” (S. Tison, Ed.), Lecture Notes in Computer Science, Vol. 2378, pp. 296–310.

[Mar90] Maranget, L. (1990), Optimal derivations in weak lambda-calculi and in orthogonal term rewriting systems,

in “Conference Record of the 18th Annual ACM Symposium on Principles of Programming Languages,

POPL’90,” pp. 255–269, Assoc. Comput. Mach., New York.

[McC60] McCarthy, J. (1960), Recursive functions of symbolic expressions and their computations by machine. I, Comm.

ACM 3(4), 184–195.

[McC78] McCarthy, J. (1978), History of lisp, in “History of Programming Languages” (R. L. Wexelblat, Ed.), Academic Press, New York.

[Mid97] Middeldorp, A. (1997), Call by need computations to root-stable form, in “Conference Record of the 24th Annual ACM Symposium on Principles of Programming Languages, POPL’97,” pp. 94–105, Assoc. Comput. Mach., New York.

[Mid99] Middeldorp, A. (1999), Context-freeness and infinitary normalization, presented at the 14th Japanese Term Rewriting Meeting, Nara Institute of Science and Technology, March 15–16.

[MN92] Mycroft, A., and Norman, A. C. (1992), Optimising compilation. II: Lazy functional languages, in “Proc. of XIX Seminar on Current Trends in Theory and Practice of Informatics, SOFSEM’92.”

[Myc80] Mycroft, A. (1980), The theory and practice of transforming call-by-need into call-by-value, in “Proc. of the 4th International Symposium on Programming” (B. Robinet, Ed.), Lecture Notes in Cumputer Science, Vol. 83, pp. 269–281, Springer-Verlag, Berlin.

[Nag99] Nagaya, T. (1999), “Reduction Strategies for Term Rewriting Systems,” Ph.D. thesis, School of Information Science, Japan Advanced Institute of Science and Technology.

[Ngu01] Nguyen, Q.-H. (2001), “Compact Normalisation Trace via Lazy Rewriting,” Electronic Notes in Theoretical Computer Science, Vol. 57, Elsevier, Amsterdam.

[NO01] Nakamura, M., and Ogata, K. (2001), The evaluation strategy for head normal form with and without on- demand flags, in “Proc. of 3rd International Workshop on Rewriting Logic and its Applications, WRLA’2000” (K. Futatsugi, Ed.), Electronic Notes in Theoretical Computer Science, Vol. 36, 17.

[NSEP92] N¨ocker, E. G. J. M. H., Smetsers, J. E. W., van Eekelen, M. C. J. D., and Plasmeijer, M. J. (1992), Concurrent clean, in “Proc. of Parallel Architectures and Languages Europe, PARLE’91” (E. H. L. Aarts, J. Leeuwen, and M. Rem, Eds.), Lecture Notes in Computer Science, Vol. 506, pp. 202–219, Springer-Verlag, Berlin.

[NST95] Nagaya, T., Sakai, M., and Toyama, Y. (1995), “NVNF-Sequentiality of Left-Linear Term Rewriting Systems,” RIMS Technical Report 918, pp. 109–117, University of Kyoto.

[NT99] Nagaya, T., and Toyama, Y. (1999), Decidability for left-linear growing term rewriting systems, in “Proc. of 10th International Conference on Rewriting Techniques and Applications, RTA’99” (P. Narendran and M. Rusinowitch, Eds.), Lecture Notes in Computer Science, Vol. 1631, pp. 256–270, Springer-Verlag, Berlin.

[O’Do77] O’Donnell, M. J. (1977), “Computing in Systems Described by Equations,” Lecture Notes in Computer Science, Vol. 58, Springer-Verlag, Berlin.

[O’Do85] O’Donnell, M. J. (1985), “Equational Logic as a Programming Language,” MIT Press, Cambridge, MA. [O’Do95] O’Donnell, M. J. (1995), Equational logic programming, in “Handbook of Logic in Artificial Intelligence and

Logic Programming” (D. M. Gabbay, C. J. Hogger, and J. A. Robinson, Eds.), Vol. 4, Chap. 3, Oxford University Press, London.

[OV02] van Oostrom, V., and de Vrijer, R. (2002), Strategies, in “Term Rewriting Systems” (TeReSe), Chap. 9, Cambridge University Press, Cambridge, UK.

[Oya93] Oyamaguchi, M. (1993), NV-Sequentiality: A decidable condition for call-by-need computations in term- rewriting systems, SIAM J. Comput. 22(1), 114–135.

[PE93] Plasmeijer, R., and van Eekelen, M. (1993), “Functional Programming and Parallel Graph Rewriting,” Addison- Wesley, Reading, MA.

[Pey87] Peyton-Jones, S. L. (1987), “The Implementation of Functional Programming Languages,” Prentice-Hall, London.

[Pol01] van de Pol, J. (2001), “Just-In-Time: On Strategy Annotations,” Electronic Notes in Theoretical Computer Science, Vol. 57, Elsevier, Amsterdam.

[Rea93] Reade, C. (1993), “Elements of Functional Programming,” Addison-Wesley, Reading, MA.

[Red85] Reddy, U. S. (1985), Narrowing as the operational semantics of functional languages, in “Proc. of IEEE Interna- tional Symposium on Logic Programming,” pp. 138–151.

[RV80] Raoult, J. C., and Vuillemin, J. (1980), Operational and semantic equivalence between recursive programs,

[Sla74] Slagle, J. R. (1974), Automated theorem-proving for theories with simplifiers, commutativity, and associativity,

J. Assoc. Comput. Mach. 21(4), 622–642.

[SR93] Sekar, R. C., and Ramakrishnan, I. V. (1993), Programming in equational logic: Beyond strong sequentiality,

Inform. and Comput. 104, 78–109.

[Str89] Strandh, R. (1989), Classes of equational programs that compile into efficient machine code, in “Proc. of 3rd International Conference on Rewriting Techniques and Applications, RTA’89” (N. Dershowitz, Ed.), Lecture Notes in Computer Science, Vol. 355, pp. 449–461, Springer-Verlag, Berlin.

[SX98] Steinbach, J., and Xi, H. (1998), “Freezing—Termination Proofs for Classical, Context-Sensitive and Innermost Rewriting,” Institut f¨ur Informatik, T. U. M¨unchen.

[TKS00] Takai, T., Kaji, Y., and Seki, H. (2000), Right-linear finite path overlapping term rewriting systems effectively preserve recognizability, in “Proc. of 11th International Conference on Rewriting Techniques and Applications, RTA’00” (L. Bachmair, Ed.), Lecture Notes in Computer Science, Vol. 1833, pp. 246–260, Springer-Verlag, Berlin.

[Toy92] Toyama, Y. (1992), Strong sequentiality of left-linear overlapping rewrite systems, in “Proc. of 7th Annual IEEE Symposium on Logic in Computer Science, LICS’92,” pp. 274–284, IEEE Comput. Soc., Los Alamitos, CA. [Zan97] Zantema, H. (1997), Termination of context-sensitive rewriting, in “Proc. of 8th International Conference on

Rewriting Techniques and Applications, RTA’97” (H. Comon, Ed.), Lecture Notes in Computer Science, Vol. 1232, pp. 172–186, Springer-Verlag, Berlin.

[Zan02] Zantema, H. (2002), Termination, in “Term Rewriting Systems” (TeReSe), Chap. 6. Cambridge University Press, Cambridge, UK.