Outline

• Programs that Print Themselves
• Recursion Theorem
• Quiz
• Applications

Machines that Print Themselves

• One interesting property of living things is that they can reproduce -- that is, they can produce exact copies of themselves.
• Can machines do this? As a first step:
  Lemma. There is a computable function `q:Sigma^star -> Sigma^star` , where if `w` is any string then `q(w)` is the description of a Turing Machine `P_w` that prints out `w` and then halts.
  Proof.
  `Q = ` "On input `w`:
  1. Construct the following TM `P_w`.
     `P_w =` "On any input:`
     1. Erase the input.
     2. Write `w` on the tape.
     3. Halt."
  2. Output `langle P_w rangle`."

`mbox{SELF}`

• Using `q` of the last slide, we next describe a machine `mbox{SELF}` which ignores its own input and prints it TM description to the output.
• `mbox{SELF}` consists of two parts `A` and `B`. `A` runs first and then passes control to `B`. `A` is the machine `P_{langle B rangle}` where `B` is:
  "On input `langle M rangle`, where `M` is a portion of a TM:
  1. Compute `q(langle M rangle)`.
  2. Combine the result with `langle M rangle` to make a complete TM.
  3. Print the description of this TM and halt.
• So once `A` is done the tape has `langle B rangle` on it.
• `B` then computes `q(langle B rangle ) = langle P_{langle B rangle} rangle = langle A rangle` and concatenates `langle B rangle ` with some extra states to make this into a whole machine. This give `langle AB rangle = langle mbox{SELF} rangle` back.
• One way to see this construction works is to consider the following English sentence:

  Print the next phrase in quotes twice the second time in quotes: "Print the next phrase in quotes twice the second time in quotes:"

  `B` is like the phrase: Print the next phrase in quotes twice the second time in quotes:; `A` is the phrase with quotes around it.

The Recursion Theorem (Kleene, 1938)

We can generalize the above argument to allow machines to compute with their own descriptions

Theorem. Let `T` be a TM that computes a function `t:Sigma^star times Sigma^star -> Sigma^star`. There is a Turing machine `R` that computes a function `r: Sigma^star -> Sigma^star`, where for every `w`, `r(w) = t(langle R rangle, w)`.

Proof. The proof is like the construction of `mbox{SELF}` except now we have the machine `T` besides `A` and `B`, and `R` will be a combined machine `ABT`. In the current construction `A=P'_{langle BT rangle}`. Here `P'_{langle BT rangle}` is like `P_{langle BT rangle}` except that it prints `langle BT rangle` after the input and a `#`. We design a `q'` so it looks for a `#`, sees the string `v` that follows it and, and appends `langle P'_{langle v rangle}rangle` to the input. So after `A` runs the tape has `w#langle BT rangle` on it. Now `B` applies `q'` to the output of `A` to get `w#langle BT rangle langle P'_{langle BT rangle} rangle = w#langle BT rangle langle A rangle`, and then reformats this as `langle langle ABT rangle, w rangle`. It then starts `T`. So we have `langle R rangle = langle ABT rangle`.

Quiz

Which of the following is true?

1. Unlike for LBAs, every question one could ask about CFGs is decidable.
2. In the Post Correspondence Problem, the string on the top of a domino is always the same length as the string on the bottom of a domino.
3. Rice's Theorem can be used to show undecidability results.

Applications of the Recursion Theorem

• The recursion theorem allows one to design TM subroutines of the form "obtain your own description".
• For instance, `mbox{SELF}` could be rewritten as:
  `mbox{SELF}=` "On any input:
  1. Obtain, via the recursion theorem, own description `langle mbox{SELF} rangle`.
  2. Print `langle mbox{SELF} rangle`."
• The obtain your own description statement is implemented by first writing the machine:
  `T=` "On any input `langle M, w rangle`:
  1. Print `langle M rangle` and halt."
  Then the recursion theorem says how to get a machine `R` which on input `w` acts like `T` on input `langle R, w rangle`.

More Applications

• We can use the recursion theorem to give an alternative proof that `A_{TM}` is undecidable:
  First, suppose `A_{TM}` were decidable by machine `H`. Then consider the machine `B`:
  `B=` "On input `w`:
  1. Obtain, via the recursion theorem, own description `langle B rangle`.
  2. Run `H` on `langle B, w rangle `.
  3. Do the opposite of what `H` does."
• So running `B` on input `w` does the opposite of what `H` on `langle B, w rangle` does. So `H` can't decide `A_{TM}`.

The Fixed-Point Theorem

A fixed point of a function `f` is a value `x` such that `f(x)=x`.

Theorem. Let `t: Sigma^star->Sigma^star` be a computable function. Then there is a machine `F` for which `L(t(langle F rangle)) = L(F)`. Here we are assuming that if a string isn't a proper TM, then it describes the empty language.

Proof. Consider the machine `F =` "On input `w`:

1. Obtain via the recursion theorem, own description .
2. Compute `t(langle F rangle)` to obtain a TM description `G`.
3. Simulate `G` on `w`."