Compositional term rewriting: An algebraic proof of Toyama's theorem

Inspired by Boyer and Moore''s approach for generating induction schemes based on terminating function definitions, Zhang, Kapur and Krishnamoorthy introduced a cover set method for designing induction schemes for automating proofs by induction from specifications expressed as equations and conditional equations. This method has been implemented in the theorem prover Rewrite Rule Laboratory (RRL) and a proof management system Tecton built on top of em RRL, and it has been used to prove many nontrivial theorems and reason about sequential as well as parallel programs. The cover set method is based on the assumption that a function symbol is defined using a finite set of terminating (conditional or unconditional) rewrite rules. The left side of the rules are then used to design different cases of an induction scheme, and recursive calls to the function made in the right side can be used to design appropriate instantiations for generating induction hypotheses. A weakness of this method is that it relies on syntactic unification for generating an induction scheme for a conjecture. This paper goes a step further by proposing semantic analysis for generating an induction scheme for a conjecture from a cover set. We discuss the use of a decision procedure for Presburger arithmetic (quantifier-free theory of numbers with the addition operation and relational predicates , , =, ) for performing semantic analysis about numbers. The decision procedure is used to generate appropriate induction schemes for a conjecture using cover sets of function taking numbers as arguments. This extension of the cover set method automates proofs of many theorems which otherwise, require human guidance and hints. The effectiveness of the method is demonstrated using some examples which commonly arise in reasoning about specifications and programs. It is also shown how semantic analysis using a Presburger arithmetic decision procedure can be used for checking the completeness of a cover set of a function defined using operations such as check, many function definitions used in a proof of the prime factorization theorem stating that every number can be factored uniquely into prime factors, which had to be checked manually, can now be checked automatically in procedure for guiding generalization for generating conjectures and merging induction schemes is also illustrated.

This paper generalizes the Huet and Lévy theory of normalization by neededness to an abstract setting. We define Stable Deterministic Residual Structures (SDRS) and Deterministic Family Structures (DFS) by axiomatizing some properties of the residual relation and the family relation on redexes in an Abstract Rewriting System. We present two proofs of the Relative Normalization Theorem, one for SDRSs for regular stable sets, and another for DFSs for all stable sets of desirable ‘normal forms’. We further prove the Relative Optimality Theorem for DFSs. We extend this result to deterministic Computation Structures which are deterministic Event Structures with an extra relation expressing self-essentiality.

Implementing conditional term rewriting by graph rewriting

For the most part, rewriting techniques have been developed and applied to support efficient equational reasoning and equational specification, verification, and programming. Therefore, a rewrite rule \(t \longrightarrow t'\) has been usually interpreted as a directed equation t = t ’. Rewriting logic is a substantial broadening of the semantics given to rewrite rules. The equational reading is abandoned, in favor of a more dynamic interpretation. There are now in fact two complementary readings of a rule \(t \longrightarrow t'\), one computational, and another logical: (i) computationally, the rewrite rule \(t \longrightarrow t'\) is interpreted as a local transition in a concurrent system; (ii) logically, the rewrite rule \(t \longrightarrow t'\) is interpreted as an inference rule. The experience gained so far strongly suggest that rewriting is indeed a very flexible and general formalism for both computational and logical applications. This means that from the computational point of view rewriting logic is a very expressive semantic framework, in which many different models of concurrency, languages, and distributed systems can be specified and programmed; and that from a logical point of view is a general logical framework in which many different logics can be represented and implemented. This paper introduces the main concepts of rewriting logic and of the Maude rewriting logic language, and discusses a wide range of semantic framework and logical framework applications that have been developed in rewriting logic using Maude.KeywordsInference RuleEquational TheoryLinear LogicLogical FrameworkConcurrent SystemThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Many functional languages based on term rewriting (such as Miranda and ML) allow the programmer to write ambiguous rule systems, with the understanding that rules will be matched against a term in the order in which the rules are written, and that the pattern-matching of a rule against a term proceeds from left to right.This gives a precise semantics to such ambiguous systems, but it has disadvantages. It depends on the textual ordering of the program, whereas the standard theory of term rewriting has no such concept. As a result, equational reasoning is not always valid for this semantics, defeating the primary virtue of functional languages. The semantics also fails to be fully lazy, in that sometimes a non-terminating computation will be performed on a term which has a normal form.We define a rule, called specificity, for computation in ambiguous term rewrite systems. This rule (really a meta-rule) stipulates that a term rewrite rule of the system can only be used to reduce a term which matches it, if that term can never match any other rule of the system which is more specific than the given rule. One rule is more specific than another if the left-hand side of the first rule is a substitution instance of the second, and the reverse is not true. Specificity captures the intuition underlying the use of ambiguity in ML and Miranda, while also providing lazy pattern-matching.A natural generalisation of the idea provides a semantics for Miranda's lawful types.KeywordsNormal FormFunction SymbolFunctional ProgramFunctional LanguageAmbiguous TermThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In this paper, we will define a custom term-graph reduction system for a simplified lazy functional language. Our custom system is geared towards flexibility, which is accomplished by leaving the choice of redex free and by making use of single-step reduction. It is therefore more suited for formal reasoning than the well-established standard reduction systems, which usually fix a single redex and realize multi-step reduction only. We will show that our custom system is correct with respect to the standard systems, by proving that it is confluent and allows standard lazy functional evaluation as a possible reduction path.Our reduction system is used in the foundation of Sparkle. Sparkle is the dedicated proof assistant for Clean, a lazy functional programming language based on term-graph rewriting. An important reasoning step in Sparkle is the replacement of an expression with one of its reducts. The flexibility of our underlying reduction mechanism ensures that as many reduction options as possible are available for this reasoning step, which improves the ease of reasoning.Because our reduction system is based on a simplified lazy functional language, our results can be applied to any other functional language based on term-graph rewriting as well.KeywordsFunction SymbolReduction SystemReduction RuleFormal ReasoningProof AssistantThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

We propose a method called back-and-forth narrowing for solving reachability goals of the form $(\exists^\rightarrow_{x}).t_{1}\rightarrow*t'_{1}\wedge...\wedge t_{n}\rightarrow * t'_{n}$ in general term rewrite systems. The method is a complete semi-decision procedure in the sense that it is guaranteed to find a solution when one exists, but in general it may not terminate when there are no solutions. The completeness result is very general in that it makes no assumptions about the given term rewrite system. Specifically, the rewrite rules need not be linear, confluent, or terminating, and can even have extra-variables in the righthand side. Such generality is often essential while modeling concurrent systems or axiomatizing inference systems as rewrite rules, and in such applications back-and-forth narrowing can be used as a sound and complete technique for symbolic reachability analysis or as a deductive procedure for proving existential formulae.

We characterize the modal logics of elementary classes of Kripke frames as precisely those modal logics that are axiomatized by modal axioms synthesized in a certain effective way from sentences of hybrid logic. These are pure positive hybrid sentences with arbitrary existential and relativized universal quantification over nominals. The proof has three steps. The first step is to use the known result that the modal logic of any elementary class of Kripke frames is also the modal logic of the closure of this class under disjoint unions, generated subframes, bounded morphic images, and ultraroots. This latter class can be defined by the first-order sentences of a special syntactic form (called pseudo-equations by Goldblatt) that are valid in the former class. The second step is to translate these pseudo-equations into equivalent quasi-positive hybrid sentences. In the third and main step, we show that any quasi-positive sentence S generates an infinite set of modal formulas called approximants, which together axiomatize a canonical modal logic that is sound and complete for the class of frames validating S. The proof is analogous to standard proofs of Sahlqvist's theorem. It generalizes to sets of quasi-positive sentences. The main result now follows.

The chemical reaction metaphor describes computation in terms of a chemical solution in which molecules interact freely according to reaction rules. Chemical solutions are represented by multisets of elements and reactions by rewrite rules which consume and produce new elements according to conditions. The chemical programming style allows to write many programs in a very elegant way. We go one step further by extending the model so that rewrite rules are themselves molecules. This higher-order extension leads to a programming style where the implementation of new features amounts to adding new active molecules in the solution representing the system. We illustrate this style by specifying an autonomic mail system with several self-managing properties.KeywordsActive MoleculeEmergency ServerReactive MoleculeMain ServerReaction RuleThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

It is undecidable in general whether or not a term-rewriting system is confluent on a given congruence class. This result is shown to hold even when the term-rewriting systems under consideration contain unary function symbols only, and all their rules are length-reducing. On the other hand, for certain subclasses of these systems confluence on a given congruence class is decidable.KeywordsWord ProblemCritical PairCongruence ClassReduction SequencePushdown AutomatonThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In [PF-85] the concepts of fair derivations and fair-termination in term-rewriting systems were introduced and studied. In this paper, we define the notion of fairness in equational term-rewriting systems, where a derivation step is a composition of the equality generated by a (finite) set of equations with one step rewriting using a set of rules. A natural generalization of E-termination (termination of equational term-rewriting systems), namely E-fair-termination, is presented. We show that fair-termination and E-fair-termination are the same whenever the underlying rewriting relation is E-fully-commuting, a property inspired by Jouannaud and Munoz' E-commutation property. We obtain analogous results for combined term-rewriting systems.KeywordsFree AlgebraFull DerivationFair TerminationInfinite ChainDerivation StepThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The purpose of this paper is not to give an overview of the state of art in unification theory. It is intended to be a short introduction into the area of equational unification which should give the reader a feeling for what unification theory might be about. The basic notions such as complete and minimal complete sets of unifiers, and unification types of equational theories are introduced and illustrated by examples. Then we shall describe the original motivations for considering unification (in the empty theory) in resolution theorem proving and term rewriting. Starting with Robinson's first unification algorithm it will be sketched how more efficient unification algorithms can be derived.We shall then explain the reasons which lead to the introduction of unification in non-empty theories into the above mentioned areas theorem proving and term rewriting. For theory unification it makes a difference whether single equations or systems of equations are considered. In addition, one has to be careful with regard to the signature over which the terms of the unification problems can be built. This leads to the distinction between elementary unification, unification with constants, and general unification (where arbitrary free function symbols may occur). Going from elementary unification to general unification is an instance of the so-called combination problem for equational theories which can be formulated as follows: Let E, F be equational theories over disjoint signatures. How can unification algorithms for E, F be combined to a unification algorithm for the theory E ∪ F.KeywordsFunction SymbolEquational TheoryVariable NodeUnification AlgorithmCritical PairThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

We consider combinations of term rewriting with built-in operations which compute objects of some external domain from ground terms. Combining a canonical term rewriting system with a computation relation does in general not lead to a canonical simplification relation. We show how a canonical simplification system can be constructed for such rewrite systems with built-in operations. Decomposition free simplification systems never need to look at the internal structure of external objects and thus a previous computation never needs to be undone. For some interesting equational specifications the construction of decomposition free canonical simplification systems succeeds. Our construction of canonical simplification systems relies on simulating combined rewriting and computing by pure term rewriting. This allows us to use the wealth of all rewrite techniques and tools to investigate and manipulate these structures.KeywordsExternal ObjectCritical PairGround TermGround InstanceMixed TermThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

This paper studies termination of curryfied term rewriting systems (CTRSs), where functional values are introduced by “partial application” The limitations of syntactic simplification orderings for such systems are discussed. A proof method is proposed, based on three techniques: 1) Requirements on stability and monotonicity are relaxed. 2) Variables and inner function symbols of (potentially) functional types are allowed to contribute in the underlying precedence. 3) A standard polymorphic type system is refined so as to express non-functional polymorphism. Founded on this method, the curryfied path ordering with status (CPOS) is introduced. CPOS coincides with the recursive path ordering with status on first-order terms, and is comparable in strength to other approaches for higher-order rewrite systems, but also allows for polymorphism. Under mild restrictions on the underlying precedence, the so called curry rules are oriented correctly under CPOS.KeywordsFunction SymbolPrincipal TypeProof MethodLambda CalculusType SubstitutionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

This paper studies termination properties of rewrite systems that are typeable using intersection types. It introduces a notion of partial type assignment on Curryfied Term Rewrite Systems, that consists of assigning intersection types to function symbols, and specifying the way in which types can be assigned to nodes and edges between nodes in the tree representation of terms. Using a more liberal approach to recursion, a general scheme for recursive definitions is presented, that generalizes primitive recursion, but has full Turing-machine computational power. It will be proved that, for all systems that satisfy this scheme, every typeable term is strongly normalizable.KeywordsFunction SymbolCombinatory LogicType AssignmentTypeable TermRecursive DefinitionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.