Term Rewrite Rules Research Articles

Zipper-based embedding of strategic attribute grammars

Strategic term re-writing and attribute grammars are two powerful programming techniques widely used in language engineering. The former relies on strategies to apply term re-write rules in defining large-scale language transformations, while the latter is suitable to express context-dependent language processing algorithms. These two techniques can be expressed and combined via a powerful navigation abstraction: generic zippers. This results in a concise zipper-based embedding offering the expressiveness of both techniques. In addition, we increase the functionalities of strategic programming, enabling the definition of outwards traversals; i.e. outside the starting position.Such elegant embedding has a severe limitation since it recomputes attribute values. This paper presents a proper and efficient embedding of both techniques. First, attribute values are memoized in the zipper data structure, thus avoiding their re-computation. Moreover, strategic zipper based functions are adapted to access such memoized values. We have hosted our memoized zipper-based embedding of strategic attribute grammars both in the Haskell and Python programming languages. Moreover, we benchmarked the libraries supporting both embedding against the state-of-the-art Haskell-based Strafunski and Scala-based Kiama libraries. The first results show that our Haskell Ztrategic library is very competitive against those two well established libraries.

Adaptation of a Refactoring DSL for the Object-Oriented Paradigm

Many development environments offer refactorings aimed at improving non-functional properties of software, but we have no guarantees that these transformations indeed preserve the observable behavior of the source code they are applied on. An existing domain-specific language makes it possible to formalize automatically verifiable refactorings via instantiating predefined transformation schemes with conditional term rewrite rules.
 We present a proposal for adapting this language from the functional to the object-oriented programming paradigm, using Java instead of Erlang as a representative. The behavior-preserving property of discussed refactorings is characterized with a multilayered definition of equivalence for Java programs, including the conformity relation of class hierarchies. Based on the decomposition of a complex refactoring rule, we show how new transformation schemes can be identified, along with modifications and extensions of the description language required to accommodate them. Finally, we formally define the chosen base refactoring as a composition of scheme instances.

Monolithic and modular termination analyses for higher-order attribute grammars

In this paper we describe a sound, but not complete, analysis to prove the termination of higher-order attribute grammar evaluation caused by the creation of an unbounded number of (finite) trees as local tree-valued attributes, which are then themselves decorated with attributes. The analysis extracts a set of term-rewriting rules from the grammar that model creation of new syntax trees during the evaluation of higher-order attributes. If this term rewriting system terminates, then only a finite number of trees will be created during attribute grammar evaluation. The analysis places an ordering on nonterminals to handle the cases in which higher-order inherited attributes are used to ensure that a finite number of trees are created using such attributes. When paired with the traditional completeness and circularity analyses for attribute grammars and the assumption that each attribute equation defines a terminating computation, this analysis can be used to show that attribute grammar evaluation will terminate normally. This analysis can be applied to a wide range of common attribute grammar idioms and has been used to show that evaluation of our specification of Java 1.4 terminates. We also describe a modular version of the analysis that is performed on independently developed language extension grammars and the host language being extended. If the extensions individually pass the modular analysis then their composition is also guaranteed to terminate.

Towards a Maude Tool for Model Checking Temporal Graph Properties

We present our prototypical tool for the verification of graph transfor ma- tion systems. The major novelty of our tool is that it provides a model checker for temporal graph properties based on counterpart semantics for quantifie d μ-calculi. Our tool can be considered as an instantiation of our approach to counterpart seman- tics which allows for a neat handling of creation, deletion and merging in syste ms with dynamic structure. Our implementation is based on the object-based machinery of Maude, which provides the basics to deal with attributed graphs. Graph transfor- mation systems are specified with term rewrite rules. The model checker evalu ates logical formulae of second-order modal μ-calculus in the automatically generated Counterpart Model (a sort of unfolded graph transition system) of the graph transfor- mation system under study. The result of evaluating a formula is a set of assignments for each state, associating node variables to actual nodes.

Descendants of a recognizable tree language for sets of linear monadic term rewrite rules

For a tree language L and a set S of term rewrite rules over Σ, the descendant of L for S is the set S ∗ ( L ) of trees reachable from a tree in L by rewriting in S. For a recognizable tree language L, we study the set D ( L ) of descendants of L for all sets of linear monadic term rewrite rules over Σ. We show that D ( L ) is finite. For each tree automaton A over Σ, we can effectively construct a set { R 1 , … , R k } of linear monadic term rewrite systems over Σ such that D ( L ( A ) ) = { R 1 ∗ ( L ( A ) ) , … , R k ∗ ( L ( A ) ) } and for any 1 ⩽ i < j ⩽ k , R i ∗ ( L ( A ) ) ≠ R j ∗ ( L ( A ) ) .

Reachability Analysis of Synchronized PA Systems

We present a generic approach for the analysis of concurrent programs with (unbounded) dynamic creation of threads and recursive procedure calls. We define a model for such programs based on a set of term rewrite rules where terms represent control configurations. The reachability problem for this model is undecidable. Therefore, we propose a method for analyzing such models based on computing abstractions of their sets of computation paths. Our approach allows to compute such abstractions as least solutions of a system of (path language) constraints. More precisely, given a program and two regular sets of configurations (process terms) T and T′, we provide (1) a construction of a system of constraints which characterizes the set of computation paths leading from T to T′, and (2) a generic framework, based on abstract interpretation, allowing to solve this system in various abstract domains leading to abstract analysis with different precision and cost.

A formal specification scheme for network diagrams that facilitates automated design

The Automated Network Diagram Designer (ANDD) designs network diagrams automatically to communicate given information. ANDD makes all the design decisions a human graphic designer would make when designing a network diagram: it determines how different types of information should be expressed graphically, specifies a desirable perceptual organization for the diagram, picks appropriate graphical-property values for symbols in the diagram and computes an aesthetic layout that exhibits appropriate perceptual groupings. The ANDD system uses a formal specification scheme for describing the syntax, semantics and pragmatics of network diagrams. The network-diagram syntax described below differs from previous work in two ways: perceptual organization is represented explicitly and syntax is specified using constraints rather than term-rewriting rules. The semantic/pragmatic specification used by ANDD is also novel: it supports the notion of mutable semantics and relates the information to be communicated directly to the graphical properties of symbols and to the overall perceptual organization of a diagram.

Some techniques for building mathematical intelligent tutoring systems

Abstract Some techniques that are useful in building intelligent tutoring systems for mathematics are described. These techniques have been implemented in Integration-Kid, an intelligent tutoring system for integral calculus. Its production system is a language which helps the problem-solver to interact with students. For the mathematical problem-solver, we have adopted term-rewriting rules which represent basic mathematical knowledge. The situation map is a representation which lays out all possible situations in the process of solving a complex problem. We shall also describe an algorithm which transforms a linear mathematical expression to a readable, two-dimensional expression.

Jungle Evaluation

Jungle evaluation is proposed as a new graph rewriting approach to the evaluation of functional expressions and, in particular, of algebraically specified operations. Jungles – being intuitively forests of coalesced trees with shared substructures – are certain acyclic hypergraphs (or equivalently, bipartite graphs) the nodes and edges of which are labeled with the sorts and operation symbols of a signature. Jungles are manipulated and evaluated by the application of jungle rewrite rules, which generalize equations or, more exactly, term rewrite rules. Indeed, jungle evaluation turns out to be a compromise between term rewriting and graph rewriting displaying some favorable properties: the inefficiency of term rewriting is partly avoided while the possibility of structural induction is maintained, and a good part of the existing graph grammar theory is applicable so that there is some hope that the rich theory of term rewriting is not lost forever without a substitute.

On “on graph rewritings”

In 1984, Raoult has given a description of graph rewriting. His description is operational, despite the similarity which his constructions have to the category-theoretic concept of a pushout. We describe a modification to Raoult's description of graph rewriting which allows the reduction of a redex to be described as a pushout, in a category of graphs where morphisms are not required to preserve graph structure. Our description can also handle term rewrite rules whose right-hand sides consist of a variable. Raoult specifically excludes such rules from his treatment. Rules of this form include the K combinator, the identity function, selector functions for extracting components of data structures, and the conditional. We prove the correctness of this implementation of term rewriting.