Digging input-driven pushdown automata

Reversible pushdown automata are deterministic pushdown automata having the property that any configuration occurring in any computation has exactly one predecessor. In this paper, the computational capacity of reversible computations in pushdown automata is investigated and turns out to lie properly in between the regular and deterministic context-free languages. Furthermore, it can be shown that a deterministic context-free language cannot be accepted reversibly if more than realtime is necessary for acceptance. Closure properties as well as decidability questions for reversible pushdown automata are studied. Finally, the question of whether a given (nondeterministic) pushdown automaton can be algorithmically tested for reversibility is answered in the affirmative, whereas it is shown to be undecidable whether the language accepted by a given nondeterministic pushdown automaton is reversible.

We determine the descriptional complexity (smallest number of states, up to constant factors) of recognizing languages {1^n} and {1^{t n} : t = 0, 1, 2, ...} with state-based finite machines of various kinds. This task is understood as counting to n and modulo n, respectively, and was previously studied for classes of finite-state automata by Kupferman, Ta-Shma, and Vardi (2001). We show that for Turing machines it requires log(n)/log(log(n)) states in the worst case, and individual values are related to Kolmogorov complexity of the binary encoding of n. For deterministic pushdown and counter automata, the complexity is log(n) and sqrt(n), respectively; for alternating counter automata, we show an upper bound of log(n). For visibly pushdown automata, i.e., if the stack movements are determined by input symbols, we consider languages {a^n b^n} and {a^{t n} b^{t n} : n t = 0, 1, 2, ...} and determine their complexity, of sqrt(n) and min(n_1 + n_2), respectively, with minimum over all factorizations n = n_1 n_2.

Fuzzy ω-automata

Input-driven pushdown automata ([Formula: see text]) are pushdown automata where the next action on the pushdown store (push, pop, nothing) is solely governed by the current input symbol. Here, we introduce sweeping input-driven pushdown automata that process the input in multiple passes (also sweeps). That is, a sweeping input-driven pushdown automaton is a two-way device that may change the input head direction only at the endmarkers. First we show that, given an arbitrary [Formula: see text], an equivalent [Formula: see text] that halts on any input can effectively be constructed. From this result further properties follow. Then we address the determinization of [Formula: see text]s and its descriptional complexity. Furthermore, the computational capacity of [Formula: see text]s is studied. To this end, we compare the family [Formula: see text] with other well-known language families. In particular, we are interested in families that have strong relations to some kind of pushdown machines. Finally, we explore several decidability problems and show that emptiness and several other problems are non-semidecidable by reductions of non-semidecidable problems of deterministic, linearly space bounded, one-tape, one-head Turing machines.

We introduce the concept of one-time nondeterminism as a new kind of limited nondeterminism for finite state machines and pushdown automata. Roughly speaking, one-time nondeterminism means that at the outset the computation is nondeterministic, but whenever it performs a guess, this guess is fixed for the rest of the computation. We characterize the computational power of one-time nondeterministic finite automata (OTNFAs) and one-time nondeterministic pushdown devices. Moreover, we study the descriptional complexity of these machines. For instance, we show that for an [Formula: see text]-state OTNFA with a sole nondeterministic state, that is nondeterministic for only one input symbol, [Formula: see text] states are sufficient and necessary in the worst case for an equivalent deterministic finite automaton. In case of pushdown automata, the conversion of a nondeterministic to a one-time nondeterministic as well as the conversion of a one-time nondeterministic to a deterministic one turn out to be non-recursive, that is, the trade-offs in size cannot be bounded by any recursive function.

With the rise of machine learning and data analytics, the ability to process large and diverse sets of data efficiently has become crucial. Research has shown that data transformation is a key performance bottleneck for applications across a variety of domains, from data analytics to scientific computing. Custom hardware accelerators and GPU implementations targeting specific data transformation tasks can alleviate the problem, but suffer from narrow applicability and lack of generality.To tackle this problem, we propose a GPU-accelerated data transformation engine grounded on pushdown transducers. We define an extended pushdown transducer abstraction (effPDT) that allows expressing a wide range of data transformations in a memory-efficient fashion, and is thus amenable for GPU deployment. The effPDT execution engine utilizes a data streaming model that reduces the application’s memory requirements significantly, facilitating deployment on high- and low-end systems. We showcase our GPU-accelerated engine on a diverse set of transformation tasks covering data encoding/decoding, parsing and querying of structured data, and matrix transformation, and we evaluate it against publicly available CPU and GPU library implementations of the considered data transformation tasks. To understand the benefits of the effPDT abstraction, we extend our data transformation engine to also support finite state transducers (FSTs), we map the considered data transformation tasks on FSTs, and we compare the performance and resource requirements of the FST-based and the effPDT-based implementations.

Semilinear sets are one of the most important concepts in theoretical computer science, as illustrated by the fact that the set of nonnegative integer solutions to any system of Diophantine equations is semilinear. Parikh's theorem enables us to represent any semilinear set as a pushdown automaton (PDA). We summarize recent results on the descriptional complexity of conversions among different representations of a semilinear set: as a vector set (conventional), a finite automaton (FA), a PDA, etc.. We also discuss semilinearity-preserving operations like union, intersection, and complement. We use Parikh's theorem to enlarge the class of finite-state machines that can represent semilinear sets. In particular, we give a simpler proof of a known result that characterizes semilinear sets in terms of machines with reversal-bounded counters. We then investigate the power of such a machine with only one counter in the context of a long-standing conjecture about repetition on words.

We present Pynini, an open-source library for the compilation of weighted finitestate transducers (WFSTs) and pushdown transducers (PDTs) from strings, contextdependent rewrite rules, and recursive transition networks. Pynini uses the OpenFst library for encoding, modifying, and applying WFSTs and PDTs. We describe the design of this library and the algorithms and interfaces used for compilation, optimization, and application, and provide two illustrations of the library in use.

Current trusted computing platform only verifies application’s static Hash value, it could not prevent application from being dynamic attacked. This paper gives one static analysis-based behavior model building method for trusted computing dynamic verification, including control flow graph (CFG) building, finite state automata (FSA) constructing, ɛ run cycle removing, ɛ transition removing, deterministic finite state (DFA) constructing, trivial FSA removing, and global push down automata (PDA) constructing. According to experiment, this model built is a reduced model for dynamic verification and covers all possible paths, because it is based on binary file static analysis.

This talk will describe the use of weighted transducers in speech and language processing. Weighted transducers are automata where each transition has an input label, an output label, and a weight. They have key applications in speech recognition and synthesis, machine translation, optical character recognition, pattern matching, string processing, machine learning, information extraction and retrieval among others. We give a brief history of the field, an overview of the theory and algorithms of weighted finite-state and pushdown transducers, a discussion of available software libraries, a description of applications to speech recognition, speech synthesis, machine translation and NLP, and a short overview of current research problems.

Descriptive Complexity has been very successful in characterizing complexity classes of decision problems in terms of the properties definable in some logics. However, descriptive complexity for counting complexity classes, such as FP and #P, has not been systematically studied, and it is not as developed as its decision counterpart. In this paper, we propose a framework based on Weighted Logics to address this issue. Specifically, by focusing on the natural numbers we obtain a logic called Quantitative Second Order Logics (QSO), and show how some of its fragments can be used to capture fundamental counting complexity classes such as FP, #P and FPSPACE, among others. We also use QSO to define a hierarchy inside #P, identifying counting complexity classes with good closure and approximation properties, and which admit natural complete problems. Finally, we add recursion to QSO, and show how this extension naturally captures lower counting complexity classes such as #L.

We compare pushdown automata (PDAs for short) against other representations. First, we show that there is a family of PDAs over a unary alphabet with \(n\) states and \(p \ge 2n + 4\) stack symbols that accepts one single long word for which every equivalent context-free grammar needs \(\varOmega (n^2(p-2n-4))\) variables. This family shows that the classical algorithm for converting a PDA into an equivalent context-free grammar is optimal even when the alphabet is unary. Moreover, we observe that language equivalence and Parikh equivalence, which ignores the ordering between symbols, coincide for this family. We conclude that, when assuming this weaker equivalence, the conversion algorithm is also optimal. Second, Parikh’s theorem motivates the comparison of PDAs against finite state automata. In particular, the same family of unary PDAs gives a lower bound on the number of states of every Parikh-equivalent finite state automaton. Finally, we look into the case of unary deterministic PDAs. We show a new construction converting a unary deterministic PDA into an equivalent context-free grammar that achieves best known bounds.

We study probabilistic complexity classes and questions of derandomisation from a logical point of view. For each logic L we introduce a new logic BPL, bounded error probabilistic L, which is defined from L in a similar way as the complexity class BPP, bounded error probabilistic polynomial time, is defined from PTIME. Our main focus lies on questions of derandomisation, and we prove that there is a query which is definable in BPFO, the probabilistic version of first-order logic, but not in Cinf, finite variable infinitary logic with counting. This implies that many of the standard logics of finite model theory, like transitive closure logic and fixed-point logic, both with and without counting, cannot be derandomised. Similarly, we present a query on ordered structures which is definable in BPFO but not in monadic second-order logic, and a query on additive structures which is definable in BPFO but not in FO. The latter of these queries shows that certain uniform variants of AC0 (bounded-depth polynomial sized circuits) cannot be derandomised. These results are in contrast to the general belief that most standard complexity classes can be derandomised. Finally, we note that BPIFP+C, the probabilistic version of fixed-point logic with counting, captures the complexity class BPP, even on unordered structures.

Universal IoT-Enabled Smart Battery Charging Optimization System introduces a novel solution to addressing the widespread problem of battery degradation in IoT-enabled devices such as smartphones, wearables, stylus pens, and wireless earbuds. The system utilizes Artificial Intelligence (AI), Automata Theory, and sensor data in real-time to develop a dynamic context-aware charging strategy that learns from the unique usage patterns and battery status of every device. By applying machine learning models like Kalman Filters, Recurrent Neural Networks (RNNs), and Finite State Machines (FSM), the system charges behaviors smartly, optimizing power consumption, charging efficiency, and battery life. Pushdown Automata (PDA) are used to facilitate non-deterministic state transitions from past charging data, providing more precise predictions of battery wear. The system constantly collects and processes data from IoT sensors with real-time charging cycle and battery health feedback. Initial results indicate that the system greatly mitigates overcharging, enhances battery life, and promotes energy efficiency, providing a green solution to maximize the lifespan of IoT-based devices in various applications. The solution offers a sound framework for further research on smart energy management and green computing.

PurposeIn this study, human activity with finite and specific ranking is modeled with finite state machine, and an application for human–robot interaction was realized. A robot arm was designed that makes specific movements. The purpose of this paper is to create a language associated to a complex task, which was then used to teach individuals by the robot that knows the language.Design/methodology/approachAlthough the complex task is known by the robot, it is not known by the human. When the application is started, the robot continuously checks the specific task performed by the human. To carry out the control, the human hand is tracked. For this, the image processing techniques and the particle filter (PF) based on the Bayesian tracking method are used. To determine the complex task performed by the human, the task is divided into a series of sub-tasks. To identify the sequence of the sub-tasks, a push-down automata that uses a context-free grammar language structure is developed. Depending on the correctness of the sequence of the sub-tasks performed by humans, the robot produces different outputs.FindingsThis application was carried out for 15 individuals. In total, 11 out of the 15 individuals completed the complex task correctly by following the different outputs.Originality/valueThis type of study is suitable for applications to improve human intelligence and to enable people to learn quickly. Also, the risky tasks of a person working in a production or assembly line can be controlled with such applications by the robots.