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 its 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 (Sec 1)

Which of the following is true?

1. There is an LBA that decides `E_{TM}`.
2. We gave a quadratic time decision procedure for Post Correspondence Problem.
3. `ALL_{CFG}` is undecidable.

Quiz (Sec 3)

Which of the following is true?

1. The language consisting of encodings of TMs which accept only unary strings over `{0,1}` is undecidable via Rice's Theorem.
2. `E_{CFG}` is undecidable.
3. PCP is decidable by an LBA.

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`."