70,643 research outputs found
State Complexity of Regular Tree Languages for Tree Matching
We study the state complexity of regular tree languages for tree matching problem. Given a tree t and a set of pattern trees L, we can decide whether or not there exists a subtree occurrence of trees in L from the tree t by considering the new language L′ which accepts all trees containing trees in L as subtrees. We consider the case when we are given a set of pattern trees as a regular tree language and investigate the state complexity. Based on the sequential and parallel tree concatenation, we define three types of tree languages for deciding the existence of different types of subtree occurrences. We also study the deterministic top-down state complexity of path-closed languages for the same problem.</jats:p
Real-time Regular Expression Matching
This paper is devoted to finite state automata, regular expression matching,
pattern recognition, and the exponential blow-up problem, which is the growing
complexity of automata exponentially depending on regular expression length.
This paper presents a theoretical and hardware solution to the exponential
blow-up problem for some complicated classes of regular languages, which caused
severe limitations in Network Intrusion Detection Systems work. The article
supports the solution with theorems on correctness and complexity.Comment: 17 pages, 11 figure
Pattern matching in compilers
In this thesis we develop tools for effective and flexible pattern matching.
We introduce a new pattern matching system called amethyst. Amethyst is not
only a generator of parsers of programming languages, but can also serve as an
alternative to tools for matching regular expressions.
Our framework also produces dynamic parsers. Its intended use is in the
context of IDE (accurate syntax highlighting and error detection on the fly).
Amethyst offers pattern matching of general data structures. This makes it a
useful tool for implementing compiler optimizations such as constant folding,
instruction scheduling, and dataflow analysis in general.
The parsers produced are essentially top-down parsers. Linear time complexity
is obtained by introducing the novel notion of structured grammars and
regularized regular expressions. Amethyst uses techniques known from compiler
optimizations to produce effective parsers.Comment: master thesi
Quotient Complexity of Ideal Languages
The final publication is available at Elsevier via http://dx.doi.org/10.1016/j.tcs.2012.10.055 © 2013. This manuscript version is made available under the CC-BY-NC-ND 4.0 license http://creativecommons.org/licenses/by-nc-nd/4.0/A language L over an alphabet Σ is a right (left) ideal if it satisfies L=LΣ∗ (L=Σ∗L). It is a two-sided ideal if L=Σ∗LΣ∗, and an all-sided ideal if L=Σ∗L, the shuffle of Σ∗ with L. Ideal languages are not only of interest from the theoretical point of view, but also have applications to pattern matching. We study the state complexity of common operations in the class of regular ideal languages, but prefer to use the equivalent term “quotient complexity”, which is the number of distinct left quotients of a language. We find tight upper bounds on the complexity of each type of ideal language in terms of the complexity of an arbitrary generator and of the minimal generator, and also on the complexity of the minimal generator in terms of the complexity of the language. Moreover, tight upper bounds on the complexity of union, intersection, set difference, symmetric difference, concatenation, star, and reversal of ideal languages are derived.Natural Sciences and Engineering Research Council of Canada grant [OGP0000871]VEGA grant 2/0111/0
Finite Countermodel Based Verification for Program Transformation (A Case Study)
Both automatic program verification and program transformation are based on
program analysis. In the past decade a number of approaches using various
automatic general-purpose program transformation techniques (partial deduction,
specialization, supercompilation) for verification of unreachability properties
of computing systems were introduced and demonstrated. On the other hand, the
semantics based unfold-fold program transformation methods pose themselves
diverse kinds of reachability tasks and try to solve them, aiming at improving
the semantics tree of the program being transformed. That means some
general-purpose verification methods may be used for strengthening program
transformation techniques. This paper considers the question how finite
countermodels for safety verification method might be used in Turchin's
supercompilation method. We extract a number of supercompilation sub-algorithms
trying to solve reachability problems and demonstrate use of an external
countermodel finder for solving some of the problems.Comment: In Proceedings VPT 2015, arXiv:1512.0221
An introduction to Graph Data Management
A graph database is a database where the data structures for the schema
and/or instances are modeled as a (labeled)(directed) graph or generalizations
of it, and where querying is expressed by graph-oriented operations and type
constructors. In this article we present the basic notions of graph databases,
give an historical overview of its main development, and study the main current
systems that implement them
- …