We define computation by formally specifying how one configuration \(C = (q, p, w)\) transitions to the next configuration \(C' = (q', p', w')\).

We say \(C\) yields \(C'\) (writing \(C \to C'\)) when \(M\) can legally go from \(C\) to \(C'\) in one step: \[ \delta(q, w[p]) = (\fragment{q'}, \fragment{w'[p]}, \fragment{m}) \hspace{5em} \]

• \(p' = \max(1, p + m)\)
  (Move tape head according to \(m\) but don’t go off the left end.)
• \(w[i] = w'[i]\) for all \(i \ne p\)
  (Leave all other tape cells unchanged.)

A configuration \((q, p, w)\) is called:
accepting if \(q = q_a\), rejecting if \(q = q_r\), halting if \(q \in \{q_a, q_r\}\).

\(M\) accepts/rejects input \(w \in \Sigma^*\) if there is a finite sequence of configurations \(C_1, C_2, \ldots, C_k\) such that:

1. \(C_1 = (\fragment{s}, \fragment{1}, \fragment{w \string{⎵}^\infty})\)
2. \(C_i \to C_{i+1}\) for all \(1 \leq i < k\)
3. \(C_k\) is accepting/rejecting

If \(M\) neither accepts nor rejects \(w\), we say \(M\) loops (does not halt) on \(w\).

• Use multiple tapes (one for input and the other for scratch space).
• Use a two-way infinite tape (instead of one-way infinite).
• Use multiple tape heads on a single tape.
• Use a “2D tape” (i.e., an unbounded grid of cells in the 2D plane), a model of “scratch paper”.
• Use random-access memory (allow \(M\) read/write access to an auxiliary “address tape;” teleport the main tape head to addresses as they are read).

• Each tape has its own independent read/write head.

• The input is loaded onto the first tape, and the other tapes start blank.

• Its transition function has the signature: \[ \delta: \fragment{(Q \setminus \{q_a, q_r\}) \times} \fragment{\Gamma^k} \to \fragment{Q} \fragment{\times \Gamma^k} \fragment{\times \{L, R, S\}^k} \]

  \[ \fragment{ \delta(q, a_1, \ldots, a_k) = (q', b_1, \ldots, b_k, m_1, \ldots, m_k) } \]

In order to define \(S\), we have to describe how it:

1. Encodes any configuration \(C_M\) of \(M\) as a configuration \(C_S\) of \(S\).
2. Initially sets up its tape to simulate \(M\) (i.e., gets to the configuration encoding \(M\)’s initial configuration).
3. Moves from \(C_S\) to a new configuration representing \(C'_M\) when \(C_M \to C'_M\).

• Graphically: replace \(a \in \Gamma\) with \(\markedCharacter{a}\) (e.g., \(\markedCharacter{\string{x}}, \markedCharacter{\string{0}}, \markedCharacter{\#}\)).
• Formally: we can represent marked/unmarked characters as tuples in \(\Gamma \cross \{\circ, \bullet\}\) (e.g., \((\string{x}, \circ)\) and \((\string{x}, \bullet)\)).

• Sipser’s approach: concatenate the tape contents with \(\#\) delimiters
  marking their starts and ends (assuming \(\# \notin \Gamma\)). \[ \# w_1 \# w_2 \# \cdots \# w_k \# \]
• Our approach: form “compound symbols” to represent the characters at the same cell of each tape.
  • Graphically: a single smushed-together symbol like \(\string{b} \markedCharacter{\string{0}} \string{x}\) to represent three tapes with respective symbols \(\string{b}, \string{0}, \string{x}\).
  • Formally: an element of \((\Gamma \cross \{\circ, \bullet\})^k\)

• Sipser: \(\# \markedCharacter{x_1} x_2 \cdots x_n \# \markedCharacter{⎵} \# \cdots \# \markedCharacter{⎵} \#\).
  1. Write \(\# \markedCharacter{x_1}\).
  2. Copy the rest of the input from \(x\) with no markers.
  3. Write \(k - 1\) copies of \(\# \markedCharacter{⎵}\), followed by a final \(\#\).
• Ours: \(\markedCharacter{x_1}\markedCharacter{⎵}^{k - 1}\; x_2{⎵}^{k - 1} \; \cdots \; x_n{⎵}^{k - 1}\)
  • Write \(\markedCharacter{x_1}\markedCharacter{⎵}^{k - 1}\)
  • For each remaining character, write \(x_1⎵^{k - 1}\)

• Scan through the tape until all \(k\) markers are found, and remember the symbols under them.
  This is a finite amount of information: \((a_1, \cdots, a_k) \in \Gamma^k\))
• \(M\)’s transition function can now be consulted \(\delta(q, a_1, \cdots, a_k)\).
• Do another pass through the tape the beginning, writing the appropriate symbols around each marked character to update the character and move the marker.

• Move-right-or-reset: the tape head can only move right or reset to the leftmost position.
• Use two stacks instead of a tape.
  (But using just one stack reduces the power to a DPDA, incapable of deciding even certain CFLs
• One queue
• Three counters: three integers that we can increment, decrement, and check if they hit zero
  (But using one counter is equivalent to a unary single-stack machine,
  which can decide \(\setbuild{0^n 1^n}{n \in \mathbb{N}}\) but not \(\setbuild{w = \reverse{w}}{w \in \binary^*}\))

Consider the problem of comparing two strings \(x\) and \(y\) to see if they are equal.

This is trivial to do in code:

def compare(x, y):
    if len(x) != len(y):
        return False
    for i in range(len(x)):
        if x[i] != y[i]:
            return False
    return True

and it’s easy to count the number of “operations” run.

How can we do this with a Turing machine?

• Decision problem: check if \(x \# y\) is in the language \(L = \setbuild{w \# w}{w \in \Sigma^*}\).
• The Turing machine would need to:
  1. Zig-zag across the tape to corresponding cells on each side of the \(\#\).
     • If the symbols mismatch, reject.
     • If they match, cross them off by writing \(\string{x}\) symbols.
  2. When all symbols to the left of \(\#\) are crossed off, accept if remaining symbols are all \(\#\) or \(\string{x}\); reject otherwise.

• Node and edge lists: \(\encoding{G} = \fragment{(1,2,3,4)}\fragment{((1,2),(2,3),(3,1),(1,4))}\)

  We use \(\encoding{O}\) to denote the encoding of an object \(O\) as a string in \(\binary^*\). We can encode multiple objects with \(\encoding{(O_1, O_2, \ldots, O_k)}\) or just \(\encoding{O_1, O_2, \ldots, O_k}\).

• Adjacency matrix: \[ \fragment{\begin{bmatrix} 0 & 1 & 1 & 1 \\ 1 & 0 & 1 & 0 \\ 1 & 1 & 0 & 0 \\ 1 & 0 & 0 & 0 \\ \end{bmatrix}} \fragment{\quad \Longrightarrow \quad \encoding{G} = } \fragment{0111101011001000} \hspace{15em} \]

  How can we determine the number of nodes?
  (labels don’t matter).

• What is the size of the adjacency matrix representation for a graph with \(n\) nodes? \(n^2\)
• What about the node+edge list representation for a graph with \(n\) nodes and \(m\) edges?
  Proportional to \(n + m\). For sparse graphs \(m \ll n^2\)…
• This sort of difference is a big deal, e.g., in high-performance computing.