Automata theory

Automata theory is the study of

.

Automata theory is closely related to

.

History

The theory of abstract automata was developed in the mid-20th century in connection with

pushdown automata

.

1956 saw the publication of Automata Studies, which collected work by scientists including

In the same year, .

The study of

In the 1960s, a body of algebraic results known as "structure theory" or "algebraic decomposition theory" emerged, which dealt with the realization of sequential machines from smaller machines by interconnection.[10] While any finite automaton can be simulated using a universal gate set, this requires that the simulating circuit contain loops of arbitrary complexity. Structure theory deals with the "loop-free" realizability of machines.^[5] The theory of computational complexity also took shape in the 1960s.^[11][12] By the end of the decade, automata theory came to be seen as "the pure mathematics of computer science".^[5]

What follows is a general definition of an automaton, which restricts a broader definition of a system to one viewed as acting in discrete time-steps, with its state behavior and outputs defined at each step by unchanging functions of only its state and input.^[5]

An automaton runs when it is given some sequence of inputs in discrete (individual) time steps (or just steps). An automaton processes one input picked from a set of

. The symbols received by the automaton as input at any step are a sequence of symbols called words. An automaton has a set of states. At each moment during a run of the automaton, the automaton is in one of its states. When the automaton receives new input, it moves to another state (or transitions) based on a transition function that takes the previous state and current input symbol as parameters. At the same time, another function called the output function produces symbols from the output alphabet, also according to the previous state and current input symbol. The automaton reads the symbols of the input word and transitions between states until the word is read completely, if it is finite in length, at which point the automaton halts. A state at which the automaton halts is called the final state.

To investigate the possible state/input/output sequences in an automaton using formal language theory, a machine can be assigned a starting state and a set of accepting states. Then, depending on whether a run starting from the starting state ends in an accepting state, the automaton can be said to accept or reject an input sequence. The set of all the words accepted by an automaton is called the language recognized by the automaton. A familiar example of a machine recognizing a language is an electronic lock, which accepts or rejects attempts to enter the correct code.

Automaton

An automaton can be represented formally by a

quintuple

${\displaystyle M=\langle \Sigma ,\Gamma ,Q,\delta ,\lambda \rangle }$, where:

• ${\displaystyle \Sigma }$ is a finite set of symbols, called the input alphabet of the automaton,
• ${\displaystyle \Gamma }$ is another finite set of symbols, called the output alphabet of the automaton,
• ${\displaystyle Q}$ is a set of states,
• ${\displaystyle \delta }$ is the next-state function or transition function ${\displaystyle \delta :Q\times \Sigma \to Q}$ mapping state-input pairs to successor states,
• ${\displaystyle \lambda }$ is the next-output function ${\displaystyle \lambda :Q\times \Sigma \to \Gamma }$ mapping state-input pairs to outputs.

If ${\displaystyle Q}$ is finite, then ${\displaystyle M}$ is a

finite automaton.^[5]

Input word

An automaton reads a finite

string

of symbols ${\displaystyle a_{1}a_{2}...a_{n}}$, where ${\displaystyle a_{i}\in \Sigma }$, which is called an input word. The set of all words is denoted by ${\displaystyle \Sigma ^{*}}$.

Run

A sequence of states ${\displaystyle q_{0},q_{1},...,q_{n}}$, where ${\displaystyle q_{i}\in Q}$ such that ${\displaystyle q_{i}=\delta (q_{i-1},a_{i})}$ for ${\displaystyle 0<i\leq n}$, is a run of the automaton on an input ${\displaystyle a_{1}a_{2}...a_{n}\in \Sigma ^{*}}$ starting from state ${\displaystyle q_{0}}$. In other words, at first the automaton is at the start state ${\displaystyle q_{0}}$, and receives input ${\displaystyle a_{1}}$. For ${\displaystyle a_{1}}$ and every following ${\displaystyle a_{i}}$ in the input string, the automaton picks the next state ${\displaystyle q_{i}}$ according to the transition function ${\displaystyle \delta (q_{i-1},a_{i})}$, until the last symbol ${\displaystyle a_{n}}$ has been read, leaving the machine in the final state of the run, ${\displaystyle q_{n}}$. Similarly, at each step, the automaton emits an output symbol according to the output function ${\displaystyle \lambda (q_{i-1},a_{i})}$.

The transition function ${\displaystyle \delta }$ is extended inductively into ${\displaystyle {\overline {\delta }}:Q\times \Sigma ^{*}\to Q}$ to describe the machine's behavior when fed whole input words. For the empty string ${\displaystyle \varepsilon }$, ${\displaystyle {\overline {\delta }}(q,\varepsilon )=q}$ for all states ${\displaystyle q}$, and for strings ${\displaystyle wa}$ where ${\displaystyle a}$ is the last symbol and ${\displaystyle w}$ is the (possibly empty) rest of the string, ${\displaystyle {\overline {\delta }}(q,wa)=\delta ({\overline {\delta }}(q,w),a)}$.[10] The output function ${\displaystyle \lambda }$ may be extended similarly into ${\displaystyle {\overline {\lambda }}(q,w)}$, which gives the complete output of the machine when run on word ${\displaystyle w}$ from state ${\displaystyle q}$.

Acceptor

In order to study an automaton with the theory of

formal languages

, an automaton may be considered as an acceptor, replacing the output alphabet and function ${\displaystyle \Gamma }$ and ${\displaystyle \lambda }$ with

• ${\displaystyle q_{0}\in Q}$, a designated start state, and
• ${\displaystyle F}$, a set of states of ${\displaystyle Q}$ (i.e. ${\displaystyle F\subseteq Q}$) called accept states.

This allows the following to be defined:

Accepting word

A word ${\displaystyle w=a_{1}a_{2}...a_{n}\in \Sigma ^{*}}$ is an accepting word for the automaton if ${\displaystyle {\overline {\delta }}(q_{0},w)\in F}$, that is, if after consuming the whole string ${\displaystyle w}$ the machine is in an accept state.

Recognized language

The language ${\displaystyle L\subseteq \Sigma ^{*}}$ recognized by an automaton is the set of all the words that are accepted by the automaton, ${\displaystyle L=\{w\in \Sigma ^{*}\ |\ {\overline {\delta }}(q_{0},w)\in F\}}$.^[13]

Recognizable languages

The

recognizable languages are the set of languages that are recognized by some automaton. For finite automata the recognizable languages are regular languages

. For different types of automata, the recognizable languages are different.

Variant definitions of automata

Automata are defined to study useful machines under mathematical formalism. So the definition of an automaton is open to variations according to the "real world machine" that we want to model using the automaton. People have studied many variations of automata. The following are some popular variations in the definition of different components of automata.

Input

• Finite input: An automaton that accepts only finite sequences of symbols. The above introductory definition only encompasses finite words.
• Infinite input: An automaton that accepts infinite words (
  ω-automata
  .
• Tree input: The input may be a tree of symbols instead of sequence of symbols. In this case after reading each symbol, the automaton reads all the successor symbols in the input tree. It is said that the automaton makes one copy of itself for each successor and each such copy starts running on one of the successor symbols from the state according to the transition relation of the automaton. Such an automaton is called a tree automaton.
• Infinite tree input : The two extensions above can be combined, so the automaton reads a tree structure with (in)finite branches. Such an automaton is called an
  infinite tree automaton
  .

States

• Single state: An automaton with one state, also called a combinational circuit, performs a transformation which may implement combinational logic.^[10]
• Finite states: An automaton that contains only a finite number of states.
• Infinite states: An automaton that may not have a finite number of states, or even a
  countable
  number of states. Different kinds of abstract memory may be used to give such machines finite descriptions.
• Stack memory: An automaton may also contain some extra memory in the form of a stack in which symbols can be pushed and popped. This kind of automaton is called a pushdown automaton.
• Queue memory: An automaton may have memory in the form of a
  queue machine
  and is Turing-complete.
• Tape memory: The inputs and outputs of automata are often described as input and output tapes. Some machines have additional working tapes, including the
  log-space transducer
  .

Transition function

• Deterministic: For a given current state and an input symbol, if an automaton can only jump to one and only one state then it is a deterministic automaton.
• Nondeterministic: An automaton that, after reading an input symbol, may jump into any of a number of states, as licensed by its transition relation. The term transition function is replaced by transition relation: The automaton non-deterministically decides to jump into one of the allowed choices. Such automata are called nondeterministic automata.
• Alternation: This idea is quite similar to tree automata but orthogonal. The automaton may run its multiple copies on the same next read symbol. Such automata are called
  alternating automata
  . The acceptance condition must be satisfied on all runs of such copies to accept the input.
• Two-wayness: Automata may read their input from left to right, or they may be allowed to move back-and-forth on the input, in a way similar to a Turing machine. Automata which can move back-and-forth on the input are called two-way finite automata.

Acceptance condition

• Acceptance of finite words: Same as described in the informal definition above.
• Acceptance of infinite words: an ω-automaton cannot have final states, as infinite words never terminate. Rather, acceptance of the word is decided by looking at the infinite sequence of visited states during the run.
• Probabilistic acceptance: An automaton need not strictly accept or reject an input. It may accept the input with some
  metric automata
  have probabilistic acceptance.

Different combinations of the above variations produce many classes of automata.

Automata theory is a subject matter that studies properties of various types of automata. For example, the following questions are studied about a given type of automata.

• Which class of formal languages is recognizable by some type of automata? (Recognizable languages)
• Are certain automata closed under union, intersection, or complementation of formal languages? (Closure properties)
• How expressive is a type of automata in terms of recognizing a class of formal languages? And, their relative expressive power? (Language hierarchy)

Automata theory also studies the existence or nonexistence of any effective algorithms to solve problems similar to the following list:

• Does an automaton accept at least one input word? (Emptiness checking)
• Is it possible to transform a given non-deterministic automaton into a deterministic automaton without changing the language recognized? (Determinization)
• For a given formal language, what is the smallest automaton that recognizes it? (Minimization)

The following is an incomplete list of types of automata.

Automaton	Recognizable languages
Nondeterministic/Deterministic finite-state machine (FSM)	regular languages
Deterministic pushdown automaton (DPDA)	deterministic context-free languages
Pushdown automaton (PDA)	context-free languages
Linear bounded automaton (LBA)	context-sensitive languages
Turing machine	recursively enumerable languages
Deterministic Büchi automaton	ω-limit languages
Nondeterministic Büchi automaton	ω-regular languages
Parity automaton, Muller automaton
Weighted automaton

Normally automata theory describes the states of abstract machines but there are discrete automata,

, which use digital data, analog data or continuous time, or digital and analog data, respectively.

Hierarchy in terms of powers

The following is an incomplete hierarchy in terms of powers of different types of virtual machines. The hierarchy reflects the nested categories of languages the machines are able to accept.[14]

Automaton

Deterministic Finite Automaton (DFA) -- Lowest Power (same power)    ${\displaystyle ||}$   (same power) Nondeterministic Finite Automaton (NFA) (above is weaker)    ${\displaystyle \cap }$    (below is stronger) Deterministic Push Down Automaton (DPDA-I) with 1 push-down store ${\displaystyle \cap }$ Nondeterministic Push Down Automaton (NPDA-I) with 1 push-down store ${\displaystyle \cap }$ Linear Bounded Automaton (LBA) ${\displaystyle \cap }$ Deterministic Push Down Automaton (DPDA-II) with 2 push-down stores ${\displaystyle ||}$ Nondeterministic Push Down Automaton (NPDA-II) with 2 push-down stores ${\displaystyle ||}$ Deterministic Turing Machine (DTM) ${\displaystyle ||}$ Nondeterministic Turing Machine (NTM) ${\displaystyle ||}$ Probabilistic Turing Machine (PTM) ${\displaystyle ||}$ Multitape Turing Machine (MTM) ${\displaystyle ||}$ Multidimensional Turing Machine

Each model in automata theory plays important roles in several applied areas.

Another problem for which automata can be used is the induction of regular languages.

Automata simulators are pedagogical tools used to teach, learn and research automata theory. An automata simulator takes as input the description of an automaton and then simulates its working for an arbitrary input string. The description of the automaton can be entered in several ways. An automaton can be defined in a symbolic language or its specification may be entered in a predesigned form or its transition diagram may be drawn by clicking and dragging the mouse. Well known automata simulators include Turing's World, JFLAP, VAS, TAGS and SimStudio.^[16]

One can define several distinct

. An automata homomorphism maps a quintuple of an automaton A_i onto the quintuple of another automaton A_j. Automata homomorphisms can also be considered as automata transformations or as semigroup homomorphisms, when the state space, S, of the automaton is defined as a semigroup S_g. Monoids are also considered as a suitable setting for automata in monoidal categories.^[19][20][21]

Categories of variable automata

One could also define a variable automaton, in the sense of Norbert Wiener in his book on The Human Use of Human Beings via the endomorphisms ${\displaystyle A_{i}\to A_{i}}$. Then one can show that such variable automata homomorphisms form a mathematical group. In the case of non-deterministic, or other complex kinds of automata, the latter set of endomorphisms may become, however, a variable automaton groupoid. Therefore, in the most general case, categories of variable automata of any kind are categories of groupoids or groupoid categories. Moreover, the category of reversible automata is then a 2-category, and also a subcategory of the 2-category of groupoids, or the groupoid category.

• Boolean differential calculus
• Petri net

Further reading

• ISBN 0-321-45536-3
  .
• ISBN 978-0-534-94728-6. (accessible to patrons with print disabilities
  ) Part One: Automata and Languages, chapters 1–2, pp. 29–122. Section 4.1: Decidable Languages, pp. 152–159. Section 5.1: Undecidable Problems from Language Theory, pp. 172–183.
• ISBN 978-0-13-228806-4
  .
• Zbl 0565.68046
  .
• Anderson, James A. (2006). Automata theory with modern applications. With contributions by Tom Head. Cambridge:
  Zbl 1127.68049
  .
• Zbl 0231.94041
  .
• MR1254435
• Sakarovitch, Jacques (2009). Elements of automata theory. Translated from the French by Reuben Thomas.
  Zbl 1188.68177
  .
• James P. Schmeiser; David T. Barnard (1995). Producing a top-down parse order with bottom-up parsing. Elsevier North-Holland.
• ISBN 978-0-8448-0657-0
  .
• Marvin Minsky (1967). Computation: Finite and infinite machines. Princeton, N.J.: Prentice Hall.
• John C. Martin (2011). Introduction to Languages and The Theory of Computation. New York: McGraw Hill.
  ISBN 978-0-07-319146-1
  .

External links

• dk.brics.automaton
• libfa