Showing papers on "Pushdown automaton published in 1996"

Pushdown Processes: Games and Model Checking

Abstract: Games given by transition graphs of pushdown processes are considered. It is shown that if there is a winning strategy in such a game then there is a winning strategy that is realized by a pushdown process. This fact turns out to be connected with the model checking problem for the pushdown automata and the propositional mu-calculus. It is shown that this model checking problem is DEXPTIME-complete.

Using domain information during the learning of a subsequential transducer

Abstract: The recently proposed OSTI algorithm allows for the identification of subsequential functions from input-output pairs. However, if the target is a partial function the convergence is not guaranteed. In this work, we extend the algorithm in order to allow for the identification of any partial subsequential function provided that either a negative sample or a description of the domain by means of a deterministic finite automaton is available.

String matching with k differences by finite automata

Abstract: Approximate string matching is a sequential problem and therefore it is possible to solve it using finite automata. A nondeterministic finite automaton is constructed for string matching with k differences. It is shown, how dynamic programming and "shift-and" based algorithms simulate this nondeterministic finite automaton. The corresponding deterministic finite automaton have O((k+2)/sup m-k/*(k+1)!) states, where m is the length of the pattern and k is the number of differences. The time complexity of algorithms based on such deterministic finite automaton is O(n), where n is the length of text.

Finite groupoids and their applications to computational complexity

Abstract: In our Master thesis the notions of recognition by semigroups and by programs over semigroups were extended to groupoids. As a consequence of this transformation, we obtained context-free languages instead of regular with recognition by groupoids, and we obtained SAC$\sp1$ instead of NC$\sp1$ with recognition by programs over groupoids. In this thesis, we continue the investigation of the computational power of finite groupoids. We consider different restrictions on the original model. We examine the effect of restricting the kind of groupoids used, the way parentheses are placed, and we distinguish between the case where parentheses are explicitly given and the case where they are guessed nondeterministically. We introduce the notions of linear recognition by groupoids and by programs over groupoids. This leads to new characterizations of linear context-free languages and NL. We also prove that the algebraic structure of finite groupoids induces a strict hierarchy on the classes of languages they linearly recognized. We investigate the classes obtained when the groupoids are restricted to be quasigroups (i.e. the multiplication table forms a latin square). We prove that languages recognized by quasigroups are regular and that programs over quasigroups characterize NC$\sp1$. We also consider the problem of evaluating a well-parenthesized expression over a finite loop (a quasigroup with an identity). This problem is in NC$\sp1$ for any finite loop, and we give algebraic conditions for its completeness. In particular, we prove that it is sufficient that the loop be nonsolvable, extending a well-known theorem of Barrington. Finally, we consider programs where the groupoids are allowed to grow with the input length. We study the relationship between these programs and more classical models of computation like Turing machines, pushdown automata, and owner-read owner-write PRAM. As a consequence, we find a restriction on Boolean circuits that has some interesting properties. In particular, circuits that characterize NP and NL are shown to correspond, in presence of our restriction, to P and L respectively.

Dynamical Implementation of Nondeterministic Automata and Concurrent Systems

Abstract: Several recent results have implemented a number of deterministic automata (finite-state, pushdown, even Turing machines and neural nets) using piecewise linear dynamical systems in one- and two-dimensional euclidean spaces. Nondeterministic devices have only been likewise implemented by iterated systems containing several maps. We show how to simulate nondeterministic and concurrent systems (finite-state automata, pushdown automata, and Petri nets) using a single deterministic piecewise linear map of the real interval. As a consequence, we establish a correspondence between nondeterminism and incremental entropy of the corresponding dynamical system. Relationship to the separation of complexity classes is discussed.

On decidability of the completeness problem for special systems of automaton functions

Abstract: We consider systems of automaton functions of the form Μ = Φ u v, where Φ is a Post class and ν is a finite system of automaton functions. We prove that if Φ e {M, D, C, F}, then the completeness and Α-completeness problems for the system Μ are algorithmically decidable. The work was supported by the Russian Foundation for Basic Research, Grant 95-01-01102.

Computing exact automaton representations for a class of hybrid systems

Abstract: It is known that one can not always have a finite state representation for hybrid systems and many decision properties can be undecidable It was shown in Cury et al (1995), however, that if one has a finite state automaton that generates an outer approximation to the hybrid system language, it may be possible to synthesize a discrete-state supervisor to control the hybrid system based on the approximating automaton using standard synthesis methods from the theory of discrete event systems (DESs) In this paper we develop conditions under which the automaton generated by a modification of the approximation algorithm from Niinomi et al (1996) generates the exact language for the hybrid system

Tree-stack automata

Abstract: We introduce a new model of stack automata, the “tree-stack automata,” extending the linear stack to a tree-stack. A main subject of our investigations is to explore the relationship between tree-stack automata and stack automata. The main result of this paper is that tree-stack have the same recognition power as stack-pushdown automata, another (well-known) extension of stack automata. Therefore we obtain that the class of languages accepted by the one-way (linear) stack automata is a proper subset of the class of languages accepted by the one-way tree-stack automata and that two-way tree-stack automata have the same recognition power as two-way (linear) stack automata. As a special case of tree-stack automata we consider tree-pushdown automata. As opposed to stack automata the tree-pushdown storage does not extend the recognition power of one-way (resp. two-way) pushdown automata.

Converting a büchi alternating automaton to a usual nondeterministic one

Abstract: We first give a method for simulating, in the case of Buchi, an alternating automaton by a usual nondeterministic one. Then, to make the satisfiability problem of Linear Propositional Temporal Logic (LPTL) use this result, we give a method for translating any formula of this logic into an equivalent Buchi alternating automaton.

How to Use Sorting Procedures to Minimize DFA

Abstract: In this paper we introduce a new idea, which can be used in minimization of a deterministic finite automaton Namely, we associate names with states of an automaton and we sort them We give a new algorithm, its correctness proof, and its proof of execution time bound This algorithm has time complexity O(n2 log n) and can be considered as a direct improvement of Wood's algorithm [6] which has time complexity O(n3), where n is the number of states Wood's algorithm checks if pairs of states are distinguishable It is improved by making better use of transitivity Similarly some other algorithms which check if pairs of states are distinguishable can be improved using sorting procedures

A fuzzy automaton model and its applications

Abstract: In this paper, a finite automaton and its applications are first discussed, and then a fuzzy automaton model is proposed. In the fuzzy automaton model, the definition, theorems, fuzzy mapping ruler, homomorphism, and minimum states for implementation are given. In the last, some applications of a fuzzy automaton are illustrated with examples.

Automaton complexity of two-place Boolean bases

Abstract: The problem on the minimal possible number of states for an automaton computing values of Boolean expressions of the given length over different operator bases is considered. It is established that the set of all the bases falls into three classes depending on whether the growth of logarithm of the necessary number of states is constant, logarithmic or linear. The criteria system of five bases classified in the stated sense is obtained and the determination of the class of any given set of operations is performed by checking its inclusion into the bases of the criteria system. This allows us to carry out the complete classification of bases of operations from the considered point of view. The proofs of the results are given. This work was supported by the Russian Foundation for Basic Research, grant 95-01-00707. In this paper we give the proof of the result announced in [1]. Formulae are considered in the operator form over the set of all two-place operations and negation [2]. We interpret the concept of a formula over a basis as usual but we do not imply variables in formulae. The constants 0 and 1 have already been substituted for them. The expression of this type is fed into a finite automaton which is to compute its value. By the word compute we mean that an automaton has the final states 0 and 1, and after the survey of the formula it turns into the final state corresponding to the value of the formula. In this paper the problem of the minimal possible number of states for an automaton computing values of Boolean expressions of the given length over different operator bases is considered. The concept of an (initial finite) automaton being used here corresponds to [3] however we do not consider the general case but an automaton without output. Thus an automaton Λ is a quintuple (V, β, φ, q0, β') where V, Q are finite sets called the input alphabet and the state alphabet respectively, φ is the transition function, φ: V x n> , q is the initial state, q e β, β' is the set of final states Q c β, β = {0,1}. The input alphabet V of the automaton A consists of the left and right round brackets, the constants 0 and 1 and also of the symbols of logical operations. The length of a formula is the number of symbols of the alphabet V it contains. *UDC 519.4. Originally published in Diskretnaya Matematika (1996) 8, No. 4, 123-134 (in Russian). Translated by T. V. Khrapchenko. 600 A. E. Andreev and A. A. Chasovskikh Later on we will use the logical operations which can be expressed in terms of the operations (*ι Λ jc2), (x\\ v jc2), -i* in the following way: x\\ = -*x, (Xl Θ X2) = (-0X1 Λ X2) V (*ι Λ -ιΧ2), (X\\ *2> = fa Λ *2> v (Xl ->*2) = (fa <-x2) = (χι Λ*2),