*The nature of the misconception of the halting problem*

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>if Ĥ applied to ⟨Ĥ⟩ does not halt<<<
(Linz:1990:320) adapted with clearer notational conventions.

[Linz 315-320](https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf)

We begin with the premise that the Linz H is a simulating halt decider.

H has been embedded in Ĥ at state Ĥ.qx. The H.qy path has been disabled
in Ĥ by appending an infinite loop.

The H.qn path of the original H that is embedded at Ĥ.qx is be named
[HALF OF COMPUTABLE FUNCTION H]:HOCFH

Now we get to the misconception about the halting problem:
Linz and everyone else believes that the condition of this Ĥ.qn path is
>>>if Ĥ applied to ⟨Ĥ⟩ does not halt<<< as if Ĥ was reporting on whether
or not itself halts. This is incorrect.

HOCFH does not transition to Ĥ.qn: >>>if Ĥ applied to <Ĥ> does not halt<<<

HOCFH transitions to Ĥ.qn when its simulation of <Ĥ> applied to <Ĥ>
never reaches the final state of <Ĥ> applied to <Ĥ>.

The input to HOCFH is ⟨Ĥ⟩ ⟨Ĥ⟩.
The input to HOCFH is not Ĥ ⟨Ĥ⟩.

HOCFH does not compute whether or not >>>Ĥ applied to <Ĥ> does not
halt<<< because an actual Turing machine cannot be input to any
computable function.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/16/21 10:44 AM, olcott wrote:
> *The nature of the misconception of the halting problem*
>
>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>
>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>>if Ĥ applied to ⟨Ĥ⟩ does not halt<<<
> (Linz:1990:320) adapted with clearer notational conventions.
>
> [Linz 315-320](https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf)
>
> We begin with the premise that the Linz H is a simulating halt decider.
>
> H has been embedded in Ĥ at state Ĥ.qx. The H.qy path has been disabled
> in Ĥ by appending an infinite loop.

Which doesn't 'Disable' that path, just makes it non-halting.

>
> The H.qn path of the original H that is embedded at Ĥ.qx is be named
> [HALF OF COMPUTABLE FUNCTION H]:HOCFH

No, BOTH paths are still there. Just the qy path acts by becoming
non-halting instead of giving an answer.

>
> Now we get to the misconception about the halting problem:
> Linz and everyone else believes that the condition of this Ĥ.qn path is
> >>>if Ĥ applied to ⟨Ĥ⟩ does not halt<<< as if Ĥ was reporting on whether
> or not itself halts. This is incorrect.
>
> HOCFH does not transition to Ĥ.qn: >>>if Ĥ applied to <Ĥ> does not halt<<<

But it NEEDS to if H is going to give the right answer, as H will go to
H.qn, and sin\ch

>
> HOCFH transitions to Ĥ.qn when its simulation of <Ĥ> applied to <Ĥ>
> never reaches the final state of <Ĥ> applied to <Ĥ>.

But since that means that H went to qn, and it means that H^ halted, it
shows that H was INCORRECT with its answer.

>
> The input to HOCFH is ⟨Ĥ⟩ ⟨Ĥ⟩.
> The input to HOCFH is not Ĥ ⟨Ĥ⟩.

But to H, the input of <H^> <H^> means giving it the QUESTION of what
does H^ applied to <H^> do, which is exactly H^(<H^>)

>
> HOCFH does not compute whether or not >>>Ĥ applied to <Ĥ> does not
> halt<<< because an actual Turing machine cannot be input to any
> computable function.
>

But the REPRESENTATION of one CAN be, which is why the Halting Problem
is defined the way it is.

You don't seem to understand what a representation is.

On 12/16/2021 8:07 PM, Richard Damon wrote:
>
> On 12/16/21 10:44 AM, olcott wrote:
>> *The nature of the misconception of the halting problem*
>>
>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>>
>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>  >>>if Ĥ applied to ⟨Ĥ⟩ does not halt<<<
>> (Linz:1990:320) adapted with clearer notational conventions.
>>
>> [Linz 315-320](https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf)
>>
>> We begin with the premise that the Linz H is a simulating halt decider.
>>
>> H has been embedded in Ĥ at state Ĥ.qx. The H.qy path has been
>> disabled in Ĥ by appending an infinite loop.
>
> Which doesn't 'Disable' that path, just makes it non-halting.
>
>>
>> The H.qn path of the original H that is embedded at Ĥ.qx is be named
>> [HALF OF COMPUTABLE FUNCTION H]:HOCFH
>
> No, BOTH paths are still there. Just the qy path acts by becoming
> non-halting instead of giving an answer.
>
>>
>> Now we get to the misconception about the halting problem:
>> Linz and everyone else believes that the condition of this Ĥ.qn path is
>>  >>>if Ĥ applied to ⟨Ĥ⟩ does not halt<<< as if Ĥ was reporting on whether
>> or not itself halts. This is incorrect.
>>
>> HOCFH does not transition to Ĥ.qn: >>>if Ĥ applied to <Ĥ> does not
>> halt<<<
>
> But it NEEDS to if H is going to give the right answer, as H will go to
> H.qn, and sin\ch
>
>>
>> HOCFH transitions to Ĥ.qn when its simulation of <Ĥ> applied to <Ĥ>
>> never reaches the final state of <Ĥ> applied to <Ĥ>.
>
> But since that means that H went to qn, and it means that H^ halted, it
> shows that H was INCORRECT with its answer.
>
>>
>> The input to HOCFH is ⟨Ĥ⟩ ⟨Ĥ⟩.
>> The input to HOCFH is not Ĥ ⟨Ĥ⟩.
>
> But to H, the input of <H^> <H^> means giving it the QUESTION of what
> does H^ applied to <H^> do, which is exactly H^(<H^>)
>
>>
>> HOCFH does not compute whether or not >>>Ĥ applied to <Ĥ> does not
>> halt<<< because an actual Turing machine cannot be input to any
>> computable function.
>>
>
> But the REPRESENTATION of one CAN be, which is why the Halting Problem
> is defined the way it is.
>
> You don't seem to understand what a representation is.

When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn it is not referring to
the halt status of its own computation that began at Ĥ.q0.

It is referring to the halt status of its simulated input ⟨Ĥ⟩ ⟨Ĥ⟩.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/16/21 9:17 PM, olcott wrote:
> On 12/16/2021 8:07 PM, Richard Damon wrote:
>>
>> On 12/16/21 10:44 AM, olcott wrote:
>>> *The nature of the misconception of the halting problem*
>>>
>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>>>
>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>  >>>if Ĥ applied to ⟨Ĥ⟩ does not halt<<<
>>> (Linz:1990:320) adapted with clearer notational conventions.
>>>
>>> [Linz 315-320](https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf)
>>>
>>> We begin with the premise that the Linz H is a simulating halt decider.
>>>
>>> H has been embedded in Ĥ at state Ĥ.qx. The H.qy path has been
>>> disabled in Ĥ by appending an infinite loop.
>>
>> Which doesn't 'Disable' that path, just makes it non-halting.
>>
>>>
>>> The H.qn path of the original H that is embedded at Ĥ.qx is be named
>>> [HALF OF COMPUTABLE FUNCTION H]:HOCFH
>>
>> No, BOTH paths are still there. Just the qy path acts by becoming
>> non-halting instead of giving an answer.
>>
>>>
>>> Now we get to the misconception about the halting problem:
>>> Linz and everyone else believes that the condition of this Ĥ.qn path is
>>>  >>>if Ĥ applied to ⟨Ĥ⟩ does not halt<<< as if Ĥ was reporting on
>>> whether
>>> or not itself halts. This is incorrect.
>>>
>>> HOCFH does not transition to Ĥ.qn: >>>if Ĥ applied to <Ĥ> does not
>>> halt<<<
>>
>> But it NEEDS to if H is going to give the right answer, as H will go
>> to H.qn, and sin\ch
>>
>>>
>>> HOCFH transitions to Ĥ.qn when its simulation of <Ĥ> applied to <Ĥ>
>>> never reaches the final state of <Ĥ> applied to <Ĥ>.
>>
>> But since that means that H went to qn, and it means that H^ halted,
>> it shows that H was INCORRECT with its answer.
>>
>>>
>>> The input to HOCFH is ⟨Ĥ⟩ ⟨Ĥ⟩.
>>> The input to HOCFH is not Ĥ ⟨Ĥ⟩.
>>
>> But to H, the input of <H^> <H^> means giving it the QUESTION of what
>> does H^ applied to <H^> do, which is exactly H^(<H^>)
>>
>>>
>>> HOCFH does not compute whether or not >>>Ĥ applied to <Ĥ> does not
>>> halt<<< because an actual Turing machine cannot be input to any
>>> computable function.
>>>
>>
>> But the REPRESENTATION of one CAN be, which is why the Halting Problem
>> is defined the way it is.
>>
>> You don't seem to understand what a representation is.
>
> When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn it is not referring to
> the halt status of its own computation that began at Ĥ.q0.
>
> It is referring to the halt status of its simulated input ⟨Ĥ⟩ ⟨Ĥ⟩.
>

And the proper simulation of the input <H^> <H^> is BY DEFINITION the
same as the machine H^ applied to <H^>.

PERIOD.

Since H^ going to H^.qn shows that the proper simulation of <H^> <H^>
WILL halt, it shows that H applied to <H^> <H^> saying non-halting is
giving the WRONG answer. PERIOD.