PlanetMath (more info)
 Math for the people, by the people.
Encyclopedia | Requests | Forums | Docs | Wiki | Random | RSS  
Login
create new user
name:
pass:
forget your password?
Main Menu
sections
Encyclopædia
Papers
Books
Expositions

meta
Requests (198)
Orphanage
Unclass'd
Unproven (490)
Corrections (7)
Classification

talkback
Polls
Forums
Feedback
Bug Reports

downloads
Snapshots
PM Book

information
News
Docs
Wiki
ChangeLog
TODO List
Legalese
About
Owner confidence rating: Very high Entry average rating: No information on entry rating
state machine (Definition)

Definition

It is a common practice to view a function as a black box that magically produces outputs upon giving an input. The inner workings of the black box are ignored.


\begin{pspicture} % latex2html id marker 64 (-4,-1)(9,1) \psline[arrows=->,arrow... ...,-1)(4,1)(-1,1) \rput(1.5,0){\textcolor{white}{$f=$\ black box}} \end{pspicture}

If one takes the internal structure of the black box into consideration, then one has a machine, or commonly known as a state machine. The word state refers to the various stages, or states, that an input goes through, before any outputs are produced.

Specifically, a state machine $ M$ is a five-tuple $ (S,\Sigma,\Delta, \delta,\lambda)$ where

  1. $ S$ is a non-empty set whose elements are called states,
  2. $ \Sigma$ is a non-empty set whose elements are called input symbols,
  3. $ \Delta$ is a non-empty set whose elements are called output symbols,
  4. $ \delta$ is a function from $ S\times \Sigma$ to $ P(S)$, the powerset of $ S$, and
  5. $ \lambda$ is a function from $ S\times \Sigma$ to $ P(\Delta)$.

$ \delta$ is called a next-state or transition function, and $ \lambda$ is the output function. A configuration of $ M$ is an element of $ S\times \Sigma$.

When an input symbol $ \alpha\in \Sigma$ is fed into the machine $ M$ current in state $ s$, a set $ \lambda(s,\alpha)$ of output symbols is produced, and machine $ M$ reaches a set of next states $ \delta(s,\alpha)$. Note that there is no restrictions on the sizes of $ \lambda(s,\alpha)$ and $ \delta(s,\alpha)$. There are various classifications of state machines, depending on the cardinality of $ \lambda(s,\alpha)$ and $ \delta(s,\alpha)$:

  • when none of the $ \lambda(s,\alpha)$ and $ \delta(s,\alpha)$ are empty sets for any configurations $ (s,\alpha)$, then $ M$ is said to be complete. Otherwise, it is incomplete;
  • when each $ \lambda(s,\alpha)$ and $ \delta(s,\alpha)$ consists of at most one element, then $ M$ is called a sequential machine.
  • Therefore, a complete sequential machine is just a state machine such that both $ \lambda(s,\alpha)$ and $ \delta(s,\alpha)$ are singletons. A complete sequential machine is also known as a Mealy machine, named after its inventor.
  • A Mealy machine $ M$ such that the output function $ \lambda$ is input-independent is called a Moore machine. Specifically, this means that for any two input symbols $ \alpha,\beta$, and any state $ s$, $ \lambda(s,\alpha)=\lambda(s,\beta)$. Alternatively, in a Moore machine, $ \lambda$ can be viewed as a function $ \Sigma \to \Delta$.
In many examples where the state machine $ M$ has finite $ S,\Sigma$ and $ \Delta$, then $ M$ is called a finite-state machine, although sometimes a finite-state machine is identified with a more specific type of machine called an automaton.

Input and Output

The transition $ \delta$ and the output $ \lambda$ functions of a state machine $ M$ are defined to work only over individual symbols in $ \Sigma$ as inputs. However, these functions can be easily extended so as to apply to all finite strings, or words over $ \Sigma$. First of all, notice that a state machine $ M=(S,\Sigma,\Delta, \delta,\lambda)$ can be thought of as a semiautomaton $ (S,\Sigma,\delta)$ with an output alphabet $ \Delta$ and an output function $ \lambda$. As such, the transition function $ \delta$ can be extended to all of $ \Sigma^*$. Therefore, the next state of a word $ \alpha_1\alpha_2\cdots \alpha_{n+1}$ is the next state of the symbol $ \alpha_{n+1}$ when the machine reaches the state as a result of processing $ \alpha_1\cdots\alpha_n$.

Given an input string $ \alpha_1\alpha_2\cdots \alpha_n\in \Sigma^*$, there are two ways of producing outputs. Without causing any confusion, let us use $ \lambda$ to denote the output function over $ \Sigma^*$. The two output methods are:

  1. $ M$ produces an output symbol every time an input symbol is processed, and is appended to the string of output symbols that have already been produced. Formally,
    $\displaystyle \lambda(s,\alpha_1\alpha_2\cdots \alpha_n):=\lambda(s,\alpha_1\cdots \alpha_{n-1})\lambda(\delta(s,\alpha_1\cdots \alpha_{n-1}),\alpha_n)$
  2. Or, an output symbol is produced only when the last symbol $ \alpha_n$ is processed. In other words,
    $\displaystyle \lambda(s,\alpha_1\alpha_2\cdots \alpha_n):=\lambda(\delta(s,\alpha_1\cdots \alpha_{n-1}),\alpha_n)$

Acceptor and Generator

A state machine $ M=(S,\Sigma,\Delta, \delta,\lambda)$ can be viewed as either a language acceptor or a language generator. The way this works is as follows:

$ M$ as an acceptor.
First fix a non-empty subset $ F\subseteq S$ and fix a non-empty subset $ A\subseteq \Delta^*$. Then $ (M,F,A)$ is called an acceptor. $ F$ is the set of final or accepting states. A string $ a\in \Sigma^*$ is said to be accepted by $ (M,F,A)$ if $ \delta(s,a)\in F$ and $ \lambda(s,a)\in A$ for some state $ s\in S$. The set of all strings accepted by $ (M,F,A)$ is denoted by $ L(M,F,A)$.

A typical example of an acceptor is an automaton: a state machine where the output alphabet and the output function are not essential ($ \Delta^*$ may be taken as a singleton).

$ M$ as a generator.
On the other hand, if we fix a non-empty $ I\subseteq S$ and a non-empty $ G\subseteq \Sigma^*$, then $ (M,I,G)$ is a generator. $ I$ is the set of initial or starting states. A string $ b\in \Delta^*$ is said to be generated by $ (M,I,G)$ if there $ b\in \lambda(s,a)$ for some $ s\in I$ and some $ a\in G$. The set of all strings generated by $ (M,I,G)$ is also denoted by $ L(M,I,G)$.

A typical example of a generator is a Post system: a state machine where the output alphabet is the input alphabet, and the set of states and the state function is suppressed ($ S$ may be taken as a singleton).

Bibliography

1
S. Ginsburg, An Introduction to Mathematical Machine Theory, Addision-Wesley, (1962).
2
M. Arbib, Algebraic Theory of Machines, Languages, and Semigroups, Academic Press (1968).



"state machine" is owned by CWoo.
(view preamble)

View style:

Other names:  machine
Also defines:  complete machine, sequential machine, complete sequential machine, incomplete sequential machine, Mealy machine, Moore machine

Attachments:
automaton (Definition) by CWoo
Log in to rate this entry.
(view current ratings)

Cross-references: Post system, generated by, subset, fix, generator, acceptor, language, alphabet, semiautomaton, strings, automaton, type, finite, singletons, incomplete, complete, empty sets, sizes, restrictions, current, configuration, transition function, powerset, state, structure, inner, function
There are 30 references to this entry.

This is version 12 of state machine, born on 2008-01-31, modified 2008-02-16.
Object id is 10231, canonical name is StateMachine.
Accessed 1090 times total.

Classification:
AMS MSC: 68Q45 (Computer science :: Theory of computing :: Formal languages and automata)
 03D05 (Mathematical logic and foundations :: Computability and recursion theory :: Automata and formal grammars in connection with logical questions)
Pending Errata and Addenda
None.
Discussion
Style: Expand: Order:
forum policy

No messages.

Interact
post | correct | update request | add derivation | add example | add (any)