Re: A simulating halt decider applied to the The Peter Linz Turing Machine description ⟨Ĥ⟩

On 5/26/24 10:43 PM, olcott wrote:

On 5/26/2024 9:06 PM, olcott wrote:

When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
  Ĥ copies its own Turing machine description: ⟨Ĥ⟩
  then invokes embedded_H that simulates ⟨Ĥ⟩ with ⟨Ĥ⟩ as input.
>
It is an easily verified fact that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by
embedded_H cannot possibly reach its own simulated final state of
⟨Ĥ.qn⟩ in any finite sequence of steps.

 *To other reviewers that are not dishonest*
The complete proof of the above statement is that when we hypothesize
that embedded_H is a UTM we can see that:

i.e. when we assume it is something it isn't, i.e we LIE to ourselves.
If you assume embedded_H is something it isn't, and in doing so change the contents of the input (which actually reference the embedded_H that actually is, not the hypothetical) you are just lying.
Now, if you want to look at the case where H and embedded_H are ACTUALLY UTMs, we can do this, and see that H will never answer and thus fails to be a decider.

 ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by UTM embedded_H cannot possibly reach its
own simulated final state of ⟨Ĥ.qn⟩ in an infinite number of steps.
 This conclusively proves that ⟨Ĥ⟩ will not reach ⟨Ĥ.qn⟩ is less than
an infinite number of steps. A decider is not allowed to simulate
an infinite number of steps.
 

Note, the CORRECT way to do that hypothetical, is to say let us assume that we give this input to a UTM, but not change the input, so it still acts as the actual H / embedded_H, and then we see that if H / embedded_H will ever decide to end its partial simulation, and go to qn, then H^ will go go H^.qn and halt, so the UTM simulation of this input will ahalt.
There is n way to actually define an input machine H^ that will change itself when we hypotosize the decider being something different and giving the input to the original machine to it.
Note, the fact that the decider doesn't get the right answer in a finite number of steps is NOT grounds for it to give the wrong answer. The problem was NEVER can H simulate the input to the final state, but ALWAYS does the machine itself get to the final state (which can by the definition of a UTM, be shown by an actual UTM simulation of the input, but NOT a 'partial simulation'). If it takes an infinite number of steps to show that the input is non-halting, then the decider is put on the spot, as it must due so, but can't, which is one cause of problems being non-computable.
Also, when we look at the actual machine, which is the actual goal of the problem refered to, we see, and Peter Olcott has agreed, that the machine H^ (H^) will go to H^.qn, despite his claim above otherwise (so he is disagreeing with himself).
Peter Olcott is just proving his total lack of understanding of the field, and is reckless disregard for the truth about it, and that he is just willing to state lies to try to prove his false thesis.