17,053 research outputs found
The HOM problem is EXPTIME-complete
We define a new class of tree automata with constraints and prove decidability of the emptiness problem for this class in exponential time. As a consequence, we obtain several EXPTIME-completeness results for problems on images of regular tree languages under tree homomorphisms, like set inclusion, regularity (HOM problem), and finiteness of set difference. Our result also has implications in term rewriting, since the set of reducible terms of a term rewrite system can be described as the image of a tree homomorphism. In particular, we prove that inclusion of sets of normal forms of term rewrite systems can be decided in exponential time. Analogous consequences arise in the context of XML typechecking, since types are defined by tree automata and some type transformations are homomorphic.Peer ReviewedPostprint (published version
Controlled Term Rewriting
International audienceMotivated by the problem of verification of imperative tree transformation programs, we study the combination, called controlled term rewriting systems (CntTRS), of term rewriting rules with con- straints selecting the possible rewrite positions. These constraints are specified, for each rewrite rule, by a selection automaton which defines a set of positions in a term based on tree automata computations. We show that reachability is PSPACE-complete for so-called monotonic CntTRS, such that the size of every left-hand-side of every rewrite rule is larger or equal to the size of the corresponding right-hand-side, and also for the class of context-free non-collapsing CntTRS, which transform Context-Free (CF) tree language into CF tree languages. When allowing size-reducing rules, reachability becomes undecidable, even for flat CntTRS (both sides of rewrite rules are of depth at most one) when restricting to words (i.e. function symbols have arity at most one), and for ground CntTRS (rewrite rules have no variables). We also consider a restricted version of the control such that a position is selected if the sequence of symbols on the path from that position to the root of the tree belongs to a given regular language. This restriction enables decision results in the above cases
Rewrite Closure and CF Hedge Automata
We introduce an extension of hedge automata called bidimensional context-free
hedge automata. The class of unranked ordered tree languages they recognize is
shown to be preserved by rewrite closure with inverse-monadic rules. We also
extend the parameterized rewriting rules used for modeling the W3C XQuery
Update Facility in previous works, by the possibility to insert a new parent
node above a given node. We show that the rewrite closure of hedge automata
languages with these extended rewriting systems are context-free hedge
languages
Non-termination using Regular Languages
We describe a method for proving non-looping non-termination, that is, of
term rewriting systems that do not admit looping reductions. As certificates of
non-termination, we employ regular (tree) automata.Comment: Published at International Workshop on Termination 201
Rewrite based Verification of XML Updates
We consider problems of access control for update of XML documents. In the
context of XML programming, types can be viewed as hedge automata, and static
type checking amounts to verify that a program always converts valid source
documents into also valid output documents. Given a set of update operations we
are particularly interested by checking safety properties such as preservation
of document types along any sequence of updates. We are also interested by the
related policy consistency problem, that is detecting whether a sequence of
authorized operations can simulate a forbidden one. We reduce these questions
to type checking problems, solved by computing variants of hedge automata
characterizing the set of ancestors and descendants of the initial document
type for the closure of parameterized rewrite rules
Proving Looping and Non-Looping Non-Termination by Finite Automata
A new technique is presented to prove non-termination of term rewriting. The
basic idea is to find a non-empty regular language of terms that is closed
under rewriting and does not contain normal forms. It is automated by
representing the language by a tree automaton with a fixed number of states,
and expressing the mentioned requirements in a SAT formula. Satisfiability of
this formula implies non-termination. Our approach succeeds for many examples
where all earlier techniques fail, for instance for the S-rule from combinatory
logic
Unified Analysis of Collapsible and Ordered Pushdown Automata via Term Rewriting
We model collapsible and ordered pushdown systems with term rewriting, by
encoding higher-order stacks and multiple stacks into trees. We show a uniform
inverse preservation of recognizability result for the resulting class of term
rewriting systems, which is obtained by extending the classic saturation-based
approach. This result subsumes and unifies similar analyses on collapsible and
ordered pushdown systems. Despite the rich literature on inverse preservation
of recognizability for term rewrite systems, our result does not seem to follow
from any previous study.Comment: in Proc. of FRE
Projector - a partially typed language for querying XML
We describe Projector, a language that can be used to perform a mixture of typed and untyped computation against data represented in XML. For some problems, notably when the data is unstructured or semistructured, the most desirable programming model is against the tree structure underlying the document. When this tree structure has been used to model regular data structures, then these regular structures themselves are a more desirable programming model. The language Projector, described here in outline, gives both models within a single partially typed algebra and is well suited for hybrid applications, for example when fragments of a known structure are embedded in a document whose overall structure is unknown. Projector is an extension of ECMA-262 (aka JavaScript), and therefore inherits an untyped DOM interface. To this has been added some static typing and a dynamic projection primitive, which can be used to assert the presence of a regular structure modelled within the XML. If this structure does exist, the data is extracted and presented as a typed value within the programming language
- …