Outline

• Ways of Building Bigger Machines
• Quiz
• More JFLAP
• Church-Turing Thesis

Formal Definition of Turing Machine

• Last Wednesday, we introduced Turing Machines informally, watched a little video about them, and said that they were going to serve as our abstract model for a general computer.
• Today, we begin by introducing this model formally, and then try to argue that TMs are actual capable of quite general computations, while still being simple enough to prove things about.
• A Turing Machine (TM)s a 6-tuple `(Q, Sigma, Gamma, delta, q_0, H)` where
  1. `Q` is a finite set of states
  2. `Sigma subseteq Gamma` are respectively the input and tape alphabets. `Gamma` contains a space symbol '`\square`' not in `Sigma`.
  3. `delta:Q times Gamma -> Q times Gamma times {L, R}` is the transition function. (JFLAP allows L,R,S where S is stay put).
  4. `q_0 in Q` is the start state.
  5. `H subseteq Q` is the set of Halting states of the machine
• A TM receives its input `w=w_1w_2 ldots w_n` on the `n` squares of its tape under and to the right of the tape head. The input is not allowed to contain blanks. The tape has arbitrarily many tape square to the right and to the left of the starting tape head location. Except for the input, the rest of the tape squares have the blank symbol. Once `M` starts, it follows the rules prescribed by the transition function. A rule `(q,a)->(q',b, L)` says in state `q` reading an `a` go to state `q'`, write a `b` in the current square then move the tape head left. `(q,a) ->(q',b, R)` would say the same thing except moves the tape head right. Computation continues until the machine enters a halt state.

Diagrams and Examples

• As you can see above, there is a diagrammatic notation for Turing Machines similar to that for PDA and DFAs.
• The states are drawn as circles; two concentric circles indicates a halt state (the book calls these final states).
• Each transition is labeled with a triple `mbox(x;y, D)`; where `x` is supposed to be the symbol being read, `y` is the symbol to write, and `D` is the direction to move.
• For example, the above machine when started on a string over the alphabet `{a,b}` converts it to a string of the same length consisting of only `b`'s, then stops on the rightmost character of the output string.

Configurations, Yields

• To specify the state of a computation at a given time (i.e., a configuration) one needs to specify the tape contents, the head position, and the current state.
• To do this it suffices to consider only the non-blank squares.
• One can use the notation `u q v` to represent this information. Here `u` is a string that represents the contents of the tape to the left of the tape head, `q` is the current state and `v` is a string consisting of what is under the tape head followed by the non-blank symbols to the right of the tape head.
• For example, one might have `0011q71100`. This says the tape contents are `00111100`, the machine is in state `q7`, and it is reading the third 1 in this string.
• We say configuration `C` yields `C'` if the TM can legally go from `C` to `C'` in one step. For instance, `ua q bv` yields `u q' acv` if `delta(q,b) =(q', c, L)`.

Accept, Reject, Recognize, Decide

• The start configuration of `M` on input `w` is the configuration `q_0 w`.
• An accepting configuration is one in which the state of the configuration is `q_mbox(accept)`, where `q_mbox(accept)` is some state in `H`.
• A rejecting configuration is one in which the state of the configuration is `q_mbox(reject)` where `q_mbox(reject)` is some state in `H`.
• A Turing machine `M` accepts `w` if a there is a sequence of configurations `C_1, C_2,ldots , C_k` such that `C_1` is the start configuration of `M` on `w`; for `i` between `1` and `k-1`, `C_i` yields `C_(i+1)` and `C_k` is an accept configuration.
• The collection of strings `M` accepts is denoted `L(M)` and is called the language recognized by `M`.
• A language is Turing-recognizable if some TM recognizes it.
• A language is called decidable if there is some TM that halts on all inputs and that recognizes the language.

Transducers

• We now have defined it means for a TM to recognize and to decide a language.
• Another useful thing that we can do with a Turing Machine is to compute functions. We call these kinds of TMs tranducers.
• For example, we might need to compute a function to convert the problem of deciding membership for one language into the problem of deciding membership in another language.
• We say a function `f` with domain `D` is computable, if there is some TM `M` which when started on inputs `w` from `D`, halts with `f(w)` on the tape.
• We next describe a TM which on `w` computes `w square w`. The book shows how to do several languages which we showed couldn't be done on a PDA.

Ways of Building Larger Turing Machines

• We now turn our attention to how to build larger Turing Machines from little Turing Machines.
• You can think of this process as very much like building larger and larger functions starting with little functions.

A Simple Turing Machine

• The transition function is the most important part of a TM's description.
• We will sometimes use a graphical notation to describe TM's and in particular this function.
• Given `a in Sigma` define a machine `M_a ={{s,h}, Sigma, Sigma\cup{ square }, delta, s, {h}}`, where for each `b in Sigma\cup{ square }`, `delta(s,b) = (h, a, R)`.
• That is, if `a` is a symbol, the only thing `M_a` does is write that symbol, move right, and halt.
• Similarly, for `a` either `L` or `R` we can build a machine such that the only thing `M_a` does is either move one square left or right.

Building Bigger TMs

• Given three TMs with a common alphabet: `M`, `N`, `P`, we can build a new machine `M'` which operates as follows:
  • Start in the initial state of `M`; operate as `M` until `M` would halt, then
  • If the currently scanned symbol is a `b`, start `N`
  • If the currently scanned symbol is an `a`, start `P`.
  • Halt otherwise.
• Diagrammatically we write:
  
• As an exercise you should work out what `M'`'s transition function would look like.
• This shows TMs can do if-then-else statements
• If one of `N` or `P` was instead a loopback to `M` we would have a while- loop. Hence, it should become clear we are starting to be able to simulate many programming language constructs.

More on Diagrams

• Similar to the if-else type diagram of the last slide we can have diagrams like:
  `M -> N`
• Notice there is no label on the arrow. This means that if machine M is about to transition to its halt state `h` we instead have it transition to the start state of `N`.
• We can also generalize the two branch construction of the previous slide to any fixed finite number of branches. This would allow us to simulate switch-case like commands.

Examples

• We sometimes abbreviate `M_R` as `R` and `M_a` as `a`. We might also make abbreviations like `Ra` for the machine which does `M_R`, then reading any symbol writes an `a`. Similarly, we might have `\R\R` or `La`.
• Let `mbox{!=}a` denote all the symbols in `Sigma` except `a`.
• Here is a machine `R_\square` that scans right to the first space:
  
• Here is a machine `L_\square` that scans left to the first space:
  

More Examples

Here is a machine which when started with a string `w` on the tape halts with `w\square w` on the tape.

• In the above, `a` is some symbol of the tape alphabet. Each place we use it though we mean the same alphabet symbol.
• The loop back to R is somewhat awkwardly drawn, we do all of `\square(R_square)^2a(L_square)^2a` before looping.
• Suppose the input was `bcd`. Here are some of the significant tape configurations:

  `q_{mbox{start}}bcd`
  `q_{mbox{done L rewind}}\square bcd`
  `\square q_{mbox{done R}}bcd`
  `\square q_{mbox{read }b mbox{ wrote space}} cd`
  `\square \square cd \square q_{mbox{right two spaces wrote b}} b`
  `\square q_{mbox{left two spaces wrote b}}bcd \square b`
  `\square b q_{mbox{done R}}cd \square b`
  `\square b q_{mbox{read }c mbox{ wrote space}}\square d \square b`
  `\square b \square d \square b q_{mbox{right two spaces wrote c}}c`
  `\square b q_{mbox{left two spaces wrote c}}c d \square b c`
  `\square b c q_{mbox{read }d mbox{ wrote space}} \square \square b c`
  `\square b c\square \square b c q_{mbox{right two spaces wrote d}}d `
  `\square b cq_{mbox{left two spaces wrote d}} d \square b c d `
  `\square b c d q_{mbox{done R}} \square b c d `
  `\square b c d \square b c d q_{mbox{done advance right space and halted}} \square`
  

Quiz

Which of the following is true?

1. To prove the CFL pumping lemma we used the PDA characterization of CFLs.
2. Sequitur would compress the string abcdefg as Rabcdefg.
3. The Context Free Languages are closed under intersection.

JFLAP

• JFLAP supports building larger machines out of smaller machines.
• If one clicks on the Turing Machine button in JFLAP, one can start building a Turing Machine.
• The two rightmost buttons:
  
  Allow one to respectively import Turing Machines you've already created as building blocks, and allow you to set up transitions between Turing Machines.

JFLAP Example

• For example, earlier today we built a machine in JFLAP that converts strings over `a`'s and `b`'s into one over just `b`'s.
• It finishes with the tape head on the rightmost symbol.
• We can combine this machine with a machine to "rewind the tape" to finish with the tape head on the leftmost symbol:
  

The Church-Turing Thesis

• This thesis is that any computational process that can be effectively carried out on a real-world computational device can be simulated by a Turing Machine.
• It was first called "Church's Thesis" by Kleene, "Recursive Predicates and Quantifiers," Trans. of the AMS. Vol. 53. No. 1. 1943.
• Since you can always come up with new computational devices, it is not something you can prove.
• However, so far no one since it was proposed in the 1940s has come up with a model which is both physically implementable which cannot be simulated by a Turing Machine.
• Over the next week, we will look at some of the models that have been considered.
• These include: multi-tape variants of Turing Machines, multi-stack PDAs, RAMs (computers with machine code instructions), cellular automata, lambda calculus (based on functional programming approaches like in LISP or scheme), rewrite systems, classical and quantum physics based processes which are measured to fixed, finite precision, etc.