Models of Computation

Models deciding regular languages:
What can be done using constant memory and a single step per input symbol?
- Finite Automata (DFA, NFA)
- Regular Grammars (RRG, LRG)
- Regular Expressions
Models deciding context-free languages:
What can be done using a NFA with access to an unbounded stack?
- Pushdown Automata (PDA) (Not covered; Section 2.2 of Sipser)
- Equivalent in power to CFGs!
Is this all we need?
Simple non-context-free languages:
\[ L_1 = \setbuild{0^n 1^n 2^n}{n \in \mathbb{N}} = \{\epsilon, 012, 001122, \ldots\}, \quad \quad \fragment{L_2 = \setbuild{w w}{w \in \binary^*}} \]
- These can be proved non-CFG-decidable using the pumping lemma for context-free languages
  (Optional Section 7.10 of lecture notes, )

While DFAs and CFGs can solve many useful problems, they are quite limited.
Source of these limitations: lacking access to arbitrary amounts of memory.
- (More precisely, pushdown automata have arbitrary memory but not arbitrary access to it. )
We now take a big leap in computational power and introduce Turing machines (TM).
- These can do anything that a real computer can!
- We will prove there are still problems that cannot be solved by TMs!
TMs are a generalization of DFAs.

This is now a Turing machine!

Turing Machine

Distinctive features of Turing machines:

They can read and write symbols on the tape.
The tape has symbols outside the input alphabet (e.g., the blank symbol “⎵”).
The read/write head can move right, left, or stay in place according to the control logic.
The tape is unbounded to the right and input starts at the leftmost cell.
- If the head moves to the right of the current rightmost cell, a new “⎵” cell is created.
- Sipser says “the tape is infinite,” but a more realistic mental model is a growable array
  (e.g., Python list, C++ std::vector, Java java.util.List).
They have exactly one accept state and one reject state
and halt immediately when either is reached.

Once we gain intuition for TMs,
we can describe the machine solving
a given problem at a high-level while still being precise.
Example: design a TM to decide: \[ P = \setbuild{w \in \{0, 1\}^*}{w = \reverse{w}} \]
The TM will:
1. “Zig-zag” back and forth between the left and right ends of the input, checking if the leftmost symbol equals the rightmost symbol. If not, reject immediately.
2. “Cross off” symbols as they are checked by overwriting them with an \(\string{x}\) symbol.
3. Continue until the entire input is crossed off, at which point the TM accepts.

\[ P = \setbuild{w \in \{0, 1\}^*}{w = \reverse{w}} \]

“Zig-zag” back and forth between the left and right ends of the input, checking if the leftmost symbol equals the rightmost symbol.
If not, reject immediately.
“Cross off” symbols as they are checked by overwriting them with an \(\string{x}\) symbol.
Continue until the entire input is crossed off, at which point the TM accepts.

A Turing machine (TM) is a 7-tuple: \(M = (Q, \Sigma, \Gamma, \delta, s, q_a, q_r)\) where:

\(Q\) is a finite set of states.
\(\Sigma\) is a finite set of input symbols (the input alphabet).
\(\Gamma\) is a finite set of tape symbols (the tape alphabet) with:
\(\Sigma \subsetneq \Gamma\) and blank symbol ⎵ \(\in \Gamma \setminus \Sigma\).
\(s \in Q\) is the start state.
\(q_a \in Q\) is the accept state.
\(q_r \in Q\) is the reject state, where \(q_r \ne q_a\).
\(\delta: \fragment{(Q \fragment{\setminus \{q_a, q_r\}}) \times \Gamma} \to \fragment{Q \times \fragment{\Gamma \times} \fragment{\{L, R, S\}}}\) is the transition function
\(L\) = move left, \(R\) = move right, \(S\) = stay in place.

\[ P = \setbuild{w \in \{0, 1\}^*}{w = \reverse{w}} \]

\(M = (Q, \Sigma, \Gamma, \delta, s, q_a, q_r)\) where:

\(Q = \{s, r_{00}, r_{11}, r_{01}, r_{10}, \string{lx}, \string{l}, q_A, q_R\}\)
\(\Sigma = \{0, 1\}\)
\(\Gamma = \{0, 1, \string{x}, ⎵\}\)
\(s\) is the start state, \(q_A\) is the accept state,
and \(q_R\) is the reject state
\(\delta\) is defined by the arrows in the diagram…