Automata theory
From Academic Kids

Automata theory is a field of computer science which studies finite state machines, by means of mathematical representations of them (automata, Turing machines). Below you will find a brief reference on how general automata are constructed and how they "work". Turing machines are explained in their own Wikipedia page, so no need to repeat here.
Contents 
Tools of the trade
Let us first define a few concepts to make our lives easier afterwards:
 Symbol
 Think of a letter. Think because it need not be a letter. It may be any symbol, as long as it is a single thing (no words here yet), and can be distinguished from other symbols.
 Word
 A finite string formed by the concatenation of a number of symbols.
 Alphabet
 A finite set of symbols.
 Language
 A set of words, formed by symbols in a given alphabet. May or may not be infinite .
Automata
Basic description
As said before, an automaton is a mathematical model for a finite state machine (FSM). An FSM is a machine that, given an input, jumps through a series of states according to a transition function (which can be expressed as a table). In the common "Mealy" variety of FSMs, this transition function tells the automaton which state to go next given a current state and a current symbol. The input is read symbol by symbol, until it is consumed completely (think of it as a tape with a word written on it, that is read by a reading head of the automaton; the head moves forward over the tape, reading one symbol at a time). Once the input is depleted, the automaton is said to have stopped. Depending on the state in which the automaton stops, it's said that the automaton either accepts or rejects the input. If it landed in an accept state, then the automaton accepts the word. If, on the other hand, it lands on a nonaccept state, the word is rejected. The set of all the words accepted by an automaton is called the language accepted by the automaton.
A little more formal description
Formally, an automaton is represented by the 5tuple <math>\langle Q, \Sigma, \delta, S_0, F\rangle<math>, where:
 Q is a finite set of states.
 ∑ is a finite set of symbols, that we will call the alphabet of the language the automaton accepts.
 δ is the transition function, that is
 This function can be extended so that instead of taking just one symbol of the alphabet, it receives a string of symbols, and returns the state in which the automaton will stay after processing the input. This can be rewritten as
 ...where ∑^{*} is the Kleene Closure of ∑.
 S_{0} is the start state, that is, the state in which the automaton is when no input has been processed yet (Obviously, S_{0}∈ Q).
 F is a set of states of Q (i.e. F⊂Q), called accept states.
With all this, we can now say that the language <math>L<math> accepted by an DFA automaton (see below. The definition of δ is a little more complex for NFA's)<math>M=\langle Q, \Sigma, \delta, S_0, F\rangle<math> is:
Types of automata
The following are three kinds of finite automata
 Deterministic Finite Automata (DFA)
 Each state of an automaton of this kind has a transition for every symbol in the alphabet.
 Nondeterministic Finite Automata (NFA)
 States of an automaton of this kind may or may not have a transition for each symbol in the alphabet, or can even have multiple transitions for a symbol. The automaton accepts a word if there exists at least one path from S_{0} to a state in F labeled with the input word. If a transition is undefined, so that the automaton knows not how to keep on reading the input, the word is rejected.
 Nondeterministic Finite Automata, with ε transitions (FNDε or εNFA)
 Besides of being able to jump to more (or none) states with any symbol, these can jump on no symbol at all. This is, if a state has transitions labeled with <math>\epsilon<math>, then the NFA can be in any of the states reached by the <math>\epsilon<math>transitions, directly or through other states with <math>\epsilon<math>transitions. The set of states that can be reached by this method from a state q, is called the <math>\epsilon<math>closure of q.
It can be shown, though, that all these automata can accept the same languages. You can always construct a DFA M that accepts the same language that a NFA M'.
Extensions of finite automata
The family of languages accepted by the abovedescribed automata is called the family of regular languages. More powerful automata can accept more complicated languages. Such automata include
 Pushdown automata (PDA)
 Such machines are identical to DFAs (or NFAs), except that they additionally carry memory in the form of a stack. The transition function <math>\delta<math> will now also depend on the symbol(s) on top of the stack, and will specify how the stack is to be changed at each transition. PDAs accept contextfree languages.
 Turing machines
 These are the most powerful computational machines. They possess an infinite memory in the form of a tape, and a head which can read and change the tape, and move in either direction along the tape. Turing machines are equivalent to algorithms, and are the theoretical basis for modern computers. Turing machines accept transformational languages.
 Linear Bounded Automata (LBA)
 An LBA is a limited Turing machine; instead of an infinite tape, the tape has an amount of space proportional to the size of the input string. LBAs accept contextsensitive languages.
References
John E. Hopcroft, Rajeev Motwani, Jeffrey D. Ullman  Introduction to Automata Theory, Languages, and Computation (2nd Edition)de:Automatentheorie he:תורת האוטומטים sk:Teria automatov