Some results about confluence on a given congruence class

Reductions in tree replacement systems

First-order spectra with one variable

The paper gives a logical characterisation of the class NTIME(n) of problems that can be solved on a nondeterministic Turing machine in linear time. It is shown that a set L of strings is in this class if and only if there is a formula of the form ∃f 1··∃f k ∃R 1··∃R m ∀xϕ that is true exactly for all strings in L. In this formula the f i are unary function symbols, the R i are unary relation symbols and ϕ is a quantifier-free formula. Furthermore, the quantification of functions is restricted to non-crossing, decreasing functions and in ϕ no equations in which different functions occur are allowed. There are a number of variations of this statement, e.g., it holds also for k = 3. From these results we derive an Ehrenfeucht game characterisation of NTIME(n).KeywordsLinear TimeTuring MachineDerivation TreeRelational AtomLogical CharacterisationThese 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.

First-order spectra with one binary predicate

For a class of extensions of lattice theory by unary function symbols and equational axioms (including modularity) algorithms for the computation of the corresponding initial algebra (if this is finite) are presented. In the case of finitely presented lattices the method amounts to a decision procedure for term equality and can be used for the computation of finite sublattices. Several examples and performance comparisons are provided.

A poor signature consists of one (unary) function symbol, a symbol for equality and a number of constant symbols. Due to the lack of internal structure, interpretations of poor signatures differ from interpretations of richer signatures in some respects. One of them is the completeness of Hoare-like systems relative to the first-order theory of the interpretation.

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.

This article proposes a compositional semantics for term rewriting systems, i.e. a semantics preserving structuring operations such as the disjoint union. The semantics is based on the categorical construct of a monad, adapting the treatment of universal algebra in category theory to term rewriting systems.As an example, the preservation of confluence under the disjoint union of two term rewriting systems is shown, obtaining an algebraic proof of Toyama's theorem, generalised slightly to term rewriting systems introducing variables on the right-hand side of the rules.KeywordsDisjoint UnionCategory TheoryUniversal AlgebraEasy InductionCompositional SemanticThese 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.

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.

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.

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.

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.