Showing papers on "Pushdown automaton published in 2007"

A Robust Class of Context-Sensitive Languages

Abstract: We define a new class of languages defined by multi-stack automata that forms a robust subclass of context-sensitive languages, with decidable emptiness and closure under boolean operations. This class, called multi-stack visibly pushdown languages (MVPLs), is defined using multi-stack pushdown automata with two restrictions: (a) the pushdown automaton is visible, i.e. the input letter determines the operation on the stacks, and (b) any computation of the machine can be split into k stages, where in each stage, there is at most one stack that is popped. MVPLs are an extension of visibly pushdown languages that captures noncontext free behaviors, and has applications in analyzing abstractions of multithreaded recursive programs, signifi- cantly enlarging the search space that can be explored for them. We show that MVPLs are closed under boolean operations, and problems such as emptiness and inclusion are decidable. We characterize MVPLs using monadic second-order logic over appropriate structures, and exhibit a Parikh theorem for them.

Visibly pushdown automata for streaming XML

Abstract: We propose the study of visibly pushdown automata (VPA) for processing XML documents. VPAs are pushdown automata where the input determines the stack operation, and XML documents are naturally visibly pushdown with the VPA pushing onto the stack on open-tags and popping the stack on close-tags. In this paper we demonstrate the power and ease visibly pushdown automata give in the design of streaming algorithms for XML documents. We study the problems of type-checking streaming XML documents against SDTD schemas, and the problem of typing tags in a streaming XML document according to an SDTD schema. For the latter problem, we consider both pre-order typing and post-order typing of a document, which dynamically determines types at open-tags and close-tags respectively as soon as they are met. We also generalize the problems of pre-order and post-order typing to prefix querying. We show that a deterministic VPA yields an algorithm to the problem of answering in one pass the set of all answers to any query that has the property that a node satisfying the query is determined solely by the prefix leading to the node. All the streaming algorithms we develop in this paper are based on the construction of deterministic VPAs, and hence, for any fixed problem, the algorithms process each element of the input in constant time, and use space (d), where d is the depth of the document.

Marrying words and trees

Abstract: Traditionally, data that has both linear and hierarchical structure, such as annotated linguistic data, is modeled using ordered trees and queried using tree automata. In this paper, we argue that nested words and automata over nested words offer a better way to capture and process the dual structure. Nested words generalize both words and ordered trees, and allow both word and tree operations. We study various classes of automata over nested words, and show that while they enjoy expressiveness and succinctness benefits over word and tree automata, their analysis complexity and closure properties are analogous to the corresponding word and tree special cases. In particular, we show that finite-state nested word automata can be exponentially more succinct than tree automata, and pushdown nested word automata include the two incomparable classes of context-free word languages and context-free tree languages.

Height-deterministic pushdown automata

Abstract: We define the notion of height-deterministic pushdown automata, a model where for any given input string the stack heights during any (nondeterministic) computation on the input are a priori fixed. Different subclasses of height-deterministic pushdown automata, strictly containing the class of regular languages and still closed under boolean language operations, are considered. Several such language classes have been described in the literature. Here, we suggest a natural and intuitive model that subsumes all the formalisms proposed so far by employing height-deterministic pushdown automata. Decidability and complexity questions are also considered.

Pushdown module checking with imperfect information

Abstract: The model checking problem for finite-state open systems (module checking) has been extensively studied in the literature, both in the context of environments with perfect and imperfect information about the system. Recently, the perfect information case has been extended to infinite-state systems (pushdown module checking). In this paper, we extend pushdown module checking to the imperfect information setting; i.e., the environment has only a partial view of the system's control states and pushdown store content. We study the complexity of this problem with respect to the branching-time temporal logic CTL, and show that pushdown module checking, which is by itself harder than pushdown model checking, becomes undecidable when the environment has imperfect information. We also show that undecidability relies on hiding information about the pushdown store. Indeed, we prove that with imperfect information about the control states, but a visible pushdown store, the problem is decidable and its complexity is the same as that of (perfect information) pushdown module checking.

Program analysis using weighted pushdown systems

Abstract: Pushdown systems (PDSs) are an automata-theoretic formalism for specifying a class of infinite-state transition systems. Infiniteness comes from the fact that each configuration 〈p,S〉 in the state space consists of a (formal) "control location" p coupled with a stack S of unbounded size. PDSs can model program paths that have matching calls and returns, and automaton-based representations allow analysis algorithms to account for the infinite control state space of recursive programs. Weighted pushdown systems (WPDSs) are a generalization of PDSs that add a general "black-box" abstraction for program data (through weights). WPDSs also generalize other frameworks for interprocedural analysis, such as the Sharir-Pnueli functional approach. This paper surveys recent work in this area, and establishes a few new connections with existing work.

Minimizing variants of visibly pushdown automata

Abstract: The minimization problem for visibly pushdown automata (VPA) is studied. Two subclasses of VPA are introduced: call driven automata, and block automata. For the first class, minimization results are given unifying and generalizing those present in the literature. Unfortunately, this class shares the drawback of all other classes for which a minimization result is known: it is exponentially less succinct than VPA. The second class, block automata, is introduced to address this problem. These automata are as succinct as VPA. A minimization procedure for them is presented that requires one additional parameter to be fixed. An example of an exponential gain in succinctness is given.

Alternating automata and a temporal fixpoint calculus for visibly pushdown languages

Abstract: We investigate various classes of alternating automata for visibly pushdown languages (VPL) over infinite words. First, we show that alternating visibly pushdown automata (AVPA) are exactly as expressive as their nondeterministic counterpart (NVPA) but basic decision problems for AVPA are 2EXPTIMEcomplete. Due to this high complexity, we introduce a new class of alternating automata called alternating jump automata (AJA). AJA extend classical alternating finite-state automata over infinite words by also allowing non-local moves. A non-local forward move leads a copy of the automaton from a call input position to the matching-return position. We also allow local and non-local backward moves. We show that one-way AJA and two-way AJA have the same expressiveness and capture exactly the class of VPL. Moreover, boolean operations for AJA are easy and basic decision problems such as emptiness, universality, and pushdown model-checking for parity two-way AJA are EXPTIME-complete. Finally, we consider a linear-time fixpoint calculus which subsumes the full linear-time µ-calculus (with both forward and backward modalities) and the logic CARET and captures exactly the class of VPL. We show that formulas of this logic can be linearly translated into parity two-way AJA, and vice versa. As a consequence satisfiability and pushdown model checking for this logic are EXPTIME-complete.

Model checking propositional projection temporal logic based on SPIN

Abstract: This paper investigates a model checking algorithm for Propositional Projection Temporal Logic (PPTL) with finite models. To this end, a PPTL formula is transformed to a Normal Form Graph (NFG), and then a Nondeterministic Finite Automaton (NFA). The NFA precisely characterizes the finite models satisfying the corresponding formula and can be equivalently represented as a Deterministic Finite Automaton (DFA). When the system to be verified can be modeled as a DFA As, and the property of the system can be specified by a PPTL formula P, then ¬P can be transformed to a DFA Ap. Thus, whether the system satisfies the property or not can be checked by computing the product automaton of As and Ap, and then checking whether or not the product automaton accepts the empty word. Further, this method can be implemented by means of the verification system SPIN.

2-visibly pushdown automata

Abstract: Visibly Pushdown Automata (VPA) are a special case of pushdown machines where the stack operations are driven by the input. In this paper, we consider VPA with two stacks, namely 2-VPA. These automata introduce a useful model to effectively describe concurrent pushdown systems using a simple communication mechanism between stacks. We show that 2-VPA are strictly more expressive than VPA. Indeed, 2-VPA accept some context-sensitive languages that are not context-free and some context-free languages that are not accepted by any VPA. Nevertheless, the class of languages accepted by 2-VPA is closed under all boolean operations and determinizable in EXPTIME, but does not preserve decidability of emptiness problem. By adding an ordering constraint on stacks (2-OVPA), decidability of emptiness can be recovered (preserving desirable closure properties) and solved in PTIME. Using these properties along with the automata-theoretic approach, we prove that the model checking problem over 2-OVPA models against 2-OVPA specifications is EXPTIME-complete.

The Complexity of Games on Higher Order Pushdown Automata

Abstract: We prove an n-EXPTIME lower bound for the problem of deciding the winner in a reachability game on Higher Order Pushdown Automata (HPDA) of level n This bound matches the known upper bound for parity games on HPDA As a consequence the mu-calculus model checking over graphs given by n-HPDA is n-EXPTIME complete

Verification of Probabilistic Recursive Sequential Programs

Abstract: This work studies algorithmic verification of infinite-state probabilistic systems generated by probabilistic pushdown automata (pPDA). Probabilistic pushdown automata are obtained as a probabilistic variant of pushdown automata that proved to be a successful abstract model of recursive sequential programs. The main aim of this work is to study decidability and complexity of the problem whether a given probabilistic system generated by a pPDA satisfies a given property expressed in a suitable formalism. There are plenty of formalisms available for specifying properties of probabilistic systems. In this work we consider various temporal properties expressed by finite-state automata on infinite words and formulae of temporal logics, long-run average properties, and properties connected with expected behavior. Concerning temporal logics, we consider both linear and branching time ones. Among others we consider linear temporal logic (LTL) and probabilistic computation tree logic (PCTL), which is a probabilistic variant of the well-known logic CTL. We also consider a general logic PECTL*, which combines automata based specifications with the structure of branching-time temporal logics. We provide a systematic presentation of results on decidability and complexity of the model-checking problem for these logics together with a detailed presentation of some verification techniques. Possibly the most important original results of this work concerning temporal logics are decidability of the model-checking problem for the qualitative fragment of PECTL* and undecidability of the same problem for PCTL. The class of long-run average properties is very useful in performance and reliability analysis of systems. These properties are tightly connected with service cycles and can be used to answer questions like: Is the average time of servicing a request lower than a given bound? In this work we define a whole class of such properties, and study decidability and complexity of the problem whether a given system satisfies these properties. We also study a notion of predictability of long-run average properties based on observing a finite part of a computation of the system. We show that all properties from our class are effectively predictable up to a given error tolerance.

Event detection method

Abstract: The embodiments of the present invention disclose an event detection method and device. The method includes: predefining event-based detection rules with a predicative context-free grammar; generating by parsing the detection rules a parsing table of pushdown automaton which supports parallel parsing; receiving an event to be detected; and analyzing by a controller the event to be detected according to the parsing table, to obtain a detection result. The present invention is especially applicable to detection of network attack events. The embodiments of the present invention detect the attacks with a predicative context-free grammar on the basis of events, and ensure a close combination of a protocol parsing process and an attack detection process, as well as a close combination of multiple attack detection rules, thus decreasing unnecessary calculations. In addition, with an optimized parallel pushdown automaton, the embodiments of the present invention can efficiently analyze the predicative context-free grammar. Consequently, besides hierarchical processing capability and state description capability, the embodiments of the present invention deliver high efficiency.

Factor automata of automata and applications

Abstract: An efficient data structure for representing the full index of a set of strings is the factor automaton, the minimal deterministic automaton representing the set of all factors or substrings of these strings. This paper presents a novel analysis of the size of the factor automaton of an automaton, that is the minimal deterministic automaton accepting the set of factors of a finite set of strings, itself represented by a finite automaton. It shows that the factor automaton of a set of strings U has at most 2|Q| - 2 states, where Q is the number of nodes of a prefix-tree representing the strings in U, a bound that significantly improves over 2||U|| - 1, the bound given by Blumer et al. (1987), where ||U|| is the sum of the lengths of all strings in U. It also gives novel and general bounds for the size of the factor automaton of an automaton as a function of the size of the original automaton and the maximal length of a suffix shared by the strings it accepts. Our analysis suggests that the use of factor automata of automata can be practical for large-scale applications, a fact that is further supported by the results of our experiments applying factor automata to a music identification task with more than 15,000 songs.

Decision problems for pushdown threads

Abstract: Threads as contained in a thread algebra emerge from the behavioral abstraction from programs in an appropriate program algebra. Threads may make use of services such as stacks, and a thread using a single stack is called a pushdown thread. Equivalence of pushdown threads is shown decidable whereas pushdown thread inclusion is undecidable. This is again an example of a borderline crossing where the equivalence problem is decidable, whereas the inclusion problem is not.

Regular languages of nested words: fixed points, automata, and synchronization

Abstract: Nested words are a restriction of the class of visibly pushdown languages that provide a natural model of runs of programs with recursive procedure calls. The usual connection between monadic second-order logic (MSO) and automata extends from words to nested words and gives us a natural notion of regular languages of nested words. In this paper we look at some well-known aspects of regular languages - their characterization via fixed points, deterministic and alternating automata for them, and synchronization for defining regular relations - and extend them to nested words. We show that mu-calculus is as expressive as MSO over finite and infinite nested words, and the equivalence holds, more generally, for mu-calculus with past modalities evaluated in arbitrary positions in a word, not only in the first position. We introduce the notion of alternating automata for nested words, show that they are as expressive as the usual automata, and also prove that Muller automata can be determinized (unlike in the case of visibly pushdown languages). Finally we look at synchronization over nested words. We show that the usual letter-to-letter synchronization is completely incompatible with nested words (in the sense that even the weakest form of it leads to an undecidable formalism) and present an alternative form of synchronization that gives us decidable notions of regular relations.

Visibly Pushdown Languages and Term Rewriting

Abstract: To combine tree languages with term rewriting, we introduce a new class of tree languages, that both extends regular languages and restricts context-free languages, and that is closed under intersection (unlike context-free languages). To do it, we combine the concept of visibly pushdown language, with top-down pushdown tree automata, and we get the visibly pushdown tree automata. Then, we use them to express the sets of descendants for a sub-class of growing term rewrite systems, and thanks to closure under intersection, we get that joinability and (restricted) unifiability are decidable.

Formal Models: Regulation and Reduction

Abstract: The subject of this monograph is divided into two parts-regulated and reduced formal models. The first part introduces and studies self-regulating finite and pushdown automata. In essence, these automata regulate the use of their rules by a sequence of rules applied during the previous moves. A special attention is paid to turns defined as moves during which a self-regulating automaton starts a new self-regulating sequence of moves. Based on the number of turns, two infinite hierarchies of language families resulting from two variants of these automata are established (see Sections 4.1.1 and 4.1.2). Section 4.1.1 demonstrates that in case of self-regulating finite automata these hierarchies coincide with the hierarchies resulting from parallel right linear and right linear simple matrix grammars, so the self-regulating finite automata can be viewed as the automaton counterparts to these grammars. Finally, both infinite hierarchies are compared. In addition, Section 4.1.2 discusses some results and open problems concerning self-regulating pushdown automata. The second part studies descriptional complexity of partially parallel grammars (Section 5.1) and grammars regulated by context conditions (Section 5.2) with respect to the number of nonterminals and a special type of productions. Specifically, Chapter 5 proves that every recursively enumerable language is gen erated (i) by a scattered context grammar with no more than four non-context-free productions and four nonterminals, (ii) by a multisequential grammar with no more than two selectors and two nonterminals, (iii) by a multicontinuous grammar with no more than two selectors and three nonterminals, (iv) by a context-conditional grammar of degree (2, 1) with no more than six conditional productions and seven nonterminals, (v) by a simple context-conditional grammar of degree (2, 1) with no more than seven conditional productions and eight nonterminals, (vi) by a generalized forbidding grammar of degree two and index six with no more than ten conditional productions and nine nonterminals, (vii) by a generalized forbidding grammar of degree two and index four with no more than eleven conditional productions and ten nonterminals, (viii) by a generalized forbidding grammar of degree two and index nine with no more than eight conditional productions and ten nonterminals, (ix) by a generalized forbidding grammar of degree two and unlimited index with no more than nine conditional productions and eight nonterminals, (x) by a semi-conditional grammar of degree (2, 1) with no more than seven conditional productions and eight nonterminals, and (xi) by a simple semi-conditional grammar of degree (2, 1) with no more than nine conditional productions and ten nonterminals. Chapter 2 contains basic definitions and the notation used during this monograph. Chapter 3 then summarizes the previous known results related to the studied formal models; regulated automata and descriptional complexity of partially parallel grammars and grammars regulated by context conditions. Chapter 4 studies self-regulating automata, and Chapter 5 presents the new results concerning descriptional complexity of partially parallel grammars and grammars regulated by context conditions.

Tree automata with memory, visibility and structural constraints

Abstract: Tree automata with one memory have been introduced in 2001. They generalize both pushdown (word) automata and the tree automata with constraints of equality between brothers of Bogaert and Tison. Though it has a decidable emptiness problem, the main weakness of this model is its lack of good closure properties. We propose a generalization of the visibly pushdown automata of Alur and Madhusudan to a family of tree recognizers which carry along their (bottom-up) computation an auxiliary unbounded memory with a tree structure (instead of a symbol stack). In other words, these recognizers, called visibly Tree Automata with Memory (VTAM) define a subclass of tree automata with one memory enjoying Boolean closure properties. We show in particular that they can be determinized and the problems like emptiness, inclusion and universality are decidable for VTAM. Moreover, we propose an extension of VTAM whose transitions may be constrained by structural equality and disequality tests between memories, and show that this extension preserves the good closure and decidability properties.

Approximate timed abstractions of hybrid automata

Abstract: Given a hybrid automaton and a desired precision, we aim at constructing an approximate abstraction by means of a timed automaton, whose discrete state trajectories approximate the discrete state trajectories of the original system, with the desired precision on switching times. We show that using the Euclidian metric on reals it is not always possible to construct a timed automaton that is close to a hybrid automaton with finite precision. For this reason, we motivate and introduce relative metrics on reachability time, external language and simulation relation to quantify the precision of our abstraction. Our main result is to propose a novel algorithm to construct a timed automaton that is an approximate timed abstraction of a hybrid automaton with desired precision, and study its convergence properties. For an extended version of this paper refer to [D'Innocenzo et al., 2007].

Incrementally-Updatable Stream Processors for XPath Queries based on Merging Automata via Ordered Hash-keys

Abstract: Various kinds of data such as news articles and sensor data are generated continuously in the form of XML data on the network. The processing systems (e.g., systems for selective dissemination of information and notification) must evaluate many filters for every XML data. Therefore, Gupta and Suciu proposed an automaton called the XPush machine, which can efficiently evaluate a large number of XPath filters, each with many predicates, on a stream of XML documents. The XPush machine is constructed by creating an AFA (Alternating Finite Automaton) for each filter, and then transforming the set of AFAs into a single DPDA (Deterministic PushDown Automaton). Since the XPush machine cannot be partially updated inherently, however, addition of a single filter necessitates recalculation (i.e., reconstruction) of the XPush machine as a whole. In other words, the cost of updating an automaton depends on the total number of AFAs (or filters). In this paper, we propose and evaluate an integrated XPush machine, which enables incremental update by constructing the whole machine from a set of sub-XPush machines. The evaluation result positively demonstrates that efficient partial exchange of the AFAs is possible without significantly affecting all of the state transition tables.

Descriptional complexity of bounded context-free languages

Abstract: Finite-turn pushdown automata (PDA) are investigated concerning their descriptional complexity. It is known that they accept exactly the class of ultralinear context-free languages. Furthermore, the increase in size when converting arbitrary PDAs accepting ultralinear languages to finite-turn PDAs cannot be bounded by any recursive function. The latter phenomenon is known as non-recursive trade-off. In this paper, finite-turn PDAs accepting letter-bounded languages are considered. It turns out that in this case the non-recursive trade-off is reduced to a recursive trade-off, more precisely, to an exponential trade-off. A conversion algorithm is presented and the optimality of the construction is shown by proving tight lower bounds. Furthermore, the question of reducing the number of turns of a given finite-turn PDA is studied. Again, a conversion algorithm is provided which shows that in this case the trade-off is at most polynomial.

On recursive and non-recursive trade-offs between finite-turn pushdown automata

Abstract: It is shown that between one-turn pushdown automata (1-turn PDAs) and deterministic finite automata (DFAs) there will be savings concerning the size of description not bounded by any recursive function, so-called non-recursive trade-offs. Considering the number of turns of the stack height as a consumable resource of PDAs, the existence of non-recursive trade-offs between PDAs performing k+1 turns and k turns for k≥1 is proven. Furthermore, non-recursive trade-offs are shown between arbitrary PDAs and PDAs which perform only a finite number of turns. In the second part, k-turn deterministic PDAs (k-turn DPDAs) are considered. The trade-offs between nondeterministic and deterministic k-turn PDAs are still non-recursive whereas it is an open question whether the trade-offs between DPDAs performing k+1 turns and k turns for k≥1 is recursive. If the trade-offs are recursive, then a doubly exponential function serves as a lower bound.

Event detection method and device

Abstract: The embodiments of the present invention disclose an event detection method and device. The method includes: predefining event-based detection rules with a predicative context-free grammar; generating by parsing the detection rules a parsing table of pushdown automaton which supports parallel parsing; receiving an event to be detected; and analyzing by a controller the event to be detected according to the parsing table, to obtain a detection result. The present invention is especially applicable to detection of network attack events. The embodiments of the present invention detect the attacks with a predicative context-free grammar on the basis of events, and ensure a close combination of a protocol parsing process and an attack detection process, as well as a close combination of multiple attack detection rules, thus decreasing unnecessary calculations. In addition, with an optimized parallel pushdown automaton, the embodiments of the present invention can efficiently analyze the predicative context-free grammar. Consequently, besides hierarchical processing capability and state description capability, the embodiments of the present invention deliver high efficiency.

Non-recursive trade-offs for deterministic restarting automata

Abstract: We investigate the descriptional complexity of deterministic restarting automata, an automaton model inspired from linguistics. Variants of deterministic and monotone restarting automata build a strict hierarchy whose top is characterized by the Church-Rosser languages and whose bottom is characterized by the deterministic context-free languages. It is shown that between nondeterministic pushdown automata and any level of the hierarchy there are savings in the size of description which cannot be bounded by any recursive function. Interestingly, the converse is also true for the Church-Rosser languages. Moreover, there are non-recursive trade-offs between the family of Church-Rosser languages and any other level of the hierarchy.