Re: Two dozen people were simply wrong --- Try to prove otherwise

On 5/30/24 9:54 PM, olcott wrote:

On 5/30/2024 8:37 PM, Richard Damon wrote:

On 5/30/24 9:31 AM, olcott wrote:

On 5/30/2024 2:40 AM, Mikko wrote:

On 2024-05-30 01:15:21 +0000, olcott said:

 

x <is> a finite string Turing machine description that SPECIFIES behavior. The term: "representing" is inaccurate.

>
No, x is a description of the Turing machine that specifies the behaviour
that H is required to report.

>
That is what I said.

>
Note, the string doesn't DIRECTLY specify behavior, but only indirectly as a description/representation of the Turing Mach
>

 The string directly SPECIFIES behavior to a UTM or to
any TM based on a UTM.

By telling that UTM information about the state-transition table of the machine.
Note, the description of the machine doesn't depend on the input given to it, so it needs to fully specify how to recreate the behavior of the machine for ALL inputs (an infinite number of them) in a finite string.

 

>

The maning of x is that there is a universal
Turing machine that, when given x and y, simulates what the described
Turing machine does when given y.

>
Yes that is also correct.

>
>
>

>
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
When embedded_H is a UTM then it never halts.

>
But it isn't unless H is also a UTM, and then H never returns.
>
You like to keep returning to that deception.
>

>
When embedded_H is a simulating halt decider then its correctly
simulated input never reaches its own simulated final state of
⟨Ĥ.qn⟩ and halts. H itself does halt and correctly rejects its
input as non-halting.

>
Except that isn't what the question is, the question is what the actual behavior of the machine described, or equivalently, the simulation by a REAL UTM (one that never stops till done).

 When embedded_H is a real UTM then Ĥ ⟨Ĥ⟩ never stops and embedded_H is
not a decider.

Right, that is YOUR delema. You can't make H / embedded_H a UTM without making it not a decider, thus "Correct Simulation by H" can't be the answer, since H can't do both.

 When embedded_H is based on a real UTM then ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated
by embedded_H never reaches its own simulated final state of ⟨Ĥ.qn⟩ in
any finite number of steps and after these finite steps embedded_H
halts.

Then its simulation isn't "correct" per the definitions that relate simulation to behavior.

 *I am going to stop here and not respond to anything else*
*that you say until AFTER this one point is fully resolved*
 

And you need to understand that if you change the UTM to abort its simulation, it is no longer a UTM and has lost that property that its simulation reveals the behavior of the input.