27,973 research outputs found
Operational State Complexity of Deterministic Unranked Tree Automata
We consider the state complexity of basic operations on tree languages
recognized by deterministic unranked tree automata. For the operations of union
and intersection the upper and lower bounds of both weakly and strongly
deterministic tree automata are obtained. For tree concatenation we establish a
tight upper bound that is of a different order than the known state complexity
of concatenation of regular string languages. We show that (n+1) (
(m+1)2^n-2^(n-1) )-1 vertical states are sufficient, and necessary in the worst
case, to recognize the concatenation of tree languages recognized by (strongly
or weakly) deterministic automata with, respectively, m and n vertical states.Comment: In Proceedings DCFS 2010, arXiv:1008.127
Root-Weighted Tree Automata and their Applications to Tree Kernels
In this paper, we define a new kind of weighted tree automata where the
weights are only supported by final states. We show that these automata are
sequentializable and we study their closures under classical regular and
algebraic operations. We then use these automata to compute the subtree kernel
of two finite tree languages in an efficient way. Finally, we present some
perspectives involving the root-weighted tree automata
Pebble alternating tree-walking automata and their recognizing power
Pebble tree-walking automata with alternation were first investigated by Milo, Suciu and Vianu (2003), who showed that tree languages recognized by these devices are exactly the regular tree languages. We strengthen this by proving the same result for pebble automata with "strong pebble handling" which means that pebbles can be lifted independently of the position of the reading head and without moving the reading head. Then we make a comparison among some restricted versions of these automata. We will show that the deterministic and non-looping pebble alternating tree-walking automata are strictly less powerful than their nondeterministic counterparts, i.e., they do not recognize all the regular tree languages. Moreover, there is a proper hierarchy of recognizing capacity of deterministic and non-looping n-pebble alternating tree-walking automata with respect to the number of pebbles, i.e., for each n ≥ 0, deterministic and non-looping (n+1)-pebble alternating tree-walking automata are more powerful than their n-pebble counterparts
Characterisation Theorems for Weighted Tree Automaton Models
In this thesis, we investigate different theoretical questions concerning weighted automata models over tree-like input structures. First, we study exact and approximated determinisation and then, we turn to Kleene-like and BĂĽchi-like characterisations. We consider multiple weighted automata models, including weighted tree automata over semirings (Chapters 3 and 4), weighted forest automata over M-monoids (Chapter 5), and rational weighted tree languages with storage (Chapter 6). For an explanation as to why the last class can be considered as a weighted automaton model, we refer to page 188 of the thesis. We will now summarise the main contributions of the thesis.
In Chapter 3, we focus on the determinisation of weighted tree automata and present our determinisation framework, called M-sequentialisation, which can model different notions of determinisation from the existing literature. Then, we provide a positive M-sequentialisation result for the case of additively idempotent semirings or finitely M-ambiguous weighted tree automata. Another important contribution of Chapter 3 is Theorem 77, where we provide a blueprint theorem that can be used to find determini- sation results for more classes of semirings and weighted tree automata easily. In fact, instead of repeating an entire determinisation construction, Theorem 77 allows us to prove a determinisation result by finding certain finite equivalence relations. This is a very potent tool for future research in the area of determinisation.
In Chapter 4, we move from exact determinisation towards approximate determini- sation. We lift the formalisms and the main results from one approach from the literature from the word case to the tree case. This successfully results in an approximated determinisation construction for weighted tree automata over the tropical semiring. We provide a formal mathematical description of the approximated determinisation construction, rather than an algorithmic description as found in the related approach from the literature.
In Chapter 5, we turn away from determinisation and instead consider Kleene-like and BĂĽchi-like characterisations of weighted recognisability. We introduce weighted forest automata over M-monoids, which are a generalisation of weighted tree automata over M-monoids and weighted forest automata over semirings. Then, we prove that our recognisable weighted forest languages can be decomposed into a finite product of recognisable weighted tree languages. We also prove that the initial algebra semantic and the run semantic for weighted forest automata are equivalent under certain conditions. Lastly, we define rational forest expressions and forest M-expressions and and prove that the classes of languages generated by these formalisms coincide with recognisable weighted forest languages under certain conditions.
In Chapter 6, we consider rational weighted tree languages with storage, where the storage is introduced by composing rational weighted tree languages without storage with a storage map. It has been proven in the literature that rational weighted tree languages with storage are closed under the rational operations. In Chapter 6, we provide alternative proofs of these closure properties. In fact, we prove that our way of introducing storage to rational weighted tree languages preserves the closure properties from rational weighted tree languages without storage.:1 Introduction
2 Preliminaries
2.1 Languages
2.2 WeightedLanguages
2.3 Weighted Tree Automata
3 A Unifying Framework for the Determinisation of Weighted Tree Automata
3.1 Introduction
3.2 Preliminaries
3.3 Factorisation in Monoids
3.3.1 Ordering Multisets over Monoids
3.3.2 Cayley Graph and Cayley Distance
3.3.3 Divisors and Rests
3.3.4 Factorisation Properties
3.4 Weighted Tree Automata over M_fin(M) and the Twinning Property
3.4.1 Weighted Tree Automata over M_fin(M)
3.4.2 The Twinning Property
3.5 Sequentialisation of Weighted Tree Automata over M_fin(M)
3.5.1 The Sequentialisation Construction
3.5.2 The Finitely R-Ambiguous Case
3.6 Relating WTA over M_fin(M) and WTA over S
3.7 M-Sequentialisation of Weighted Tree Automata
3.7.1 Accumulation of D_B
3.7.2 M-Sequentialisation Results
3.8 Comparison of our Results to the Literature
3.8.1 Determinisation of Unweighted Tree Automata
3.8.2 The Free Monoid Case
3.8.3 The Group Case
3.8.4 The Extremal Case
3.9 Conclusion
4 Approximated Determinisation of Weighted Tree Automata 125
4.1 Introduction
4.2 Preliminaries
4.3 Approximated Determinisation
4.3.1 The Approximated Determinisation Construction
4.3.2 Correctness of the Construction
4.4 The Approximated Twinning Property
4.4.1 Implications for Approximated Determinisability
4.4.2 Decidability of the Twinning Property
4.5 Conclusion
5 Kleene and BĂĽchi Theorems for Weighted Forest Languages over M-Monoids
5.1 Introduction
5.2 Preliminaries
5.3 WeightedForestAutomata
5.3.1 Forests
5.3.2 WeightedForestAutomata
5.3.3 Rectangularity
5.3.4 I-recognisable is R-recognisable
5.4 Kleene’s Theorem
5.4.1 Kleene’s Theorem for Trees
5.4.2 Kleene’s Theorem for Forests
5.4.3 An Inductive Approach
5.5 Büchi’s Theorem
5.5.1 Büchi’s Theorem for Trees
5.5.2 Büchi’s Theorem for Forests
5.6 Conclusion
6 Rational Weighted Tree Languages with Storage
6.1 Introduction
6.2 Preliminaries
6.3 Rational Weighted Tree Languages with Storage
6.4 The Kleene-Goldstine Theorem
6.5 Closure of Rat(S¢,Σ,S) under Rational Operations
6.5.1 Top-Concatenation, Scalar Multiplication, and Sum
6.5.2 α-Concatenation
6.5.3 α-Kleene Star
6.6 Conclusion
7 Outlook
Reference
Deterministic Real-Time Tree-Walking-Storage Automata
We study deterministic tree-walking-storage automata, which are finite-state
devices equipped with a tree-like storage. These automata are generalized stack
automata, where the linear stack storage is replaced by a non-linear tree-like
stack. Therefore, tree-walking-storage automata have the ability to explore the
interior of the tree storage without altering the contents, with the possible
moves of the tree pointer corresponding to those of tree-walking automata. In
addition, a tree-walking-storage automaton can append (push) non-existent
descendants to a tree node and remove (pop) leaves from the tree. Here we are
particularly considering the capacities of deterministic tree-walking-storage
automata working in real time. It is shown that even the non-erasing variant
can accept rather complicated unary languages as, for example, the language of
words whose lengths are powers of two, or the language of words whose lengths
are Fibonacci numbers. Comparing the computational capacities with automata
from the classical automata hierarchy, we derive that the families of languages
accepted by real-time deterministic (non-erasing) tree-walking-storage automata
is located between the regular and the deterministic context-sensitive
languages. There is a context-free language that is not accepted by any
real-time deterministic tree-walking-storage automaton. On the other hand,
these devices accept a unary language in non-erasing mode that cannot be
accepted by any classical stack automaton, even in erasing mode and arbitrary
time. Basic closure properties of the induced families of languages are shown.
In particular, we consider Boolean operations (complementation, union,
intersection) and AFL operations (union, intersection with regular languages,
homomorphism, inverse homomorphism, concatenation, iteration). It turns out
that the two families in question have the same properties and, in particular,
share all but one of these closure properties with the important family of
deterministic context-free languages.Comment: In Proceedings NCMA 2023, arXiv:2309.0733
Transformations Between Different Types of Unranked Bottom-Up Tree Automata
We consider the representational state complexity of unranked tree automata.
The bottom-up computation of an unranked tree automaton may be either
deterministic or nondeterministic, and further variants arise depending on
whether the horizontal string languages defining the transitions are
represented by a DFA or an NFA. Also, we consider for unranked tree automata
the alternative syntactic definition of determinism introduced by Cristau et
al. (FCT'05, Lect. Notes Comput. Sci. 3623, pp. 68-79).
We establish upper and lower bounds for the state complexity of conversions
between different types of unranked tree automata.Comment: In Proceedings DCFS 2010, arXiv:1008.127
Logical definability of Y-tree and trellis systolic ω-languages
In this paper we investigate the correspondence (in the style of the well known Büchi Theorem) between ω-languages accepted by systolic automata and suitable (proper) extensions of the Monadic Second Order theory of one successor (MSO[<]). To this purpose we extend Y-tree and trellis systolic automata to deal with ω-words and we study the expressiveness, closure and
decidability properties of the two classes of ω-languages accepted by Y-tree and trellis automata, respectively. We define, then, two extensions of MSO[<], MSO[<,adj] and MSO[<,2x], which allow to express Y-tree ω-languages and trellis ω-languages, respectively
Regular sets over extended tree structures
We investigate notions of decidability and definability for the Monadic Second-Order Logic of labeled tree structures, and links with finite automata using oracles to test input prefixes. A general framework is defined allowing to transfer some MSO-properties from a graph-structure to a labeled tree structure. Transferred properties are decidability of sentences and existence of a definable model for every satisfiable formula. A class of finite automata with prefix-oracles is also defined, recognizing exactly languages defined by MSO-formulas in any labeled tree-structure. Applying these results, the well-known equality between languages recognized by finite automata,sets of vertices MSO definable in a tree-structure and sets of pushdown contexts generated by pushdown-automata is extended to iterated pushdown automata
- …