Kind Of Automata Research Articles

Extending the Tsetlin Machine With Integer-Weighted Clauses for Increased Interpretability

Building models that are both interpretable and accurate is an unresolved challenge for many pattern recognition problems. In general, rule-based and linear models lack accuracy, while deep learning interpretability is based on rough approximations of the underlying inference. However, recently, the rule-based Tsetlin Machines (TMs) have obtained competitive performance in terms of accuracy, memory footprint, and inference speed on diverse benchmarks (image classification, regression, natural language understanding, and game-playing). TMs construct rules using human-interpretable conjunctive clauses in propositional logic. These, in turn, are combined linearly to solve complex pattern recognition tasks. This paper addresses the accuracy-interpretability challenge in machine learning by introducing a TM with integer weighted clauses - the Integer Weighted TM (IWTM). The intent is to increase TM interpretability by reducing the number of clauses required for competitive performance. The IWTM achieves this by weighting the clauses so that a single clause can replace multiple duplicates. Since each TM clause is formed adaptively by a Tsetlin Automata (TA) team, identifying effective weights becomes a challenging online learning problem. We solve this problem by extending each team of TA with another kind of automaton: the stochastic searching on the line (SSL) automaton. We evaluate the performance of the new scheme empirically using five datasets, along with a study of interpretability. On average, IWTM uses 6.5 times fewer literals than the vanilla TM and 120 times fewer literals than a TM with real-valued weights. Furthermore, in terms of average memory usage and F1-Score, IWTM outperforms simple Multi-Layered Artificial Neural Networks, Decision Trees, Support Vector Machines, K-Nearest Neighbor, Random Forest, Gradient Boosted Trees (XGBoost), Explainable Boosting Machines (EBMs), as well as the standard and real-value weighted TMs. IWTM finally outperforms Neural Additive Models on Fraud Detection and StructureBoost on CA-58 in terms of Area Under Curve, while performing competitively on COMPAS.

Constant-Delay Enumeration for Nondeterministic Document Spanners

One of the classical tasks in information extraction is to extract subparts of texts through regular expressions. In the database theory literature, this approach has been generalized and formalized as document spanners. In this model, extraction is performed by evaluating a particular kind of automata, called a sequential variable-set automaton (VA). The efficiency of this task is then measured in the context of enumeration algorithms: we first run a preprocessing phase computing a compact representation of the answers, and second we produce the results one after the other with a short time between consecutive answers, called the delay of the enumeration. Our goal is to have an algorithm that is tractable in combined complexity, i.e., in the sizes of the input document and the VA, while ensuring the best possible data complexity bounds in the input document size, i.e., a constant delay that does not depend on the document. We present such an algorithm for a variant of VAs called extended sequential VAs and give an experimental evaluation of this algorithm.

Projection for Büchi Tree Automata with Constraints between Siblings

We consider an extension of tree automata on infinite trees that can use equality and disequality constraints between direct subtrees of a node. Recently, it has been shown that the emptiness problem for these kind of automata with a parity acceptance condition is decidable and that the corresponding class of languages is closed under Boolean operations. In this paper, we show that the class of languages recognizable by such tree automata with a Büchi acceptance condition is closed under projection. This construction yields a new algorithm for the emptiness problem, implies that a regular tree is accepted if the language is non-empty (for the Büchi condition), and can be used to obtain a decision procedure for an extension of monadic second-order logic with predicates for subtree comparisons.

Incompleteness Theorems, Large Cardinals, and Automata Over Finite Words

We prove that one can construct various kinds of automata over finite words for which some elementary properties are actually independent from strong set theories like [Formula: see text] [Formula: see text] “There exist (at least) [Formula: see text] inaccessible cardinals”, for integers [Formula: see text]. In particular, we prove independence results for languages of finite words generated by context-free grammars, or accepted by 2-tape or 1-counter automata. Moreover we get some independence results for weighted automata and for some related finitely generated subsemigroups of the set [Formula: see text] of 3-3 matrices with integer entries. Some of these latter results are independence results from the Peano axiomatic system PA.

Waiting for the rapture: What can we do with computers to (hopefully) witness the emergence of life?

Hadn’t this question already been answered? We all know about computation-universal Turing Machines. And we know that any such machine can simulate a space–time dynamics not unlike von Neumann’s cellular automaton (CA), which is computation- and construction-universal and among other things can play host to self-replicating machines. And that self-replication sprinkled with a bit of randomness should inexorably lead to descent with variation, competition, and thence to evolution and all that. “So what?” Enrico Fermi would have asked, “Where is your emergent life?” (and note that our understanding of both natural and artificial life has much advanced in the 50 years since). It turns out that life is by its very nature a marginal, fragile, and ephemeral kind of phenomenon. For a substrate or a “culture medium” to be able to support the emergence from scratch of a lifelike lineage, computation- and construction-universality are necessary—but by no means sufficient! Paraphrasing Fermi, what automata that you know—including von Neumann’s CA and Conway’s very game of Life—have managed so far to “capture for us on film” the origin of some kind of life? What questions, then, should we ask of a prospective medium—be it a Turing machine, a CA, or some other kind of automaton—that will best probe its capabilities to originate (as well as sustain) some form of life, and which will provide us with a sense of direction to help us more quickly converge in this quest.

Deterministic Temporal Logics and Interval Constraints

In temporal logics, a central question is about the choice of modalities and their relative expressive power, in comparison to the complexity of decision problems such as satisfiability. In this tutorial, we will illustrate the study of such questions over finite word models, first with logics for Unambiguous Starfree Regular Languages (UL), originally defined by Schutzenberger, and then for extensions with constraints, which appear in interval logics. We present Deterministic temporal logics, with diverse sets of modalities, which also characterize UL. The tools and techniques used go under the name of "Turtle Programs" or "Rankers". These are simple kinds of automata. We use properties such as Ranker Directionality and Ranker Convexity to show that all these logics have NP satisfiability. A recursive extension of some of these modalities gives us the full power of first-order logic over finite linear orders. We also discuss Interval Constraint modalities extending Deterministic temporal logics, with intermediate expressiveness. These allow counting or simple algebraic operations on paths. The complexity of these extended logics is PSpace, as of full temporal logic (and ExpSpace when using binary notation).

Regular and context-free nominal traces

Two kinds of automata are presented, for recognising new classes of regular and context-free nominal languages. We compare their expressive power with analogous proposals in the literature, showing that they express novel classes of languages. Although many properties of classical languages hold no longer in the nominal case, we design a slight restriction of our models that preserve some interesting ones. In particular, we prove the emptiness problem decidable and we construct the intersection between (restricted) regular and context-free automata. By examples and walking through their properties we argue the relevance of our models in the context of the verification of resource usage patterns.

Document Spanners

An intrinsic part of information extraction is the creation and manipulation of relations extracted from text. In this article, we develop a foundational framework where the central construct is what we call a document spanner (or just spanner for short). A spanner maps an input string into a relation over the spans (intervals specified by bounding indices) of the string. The focus of this article is on the representation of spanners. Conceptually, there are two kinds of such representations. Spanners defined in a primitive representation extract relations directly from the input string; those defined in an algebra apply algebraic operations to the primitively represented spanners. This framework is driven by SystemT, an IBM commercial product for text analysis, where the primitive representation is that of regular expressions with capture variables. We define additional types of primitive spanner representations by means of two kinds of automata that assign spans to variables. We prove that the first kind has the same expressive power as regular expressions with capture variables; the second kind expresses precisely the algebra of the regular spanners—the closure of the first kind under standard relational operators. The core spanners extend the regular ones by string-equality selection (an extension used in SystemT). We give some fundamental results on the expressiveness of regular and core spanners. As an example, we prove that regular spanners are closed under difference (and complement), but core spanners are not. Finally, we establish connections with related notions in the literature.

JFLAP SEBAGAI ALAT BANTU PENGAJARAN AUTOMATA

Automata is a plural form of automaton. Automaton means machine, so automata means machines. There are many kinds of automata. Automata which we discuss in this paper is DFA, NFA, CFG, and PDA. We give each of them definition, example, accepted or rejected strings, and process about how to accept string visually in JFLAP

Symbolic Algorithms for Language Equivalence and Kleene Algebra with Tests

We propose algorithms for checking language equivalence of finite automata over a large alphabet. We use symbolic automata, where the transition function is compactly represented using (multi-terminal) binary decision diagrams (BDD). The key idea consists in computing a bisimulation by exploring reachable pairs symbolically, so as to avoid redundancies. This idea can be combined with already existing optimisations, and we show in particular a nice integration with the disjoint sets forest data-structure from Hopcroft and Karp's standard algorithm. Then we consider Kleene algebra with tests (KAT), an algebraic theory that can be used for verification in various domains ranging from compiler optimisation to network programming analysis. This theory is decidable by reduction to language equivalence of automata on guarded strings, a particular kind of automata that have exponentially large alphabets. We propose several methods allowing to construct symbolic automata out of KAT expressions, based either on Brzozowski's derivatives or on standard automata constructions. All in all, this results in efficient algorithms for deciding equivalence of KAT expressions.

Synthesis of Reo Connectors for Strategies and Controllers

In controller synthesis, i.e., the question whether there is a controller or strategy to achieve some objective in a given system, the controller is often realized as some kind of automaton. In the context of the exogenous coordination language Reo, where the coordination glue code between the components is realized as a network of channels, it is desirable for such synthesized controllers to also take the form of a Reo connector built from a repertoire of basic channels. In this paper, we address the automatic construction of such Reo connectors directly from a constraint automaton representation.

Non-Linear Rewrite Closure and Weak Normalization

A rewrite closure is an extension of a term rewrite system with new rules, usually deduced by transitivity. Rewrite closures have the nice property that all rewrite derivations can be transformed into derivations of a simple form. This property has been useful for proving decidability results in term rewriting. Unfortunately, when the term rewrite system is not linear, the construction of a rewrite closure is quite challenging. In this paper, we construct a rewrite closure for term rewrite systems that satisfy two properties: the right-hand side term in each rewrite rule contains no repeated variable (right-linear) and contains no variable occurring at depth greater than one (right-shallow). The left-hand side term is unrestricted, and in particular, it may be non-linear. As a consequence of the rewrite closure construction, we are able to prove decidability of the weak normalization problem for right-linear right-shallow term rewrite systems. Proving this result also requires tree automata theory. We use the fact that right-shallow right-linear term rewrite systems are regularity preserving. Moreover, their set of normal forms can be represented with a tree automaton with disequality constraints, and emptiness of this kind of automata, as well as its generalization to reduction automata, is decidable. A preliminary version of this work was presented at LICS 2009 (Creus 2009).

Methods for the estimation of the size of lookahead tree state-space

Limited lookahead supervision is a discrete-event systems framework in which control decisions are made by looking at finite-step projections of the behaviour of the system's underlying automata. Projected system behaviour is represented as a lookahead tree with some depth limit decided on by the user. It can be difficult to strike a balance between the complexities associated with storing and analyzing the trees and the amount of information available to make decisions, both of which increase with depth. This paper considers the problem of accurately estimating the state space of lookahead trees with the intent of simplifying the process of determining a favourable depth to use. Although the estimation methods presented here apply cleanly to only certain kinds of automata, they also shed light onto the more complex behaviour of the others.

A TAXONOMY OF DETERMINISTIC FORGETTING AUTOMATA

We investigate deterministic forgetting automata, i.e., deterministic linear bounded automata which can only use the operations 'move', 'erase' (rewrite with a blank symbol) and 'delete' (remove completely). We give a taxonomy of deterministic forgetting automata and draw comparisons to other kinds of automata (namely deterministic one-turn pushdown automata and one-way one-counter automata).

Modeling and verification using UML Statecharts. By Doron Drusinsky. Published by Newnes Publishers, 2006. ISBN: 0‐7506‐7617‐5, 306 pages. Price £39.99. Hard Cover.

Modeling and verification using UML Statecharts. By Doron Drusinsky. Published by Newnes Publishers, 2006. ISBN: 0‐7506‐7617‐5, 306 pages. Price £39.99. Hard Cover.

Finite Automata Implementations Considering CPU Cache

The finite automata are mathematical models for finite state systems. More general finite automaton is the nondeterministic finite automaton (NFA) that cannot be directly used. It is usually transformed to the deterministic finite automaton (DFA) that then runs in time O(n), where n is the size of the input text. We present two main approaches to practical implementation of DFA considering CPU cache. The first approach (represented by Table Driven and Hard Coded implementations) is suitable forautomata being run very frequently, typically having cycles. The other approach is suitable for a collection of automata from which various automata are retrieved and then run. This second kind of automata are expected to be cycle-free.

Automata for XML—A survey

Automata play an important role for the theoretical foundations of XML data management, but also in tools for various XML processing tasks. This survey article aims to give an overview of fundamental properties of the different kinds of automata used in this area and to relate them to the four key aspects of XML processing: schemas, navigation, querying and transformation.

Complementing deterministic tree-walking automata

We consider various kinds of deterministic tree-walking automata, with and without pebbles, over ranked and unranked trees. For each such kind of automata we show that there is an equivalent one which never loops. The main consequence of this result is the closure under complementation of the various types of automata we consider with a focus on the number of pebbles used in order to complement the automata.

Recurrent neural networks and prior knowledge for sequence processing: a constrained nondeterministic approach

The paper focuses on methods for injecting prior knowledge into adaptive recurrent networks for sequence processing. In order to increase the flexibility needed for specifying partially known rules, a nondeterministic approach for modelling domain knowledge is proposed. The algorithms presented in the paper allow time-warping nondeterministic automata to be mapped into recurrent architectures with first-order connections. These kinds of automata are suitable for modeling temporal scale distortions in data such as acoustic sequences occurring in problems of speech recognition. The algorithms output a recurrent architecture and a feasible region in the connection weight space. It is demonstrated that, as long as the weights are constrained into the feasible region, the nondeterministic rules introduced using prior knowledge are not destroyed by learning. The paper focuses primarily on architectural issues, but the proposed method allows the connection weights to be subsequently tuned to adapt the behavior of the network to data.

ω-Languages accepted by finite automata whose structures are cascade products of resets

We study ω-languages accepted by finite automata whose structures are cascade products of resets. It is proved that the class of ω-languages accepted by these kinds of automata under Muller-type conditions coincides with the class of star-free ω-regular languages and that it properly includes the class of ω-languages accepted by these kinds of automata under Büch-type conditions. Furthermore we prove that the class of projective images of star-free ω-regular languages coincides with the class of ω-regular languages.