Editing Automata theory

{{short description|Study of abstract machines and automata}}
{{Use dmy dates|date=May 2019|cs1-dates=y}}
{{Automata theory}}

[[File:DFAexample.svg|thumb|300px| The automaton described by this [[state diagram]] starts in state S<sub>1</sub>, and changes states following the arrows marked 0 or 1 according to the input symbols as they arrive. The double circle marks S<sub>1</sub> as an accepting state. Since all paths from S<sub>1</sub> to itself contain an even number of arrows marked 0, this automaton accepts strings containing even numbers of 0s.]]

'''Automata theory''' is the study of [[abstract machine]]s and [[automaton|automata]], as well as the [[computational problem]]s that can be solved using them. It is a theory in [[theoretical computer science]] with close connections to [[cognitive science]] and [[mathematical logic]]. The word ''automata'' comes from the [[Greek language|Greek]] word αὐτόματος, which means "self-acting, self-willed, self-moving". An [[automaton]] (automata in plural) is an abstract self-propelled [[computing device]] which follows a predetermined sequence of operations automatically. An automaton with a finite number of [[State (computer science)|states]] is called a finite automaton (FA) or [[finite-state machine]] (FSM). The figure on the right illustrates a finite-state machine, which is a well-known type of automaton. This automaton consists of [[State (computer science)|states]] (represented in the figure by circles) and [[Transition (computer science)|transitions]] (represented by arrows).  As the automaton sees a symbol of input, it makes a transition (or jump) to another state, according to its [[transition table|transition function]], which takes the previous state and current input symbol as its [[Parameter (computer programming)|arguments]].

Automata theory is closely related to [[formal language]] theory. In this context, automata are used as finite representations of formal languages that may be infinite. Automata are often classified by the class of formal languages they can recognize, as in the [[Chomsky hierarchy]], which describes a nesting relationship between major classes of automata. Automata play a major role in the [[theory of computation]], [[compiler construction]], [[artificial intelligence]], [[parsing]] and [[formal verification]].

==History==
The theory of abstract automata was developed in the mid-20th century in connection with [[finite automata]].<ref>{{cite web | url=http://www.rutherfordjournal.org/article030107.html | title=The Structures of Computation and the Mathematical Structure of Nature | first=Michael S. | last=Mahoney | publisher=The Rutherford Journal | access-date=7 June 2020 }}</ref> Automata theory was initially considered a branch of mathematical [[systems theory]], studying the behavior of discrete-parameter systems. Early work in automata theory differed from previous work on systems by using [[abstract algebra]] to describe [[information system]]s rather than [[differential calculus]] to describe material systems.<ref>{{cite book
 |last=Booth
 |first=Taylor
 |date=1967
 |title=Sequential Machines and Automata Theory
 |location= New York
 |publisher= John Wiley & Sons
 |page= 1-13
 |isbn= 0-471-08848-X
}}</ref> The theory of the [[finite-state transducer]] was developed under different names by different research communities.<ref>{{cite journal
 |last1        = Ashby
 |first1       = William Ross
 |date         = January 15, 1967
 |title        = The Place of the Brain in the Natural World
 |url          = http://www.rossashby.info/Ashby-Mechanisms_of_intelligence.pdf#16
 |journal      = Currents in Modern Biology
 |volume       = 1
 |issue        = 2
 |pages        = 95–104
 |doi          = 10.1016/0303-2647(67)90021-4
 |pmid         = 6060865
 |bibcode = 1967BiSys...1...95A
 |access-date  = 2021-03-29 
 |archive-date = 2023-06-04 
 |archive-url  = https://web.archive.org/web/20230604002636/http://rossashby.info/Ashby-Mechanisms_of_intelligence.pdf#16
 |url-status   = dead
}}: "The theories, now well developed, of the "finite-state machine" (Gill, 1962), of the "noiseless transducer" (Shannon and Weaver, 1949), of the "state-determined system" (Ashby, 1952), and of the "sequential circuit", are essentially homologous."</ref> The earlier concept of [[Turing machine]] was also included in the discipline along with new forms of infinite-state automata, such as [[pushdown automata]].

1956 saw the publication of ''Automata Studies'', which collected work by scientists including [[Claude Shannon]], [[W. Ross Ashby]], [[John von Neumann]], [[Marvin Minsky]], [[Edward F. Moore]], and [[Stephen Cole Kleene]].<ref>{{cite book
 |last=Ashby
 |first=W. R.
 |display-authors=etal
 |editor1=C.E. Shannon
 |editor2=J. McCarthy
 |date=1956
 |title=Automata Studies
 |location= Princeton, N.J.
 |publisher= Princeton University Press
}}</ref> With the publication of this volume, "automata theory emerged as a relatively autonomous discipline".<ref name="Arbib 1969"/> The book included Kleene's description of the set of regular events, or [[regular languages]], and a relatively stable measure of complexity in Turing machine programs by Shannon.<ref>{{cite book
 |last1=Li
 |first1=Ming
 |first2=Vitanyi
 |last2=Paul
 |date=1997
 |title=An Introduction to Kolmogorov Complexity and its Applications
 |location= New York
 |publisher= Springer-Verlag
 |page=84
}}</ref> 
In the same year, [[Noam Chomsky]] described the [[Chomsky hierarchy]], a correspondence between automata and [[formal grammars]],<ref>{{cite journal |last=Chomsky |first=Noam |author-link=Noam Chomsky |date=1956 |title=Three models for the description of language |doi=10.1109/TIT.1956.1056813 |journal=IRE Transactions on Information Theory |volume=2 |issue=3 |pages=113–124 |s2cid=19519474 |url=https://chomsky.info/wp-content/uploads/195609-.pdf |archive-url=https://web.archive.org/web/20160307035549/https://chomsky.info/wp-content/uploads/195609-.pdf |archive-date=2016-03-07 |url-status=live }}</ref> and Ross Ashby published ''[[An Introduction to Cybernetics]]'', an accessible textbook explaining automata and information using basic [[set theory]].

The study of [[linear bounded automata]] led to the [[Myhill–Nerode theorem]],<ref>{{cite journal
| last1      = Nerode
| first1     = A.
|author1-link = Anil Nerode
| date       = 1958
| title      = Linear Automaton Transformations
| journal = Proceedings of the American Mathematical Society
| volume = 9
| issue = 4
| page = 541
| doi = 10.1090/S0002-9939-1958-0135681-9
| url        = https://www.ams.org/journals/proc/1958-009-04/S0002-9939-1958-0135681-9/
| doi-access = free
}}</ref> which gives a necessary and sufficient condition for a formal language to be regular, and an exact count of the number of states in a minimal machine for the language. The [[pumping lemma for regular languages]], also useful in regularity proofs, was proven in this period by [[Michael O. Rabin]] and [[Dana Scott]], along with the computational equivalence of deterministic and nondeterministic finite automata.<ref>{{cite journal|last1=Rabin |first1=Michael |author-link1=Michael O. Rabin|last2=Scott |first2=Dana |author-link2=Dana Scott  |date=Apr 1959 |title=Finite Automata and Their Decision Problems |journal=IBM Journal of Research and Development |volume=3 |issue=2 |pages=114–125 |url=http://www.cse.chalmers.se/~coquand/AUTOMATA/rs.pdf |doi=10.1147/rd.32.0114 |url-status=unfit |archive-url=https://web.archive.org/web/20101214122150/http://www.cse.chalmers.se/~coquand/AUTOMATA/rs.pdf |archive-date=December 14, 2010 }}</ref> 

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.<ref name="structure theory">{{cite book
 |last1=Hartmanis
 |first1=J.
|author1-link = Juris Hartmanis
 |last2=Stearns
 |first2=R.E.
|author2-link = Richard E. Stearns
 |date=1966
 |title=Algebraic Structure Theory of Sequential Machines
 |location=Englewood Cliffs, N.J.
 |publisher=Prentice-Hall
}}</ref> While any finite automaton can be simulated using a [[functional completeness | universal gate set]], this requires that the simulating circuit contain loops of arbitrary complexity. Structure theory deals with the "loop-free" realizability of machines.<ref name="Arbib 1969"/>
The theory of [[computational complexity]] also took shape in the 1960s.<ref>{{cite web
| last1      = Hartmanis
| first1     = J.
| last2      = Stearns
| first2     = R. E.
| date       = 1964
| title      = Computational complexity of recursive sequences
| url        = http://www.cs.albany.edu/~res/complexity_recursive_seq_1964.pdf
}}</ref><ref>{{cite web
| last1      = Fortnow
| first1     = Lance
| last2      = Homer
| first2     = Steve
| date       = 2002
| title      = A Short History of Computational Complexity
| url        = https://people.cs.uchicago.edu/~fortnow/papers/history.pdf
}}</ref> By the end of the decade, automata theory came to be seen as "the pure mathematics of computer science".<ref name="Arbib 1969">{{cite book
 |last=Arbib
 |first=Michael
 |date=1969
 |title=Theories of Abstract Automata
 |location= Englewood Cliffs, N.J.
 |publisher= Prentice-Hall
}}</ref>

==Automata==

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.<ref name="Arbib 1969"/>

===Informal description===
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 ''[[Symbol (formal)|symbols]]'' or ''letters'', which is called an ''input [[alphabet (computer science)|alphabet]]''. 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#Numerical_codes,_passwords,_and_passphrases|electronic lock]], which accepts or rejects attempts to enter the correct code.

===Formal definition===

;Automaton

:An automaton can be represented formally by a [[N-tuple|quintuple]] <math>M = \langle \Sigma, \Gamma, Q, \delta, \lambda \rangle</math>, where:
:* <math>\Sigma</math> is a finite set of ''symbols'', called the ''input alphabet'' of the automaton,
:* <math>\Gamma</math> is another finite set of symbols, called the ''output alphabet'' of the automaton,
:* <math>Q</math> is a set of ''states'',
:* <math>\delta</math> is the ''next-state function'' or ''transition function'' <math>\delta : Q \times \Sigma \to Q</math> mapping state-input pairs to successor states,
:* <math>\lambda</math> is the ''next-output function'' <math>\lambda : Q \times \Sigma \to \Gamma</math> mapping state-input pairs to outputs.
:If <math>Q</math> is finite, then <math>M</math> is a [[finite automaton]].<ref name="Arbib 1969"/>

;Input word
:An automaton reads a finite [[Word (mathematics)|string]] of symbols <math>a_1a_2...a_n</math>, where <math>a_i \in \Sigma</math>, which is called an ''input word''. The set of all words is denoted by <math>\Sigma^*</math>.

;Run
:A sequence of states <math>q_0,q_1,...,q_n</math>, where <math>q_i \in Q</math> such that <math>q_i = \delta(q_{i-1}, a_i)</math> for <math>0 < i \le n</math>, is a ''run'' of the automaton on an input <math>a_1a_2...a_n \in \Sigma^*</math> starting from state <math>q_0</math>. In other words, at first the automaton is at the start state <math>q_0</math>, and receives input <math>a_1</math>. For <math>a_1</math> and every following <math>a_i</math> in the input string, the automaton picks the next state <math>q_i</math> according to the transition function <math>\delta(q_{i-1},a_i)</math>, until the last symbol <math>a_n</math> has been read, leaving the machine in the ''final state'' of the run, <math>q_n</math>. Similarly, at each step, the automaton emits an output symbol according to the output function <math>\lambda(q_{i-1},a_i)</math>.

:The transition function <math>\delta</math> is extended inductively into <math>\overline\delta: Q \times \Sigma^* \to Q</math> to describe the machine's behavior when fed whole input words. For the empty string <math>\varepsilon</math>, <math>\overline\delta(q, \varepsilon) = q</math> for all states <math>q</math>, and for strings <math>wa</math> where <math>a</math> is the last symbol and <math>w</math> is the (possibly empty) rest of the string, <math>\overline\delta(q, wa) = \delta(\overline\delta(q,w),a)</math>.<ref name="structure theory"/> The output function <math>\lambda</math> may be extended similarly into <math>\overline\lambda(q,w)</math>, which gives the complete output of the machine when run on word <math>w</math> from state <math>q</math>.
;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 <math>\Gamma</math> and <math>\lambda</math> with 
:* <math>q_0 \in Q</math>, a designated ''start state'', and
:* <math>F</math>, a set of states of <math>Q</math> (i.e. <math>F \subseteq Q</math>) called ''accept states''. 
:This allows the following to be defined:

;Accepting word
:A word <math>w = a_1a_2...a_n \in \Sigma^*</math> is an ''accepting word'' for the automaton if <math>\overline\delta(q_0,w) \in F</math>, that is, if after consuming the whole string <math>w</math> the machine is in an accept state.

;Recognized language
:The language <math>L \subseteq \Sigma^*</math> ''recognized'' by an automaton is the set of all the words that are accepted by the automaton, <math>L = \{w \in \Sigma^* \ |\  \overline\delta(q_0,w) \in F\}</math>.<ref>{{cite arXiv
 | last       = Moore
 | first      = Cristopher
 | title      = Automata, languages, and grammars
 | class      = cs.CC
 | date       = July 31, 2019
 | eprint = 1907.12713
 }}</ref>

;Recognizable languages
:The [[recognizable language]]s are the set of languages that are recognized by some automaton. For ''finite automata'' the recognizable languages are [[regular language|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 ([[Omega language|ω-words]]). Such automata are called ''[[omega automaton|ω-automata]]''.
* ''Tree input'': The input may be a ''[[tree (automata theory)|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]].<ref name="structure theory"/>
* ''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 (abstract data type)|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 (abstract data type)|queue]]. Such a machine is called ''[[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 [[Turing machine]], [[linear bounded automaton]], and [[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 automaton|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 automaton|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 [[probability]] between zero and one. For example, [[Quantum finite automaton|quantum finite automata]], [[geometric automata]] and [[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 method|effective algorithm]]s 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? ([[DFA minimization|Minimization]])

== Types of automata ==
The following is an incomplete list of types of automata.

{| class="wikitable"
|-
! Automaton
! Recognizable languages
|-
|[[Finite-state machine|Nondeterministic/Deterministic finite-state machine]] (FSM)
|[[regular language]]s
|-
| [[Deterministic pushdown automaton]] (DPDA)
| [[deterministic context-free language]]s
|-
| [[Pushdown automaton]] (PDA)
| [[context-free language]]s
|-
| [[Linear bounded automaton]] (LBA)
| [[context-sensitive language]]s
|-
| [[Turing machine]]
| [[recursively enumerable language]]s
|-
| Deterministic [[Büchi automaton]]
| [[Omega language#Operations|ω-limit languages]]
|-
| Nondeterministic Büchi automaton
| rowspan="2" | [[Omega-regular language|ω-regular languages]]
|-
| [[Rabin automaton]], [[Streett automaton]], [[Parity automaton]], [[Muller automaton]]
|-
| [[Weighted automaton]]
|
|-
|}

===Discrete, continuous, and hybrid automata===
Normally automata theory describes the states of abstract machines but there are discrete automata, [[analog automata]] or [[continuous automaton|continuous automata]], or [[Hybrid automaton|hybrid discrete-continuous 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.<ref name="Aaniya B">{{cite book|last=Yan|first=Song Y.|title=An Introduction to Formal Languages and Machine Computation|year=1998|publisher=World Scientific Publishing Co. Pte. Ltd.|location=Singapore|pages=155–156|url=https://books.google.com/books?id=ySOwQgAACAAJ|isbn=978-981-02-3422-5}}</ref> 
{| class="wikitable" style="text-align:center"
|-
! Automaton
|-
| [[Deterministic Finite Automaton]] (DFA)  -- Lowest Power <br/>
(same power) &nbsp;&nbsp; <math>||</math>  &nbsp;&nbsp;(same power) <br/>
[[Nondeterministic Finite Automaton]] (NFA)<br/>
(above is weaker) &nbsp;&nbsp; <math>\cap</math> &nbsp;&nbsp; (below is stronger) <br/>
[[Deterministic pushdown automaton|Deterministic Push Down Automaton]]  (DPDA-I) <br/>
with 1 push-down store <br/>
<math>\cap</math> <br/>
[[Nondeterministic Push Down Automaton]] (NPDA-I) <br/>
with 1 push-down store <br/>
<math>\cap</math> <br/>
[[Linear bounded automaton|Linear Bounded Automaton]] (LBA) <br/>
<math>\cap</math> <br/>
[[Deterministic pushdown automaton|Deterministic Push Down Automaton]] (DPDA-II) <br/>
with 2 push-down stores <br/>
<math>||</math> <br/>
[[Nondeterministic Push Down Automaton]] (NPDA-II) <br/>
with 2 push-down stores <br/>
<math>||</math> <br/>
[[Deterministic Turing machine|Deterministic Turing Machine]] (DTM) <br/>
<math>||</math> <br/>
[[Nondeterministic Turing machine|Nondeterministic Turing Machine]] (NTM) <br/>
<math>||</math> <br/>
[[Probabilistic Turing machine|Probabilistic Turing Machine]] (PTM) <br/>
<math>||</math> <br/>
[[Multitape Turing machine|Multitape Turing Machine]] (MTM) <br/>
<math>||</math> <br/>
[[Turing machine equivalents#Other equivalent machines and methods|Multidimensional Turing Machine]]
|}

== Applications ==
Each model in automata theory plays important roles in several applied areas. [[Finite automata]] are used in [[text processing]], compilers, and [[hardware design]]. [[Context-free grammar]] (CFGs) are used in [[programming language specification|programming language]]s and artificial intelligence. Originally, CFGs were used in the study of [[natural language|human language]]s. [[Cellular automata]] are used in the field of [[artificial life]], the most famous example being [[John Horton Conway|John Conway]]'s [[Conway's Game of Life|Game of Life]]. Some other examples which could be explained using automata theory in biology include mollusk and pine cone growth and pigmentation patterns. Going further, a theory suggesting that the whole universe is computed by some sort of a discrete automaton, is advocated by some scientists. The idea originated in the work of [[Konrad Zuse]], and was popularized in America by [[Edward Fredkin]]. Automata also appear in the theory of [[finite field]]s: the set of [[irreducible polynomial]]s that can be written as composition of degree two polynomials is in fact a regular language.<ref>{{Citation
  | last1 = Ferraguti
  | first1 = A.
  | last2 = Micheli
  | first2 = G.
  | last3 = Schnyder
  | first3 = R.
  | title = Irreducible compositions of degree two polynomials over finite fields have regular structure
  | volume = 69
  | issue = 3
  | pages = 1089–1099
  | series = The Quarterly Journal of Mathematics
  | publisher = Oxford University Press
  | doi = 10.1093/qmath/hay015
  | year = 2018
  | arxiv = 1701.06040
  | s2cid = 3962424
 }}</ref>
Another problem for which automata can be used is the [[induction of regular languages]].

==Automata simulators==
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 (programming)|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.<ref>{{cite journal|last1= Chakraborty|first1= P.|last2= Saxena |first2= P. C.|last3= Katti|first3 = C. P.|year = 2011|title = Fifty Years of Automata Simulation: A Review|journal =ACM Inroads |volume =2|number= 4|pages =59–70|url = http://dl.acm.org/citation.cfm?id=2038893&dl=ACM&coll=DL&CFID=65021406&CFTOKEN=86634854|doi = 10.1145/2038876.2038893|s2cid= 6446749}}</ref>

==Category-theoretic models==
One can define several distinct [[category (mathematics)|categories]] of automata<ref>Jirí Adámek and [[Věra Trnková]]. 1990. ''Automata and Algebras in Categories''. Kluwer Academic Publishers:Dordrecht and Prague</ref> following the automata classification into different types described in the previous section. The mathematical category of deterministic automata, [[sequential machine]]s or ''sequential automata'', and Turing machines with ''automata homomorphisms'' defining the arrows between automata is a [[Cartesian closed category]],<ref>{{cite book|first = Saunders|last = Mac Lane|author-link = Saunders Mac Lane|title = Categories for the Working Mathematician|publisher = Springer|location= New York |date =1971|isbn = 978-0-387-90036-0}}</ref> it has both categorical [[limit (category theory)|limit]]s and [[colimit]]s. An automata homomorphism maps a quintuple of an automaton ''A''<sub>''i''</sub> onto the quintuple of another automaton 
'' A''<sub>''j''</sub>. 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'''<sub>g</sub>. [[Monoid]]s are also considered as a suitable setting for automata in [[monoidal category|monoidal categories]].<ref>http://www.math.cornell.edu/~worthing/asl2010.pdf James Worthington.2010.Determinizing, Forgetting, and Automata in Monoidal Categories. ASL North American Annual Meeting, 17 March 2010</ref><ref>Aguiar, M. and Mahajan, S.2010. ''"Monoidal Functors, Species, and Hopf Algebras"''.</ref><ref>Meseguer, J., Montanari, U.: 1990 Petri nets are monoids. ''Information and Computation'' '''88''':105–155</ref>

;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 <math>A_{i}\to A_{i}</math>. 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 category|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.

==See also==
* [[Boolean differential calculus]]
* [[Petri net]]

==References==
{{Reflist}}

==Further reading==
* {{Hopcroft, Motwani, and Ullman 2006}}
* {{Sipser 1997}} Part One: Automata and Languages, chapters 1–2, pp.&nbsp;29–122. Section 4.1: Decidable Languages, pp.&nbsp;152–159. Section 5.1: Undecidable Problems from Language Theory, pp.&nbsp;172–183.
* {{cite book|author = [[Elaine Rich]] | year = 2008| title = Automata, Computability and Complexity: Theory and Applications | publisher = Pearson | isbn = 978-0-13-228806-4| title-link = Automata, Computability and Complexity: Theory and Applications}} 
* {{cite book | zbl=0565.68046 | last=Salomaa | first=Arto | author-link=Arto Salomaa | title=Computation and automata | series=Encyclopedia of Mathematics and Its Applications | volume=25 | publisher=[[Cambridge University Press]] | year=1985 | isbn=978-0-521-30245-6 | url-access=registration | url=https://archive.org/details/computationautom0000salo }}
* {{cite book | last=Anderson | first=James A. | title=Automata theory with modern applications | others=With contributions by Tom Head | location=Cambridge | publisher=[[Cambridge University Press]] | year=2006 | isbn=978-0-521-61324-8 | zbl=1127.68049 }}
* {{cite book | last=Conway | first=J.H. | author-link=John Horton Conway | title=Regular algebra and finite machines | series=Chapman and Hall Mathematics Series | location=London | publisher=[[Chapman & Hall]] | year=1971 | zbl=0231.94041 }} 
* [[John M. Howie]] (1991) ''Automata and Languages'', [[Clarendon Press]] {{ISBN|0-19-853424-8}} {{mr|id=1254435}}
* {{cite book | last=Sakarovitch | first=Jacques | title=Elements of automata theory | others=Translated from the French by Reuben Thomas | publisher=[[Cambridge University Press]] | year=2009 | isbn=978-0-521-84425-3 | zbl=1188.68177 }}
* {{cite book |author=[[James P. Schmeiser]] |author2=[[David T. Barnard]] | year = 1995 | title = Producing a top-down parse order with bottom-up parsing | publisher = Elsevier North-Holland}}
* {{cite book |author=[[Igor Aleksander]] |author2=F. Keith Hanna | year = 1975 | title = Automata Theory: An Engineering Approach | publisher = Crane Russak | location=New York  | isbn = 978-0-8448-0657-0}}
* {{cite book|author = [[Marvin Minsky]] | year = 1967 | title = Computation: Finite and infinite machines |url = https://archive.org/details/computationfinit0000mins |url-access = registration | publisher = Prentice Hall | location=Princeton, N.J.}}
* {{cite book|author = John C. Martin | year = 2011 | title = Introduction to Languages and The Theory of Computation | publisher = McGraw Hill | location= New York| isbn = 978-0-07-319146-1}}

== External links ==
* [http://www.brics.dk/automaton dk.brics.automaton]
* [http://www.augeas.net/libfa/index.html libfa]
{{Formal languages and grammars}}
{{Computer science}}
{{Industrial and applied mathematics}}

{{Authority control}}

[[Category:Automata (computation)| ]]