Re: Working out the details of the steps of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn

On 3/8/2024 11:43 PM, Richard Damon wrote:

On 3/8/24 9:10 PM, olcott wrote:

On 3/8/2024 10:58 PM, Richard Damon wrote:

On 3/8/24 8:45 PM, olcott wrote:

On 3/8/2024 10:33 PM, Richard Damon wrote:

On 3/8/24 8:20 PM, olcott wrote:

On 3/8/2024 9:41 PM, Richard Damon wrote:

On 3/8/24 7:06 PM, olcott wrote:

Ĥ.H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to Ĥ.Hqn
therefore
H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to H.qy
>
I still don't know the detailed steps of how
H computes the mapping from ⟨H⟩ ⟨H⟩ <H> to H.qy
YET WE CAN SEE THAT IT IS CORRECT

>
No, you see that you have a set of results that makes

>
Every H needs a criteria to use whether it is contradicted
or not. When it is not contradicted this same criteria
correctly decides halting for its input.
>
When H is contradicted it provides a consistent way
that H can provide the wrong answer.

>
But if you admit that it will get a wrong answer, how can you claim it is a correct Halt Decider, which means it always gets the Right answer.
>

>
When the input data gets the wrong answer this allows the
actual decider to get the right answer.

>
But the algorith at H^.H IS an instanc eof the decide,r, and must get the answer right.
>
You are just admitting to being a STUPID LIAR.

>
>
You are the one that does not understand that making changes to
a machine to so it will not work properly does make this machine
not work properly.

 What CHANGES have I been saying to make?
 

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.

YOU need to define the details of the Algorithm that you will call H.
 You have full control over it, it just nedds to be actual Turing Machine code, or code that is ACTUAL the equivalent of a Turing Machine.
 That means it is defined by what steps it does, and how it does it. NOT "get such-and-such an answer".
 These are fixed deterministic steps.
 Once you do that, the Linz proof defines how to built the machine H^ by its SEMANTIC DEFINITION of H^ adjusts the tape so it can use an exact copy of the algorithm of the H it is to confound, with exactly the same inputs as that will have when answering about this H^ applied to its input.
 We can the run your H with the description of that H^, and see what it predicts H^ (H^) will do.
 We can also then run that H^ (H^) and see what it does.
 Because of the requirement that H be a computation, then the copy of H at H^.H since it is given the exact same input as when we ran it earlier, must give the exact same answer as it did above.
 We can then compare the results of what H said its input would do to what the input actually did. If they match, it passed that test.
 If they differ, H was proven to not be a correct Halt Decider.
 Nowhere did we make "changes" to any machine to make it not work properly. The algorithm you provided for H was exactly used to make H, and to be put at H^.H.
 Remember, Machines are DEFINED by the algorithm they were defined with, NOT the specification or requirements that algorithm was supposed to meet. It is the creater of the Algorithms job to meet that, and the algorithm will either acheive of fail at meeting the reqquirements.
 

>

>

You are just admitting that you are lying about refuting the proof that we can not make an always correct Halt Decider.
>
You don't get to claim to be right, when the machine gives the wrong answer.
>

>
You already know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must be aborted by Ĥ.H
or it will never halt.
>
When every H has the same way to say that, then when it is
contradicted it has something to say and when it is not
contradicted this is the correct halt status of its input.
>

>
No, if ANY copy of H gives the wrong answer to some input, then H is not a Halt Decider.

>
When the input data gets the wrong answer this allows the
actual decider to get the right answer.

>
And thus you admit that H is WRONG, as all copies of it are the ACTUAL DECIDER.
>

>
I never said anything like that. I say that Ĥ.H and you twist
this to man that I said H was wrong.

 Because the code at H^.H *IS* an instance of H.
 

H ⟨Ĥ⟩ ⟨Ĥ⟩ is not contradicted is not the same one
that is contradicted Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩

If it isn't, then you have been lying and I can't help you.
 

>

That is the nature of a Computation.
>
ANY instance of the algorithm applied to its input must get the same answer for the same data and to be correct must match the mapping that it is supposed to derive.
>

>
*Every H reports whether its input halts from its POV*

 It might HAVE to do that, but to meet its requirements it needs to answer about the FACTUAL behavior of the computation its input defines.

The one that is contradicted Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets right answer from its POV
which is the wrong answer for the behavior of Ĥ ⟨Ĥ⟩.
The one that is not contradicted H ⟨Ĥ⟩ ⟨Ĥ⟩ get right answer from its POV
which is the also the right answer for the behavior of Ĥ ⟨Ĥ⟩.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer