Constructor Systems Research Articles

Methods of Modeling the Process of Building the Conceptual Model of TIAV Multimedia System

In the article describes methods for modeling the process of building a conceptual model of a multimedia system, described the principal model multimedia system, the development of an algorithm for constructing online system - Designer TIAV-multimedia systems are described information-functional model of the online system constructor TIAV-multimedia systems, presents the conceptual model of the process processing of information resources in TIAV-multimedia systems, as well as the information considered simulation model of discrete-continuous processes processing of information resources.

Lifting Term Rewriting Derivations in Constructor Systems by Using Generators

Narrowing is a procedure that was first studied in the context of equational E-unification and that has been used in a wide range of applications. The classic completeness result due to Hullot states that any term rewriting derivation starting from an instance of an expression can be "lifted" to a narrowing derivation, whenever the substitution employed is normalized. In this paper we adapt the generator- based extra-variables-elimination transformation used in functional-logic programming to overcome that limitation, so we are able to lift term rewriting derivations starting from arbitrary instances of expressions. The proposed technique is limited to left-linear constructor systems and to derivations reaching a ground expression. We also present a Maude-based implementation of the technique, using natural rewriting for the on-demand evaluation strategy.

Conversion to tail recursion in term rewriting

Tail recursive functions are a special kind of recursive functions where the last action in their body is the recursive call. Tail recursion is important for a number of reasons (e.g., they are usually more efficient). In this article, we introduce an automatic transformation of first-order functions into tail recursive form. Functions are defined using a (first-order) term rewrite system. We prove the correctness of the transformation for constructor-based reduction over constructor systems (i.e., typical first-order functional programs).

Rewriting and narrowing for constructor systems with call-time choice semantics

AbstractNon-confluent and non-terminating {constructor-based term rewriting systems are useful for the purpose of specification and programming. In particular, existing functional logic languages use such kinds of rewrite systems to define possibly non-strict non-deterministic functions. The semantics adopted for non-determinism iscall-time choice, whose combination with non-strictness is a non-trivial issue, addressed years ago from a semantic point of view with the Constructor-based Rewriting Logic (CRWL), a well-known semantic framework commonly accepted as suitable semantic basis of modern functional logic languages. A drawback of CRWL is that it does not come with a proper notion of one-step reduction, which would be very useful to understand and reason about how computations proceed. In this paper, we develop thoroughly the theory for the first-order version of let-rewriting, a simple reduction notion close to that of classical term rewriting, but extended with a let-binding construction to adequately express the combination of call-time choice with non-strict semantics. Let-rewriting can be seen as a particular textual presentation of term graph rewriting. We investigate the properties of let-rewriting, most remarkably their equivalence with respect to a conservative extension of the CRWL-semantics coping with let-bindings, and we show by some case studies that having two interchangeable formal views (reduction/semantics) of the same language is a powerful reasoning tool. After that, we provide a notion of let-narrowing, which is adequate for call-time choice as proved by soundness and completeness results of let-narrowing with respect to let-rewriting. Moreover, we relate those let-rewriting and let-narrowing relations (and hence CRWL) with ordinary term rewriting and narrowing, providing in particular soundness and completeness of let-rewriting with respect to term rewriting for a class of programs which are deterministic in a semantic sense.

Singular and plural functions for functional logic programming

AbstractModern functional logic programming (FLP) languages use non-terminating and non-confluent constructor systems (CSs) as programs in order to define non-strict and non-deterministic functions. Two semantic alternatives have been usually considered for parameter passing with this kind of functions: call-time choice and run-time choice. While the former is the standard choice of modern FLP languages, the latter lacks some basic properties – mainly compositionality – that have prevented its use in practical FLP systems. Traditionally it has been considered that call-time choice induces a singular denotational semantics, while run-time choice induces a plural semantics. We have discovered that this latter identification is wrong when pattern matching is involved, and thus in this paper we propose two novel compositional plural semantics for CSs that are different from run-time choice.We investigate the basic properties of our plural semantics – compositionality, polarity, and monotonicity for substitutions, and a restricted form of the bubbling property for CSs – and the relation between them and to previous proposals, concluding that these semantics form a hierarchy in the sense of set inclusion of the set of values computed by them. Besides, we have identified a class of programs characterized by a simple syntactic criterion for which the proposed plural semantics behave the same, and a program transformation that can be used to simulate one of the proposed plural semantics by term rewriting. At the practical level, we study how to use the new expressive capabilities of these semantics for improving the declarative flavor of programs. As call-time choice is the standard semantics for FLP, it still remains the best option for many common programming patterns. Therefore, we propose a language that combines call-time choice and our plural semantics, which we have implemented in the Maude system. The resulting interpreter is then employed to develop and test several significant examples showing the capabilities of the combined semantics.

Problems and Solution of Practice Qualification Institution of Constructor in China

Although the Chinese constructor system has already begun to receive efforts, there are still some shortcomings and questions existing in development procedures. This paper intends to analyze those problems and make effort to find the solutions of those questions.

Termination of narrowing via termination of rewriting

Narrowing extends rewriting with logic capabilities by allowing logic variables in terms and by replacing matching with unification. Narrowing has been widely used in different contexts, ranging from theorem proving (e.g., protocol verification) to language design (e.g., it forms the basis of functional logic languages). Surprisingly, the termination of narrowing has been mostly overlooked. In this work, we present a novel approach for analyzing the termination of narrowing in left-linear constructor systems—a widely accepted class of systems—that allows us to reuse existing methods in the literature on termination of rewriting.

Inducing Constructor Systems from Example-Terms by Detecting Syntactical Regularities

We present a technique for inducing functional programs from few, well chosen input/output-examples (I/O-examples). Potential applications for automatic program or algorithm induction are to enable end users to create their own simple programs, to assist professional programmers, or to automatically invent completely new and efficient algorithms. In our approach, functional programs are represented as constructor term rewriting systems (CSs) containing recursive rules. I/O-examples for a target function to be implemented are a set of pairs of terms (F(ii),oi) meaning that F(ii)—denoting application of function F to input ii—is rewritten to oi by a CS implementing the function F. Induction is based on detecting syntactic regularities between example terms. In this paper we present theoretical results and describe an algorithm for inducing CSs over arbitrary signatures/data types which consist of one function defined by an arbitrary number of rules with an arbitrary number of non-nested recursive calls in each rule. Moreover, we present empirical results based on a prototypical implementation.

Strong and NV-sequentiality of constructor systems

Constructor Systems (CSs) are an important subclass of Term Rewriting Systems (TRSs) which can be used as an abstract model of some programming languages. While normalizing strategies are always desirable for achieving a good computational behavior of programs, when dealing with lazy languages infinitary normalizing strategies should be considered instead since (finite approximations of ) infinite data structures can be returned as the result of computations. We have shown that NV-sequential TRSs (hence strongly sequential TRSs, a subclass of them) provide an appropriate basis for the effective definition of normalizing and infinitary normalizing strategies. In this paper, we show that strongly sequential and NV-sequential CSs coincide. Since the implementation of NV-sequential TRSs has been underexplored in comparison to strongly sequential TRSs, this coincidence suggests that, in programming languages, it is a good option to implement NV-sequentiality as strong sequentiality.

Narrowing-based simulation of term rewriting systems with extra variables and its Termination Proof

Term rewriting systems (TRSs) extended by allowing to contain extra variables in their rewrite rules are called EV-TRSs. They are ill-natured since every one-step reduction by their rules with extra variables is infinitely branching and they are not terminating. To solve these problems, this paper shows that narrowing can simulate reduction sequences of EV-TRSs as narrowing sequences starting from ground terms. We prove the soundness of ground narrowing sequences for the reduction sequences. We prove the completeness for the case of right-linear systems, and also for the case that any redex reduced in the reduction sequence is not introduced by means of extra variables. Moreover, we give a method to prove the termination of the simulation, extending the dependency pair method to prove termination of TRSs, into that of narrowing on EV-TRSs starting from ground terms. We show that the method is useful for right-linear or constructor systems.

A Deterministic Lazy Narrowing Calculus

In this paper we study the non-determinism between the inference rules of the lazy narrowing calculusLNC(Middeldorpet al., 1996,Theoret. Comput. Sci.,167, 95–130. We show that all non-determinism can be removed without losing the important completeness property by restricting the underlying term rewriting systems to left-linear confluent constructor systems and interpreting equality as strict equality. For the subclass of orthogonal constructor systems the resulting narrowing calculus is shown to have the nice property that solutions computed by different derivations starting from the same goal are incomparable.

Head boundedness of nonterminating rewritings

Further research about nonterminating rewritings is introduced. First, the previous definition of head boundedness is modified to exclude non-fair reduction sequences. A sufficient condition is then given to determine head boundedness of term rewriting systems. The condition is then developed to a method to determine head boundedness of constructor systems.

Simple termination is difficult

A terminating term rewriting system is called simply terminating if its termination can be shown by means of a simplification ordering, an ordering with the property that a term is always bigger than its proper subterms. Almost all methods for proving termination yield, when applicable, simple termination. We show that simple termination is an undecidable property, even for one-rule systems. This contradicts a result by Jouannaud and Kirchner. The proof is based on the ingenious construction of Dauchet who showed the undecidability of termination for one-rule systems. Our results may be summarized as follows: being simply terminating, (non-)self-embedding, and (non-)looping are undecidable properties of orthogonal, variable preserving, one-rule constructor systems.

ABSTRACT RELATIONS BETWEEN RESTRICTED TERMINATION AND CONFLUENCE PROPERTIES OF REWRITE SYSTEMS

We investigate restricted termination and confluence properties of term rewriting systems, in particular weak termination, weak innermost termination, (strong) innermost termination, (strong) termination, and their interrelations. New criteria are provided which are sufficient for the equivalence of these properties. These criteria provide interesting possibilities to infer completeness, i.e. termination plus confluence, from restricted termination and confluence properties. Our main result states that any (strongly) innermost terminating, locally confluent overlay system is terminating, and hence confluent and complete. Using these basic results we are also able to prove some new results about modular termination of rewriting. In particular, we show that termination is modular for some classes of innermost terminating and locally confluent term rewriting systems, namely for non-overlapping and even for overlay systems. As an easy consequence this latter result also entails a simplified proof of the fact that completeness is a decomposable property of constructor systems. Similarly, a combined overlay system with shared constructors is complete if and only if its component sytems are complete overlay systems. Interestingly, these modularity results are obtained by means of a proof technique which itself constitutes a modular approach.

Decidability of reachability for disjoint union of term rewriting systems

The reachability problem for term rewriting systems is the problem of deciding for a system S and two terms t and t′, whether t can be reduced to t′ with rules of S. On the one hand, we study the disjoint union of term rewriting systems the reachability problem of which is decidable and give sufficient conditions for obtaining the modularity of decidability of this problem. On the other hand, we study composition of constructor systems. This notion of composition does not imply disjointness.

Completeness of Combinations of Conditional Constructor Systems

In this paper we extend the divide and conquer technique of Middeldorp and Toyama for establishing (semi-)completeness of constructor systems to conditional constructor systems. We show that both completeness (i.e. the combination of confluence and strong normalisation) and semi-completeness (confluence plus weak normalisation) are decomposable properties of conditional constructor systems without extra variables in the conditions of the rewrite rules.

Completeness of Combinations of Constructor Systems

A term rewriting system is called complete if it is both confluent and strongly normalising. Barendregt and Klop showed that the disjoint union of complete term rewriting systems does not need to be complete. In other words, completeness is not a modular property of term rewriting systems. Toyama, Klop and Barendregt showed that completeness is a modular property of left-linear term rewriting systems. In this paper we show that it is sufficient to impose the constructor discipline for obtaining the modularity of completeness. This result is a simple consequence of a quite powerful divide and conquer technique for establishing completeness of such constructor systems. Our approach is not limited to systems which are composed of disjoint parts. The importance of our method is that we may decompose a given constructor system into parts which possibly share function symbols and rewrite rules in order to infer completeness. We obtain a similar technique for semi-completeness, i.e. the combination of confluence and weak normalisation.

Implementing first-order rewriting with constructor systems

In previous work [8] we described a technique for translating a general class of equational rewriting systems called regular systems [3] to constructor-based systems. This paper extends the previous results by showing that the translation technique described in [8] is much more generally applicable under a slight restriction of rewriting in the translated version of the system. The three additional classes we consider are those of semiregular systems (a generalization of regular systems), canonical systems, and arbitrary call-by-value confluent systems. It is shown that in each case the translation preserves the defining characteristics and normal forms of the class.