In automata theory, the **thread automaton** (plural: automata) is an extended type of finite-state automata that recognizes a mildly context-sensitive language class above the tree-adjoining languages.^{ [1] }

A **thread automaton** consists of

- a set
*N*of states,^{ [note 1] } - a set Σ of terminal symbols,
- a start state
*A*_{S}∈*N*, - a final state
*A*_{F}∈*N*, - a set
*U*of path components, - a partial function δ:
*N*→*U*^{⊥}, where*U*^{⊥}=*U*∪ {⊥} for ⊥ ∉*U*, - a finite set Θ of transitions.

A **path***u*_{1}...*u*_{n} ∈ *U*^{ * } is a string of path components *u*_{i} ∈ *U*; *n* may be 0, with the empty path denoted by ε. A **thread** has the form *u*_{1}...*u*_{n}:*A*, where *u*_{1}...*u*_{n} ∈ *U*^{*} is a path, and *A* ∈ *N* is a state. A **thread store***S* is a finite set of threads, viewed as a partial function from *U*^{*} to *N*, such that *dom*(*S*) is closed by prefix.

A thread automaton **configuration** is a triple ‹*l*,*p*,*S*›, where *l* denotes the current position in the input string, *p* is the active thread, and *S* is a thread store containing *p*. The **initial configuration** is ‹0,ε,{ε:*A*_{S}}›. The **final configuration** is ‹*n*,*u*,{ε:*A*_{S},*u*:*A*_{F}}›, where *n* is the length of the input string and *u* abbreviates δ(*A*_{S}). A **transition** in the set Θ may have one of the following forms, and changes the current automaton configuration in the following way:

**SWAP***B*→_{a}*C*: consumes the input symbol*a*, and changes the state of the active thread:

- changes the configuration from ‹
*l*,*p*,*S*∪{*p*:*B*}› to ‹*l*+1,*p*,*S*∪{*p*:*C*}›

**SWAP***B*→_{ε}*C*: similar, but consumes no input:

- changes ‹
*l*,*p*,*S*∪{*p*:*B*}› to ‹*l*,*p*,*S*∪{*p*:*C*}›

**PUSH***C*: creates a new subthread, and suspends its parent thread:

- changes ‹
*l*,*p*,*S*∪{*p*:*B*}› to ‹*l*,*pu*,*S*∪{*p*:*B*,*pu*:*C*}› where*u*=δ(*B*) and*pu*∉dom(*S*)

**POP**[*B*]*C*: ends the active thread, returning control to its parent:

- changes ‹
*l*,*pu*,*S*∪{*p*:*B*,*pu*:*C*}› to ‹*l*,*p*,*S*∪{*p*:*C*}› where δ(*C*)=⊥ and*pu*∉dom(*S*)

**SPUSH**[*C*]*D*: resumes a suspended subthread of the active thread:

- changes ‹
*l*,*p*,*S*∪{*p*:*B*,*pu*:*C*}› to ‹*l*,*pu*,*S*∪{*p*:*B*,*pu*:*D*}› where*u*=δ(*B*)

**SPOP**[*B*]*D*: resumes the parent of the active thread:

- changes ‹
*l*,*pu*,*S*∪{*p*:*B*,*pu*:*C*}› to ‹*l*,*p*,*S*∪{*p*:*D*,*pu*:*C*}› where δ(*C*)=⊥

One may prove that δ(*B*)=*u* for **POP** and **SPOP** transitions, and δ(*C*)=⊥ for **SPUSH** transitions.^{ [2] }

An input string is **accepted** by the automaton if there is a sequence of transitions changing the initial into the final configuration.

- ↑ called
*non-terminal symbols*by Villemonte (2002), p.1r

A **finite-state machine** (**FSM**) or **finite-state automaton**, **finite automaton**, or simply a **state machine**, is a mathematical model of computation. It is an abstract machine that can be in exactly one of a finite number of *states* at any given time. The FSM can change from one state to another in response to some inputs; the change from one state to another is called a *transition*. An FSM is defined by a list of its states, its initial state, and the inputs that trigger each transition. Finite-state machines are of two types—deterministic finite-state machines and non-deterministic finite-state machines. A deterministic finite-state machine can be constructed equivalent to any non-deterministic one.

In the theory of computation, a branch of theoretical computer science, a **pushdown automaton** (**PDA**) is a type of automaton that employs a stack.

A **tree automaton** is a type of state machine. Tree automata deal with tree structures, rather than the strings of more conventional state machines.

In computer science and automata theory, a **Büchi automaton** is a type of ω-automaton, which extends a finite automaton to infinite inputs. It accepts an infinite input sequence if there exists a run of the automaton that visits one of the final states infinitely often. Büchi automata recognize the omega-regular languages, the infinite word version of regular languages. They are named after the Swiss mathematician Julius Richard Büchi, who invented this kind of automaton in 1962.

In the theory of computation, a branch of theoretical computer science, a **deterministic finite automaton** (**DFA**)—also known as **deterministic finite acceptor** (**DFA**), **deterministic finite-state machine** (**DFSM**), or **deterministic finite-state automaton** (**DFSA**)—is a finite-state machine that accepts or rejects a given string of symbols, by running through a state sequence uniquely determined by the string. *Deterministic* refers to the uniqueness of the computation run. In search of the simplest models to capture finite-state machines, Warren McCulloch and Walter Pitts were among the first researchers to introduce a concept similar to finite automata in 1943.

In automata theory, a finite-state machine is called a deterministic finite automaton (DFA), if

A **finite-state transducer** (**FST**) is a finite-state machine with two memory *tapes*, following the terminology for Turing machines: an input tape and an output tape. This contrasts with an ordinary finite-state automaton, which has a single tape. An FST is a type of finite-state automaton that maps between two sets of symbols. An FST is more general than a finite-state automaton (FSA). An FSA defines a formal language by defining a set of accepted strings, while an FST defines relations between sets of strings.

In automata theory, a **deterministic pushdown automaton** is a variation of the pushdown automaton. The class of deterministic pushdown automata accepts the deterministic context-free languages, a proper subset of context-free languages.

In quantum computing, **quantum finite automata** (**QFA**) or **quantum state machines** are a quantum analog of probabilistic automata or a Markov decision process. They provide a mathematical abstraction of real-world quantum computers. Several types of automata may be defined, including *measure-once* and *measure-many* automata. Quantum finite automata can also be understood as the quantization of subshifts of finite type, or as a quantization of Markov chains. QFAs are, in turn, special cases of **geometric finite automata** or **topological finite automata**.

In automata theory, a **nested stack automaton** is a finite automaton that can make use of a stack containing data which can be additional stacks. Like a stack automaton, a nested stack automaton may step up or down in the stack, and read the current symbol; in addition, it may at any place create a new stack, operate on that one, eventually destroy it, and continue operating on the old stack. This way, stacks can be nested recursively to an arbitrary depth; however, the automaton always operates on the innermost stack only.

In mathematics and computer science, the **probabilistic automaton** (**PA**) is a generalization of the nondeterministic finite automaton; it includes the probability of a given transition into the transition function, turning it into a transition matrix. Thus, the probabilistic automaton generalizes the concept of a Markov chain or subshift of finite type. The languages recognized by probabilistic automata are called **stochastic languages**; these include the regular languages as a subset. The number of stochastic languages is uncountable.

A **queue machine** or **queue automaton** is a finite state machine with the ability to store and retrieve data from an infinite-memory queue. It is a model of computation equivalent to a Turing machine, and therefore it can process the same class of formal languages.

In computer science, more specifically in automata and formal language theory, **nested words** are a concept proposed by Alur and Madhusudan as a joint generalization of words, as traditionally used for modelling linearly ordered structures, and of ordered unranked trees, as traditionally used for modelling hierarchical structures. Finite-state acceptors for nested words, so-called **nested word automata**, then give a more expressive generalization of finite automata on words. The linear encodings of languages accepted by finite nested word automata gives the class of **visibly pushdown languages**. The latter language class lies properly between the regular languages and the deterministic context-free languages. Since their introduction in 2004, these concepts have triggered much research in that area.

In computer science and mathematical logic, an **infinite-tree automaton** is a state machine that deals with infinite tree structures. It can be seen as an extension of top-down finite-tree automata to infinite trees or as an extension of infinite-word automata to infinite trees.

In automata theory, a branch of theoretical computer science, an **ω-automaton** is a variation of finite automata that runs on infinite, rather than finite, strings as input. Since ω-automata do not stop, they have a variety of acceptance conditions rather than simply a set of accepting states.

In computer science, **Thompson's construction** algorithm, also called the McNaughton-Yamada-Thompson algorithm, is a method of transforming a regular expression into an equivalent nondeterministic finite automaton (NFA). This NFA can be used to match strings against the regular expression. This algorithm is credited to Ken Thompson.

In computational learning theory, **induction of regular languages** refers to the task of learning a formal description of a regular language from a given set of example strings. Although Mark E. Gold has shown that not every regular language can be learned this way, approaches have been investigated for a variety of subclasses. They are sketched in this article. For learning of more general grammars, see Grammar induction.

In theoretical computer science, in particular in formal language theory, **Kleene's algorithm** transforms a given nondeterministic finite automaton (NFA) into a regular expression. Together with other conversion algorithms, it establishes the equivalence of several description formats for regular languages. Alternative presentations of the same method include the "elimination method" attributed to Brzozowski and McCluskey, the algorithm of McNaughton and Yamada, and the use of Arden's lemma.

In computer science, in particular in formal language theory, a **quotient automaton** can be obtained from a given nondeterministic finite automaton by joining some of its states. The quotient recognizes a superset of the given automaton; in some cases, handled by the Myhill–Nerode theorem, both languages are equal.

A tree stack automaton is a formalism considered in automata theory. It is a finite state automaton with the additional ability to manipulate a tree-shaped stack. It is an automaton with storage whose storage roughly resembles the configurations of a thread automaton. A restricted class of tree stack automata recognises exactly the languages generated by multiple context-free grammars.

- ↑ Villemonte de la Clergerie, Éric (2002). "Parsing mildly context-sensitive languages with thread automata".
*COLING '02 Proceedings of the 19th International Conference on Computational Linguistics*.**1**(3): 1–7. doi: 10.3115/1072228.1072256 . Retrieved 2016-10-15. - ↑ Villemonte (2002), p.1r-2r

This page is based on this Wikipedia article

Text is available under the CC BY-SA 4.0 license; additional terms may apply.

Images, videos and audio are available under their respective licenses.

Text is available under the CC BY-SA 4.0 license; additional terms may apply.

Images, videos and audio are available under their respective licenses.