Showing how the Linz Ĥ can be correctly decided as non-halting

Revised Linz H halt deciding criteria (My criteria Ben's notation)
H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt

For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.

Simplified syntax adapted from bottom of page 319:
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
this input would never reach a final state and stop running.

These steps would keep repeating:
Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...

computation that halts
....the Turing machine will halt whenever it enters a final state
(Linz:1990:234)

That the pure simulation of an input would never reaches its final state
conclusively proves that this input specifies a non-halting computation.

This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn

Peter Linz HP Proof
https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf

--
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 1/1/22 4:09 PM, olcott wrote:
> Showing how the Linz Ĥ can be correctly decided as non-halting
>
> Revised Linz H halt deciding criteria (My criteria Ben's notation)
> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>
> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>
> Simplified syntax adapted from bottom of page 319:
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
> this input would never reach a final state and stop running.
>
> These steps would keep repeating:
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>
> computation that halts
> ...the Turing machine will halt whenever it enters a final state
> (Linz:1990:234)
>
> That the pure simulation of an input would never reaches its final state
> conclusively proves that this input specifies a non-halting computation.
>
> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn

Except that you made the conclusion with the assumption that embedded_H
never stopped its simulation.

If it never stopped its simulation, it did NOT mapped its input to Qn,
wven though it SHOUULD have, so it failed to make the right mapping.

As has been shown, if embedded_H DOES abort its simulation and goes to
Qn, then the H^ that its input represents Halts, and thus embedded_H
SHOULD have mapped the input to Qy, so it failed to compute the right
mapping.

FAIL.

FALSE ASSUMPTIONS result in UNSOUND conclusions.

FAIL.

>
> Peter Linz HP Proof
> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>
>

On 1/1/22 4:09 PM, olcott wrote:
> Showing how the Linz Ĥ can be correctly decided as non-halting
>
> Revised Linz H halt deciding criteria (My criteria Ben's notation)
> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>
> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>
> Simplified syntax adapted from bottom of page 319:
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
> this input would never reach a final state and stop running.
>
> These steps would keep repeating:
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>
> computation that halts
> ...the Turing machine will halt whenever it enters a final state
> (Linz:1990:234)
>
> That the pure simulation of an input would never reaches its final state
> conclusively proves that this input specifies a non-halting computation.
>
> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>
> Peter Linz HP Proof
> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>
>

To be bit more clear, the critera that defines Halting is NOT if H needs
to abort its simulation, but does a UTM processing that same input, with
that input EXACTLY as presented, which means the H embedded in it is
still H and behaves like H, NOT, as you presume, replaceed also with a UTM.

This is why your logic is wrong.

On 1/1/2022 3:15 PM, Richard Damon wrote:
> On 1/1/22 4:09 PM, olcott wrote:
>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>
>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>
>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>>
>> Simplified syntax adapted from bottom of page 319:
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>> this input would never reach a final state and stop running.
>>
>> These steps would keep repeating:
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>
>> computation that halts
>> ...the Turing machine will halt whenever it enters a final state
>> (Linz:1990:234)
>>
>> That the pure simulation of an input would never reaches its final
>> state conclusively proves that this input specifies a non-halting
>> computation.
>>
>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>
> Except that you made the conclusion with the assumption that embedded_H
> never stopped its simulation.

Is English your second language?
If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
Do you know the difference between "would" and "does" ?

would
2. (expressing the conditional mood) indicating the consequence of an
imagined event or situation. Definitions from Oxford Languages

--
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 1/1/2022 3:19 PM, Richard Damon wrote:
> On 1/1/22 4:09 PM, olcott wrote:
>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>
>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>
>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>>
>> Simplified syntax adapted from bottom of page 319:
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>> this input would never reach a final state and stop running.
>>
>> These steps would keep repeating:
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>
>> computation that halts
>> ...the Turing machine will halt whenever it enters a final state
>> (Linz:1990:234)
>>
>> That the pure simulation of an input would never reaches its final
>> state conclusively proves that this input specifies a non-halting
>> computation.
>>
>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>
>> Peter Linz HP Proof
>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>
>>
>
> To be bit more clear, the critera that defines Halting is NOT if H needs
> to abort its simulation, but does a UTM processing that same input, with
> that input EXACTLY as presented, which means the H embedded in it is
> still H and behaves like H, NOT, as you presume, replaceed also with a UTM.
>
> This is why your logic is wrong.

H(x,y) halts iff UTM(x,y) halts (reaches its final state)

--
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 1/1/22 4:31 PM, olcott wrote:
> On 1/1/2022 3:19 PM, Richard Damon wrote:
>> On 1/1/22 4:09 PM, olcott wrote:
>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>
>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>
>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>>>
>>> Simplified syntax adapted from bottom of page 319:
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>> this input would never reach a final state and stop running.
>>>
>>> These steps would keep repeating:
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>
>>> computation that halts
>>> ...the Turing machine will halt whenever it enters a final state
>>> (Linz:1990:234)
>>>
>>> That the pure simulation of an input would never reaches its final
>>> state conclusively proves that this input specifies a non-halting
>>> computation.
>>>
>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>
>>> Peter Linz HP Proof
>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>
>>>
>>
>> To be bit more clear, the critera that defines Halting is NOT if H
>> needs to abort its simulation, but does a UTM processing that same
>> input, with that input EXACTLY as presented, which means the H
>> embedded in it is still H and behaves like H, NOT, as you presume,
>> replaceed also with a UTM.
>>
>> This is why your logic is wrong.
>
> H(x,y) halts iff UTM(x,y) halts (reaches its final state)

Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y) Halts.

NOT that "unless H aborts its simulation", it is iff UTM(x,y).

If H -> H.qn, then H^ -> H^.qn and HALTS, as does UTM(<H^>,<H^>) thus if
H(<H^>,<H>) -> H.qn is is WRONG as H^(<H^>) will also go to H^.qn and HALT.

Your 'arguement' wasn't base on UTM(x,y) not halting, but H(x,y) not
halting, which is a different condition.

FAIL.
>

On 1/1/22 4:27 PM, olcott wrote:
> On 1/1/2022 3:15 PM, Richard Damon wrote:
>> On 1/1/22 4:09 PM, olcott wrote:
>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>
>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>
>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>>>
>>> Simplified syntax adapted from bottom of page 319:
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>> this input would never reach a final state and stop running.
>>>
>>> These steps would keep repeating:
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>
>>> computation that halts
>>> ...the Turing machine will halt whenever it enters a final state
>>> (Linz:1990:234)
>>>
>>> That the pure simulation of an input would never reaches its final
>>> state conclusively proves that this input specifies a non-halting
>>> computation.
>>>
>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>
>> Except that you made the conclusion with the assumption that
>> embedded_H never stopped its simulation.
>
> Is English your second language?
> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
> Do you know the difference between "would" and "does" ?
>

Excect you are using the wrong condition.

The condition is if *UTM* of the input does not halt.

embedded_H is a Turing Machine and thus has definite behavior. Either
embedded_H will or will not abort is simulation of <H^>,<H^> so 'would'
is not an appropriate word.

IF embedded_H DOES NOT abort its simulation, then we see non-halting
behavior.

if embedded_H DOES abort its simuiation, then UTM(<H^><H^>) WILL Halt.

FAIL.

> would
> 2. (expressing the conditional mood) indicating the consequence of an
> imagined event or situation.   Definitions from Oxford Languages
>

And the problem is that just because the IMAGINED condition of
embedded_H not aborting results in *ITS* H^ being non-halting does NOT
mean that the H^ for the embedded_H that DOES abort is also non-halting.

That is using the wrogn definition and unsound logic.

FAIL.

On 1/1/2022 3:47 PM, Richard Damon wrote:
> On 1/1/22 4:31 PM, olcott wrote:
>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>> On 1/1/22 4:09 PM, olcott wrote:
>>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>>
>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>
>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>>>>
>>>> Simplified syntax adapted from bottom of page 319:
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> this input would never reach a final state and stop running.
>>>>
>>>> These steps would keep repeating:
>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>
>>>> computation that halts
>>>> ...the Turing machine will halt whenever it enters a final state
>>>> (Linz:1990:234)
>>>>
>>>> That the pure simulation of an input would never reaches its final
>>>> state conclusively proves that this input specifies a non-halting
>>>> computation.
>>>>
>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>>
>>>> Peter Linz HP Proof
>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>
>>>>
>>>
>>> To be bit more clear, the critera that defines Halting is NOT if H
>>> needs to abort its simulation, but does a UTM processing that same
>>> input, with that input EXACTLY as presented, which means the H
>>> embedded in it is still H and behaves like H, NOT, as you presume,
>>> replaceed also with a UTM.
>>>
>>> This is why your logic is wrong.
>>
>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>
> Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y) Halts.

computation that halts
… the Turing machine will halt whenever it enters a final state.
(Linz:1990:234)

Since I just proved the the simulated input would never reach its final
state that means that it never halts.

I generally have to tell you the same thing at least fifty times before
you notice that I ever said it at least once.

--
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 1/1/22 6:02 PM, olcott wrote:
> On 1/1/2022 3:47 PM, Richard Damon wrote:
>> On 1/1/22 4:31 PM, olcott wrote:
>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>>>
>>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>
>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>>>>>
>>>>> Simplified syntax adapted from bottom of page 319:
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> this input would never reach a final state and stop running.
>>>>>
>>>>> These steps would keep repeating:
>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>
>>>>> computation that halts
>>>>> ...the Turing machine will halt whenever it enters a final state
>>>>> (Linz:1990:234)
>>>>>
>>>>> That the pure simulation of an input would never reaches its final
>>>>> state conclusively proves that this input specifies a non-halting
>>>>> computation.
>>>>>
>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>>>
>>>>> Peter Linz HP Proof
>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>
>>>>>
>>>>
>>>> To be bit more clear, the critera that defines Halting is NOT if H
>>>> needs to abort its simulation, but does a UTM processing that same
>>>> input, with that input EXACTLY as presented, which means the H
>>>> embedded in it is still H and behaves like H, NOT, as you presume,
>>>> replaceed also with a UTM.
>>>>
>>>> This is why your logic is wrong.
>>>
>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>
>> Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y) Halts.
>
>
> computation that halts
> … the Turing machine will halt whenever it enters a final state.
> (Linz:1990:234)
>
> Since I just proved the the simulated input would never reach its final
> state that means that it never halts.
>
> I generally have to tell you the same thing at least fifty times before
> you notice that I ever said it at least once.
>

No, you didn't. You proved that IF H/embedded_H was designed to never
halt its simulation, then the H^ built on THAT version of H would never
halt.

Once you change H/embedded_H to actually abort its simulation and go to
H.qn, you now have a DIFFERENT H^, and THAT one will Halt.

You don't seem to understand that H^ is tied to the H that it is
constructed from, as it includes a copy of it.

In clearer symbology, giving each machine a unique name:

Given your first Hn that doesn't abort, you have proved that Hn^(<Hn^>)
is non-halting, but Hn(<Hn^>,<Hn^>) doesn't answer, so it fails.

When you change H to Ha, that does abort and go to H.qn, then we can
prove that Ha^(<Ha^>) is a Halting Computation, and thus Ha was wrong in
saying it was non-halting.

All you have shown is that Ha(<Hn^>,<Hn^>) correctly determines that
Hn^(<Hn>) is non-halting, but that isn't the decision needed to be a
counter example of Linz.

FAIL.

On 1/1/2022 6:12 PM, Richard Damon wrote:
> On 1/1/22 6:02 PM, olcott wrote:
>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>> On 1/1/22 4:31 PM, olcott wrote:
>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>>>>
>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>
>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>> embedded_H.
>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>>>>>>
>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> this input would never reach a final state and stop running.
>>>>>>
>>>>>> These steps would keep repeating:
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>
>>>>>> computation that halts
>>>>>> ...the Turing machine will halt whenever it enters a final state
>>>>>> (Linz:1990:234)
>>>>>>
>>>>>> That the pure simulation of an input would never reaches its final
>>>>>> state conclusively proves that this input specifies a non-halting
>>>>>> computation.
>>>>>>
>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>>>>
>>>>>> Peter Linz HP Proof
>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>
>>>>>>
>>>>>
>>>>> To be bit more clear, the critera that defines Halting is NOT if H
>>>>> needs to abort its simulation, but does a UTM processing that same
>>>>> input, with that input EXACTLY as presented, which means the H
>>>>> embedded in it is still H and behaves like H, NOT, as you presume,
>>>>> replaceed also with a UTM.
>>>>>
>>>>> This is why your logic is wrong.
>>>>
>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>
>>> Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y) Halts.
>>
>>
>> computation that halts
>> … the Turing machine will halt whenever it enters a final state.
>> (Linz:1990:234)
>>
>> Since I just proved the the simulated input would never reach its
>> final state that means that it never halts.
>>
>> I generally have to tell you the same thing at least fifty times
>> before you notice that I ever said it at least once.
>>
>
> No, you didn't. You proved that IF H/embedded_H was designed to never
> halt its simulation, then the H^ built on THAT version of H would never
> halt.
>
> Once you change H/embedded_H to actually abort its simulation and go to
> H.qn, you now have a DIFFERENT H^, and THAT one will Halt.
>

If it is the case that no amount of simulation will cause a machine to
reach its final state then this machine is a non halting computation
because halting computations only include machines that reach their
final state.

If it is the case that no amount of simulation will cause a machine to
reach its final state then this machine is a not halting computation
because halting computations only include machine that reach their final
state.

If it is the case that no amount of simulation will cause a machine to
reach its final state then this machine is a not halting computation
because halting computations only include machine that reach their final
state.

If it is the case that no amount of simulation will cause a machine to
reach its final state then this machine is a not halting computation
because halting computations only include machine that reach their final
state.

If it is the case that no amount of simulation will cause a machine to
reach its final state then this machine is a not halting computation
because halting computations only include machine that reach their final
state.

If it is the case that no amount of simulation will cause a machine to
reach its final state then this machine is a not halting computation
because halting computations only include machine that reach their final
state.

If it is the case that no amount of simulation will cause a machine to
reach its final state then this machine is a not halting computation
because halting computations only include machine that reach their final
state.

If it is the case that no amount of simulation will cause a machine to
reach its final state then this machine is a not halting computation
because halting computations only include machine that reach their final
state.

--
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 1/1/22 7:35 PM, olcott wrote:
> On 1/1/2022 6:12 PM, Richard Damon wrote:
>> On 1/1/22 6:02 PM, olcott wrote:
>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>>>>>
>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>
>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>> embedded_H.
>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>>>>>>>
>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> this input would never reach a final state and stop running.
>>>>>>>
>>>>>>> These steps would keep repeating:
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>
>>>>>>> computation that halts
>>>>>>> ...the Turing machine will halt whenever it enters a final state
>>>>>>> (Linz:1990:234)
>>>>>>>
>>>>>>> That the pure simulation of an input would never reaches its
>>>>>>> final state conclusively proves that this input specifies a
>>>>>>> non-halting computation.
>>>>>>>
>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>>>>>
>>>>>>> Peter Linz HP Proof
>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> To be bit more clear, the critera that defines Halting is NOT if H
>>>>>> needs to abort its simulation, but does a UTM processing that same
>>>>>> input, with that input EXACTLY as presented, which means the H
>>>>>> embedded in it is still H and behaves like H, NOT, as you presume,
>>>>>> replaceed also with a UTM.
>>>>>>
>>>>>> This is why your logic is wrong.
>>>>>
>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>
>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y) Halts.
>>>
>>>
>>> computation that halts
>>> … the Turing machine will halt whenever it enters a final state.
>>> (Linz:1990:234)
>>>
>>> Since I just proved the the simulated input would never reach its
>>> final state that means that it never halts.
>>>
>>> I generally have to tell you the same thing at least fifty times
>>> before you notice that I ever said it at least once.
>>>
>>
>> No, you didn't. You proved that IF H/embedded_H was designed to never
>> halt its simulation, then the H^ built on THAT version of H would
>> never halt.
>>
>> Once you change H/embedded_H to actually abort its simulation and go
>> to H.qn, you now have a DIFFERENT H^, and THAT one will Halt.
>>
>
> If it is the case that no amount of simulation will cause a machine to
> reach its final state then this machine is a non halting computation
> because halting computations only include machines that reach their
> final state.
>
> If it is the case that no amount of simulation will cause a machine to
> reach its final state then this machine is a not halting computation
> because halting computations only include machine that reach their final
> state.
>
> If it is the case that no amount of simulation will cause a machine to
> reach its final state then this machine is a not halting computation
> because halting computations only include machine that reach their final
> state.
>
> If it is the case that no amount of simulation will cause a machine to
> reach its final state then this machine is a not halting computation
> because halting computations only include machine that reach their final
> state.
>
> If it is the case that no amount of simulation will cause a machine to
> reach its final state then this machine is a not halting computation
> because halting computations only include machine that reach their final
> state.
>
> If it is the case that no amount of simulation will cause a machine to
> reach its final state then this machine is a not halting computation
> because halting computations only include machine that reach their final
> state.
>
> If it is the case that no amount of simulation will cause a machine to
> reach its final state then this machine is a not halting computation
> because halting computations only include machine that reach their final
> state.
>
> If it is the case that no amount of simulation will cause a machine to
> reach its final state then this machine is a not halting computation
> because halting computations only include machine that reach their final
> state.
>

You don't get it, do you.

The logic of arguing about different behaviors of H is invalid, because
just because the H that doesn't about leads to a non-halting H^, doesn't
mean that an aborting H, which gives a DIFFERENT H^, is correct about
calling ITS H^ to be non-haling.

If H doesn't abort, then it does act like a UTM, and its behavior does
show what H^ does.

Change H to abort, and now you have a NEW H^, so that previous result
needs to be thrown out (that is the answer to Hn^, not Ha^) and now
since H isn't a UTM, you need to give that input to a REAL UTM to see if
it halrs, which it does.

Remeber, the answer is based on what a REAL UTM does, not what a partial
simulating decider does. The question isn't does H need to abort its
simulation, it is given your H, does the UTM Halt or Not.

FFFFF A IIIII L
F AAA I L
FFF A A I L
F AAAAA I L
F A A I L
F A A IIIII LLLLL

On 1/1/2022 8:11 PM, Richard Damon wrote:
> On 1/1/22 7:35 PM, olcott wrote:
>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>> On 1/1/22 6:02 PM, olcott wrote:
>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>>>>>>
>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>
>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>> embedded_H.
>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>>>>>>>>
>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> this input would never reach a final state and stop running.
>>>>>>>>
>>>>>>>> These steps would keep repeating:
>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>
>>>>>>>> computation that halts
>>>>>>>> ...the Turing machine will halt whenever it enters a final state
>>>>>>>> (Linz:1990:234)
>>>>>>>>
>>>>>>>> That the pure simulation of an input would never reaches its
>>>>>>>> final state conclusively proves that this input specifies a
>>>>>>>> non-halting computation.
>>>>>>>>
>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>>>>>>
>>>>>>>> Peter Linz HP Proof
>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> To be bit more clear, the critera that defines Halting is NOT if
>>>>>>> H needs to abort its simulation, but does a UTM processing that
>>>>>>> same input, with that input EXACTLY as presented, which means the
>>>>>>> H embedded in it is still H and behaves like H, NOT, as you
>>>>>>> presume, replaceed also with a UTM.
>>>>>>>
>>>>>>> This is why your logic is wrong.
>>>>>>
>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>
>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y) Halts.
>>>>
>>>>
>>>> computation that halts
>>>> … the Turing machine will halt whenever it enters a final state.
>>>> (Linz:1990:234)
>>>>
>>>> Since I just proved the the simulated input would never reach its
>>>> final state that means that it never halts.
>>>>
>>>> I generally have to tell you the same thing at least fifty times
>>>> before you notice that I ever said it at least once.
>>>>
>>>
>>> No, you didn't. You proved that IF H/embedded_H was designed to never
>>> halt its simulation, then the H^ built on THAT version of H would
>>> never halt.
>>>
>>> Once you change H/embedded_H to actually abort its simulation and go
>>> to H.qn, you now have a DIFFERENT H^, and THAT one will Halt.
>>>
>>
>> If it is the case that no amount of simulation will cause a machine to
>> reach its final state then this machine is a non halting computation
>> because halting computations only include machines that reach their
>> final state.
>>
>> If it is the case that no amount of simulation will cause a machine to
>> reach its final state then this machine is a not halting computation
>> because halting computations only include machine that reach their
>> final state.
>>
>> If it is the case that no amount of simulation will cause a machine to
>> reach its final state then this machine is a not halting computation
>> because halting computations only include machine that reach their
>> final state.
>>
>> If it is the case that no amount of simulation will cause a machine to
>> reach its final state then this machine is a not halting computation
>> because halting computations only include machine that reach their
>> final state.
>>
>> If it is the case that no amount of simulation will cause a machine to
>> reach its final state then this machine is a not halting computation
>> because halting computations only include machine that reach their
>> final state.
>>
>> If it is the case that no amount of simulation will cause a machine to
>> reach its final state then this machine is a not halting computation
>> because halting computations only include machine that reach their
>> final state.
>>
>> If it is the case that no amount of simulation will cause a machine to
>> reach its final state then this machine is a not halting computation
>> because halting computations only include machine that reach their
>> final state.
>>
>> If it is the case that no amount of simulation will cause a machine to
>> reach its final state then this machine is a not halting computation
>> because halting computations only include machine that reach their
>> final state.
>>
>
> You don't get it, do you.
>
> The logic of arguing about different behaviors of H is invalid, because
Not at all. H does not report that an infinite loop does not halt H
reports that in infinite loop would not halt, so there are always two
behaviors for every computation that would not halt.

--
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 1/1/22 9:31 PM, olcott wrote:
> On 1/1/2022 8:11 PM, Richard Damon wrote:
>> On 1/1/22 7:35 PM, olcott wrote:
>>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>>> On 1/1/22 6:02 PM, olcott wrote:
>>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>>>>>>>
>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's notation)
>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>
>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>> embedded_H.
>>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>> halts.
>>>>>>>>>
>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> this input would never reach a final state and stop running.
>>>>>>>>>
>>>>>>>>> These steps would keep repeating:
>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>
>>>>>>>>> computation that halts
>>>>>>>>> ...the Turing machine will halt whenever it enters a final
>>>>>>>>> state (Linz:1990:234)
>>>>>>>>>
>>>>>>>>> That the pure simulation of an input would never reaches its
>>>>>>>>> final state conclusively proves that this input specifies a
>>>>>>>>> non-halting computation.
>>>>>>>>>
>>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>>>>>>>
>>>>>>>>> Peter Linz HP Proof
>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> To be bit more clear, the critera that defines Halting is NOT if
>>>>>>>> H needs to abort its simulation, but does a UTM processing that
>>>>>>>> same input, with that input EXACTLY as presented, which means
>>>>>>>> the H embedded in it is still H and behaves like H, NOT, as you
>>>>>>>> presume, replaceed also with a UTM.
>>>>>>>>
>>>>>>>> This is why your logic is wrong.
>>>>>>>
>>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>>
>>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y) Halts.
>>>>>
>>>>>
>>>>> computation that halts
>>>>> … the Turing machine will halt whenever it enters a final state.
>>>>> (Linz:1990:234)
>>>>>
>>>>> Since I just proved the the simulated input would never reach its
>>>>> final state that means that it never halts.
>>>>>
>>>>> I generally have to tell you the same thing at least fifty times
>>>>> before you notice that I ever said it at least once.
>>>>>
>>>>
>>>> No, you didn't. You proved that IF H/embedded_H was designed to
>>>> never halt its simulation, then the H^ built on THAT version of H
>>>> would never halt.
>>>>
>>>> Once you change H/embedded_H to actually abort its simulation and go
>>>> to H.qn, you now have a DIFFERENT H^, and THAT one will Halt.
>>>>
>>>
>>> If it is the case that no amount of simulation will cause a machine
>>> to reach its final state then this machine is a non halting
>>> computation because halting computations only include machines that
>>> reach their final state.
>>>
>>> If it is the case that no amount of simulation will cause a machine
>>> to reach its final state then this machine is a not halting
>>> computation because halting computations only include machine that
>>> reach their final state.
>>>
>>> If it is the case that no amount of simulation will cause a machine
>>> to reach its final state then this machine is a not halting
>>> computation because halting computations only include machine that
>>> reach their final state.
>>>
>>> If it is the case that no amount of simulation will cause a machine
>>> to reach its final state then this machine is a not halting
>>> computation because halting computations only include machine that
>>> reach their final state.
>>>
>>> If it is the case that no amount of simulation will cause a machine
>>> to reach its final state then this machine is a not halting
>>> computation because halting computations only include machine that
>>> reach their final state.
>>>
>>> If it is the case that no amount of simulation will cause a machine
>>> to reach its final state then this machine is a not halting
>>> computation because halting computations only include machine that
>>> reach their final state.
>>>
>>> If it is the case that no amount of simulation will cause a machine
>>> to reach its final state then this machine is a not halting
>>> computation because halting computations only include machine that
>>> reach their final state.
>>>
>>> If it is the case that no amount of simulation will cause a machine
>>> to reach its final state then this machine is a not halting
>>> computation because halting computations only include machine that
>>> reach their final state.
>>>
>>
>> You don't get it, do you.
>>
>> The logic of arguing about different behaviors of H is invalid, because
> Not at all. H does not report that an infinite loop does not halt H
> reports that in infinite loop would not halt, so there are always two
> behaviors for every computation that would not halt.
>

If H reports that H^(<H^>,<H^>) does not halt, then H^(<H^>) Halts, so
it is wrong.

You are AGAIN assuming that H CAN be correct, it can't be, as proven.

You logic (and it seems you brain) is UNSOUND.

You can not ignore the definition of Halting.

If H -> H.qn, then H^ ->qn and Halts. FUNDAMENTAL DESIGN REQUIREMENT,
which makes H (and your argument) WRONG.

You keep on looking at the WRONG H^, H^ MUST match the H that you claim
to be getting the right answer.

FAIL.

On 1/1/2022 8:59 PM, Richard Damon wrote:
>
> On 1/1/22 9:31 PM, olcott wrote:
>> On 1/1/2022 8:11 PM, Richard Damon wrote:
>>> On 1/1/22 7:35 PM, olcott wrote:
>>>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>>>> On 1/1/22 6:02 PM, olcott wrote:
>>>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>>>>>>>>
>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>> notation)
>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>
>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>> embedded_H.
>>>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>> halts.
>>>>>>>>>>
>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>> this input would never reach a final state and stop running.
>>>>>>>>>>
>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>
>>>>>>>>>> computation that halts
>>>>>>>>>> ...the Turing machine will halt whenever it enters a final
>>>>>>>>>> state (Linz:1990:234)
>>>>>>>>>>
>>>>>>>>>> That the pure simulation of an input would never reaches its
>>>>>>>>>> final state conclusively proves that this input specifies a
>>>>>>>>>> non-halting computation.
>>>>>>>>>>
>>>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> Peter Linz HP Proof
>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> To be bit more clear, the critera that defines Halting is NOT
>>>>>>>>> if H needs to abort its simulation, but does a UTM processing
>>>>>>>>> that same input, with that input EXACTLY as presented, which
>>>>>>>>> means the H embedded in it is still H and behaves like H, NOT,
>>>>>>>>> as you presume, replaceed also with a UTM.
>>>>>>>>>
>>>>>>>>> This is why your logic is wrong.
>>>>>>>>
>>>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>>>
>>>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y) Halts.
>>>>>>
>>>>>>
>>>>>> computation that halts
>>>>>> … the Turing machine will halt whenever it enters a final state.
>>>>>> (Linz:1990:234)
>>>>>>
>>>>>> Since I just proved the the simulated input would never reach its
>>>>>> final state that means that it never halts.
>>>>>>
>>>>>> I generally have to tell you the same thing at least fifty times
>>>>>> before you notice that I ever said it at least once.
>>>>>>
>>>>>
>>>>> No, you didn't. You proved that IF H/embedded_H was designed to
>>>>> never halt its simulation, then the H^ built on THAT version of H
>>>>> would never halt.
>>>>>
>>>>> Once you change H/embedded_H to actually abort its simulation and
>>>>> go to H.qn, you now have a DIFFERENT H^, and THAT one will Halt.
>>>>>
>>>>
>>>> If it is the case that no amount of simulation will cause a machine
>>>> to reach its final state then this machine is a non halting
>>>> computation because halting computations only include machines that
>>>> reach their final state.
>>>>
>>>> If it is the case that no amount of simulation will cause a machine
>>>> to reach its final state then this machine is a not halting
>>>> computation because halting computations only include machine that
>>>> reach their final state.
>>>>
>>>> If it is the case that no amount of simulation will cause a machine
>>>> to reach its final state then this machine is a not halting
>>>> computation because halting computations only include machine that
>>>> reach their final state.
>>>>
>>>> If it is the case that no amount of simulation will cause a machine
>>>> to reach its final state then this machine is a not halting
>>>> computation because halting computations only include machine that
>>>> reach their final state.
>>>>
>>>> If it is the case that no amount of simulation will cause a machine
>>>> to reach its final state then this machine is a not halting
>>>> computation because halting computations only include machine that
>>>> reach their final state.
>>>>
>>>> If it is the case that no amount of simulation will cause a machine
>>>> to reach its final state then this machine is a not halting
>>>> computation because halting computations only include machine that
>>>> reach their final state.
>>>>
>>>> If it is the case that no amount of simulation will cause a machine
>>>> to reach its final state then this machine is a not halting
>>>> computation because halting computations only include machine that
>>>> reach their final state.
>>>>
>>>> If it is the case that no amount of simulation will cause a machine
>>>> to reach its final state then this machine is a not halting
>>>> computation because halting computations only include machine that
>>>> reach their final state.
>>>>
>>>
>>> You don't get it, do you.
>>>
>>> The logic of arguing about different behaviors of H is invalid, because
>> Not at all. H does not report that an infinite loop does not halt H
>> reports that in infinite loop would not halt, so there are always two
>> behaviors for every computation that would not halt.
>>
>
> If H reports that H^(<H^>,<H^>) does not halt, then H^(<H^>) Halts, so
> it is wrong.
>

Because it is true that the input to embedded_H would never reach its
final state even if an infinite number of its steps were simulated then
by the Linz definition of halting this input never halts.

THERE REALLY IS NO WAY AROUND THIS.
THERE REALLY IS NO WAY AROUND THIS.
THERE REALLY IS NO WAY AROUND THIS.

--
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 1/1/22 10:15 PM, olcott wrote:
> On 1/1/2022 8:59 PM, Richard Damon wrote:
>>
>> On 1/1/22 9:31 PM, olcott wrote:
>>> On 1/1/2022 8:11 PM, Richard Damon wrote:
>>>> On 1/1/22 7:35 PM, olcott wrote:
>>>>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>>>>> On 1/1/22 6:02 PM, olcott wrote:
>>>>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>>>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>>>>>>>>>
>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>> notation)
>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>
>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>>> embedded_H.
>>>>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>> halts.
>>>>>>>>>>>
>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>> this input would never reach a final state and stop running.
>>>>>>>>>>>
>>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>
>>>>>>>>>>> computation that halts
>>>>>>>>>>> ...the Turing machine will halt whenever it enters a final
>>>>>>>>>>> state (Linz:1990:234)
>>>>>>>>>>>
>>>>>>>>>>> That the pure simulation of an input would never reaches its
>>>>>>>>>>> final state conclusively proves that this input specifies a
>>>>>>>>>>> non-halting computation.
>>>>>>>>>>>
>>>>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> Peter Linz HP Proof
>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> To be bit more clear, the critera that defines Halting is NOT
>>>>>>>>>> if H needs to abort its simulation, but does a UTM processing
>>>>>>>>>> that same input, with that input EXACTLY as presented, which
>>>>>>>>>> means the H embedded in it is still H and behaves like H, NOT,
>>>>>>>>>> as you presume, replaceed also with a UTM.
>>>>>>>>>>
>>>>>>>>>> This is why your logic is wrong.
>>>>>>>>>
>>>>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>>>>
>>>>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y)
>>>>>>>> Halts.
>>>>>>>
>>>>>>>
>>>>>>> computation that halts
>>>>>>> … the Turing machine will halt whenever it enters a final state.
>>>>>>> (Linz:1990:234)
>>>>>>>
>>>>>>> Since I just proved the the simulated input would never reach its
>>>>>>> final state that means that it never halts.
>>>>>>>
>>>>>>> I generally have to tell you the same thing at least fifty times
>>>>>>> before you notice that I ever said it at least once.
>>>>>>>
>>>>>>
>>>>>> No, you didn't. You proved that IF H/embedded_H was designed to
>>>>>> never halt its simulation, then the H^ built on THAT version of H
>>>>>> would never halt.
>>>>>>
>>>>>> Once you change H/embedded_H to actually abort its simulation and
>>>>>> go to H.qn, you now have a DIFFERENT H^, and THAT one will Halt.
>>>>>>
>>>>>
>>>>> If it is the case that no amount of simulation will cause a machine
>>>>> to reach its final state then this machine is a non halting
>>>>> computation because halting computations only include machines that
>>>>> reach their final state.
>>>>>
>>>>> If it is the case that no amount of simulation will cause a machine
>>>>> to reach its final state then this machine is a not halting
>>>>> computation because halting computations only include machine that
>>>>> reach their final state.
>>>>>
>>>>> If it is the case that no amount of simulation will cause a machine
>>>>> to reach its final state then this machine is a not halting
>>>>> computation because halting computations only include machine that
>>>>> reach their final state.
>>>>>
>>>>> If it is the case that no amount of simulation will cause a machine
>>>>> to reach its final state then this machine is a not halting
>>>>> computation because halting computations only include machine that
>>>>> reach their final state.
>>>>>
>>>>> If it is the case that no amount of simulation will cause a machine
>>>>> to reach its final state then this machine is a not halting
>>>>> computation because halting computations only include machine that
>>>>> reach their final state.
>>>>>
>>>>> If it is the case that no amount of simulation will cause a machine
>>>>> to reach its final state then this machine is a not halting
>>>>> computation because halting computations only include machine that
>>>>> reach their final state.
>>>>>
>>>>> If it is the case that no amount of simulation will cause a machine
>>>>> to reach its final state then this machine is a not halting
>>>>> computation because halting computations only include machine that
>>>>> reach their final state.
>>>>>
>>>>> If it is the case that no amount of simulation will cause a machine
>>>>> to reach its final state then this machine is a not halting
>>>>> computation because halting computations only include machine that
>>>>> reach their final state.
>>>>>
>>>>
>>>> You don't get it, do you.
>>>>
>>>> The logic of arguing about different behaviors of H is invalid, because
>>> Not at all. H does not report that an infinite loop does not halt H
>>> reports that in infinite loop would not halt, so there are always two
>>> behaviors for every computation that would not halt.
>>>
>>
>> If H reports that H^(<H^>,<H^>) does not halt, then H^(<H^>) Halts, so
>> it is wrong.
>>
>
> Because it is true that the input to embedded_H would never reach its
> final state even if an infinite number of its steps were simulated then
> by the Linz definition of halting this input never halts.
>
> THERE REALLY IS NO WAY AROUND THIS.
> THERE REALLY IS NO WAY AROUND THIS.
> THERE REALLY IS NO WAY AROUND THIS.
>

That doesn't matter, as non-halting is only measured by a REAL UTM, not
by your halt decider.

On 1/1/2022 9:26 PM, Richard Damon wrote:
>
> On 1/1/22 10:15 PM, olcott wrote:
>> On 1/1/2022 8:59 PM, Richard Damon wrote:
>>>
>>> On 1/1/22 9:31 PM, olcott wrote:
>>>> On 1/1/2022 8:11 PM, Richard Damon wrote:
>>>>> On 1/1/22 7:35 PM, olcott wrote:
>>>>>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>>>>>> On 1/1/22 6:02 PM, olcott wrote:
>>>>>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>>>>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>>>>>>>>>>
>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>>> notation)
>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>
>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>>> halts.
>>>>>>>>>>>>
>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>> this input would never reach a final state and stop running.
>>>>>>>>>>>>
>>>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>
>>>>>>>>>>>> computation that halts
>>>>>>>>>>>> ...the Turing machine will halt whenever it enters a final
>>>>>>>>>>>> state (Linz:1990:234)
>>>>>>>>>>>>
>>>>>>>>>>>> That the pure simulation of an input would never reaches its
>>>>>>>>>>>> final state conclusively proves that this input specifies a
>>>>>>>>>>>> non-halting computation.
>>>>>>>>>>>>
>>>>>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> Peter Linz HP Proof
>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> To be bit more clear, the critera that defines Halting is NOT
>>>>>>>>>>> if H needs to abort its simulation, but does a UTM processing
>>>>>>>>>>> that same input, with that input EXACTLY as presented, which
>>>>>>>>>>> means the H embedded in it is still H and behaves like H,
>>>>>>>>>>> NOT, as you presume, replaceed also with a UTM.
>>>>>>>>>>>
>>>>>>>>>>> This is why your logic is wrong.
>>>>>>>>>>
>>>>>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>>>>>
>>>>>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y)
>>>>>>>>> Halts.
>>>>>>>>
>>>>>>>>
>>>>>>>> computation that halts
>>>>>>>> … the Turing machine will halt whenever it enters a final state.
>>>>>>>> (Linz:1990:234)
>>>>>>>>
>>>>>>>> Since I just proved the the simulated input would never reach
>>>>>>>> its final state that means that it never halts.
>>>>>>>>
>>>>>>>> I generally have to tell you the same thing at least fifty times
>>>>>>>> before you notice that I ever said it at least once.
>>>>>>>>
>>>>>>>
>>>>>>> No, you didn't. You proved that IF H/embedded_H was designed to
>>>>>>> never halt its simulation, then the H^ built on THAT version of H
>>>>>>> would never halt.
>>>>>>>
>>>>>>> Once you change H/embedded_H to actually abort its simulation and
>>>>>>> go to H.qn, you now have a DIFFERENT H^, and THAT one will Halt.
>>>>>>>
>>>>>>
>>>>>> If it is the case that no amount of simulation will cause a
>>>>>> machine to reach its final state then this machine is a non
>>>>>> halting computation because halting computations only include
>>>>>> machines that reach their final state.
>>>>>>
>>>>>> If it is the case that no amount of simulation will cause a
>>>>>> machine to reach its final state then this machine is a not
>>>>>> halting computation because halting computations only include
>>>>>> machine that reach their final state.
>>>>>>
>>>>>> If it is the case that no amount of simulation will cause a
>>>>>> machine to reach its final state then this machine is a not
>>>>>> halting computation because halting computations only include
>>>>>> machine that reach their final state.
>>>>>>
>>>>>> If it is the case that no amount of simulation will cause a
>>>>>> machine to reach its final state then this machine is a not
>>>>>> halting computation because halting computations only include
>>>>>> machine that reach their final state.
>>>>>>
>>>>>> If it is the case that no amount of simulation will cause a
>>>>>> machine to reach its final state then this machine is a not
>>>>>> halting computation because halting computations only include
>>>>>> machine that reach their final state.
>>>>>>
>>>>>> If it is the case that no amount of simulation will cause a
>>>>>> machine to reach its final state then this machine is a not
>>>>>> halting computation because halting computations only include
>>>>>> machine that reach their final state.
>>>>>>
>>>>>> If it is the case that no amount of simulation will cause a
>>>>>> machine to reach its final state then this machine is a not
>>>>>> halting computation because halting computations only include
>>>>>> machine that reach their final state.
>>>>>>
>>>>>> If it is the case that no amount of simulation will cause a
>>>>>> machine to reach its final state then this machine is a not
>>>>>> halting computation because halting computations only include
>>>>>> machine that reach their final state.
>>>>>>
>>>>>
>>>>> You don't get it, do you.
>>>>>
>>>>> The logic of arguing about different behaviors of H is invalid,
>>>>> because
>>>> Not at all. H does not report that an infinite loop does not halt H
>>>> reports that in infinite loop would not halt, so there are always
>>>> two behaviors for every computation that would not halt.
>>>>
>>>
>>> If H reports that H^(<H^>,<H^>) does not halt, then H^(<H^>) Halts,
>>> so it is wrong.
>>>
>>
>> Because it is true that the input to embedded_H would never reach its
>> final state even if an infinite number of its steps were simulated
>> then by the Linz definition of halting this input never halts.
>>
>> THERE REALLY IS NO WAY AROUND THIS.
>> THERE REALLY IS NO WAY AROUND THIS.
>> THERE REALLY IS NO WAY AROUND THIS.
>>
>
> That doesn't matter, as non-halting is only measured by a REAL UTM, not
> by your halt decider.
>
That is certainly a foolish thing to say when you are already admitted
that a real UTM at Ĥ.qx would also cause Ĥ applied to ⟨Ĥ⟩ to never stop
running.

On 1/1/22 10:32 PM, olcott wrote:
> On 1/1/2022 9:26 PM, Richard Damon wrote:
>>
>> On 1/1/22 10:15 PM, olcott wrote:
>>> On 1/1/2022 8:59 PM, Richard Damon wrote:
>>>>
>>>> On 1/1/22 9:31 PM, olcott wrote:
>>>>> On 1/1/2022 8:11 PM, Richard Damon wrote:
>>>>>> On 1/1/22 7:35 PM, olcott wrote:
>>>>>>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>>>>>>> On 1/1/22 6:02 PM, olcott wrote:
>>>>>>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>>>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>>>>>>> Showing how the Linz Ĥ can be correctly decided as non-halting
>>>>>>>>>>>>>
>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>>>> notation)
>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>
>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>> this input would never reach a final state and stop running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>>
>>>>>>>>>>>>> computation that halts
>>>>>>>>>>>>> ...the Turing machine will halt whenever it enters a final
>>>>>>>>>>>>> state (Linz:1990:234)
>>>>>>>>>>>>>
>>>>>>>>>>>>> That the pure simulation of an input would never reaches
>>>>>>>>>>>>> its final state conclusively proves that this input
>>>>>>>>>>>>> specifies a non-halting computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> Peter Linz HP Proof
>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> To be bit more clear, the critera that defines Halting is
>>>>>>>>>>>> NOT if H needs to abort its simulation, but does a UTM
>>>>>>>>>>>> processing that same input, with that input EXACTLY as
>>>>>>>>>>>> presented, which means the H embedded in it is still H and
>>>>>>>>>>>> behaves like H, NOT, as you presume, replaceed also with a UTM.
>>>>>>>>>>>>
>>>>>>>>>>>> This is why your logic is wrong.
>>>>>>>>>>>
>>>>>>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>>>>>>
>>>>>>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y)
>>>>>>>>>> Halts.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> computation that halts
>>>>>>>>> … the Turing machine will halt whenever it enters a final
>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>
>>>>>>>>> Since I just proved the the simulated input would never reach
>>>>>>>>> its final state that means that it never halts.
>>>>>>>>>
>>>>>>>>> I generally have to tell you the same thing at least fifty
>>>>>>>>> times before you notice that I ever said it at least once.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, you didn't. You proved that IF H/embedded_H was designed to
>>>>>>>> never halt its simulation, then the H^ built on THAT version of
>>>>>>>> H would never halt.
>>>>>>>>
>>>>>>>> Once you change H/embedded_H to actually abort its simulation
>>>>>>>> and go to H.qn, you now have a DIFFERENT H^, and THAT one will
>>>>>>>> Halt.
>>>>>>>>
>>>>>>>
>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>> machine to reach its final state then this machine is a non
>>>>>>> halting computation because halting computations only include
>>>>>>> machines that reach their final state.
>>>>>>>
>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>> machine to reach its final state then this machine is a not
>>>>>>> halting computation because halting computations only include
>>>>>>> machine that reach their final state.
>>>>>>>
>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>> machine to reach its final state then this machine is a not
>>>>>>> halting computation because halting computations only include
>>>>>>> machine that reach their final state.
>>>>>>>
>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>> machine to reach its final state then this machine is a not
>>>>>>> halting computation because halting computations only include
>>>>>>> machine that reach their final state.
>>>>>>>
>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>> machine to reach its final state then this machine is a not
>>>>>>> halting computation because halting computations only include
>>>>>>> machine that reach their final state.
>>>>>>>
>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>> machine to reach its final state then this machine is a not
>>>>>>> halting computation because halting computations only include
>>>>>>> machine that reach their final state.
>>>>>>>
>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>> machine to reach its final state then this machine is a not
>>>>>>> halting computation because halting computations only include
>>>>>>> machine that reach their final state.
>>>>>>>
>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>> machine to reach its final state then this machine is a not
>>>>>>> halting computation because halting computations only include
>>>>>>> machine that reach their final state.
>>>>>>>
>>>>>>
>>>>>> You don't get it, do you.
>>>>>>
>>>>>> The logic of arguing about different behaviors of H is invalid,
>>>>>> because
>>>>> Not at all. H does not report that an infinite loop does not halt H
>>>>> reports that in infinite loop would not halt, so there are always
>>>>> two behaviors for every computation that would not halt.
>>>>>
>>>>
>>>> If H reports that H^(<H^>,<H^>) does not halt, then H^(<H^>) Halts,
>>>> so it is wrong.
>>>>
>>>
>>> Because it is true that the input to embedded_H would never reach its
>>> final state even if an infinite number of its steps were simulated
>>> then by the Linz definition of halting this input never halts.
>>>
>>> THERE REALLY IS NO WAY AROUND THIS.
>>> THERE REALLY IS NO WAY AROUND THIS.
>>> THERE REALLY IS NO WAY AROUND THIS.
>>>
>>
>> That doesn't matter, as non-halting is only measured by a REAL UTM,
>> not by your halt decider.
>>
> That is certainly a foolish thing to say when you are already admitted
> that a real UTM at Ĥ.qx would also cause Ĥ applied to ⟨Ĥ⟩ to never stop
> running.
>
> THERE REALLY IS NO WAY AROUND THIS.
> THERE REALLY IS NO WAY AROUND THIS.
> THERE REALLY IS NO WAY AROUND THIS.
>
>

On 1/1/2022 9:46 PM, Richard Damon wrote:
>
> On 1/1/22 10:32 PM, olcott wrote:
>> On 1/1/2022 9:26 PM, Richard Damon wrote:
>>>
>>> On 1/1/22 10:15 PM, olcott wrote:
>>>> On 1/1/2022 8:59 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/1/22 9:31 PM, olcott wrote:
>>>>>> On 1/1/2022 8:11 PM, Richard Damon wrote:
>>>>>>> On 1/1/22 7:35 PM, olcott wrote:
>>>>>>>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>>>>>>>> On 1/1/22 6:02 PM, olcott wrote:
>>>>>>>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>>>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>>>>>>>> Showing how the Linz Ĥ can be correctly decided as
>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>>>>> notation)
>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>> this input would never reach a final state and stop running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> computation that halts
>>>>>>>>>>>>>> ...the Turing machine will halt whenever it enters a final
>>>>>>>>>>>>>> state (Linz:1990:234)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That the pure simulation of an input would never reaches
>>>>>>>>>>>>>> its final state conclusively proves that this input
>>>>>>>>>>>>>> specifies a non-halting computation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Peter Linz HP Proof
>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> To be bit more clear, the critera that defines Halting is
>>>>>>>>>>>>> NOT if H needs to abort its simulation, but does a UTM
>>>>>>>>>>>>> processing that same input, with that input EXACTLY as
>>>>>>>>>>>>> presented, which means the H embedded in it is still H and
>>>>>>>>>>>>> behaves like H, NOT, as you presume, replaceed also with a
>>>>>>>>>>>>> UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is why your logic is wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>>>>>>>
>>>>>>>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF UTM(x,y)
>>>>>>>>>>> Halts.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> computation that halts
>>>>>>>>>> … the Turing machine will halt whenever it enters a final
>>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>>
>>>>>>>>>> Since I just proved the the simulated input would never reach
>>>>>>>>>> its final state that means that it never halts.
>>>>>>>>>>
>>>>>>>>>> I generally have to tell you the same thing at least fifty
>>>>>>>>>> times before you notice that I ever said it at least once.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, you didn't. You proved that IF H/embedded_H was designed to
>>>>>>>>> never halt its simulation, then the H^ built on THAT version of
>>>>>>>>> H would never halt.
>>>>>>>>>
>>>>>>>>> Once you change H/embedded_H to actually abort its simulation
>>>>>>>>> and go to H.qn, you now have a DIFFERENT H^, and THAT one will
>>>>>>>>> Halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>> machine to reach its final state then this machine is a non
>>>>>>>> halting computation because halting computations only include
>>>>>>>> machines that reach their final state.
>>>>>>>>
>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>> halting computation because halting computations only include
>>>>>>>> machine that reach their final state.
>>>>>>>>
>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>> halting computation because halting computations only include
>>>>>>>> machine that reach their final state.
>>>>>>>>
>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>> halting computation because halting computations only include
>>>>>>>> machine that reach their final state.
>>>>>>>>
>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>> halting computation because halting computations only include
>>>>>>>> machine that reach their final state.
>>>>>>>>
>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>> halting computation because halting computations only include
>>>>>>>> machine that reach their final state.
>>>>>>>>
>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>> halting computation because halting computations only include
>>>>>>>> machine that reach their final state.
>>>>>>>>
>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>> halting computation because halting computations only include
>>>>>>>> machine that reach their final state.
>>>>>>>>
>>>>>>>
>>>>>>> You don't get it, do you.
>>>>>>>
>>>>>>> The logic of arguing about different behaviors of H is invalid,
>>>>>>> because
>>>>>> Not at all. H does not report that an infinite loop does not halt
>>>>>> H reports that in infinite loop would not halt, so there are
>>>>>> always two behaviors for every computation that would not halt.
>>>>>>
>>>>>
>>>>> If H reports that H^(<H^>,<H^>) does not halt, then H^(<H^>) Halts,
>>>>> so it is wrong.
>>>>>
>>>>
>>>> Because it is true that the input to embedded_H would never reach
>>>> its final state even if an infinite number of its steps were
>>>> simulated then by the Linz definition of halting this input never
>>>> halts.
>>>>
>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>
>>>
>>> That doesn't matter, as non-halting is only measured by a REAL UTM,
>>> not by your halt decider.
>>>
>> That is certainly a foolish thing to say when you are already admitted
>> that a real UTM at Ĥ.qx would also cause Ĥ applied to ⟨Ĥ⟩ to never
>> stop running.
>>
>> THERE REALLY IS NO WAY AROUND THIS.
>> THERE REALLY IS NO WAY AROUND THIS.
>> THERE REALLY IS NO WAY AROUND THIS.
>>
>>
>
> Right, a REAL UTM would.
>
> A maybe UTM only maybe says it is non-halt (only if it never aborts)
>
> Are you claiming your H is a real UTM and never aborts?
>

On 1/1/22 10:57 PM, olcott wrote:
> On 1/1/2022 9:46 PM, Richard Damon wrote:
>>
>> On 1/1/22 10:32 PM, olcott wrote:
>>> On 1/1/2022 9:26 PM, Richard Damon wrote:
>>>>
>>>> On 1/1/22 10:15 PM, olcott wrote:
>>>>> On 1/1/2022 8:59 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/1/22 9:31 PM, olcott wrote:
>>>>>>> On 1/1/2022 8:11 PM, Richard Damon wrote:
>>>>>>>> On 1/1/22 7:35 PM, olcott wrote:
>>>>>>>>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>>>>>>>>> On 1/1/22 6:02 PM, olcott wrote:
>>>>>>>>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>>>>>>>>> Showing how the Linz Ĥ can be correctly decided as
>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>>>>>> notation)
>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at
>>>>>>>>>>>>>>> Ĥ.qx embedded_H.
>>>>>>>>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>> this input would never reach a final state and stop running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> computation that halts
>>>>>>>>>>>>>>> ...the Turing machine will halt whenever it enters a
>>>>>>>>>>>>>>> final state (Linz:1990:234)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That the pure simulation of an input would never reaches
>>>>>>>>>>>>>>> its final state conclusively proves that this input
>>>>>>>>>>>>>>> specifies a non-halting computation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to
>>>>>>>>>>>>>>> Ĥ.qn
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Peter Linz HP Proof
>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To be bit more clear, the critera that defines Halting is
>>>>>>>>>>>>>> NOT if H needs to abort its simulation, but does a UTM
>>>>>>>>>>>>>> processing that same input, with that input EXACTLY as
>>>>>>>>>>>>>> presented, which means the H embedded in it is still H and
>>>>>>>>>>>>>> behaves like H, NOT, as you presume, replaceed also with a
>>>>>>>>>>>>>> UTM.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This is why your logic is wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>>>>>>>>
>>>>>>>>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF
>>>>>>>>>>>> UTM(x,y) Halts.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> computation that halts
>>>>>>>>>>> … the Turing machine will halt whenever it enters a final
>>>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>>>
>>>>>>>>>>> Since I just proved the the simulated input would never reach
>>>>>>>>>>> its final state that means that it never halts.
>>>>>>>>>>>
>>>>>>>>>>> I generally have to tell you the same thing at least fifty
>>>>>>>>>>> times before you notice that I ever said it at least once.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, you didn't. You proved that IF H/embedded_H was designed
>>>>>>>>>> to never halt its simulation, then the H^ built on THAT
>>>>>>>>>> version of H would never halt.
>>>>>>>>>>
>>>>>>>>>> Once you change H/embedded_H to actually abort its simulation
>>>>>>>>>> and go to H.qn, you now have a DIFFERENT H^, and THAT one will
>>>>>>>>>> Halt.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>> machine to reach its final state then this machine is a non
>>>>>>>>> halting computation because halting computations only include
>>>>>>>>> machines that reach their final state.
>>>>>>>>>
>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>> halting computation because halting computations only include
>>>>>>>>> machine that reach their final state.
>>>>>>>>>
>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>> halting computation because halting computations only include
>>>>>>>>> machine that reach their final state.
>>>>>>>>>
>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>> halting computation because halting computations only include
>>>>>>>>> machine that reach their final state.
>>>>>>>>>
>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>> halting computation because halting computations only include
>>>>>>>>> machine that reach their final state.
>>>>>>>>>
>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>> halting computation because halting computations only include
>>>>>>>>> machine that reach their final state.
>>>>>>>>>
>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>> halting computation because halting computations only include
>>>>>>>>> machine that reach their final state.
>>>>>>>>>
>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>> halting computation because halting computations only include
>>>>>>>>> machine that reach their final state.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You don't get it, do you.
>>>>>>>>
>>>>>>>> The logic of arguing about different behaviors of H is invalid,
>>>>>>>> because
>>>>>>> Not at all. H does not report that an infinite loop does not halt
>>>>>>> H reports that in infinite loop would not halt, so there are
>>>>>>> always two behaviors for every computation that would not halt.
>>>>>>>
>>>>>>
>>>>>> If H reports that H^(<H^>,<H^>) does not halt, then H^(<H^>)
>>>>>> Halts, so it is wrong.
>>>>>>
>>>>>
>>>>> Because it is true that the input to embedded_H would never reach
>>>>> its final state even if an infinite number of its steps were
>>>>> simulated then by the Linz definition of halting this input never
>>>>> halts.
>>>>>
>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>
>>>>
>>>> That doesn't matter, as non-halting is only measured by a REAL UTM,
>>>> not by your halt decider.
>>>>
>>> That is certainly a foolish thing to say when you are already
>>> admitted that a real UTM at Ĥ.qx would also cause Ĥ applied to ⟨Ĥ⟩ to
>>> never stop running.
>>>
>>> THERE REALLY IS NO WAY AROUND THIS.
>>> THERE REALLY IS NO WAY AROUND THIS.
>>> THERE REALLY IS NO WAY AROUND THIS.
>>>
>>>
>>
>> Right, a REAL UTM would.
>>
>> A maybe UTM only maybe says it is non-halt (only if it never aborts)
>>
>> Are you claiming your H is a real UTM and never aborts?
>>
>
> The key point that seems to be utterly beyond your intellectual capacity
> is that because the input to embedded_H would never reach its final
> state under any condition what-so-ever (0 to ∞ steps simulated) this
> input never halts.
>
So, you are saying embedded_H never gets to either qn or qy? That is
the only way it never reaches its final state.

On 1/1/2022 10:15 PM, Richard Damon wrote:
> On 1/1/22 10:57 PM, olcott wrote:
>> On 1/1/2022 9:46 PM, Richard Damon wrote:
>>>
>>> On 1/1/22 10:32 PM, olcott wrote:
>>>> On 1/1/2022 9:26 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/1/22 10:15 PM, olcott wrote:
>>>>>> On 1/1/2022 8:59 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/1/22 9:31 PM, olcott wrote:
>>>>>>>> On 1/1/2022 8:11 PM, Richard Damon wrote:
>>>>>>>>> On 1/1/22 7:35 PM, olcott wrote:
>>>>>>>>>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/1/22 6:02 PM, olcott wrote:
>>>>>>>>>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>>>>>>>>>> Showing how the Linz Ĥ can be correctly decided as
>>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria Ben's
>>>>>>>>>>>>>>>> notation)
>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at
>>>>>>>>>>>>>>>> Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>> this input would never reach a final state and stop
>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> computation that halts
>>>>>>>>>>>>>>>> ...the Turing machine will halt whenever it enters a
>>>>>>>>>>>>>>>> final state (Linz:1990:234)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That the pure simulation of an input would never reaches
>>>>>>>>>>>>>>>> its final state conclusively proves that this input
>>>>>>>>>>>>>>>> specifies a non-halting computation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps to
>>>>>>>>>>>>>>>> Ĥ.qn
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Peter Linz HP Proof
>>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To be bit more clear, the critera that defines Halting is
>>>>>>>>>>>>>>> NOT if H needs to abort its simulation, but does a UTM
>>>>>>>>>>>>>>> processing that same input, with that input EXACTLY as
>>>>>>>>>>>>>>> presented, which means the H embedded in it is still H
>>>>>>>>>>>>>>> and behaves like H, NOT, as you presume, replaceed also
>>>>>>>>>>>>>>> with a UTM.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This is why your logic is wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF
>>>>>>>>>>>>> UTM(x,y) Halts.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> computation that halts
>>>>>>>>>>>> … the Turing machine will halt whenever it enters a final
>>>>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>>>>
>>>>>>>>>>>> Since I just proved the the simulated input would never
>>>>>>>>>>>> reach its final state that means that it never halts.
>>>>>>>>>>>>
>>>>>>>>>>>> I generally have to tell you the same thing at least fifty
>>>>>>>>>>>> times before you notice that I ever said it at least once.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, you didn't. You proved that IF H/embedded_H was designed
>>>>>>>>>>> to never halt its simulation, then the H^ built on THAT
>>>>>>>>>>> version of H would never halt.
>>>>>>>>>>>
>>>>>>>>>>> Once you change H/embedded_H to actually abort its simulation
>>>>>>>>>>> and go to H.qn, you now have a DIFFERENT H^, and THAT one
>>>>>>>>>>> will Halt.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>> machine to reach its final state then this machine is a non
>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>> machines that reach their final state.
>>>>>>>>>>
>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>
>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>
>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>
>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>
>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>
>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>
>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You don't get it, do you.
>>>>>>>>>
>>>>>>>>> The logic of arguing about different behaviors of H is invalid,
>>>>>>>>> because
>>>>>>>> Not at all. H does not report that an infinite loop does not
>>>>>>>> halt H reports that in infinite loop would not halt, so there
>>>>>>>> are always two behaviors for every computation that would not halt.
>>>>>>>>
>>>>>>>
>>>>>>> If H reports that H^(<H^>,<H^>) does not halt, then H^(<H^>)
>>>>>>> Halts, so it is wrong.
>>>>>>>
>>>>>>
>>>>>> Because it is true that the input to embedded_H would never reach
>>>>>> its final state even if an infinite number of its steps were
>>>>>> simulated then by the Linz definition of halting this input never
>>>>>> halts.
>>>>>>
>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>
>>>>>
>>>>> That doesn't matter, as non-halting is only measured by a REAL UTM,
>>>>> not by your halt decider.
>>>>>
>>>> That is certainly a foolish thing to say when you are already
>>>> admitted that a real UTM at Ĥ.qx would also cause Ĥ applied to ⟨Ĥ⟩
>>>> to never stop running.
>>>>
>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>
>>>>
>>>
>>> Right, a REAL UTM would.
>>>
>>> A maybe UTM only maybe says it is non-halt (only if it never aborts)
>>>
>>> Are you claiming your H is a real UTM and never aborts?
>>>
>>
>> The key point that seems to be utterly beyond your intellectual
>> capacity is that because the input to embedded_H would never reach its
>> final state under any condition what-so-ever (0 to ∞ steps simulated)
>> this input never halts.
>>
> So, you are saying embedded_H never gets to either qn or qy?  That is
> the only way it never reaches its final state.
>

On 1/1/22 11:34 PM, olcott wrote:
> On 1/1/2022 10:15 PM, Richard Damon wrote:
>> On 1/1/22 10:57 PM, olcott wrote:
>>> On 1/1/2022 9:46 PM, Richard Damon wrote:
>>>>
>>>> On 1/1/22 10:32 PM, olcott wrote:
>>>>> On 1/1/2022 9:26 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/1/22 10:15 PM, olcott wrote:
>>>>>>> On 1/1/2022 8:59 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/1/22 9:31 PM, olcott wrote:
>>>>>>>>> On 1/1/2022 8:11 PM, Richard Damon wrote:
>>>>>>>>>> On 1/1/22 7:35 PM, olcott wrote:
>>>>>>>>>>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/1/22 6:02 PM, olcott wrote:
>>>>>>>>>>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>> Showing how the Linz Ĥ can be correctly decided as
>>>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria
>>>>>>>>>>>>>>>>> Ben's notation)
>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at
>>>>>>>>>>>>>>>>> Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> this input would never reach a final state and stop
>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> computation that halts
>>>>>>>>>>>>>>>>> ...the Turing machine will halt whenever it enters a
>>>>>>>>>>>>>>>>> final state (Linz:1990:234)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That the pure simulation of an input would never
>>>>>>>>>>>>>>>>> reaches its final state conclusively proves that this
>>>>>>>>>>>>>>>>> input specifies a non-halting computation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps
>>>>>>>>>>>>>>>>> to Ĥ.qn
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Peter Linz HP Proof
>>>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> To be bit more clear, the critera that defines Halting
>>>>>>>>>>>>>>>> is NOT if H needs to abort its simulation, but does a
>>>>>>>>>>>>>>>> UTM processing that same input, with that input EXACTLY
>>>>>>>>>>>>>>>> as presented, which means the H embedded in it is still
>>>>>>>>>>>>>>>> H and behaves like H, NOT, as you presume, replaceed
>>>>>>>>>>>>>>>> also with a UTM.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This is why your logic is wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF
>>>>>>>>>>>>>> UTM(x,y) Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> computation that halts
>>>>>>>>>>>>> … the Turing machine will halt whenever it enters a final
>>>>>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since I just proved the the simulated input would never
>>>>>>>>>>>>> reach its final state that means that it never halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I generally have to tell you the same thing at least fifty
>>>>>>>>>>>>> times before you notice that I ever said it at least once.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, you didn't. You proved that IF H/embedded_H was designed
>>>>>>>>>>>> to never halt its simulation, then the H^ built on THAT
>>>>>>>>>>>> version of H would never halt.
>>>>>>>>>>>>
>>>>>>>>>>>> Once you change H/embedded_H to actually abort its
>>>>>>>>>>>> simulation and go to H.qn, you now have a DIFFERENT H^, and
>>>>>>>>>>>> THAT one will Halt.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>> machine to reach its final state then this machine is a non
>>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>>> machines that reach their final state.
>>>>>>>>>>>
>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>>
>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>>
>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>>
>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>>
>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>>
>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>>
>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>> halting computation because halting computations only include
>>>>>>>>>>> machine that reach their final state.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You don't get it, do you.
>>>>>>>>>>
>>>>>>>>>> The logic of arguing about different behaviors of H is
>>>>>>>>>> invalid, because
>>>>>>>>> Not at all. H does not report that an infinite loop does not
>>>>>>>>> halt H reports that in infinite loop would not halt, so there
>>>>>>>>> are always two behaviors for every computation that would not
>>>>>>>>> halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If H reports that H^(<H^>,<H^>) does not halt, then H^(<H^>)
>>>>>>>> Halts, so it is wrong.
>>>>>>>>
>>>>>>>
>>>>>>> Because it is true that the input to embedded_H would never reach
>>>>>>> its final state even if an infinite number of its steps were
>>>>>>> simulated then by the Linz definition of halting this input never
>>>>>>> halts.
>>>>>>>
>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>>
>>>>>>
>>>>>> That doesn't matter, as non-halting is only measured by a REAL
>>>>>> UTM, not by your halt decider.
>>>>>>
>>>>> That is certainly a foolish thing to say when you are already
>>>>> admitted that a real UTM at Ĥ.qx would also cause Ĥ applied to ⟨Ĥ⟩
>>>>> to never stop running.
>>>>>
>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>
>>>>>
>>>>
>>>> Right, a REAL UTM would.
>>>>
>>>> A maybe UTM only maybe says it is non-halt (only if it never aborts)
>>>>
>>>> Are you claiming your H is a real UTM and never aborts?
>>>>
>>>
>>> The key point that seems to be utterly beyond your intellectual
>>> capacity is that because the input to embedded_H would never reach
>>> its final state under any condition what-so-ever (0 to ∞ steps
>>> simulated) this input never halts.
>>>
>> So, you are saying embedded_H never gets to either qn or qy?  That is
>> the only way it never reaches its final state.
>>
>
> I don't believe that are are as stupid as you are acting.
>
> That fact that an infinite pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches a
> final state is the same basis that an infinite pure simulation of an
> infinite loop would never reach a final state thus in both cases
> complete proof that a transition to qn is correct.
>

On 1/2/2022 6:13 AM, Richard Damon wrote:
> On 1/1/22 11:34 PM, olcott wrote:
>> On 1/1/2022 10:15 PM, Richard Damon wrote:
>>> On 1/1/22 10:57 PM, olcott wrote:
>>>> On 1/1/2022 9:46 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/1/22 10:32 PM, olcott wrote:
>>>>>> On 1/1/2022 9:26 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/1/22 10:15 PM, olcott wrote:
>>>>>>>> On 1/1/2022 8:59 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/1/22 9:31 PM, olcott wrote:
>>>>>>>>>> On 1/1/2022 8:11 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/1/22 7:35 PM, olcott wrote:
>>>>>>>>>>>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/1/22 6:02 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> Showing how the Linz Ĥ can be correctly decided as
>>>>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria
>>>>>>>>>>>>>>>>>> Ben's notation)
>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at
>>>>>>>>>>>>>>>>>> Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If embedded_H would never stop simulating its input
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> this input would never reach a final state and stop
>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> computation that halts
>>>>>>>>>>>>>>>>>> ...the Turing machine will halt whenever it enters a
>>>>>>>>>>>>>>>>>> final state (Linz:1990:234)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That the pure simulation of an input would never
>>>>>>>>>>>>>>>>>> reaches its final state conclusively proves that this
>>>>>>>>>>>>>>>>>> input specifies a non-halting computation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps
>>>>>>>>>>>>>>>>>> to Ĥ.qn
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Peter Linz HP Proof
>>>>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> To be bit more clear, the critera that defines Halting
>>>>>>>>>>>>>>>>> is NOT if H needs to abort its simulation, but does a
>>>>>>>>>>>>>>>>> UTM processing that same input, with that input EXACTLY
>>>>>>>>>>>>>>>>> as presented, which means the H embedded in it is still
>>>>>>>>>>>>>>>>> H and behaves like H, NOT, as you presume, replaceed
>>>>>>>>>>>>>>>>> also with a UTM.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This is why your logic is wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF
>>>>>>>>>>>>>>> UTM(x,y) Halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> computation that halts
>>>>>>>>>>>>>> … the Turing machine will halt whenever it enters a final
>>>>>>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since I just proved the the simulated input would never
>>>>>>>>>>>>>> reach its final state that means that it never halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I generally have to tell you the same thing at least fifty
>>>>>>>>>>>>>> times before you notice that I ever said it at least once.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, you didn't. You proved that IF H/embedded_H was
>>>>>>>>>>>>> designed to never halt its simulation, then the H^ built on
>>>>>>>>>>>>> THAT version of H would never halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Once you change H/embedded_H to actually abort its
>>>>>>>>>>>>> simulation and go to H.qn, you now have a DIFFERENT H^, and
>>>>>>>>>>>>> THAT one will Halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>> machine to reach its final state then this machine is a non
>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>> include machines that reach their final state.
>>>>>>>>>>>>
>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>
>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>
>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>
>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>
>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>
>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>
>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You don't get it, do you.
>>>>>>>>>>>
>>>>>>>>>>> The logic of arguing about different behaviors of H is
>>>>>>>>>>> invalid, because
>>>>>>>>>> Not at all. H does not report that an infinite loop does not
>>>>>>>>>> halt H reports that in infinite loop would not halt, so there
>>>>>>>>>> are always two behaviors for every computation that would not
>>>>>>>>>> halt.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If H reports that H^(<H^>,<H^>) does not halt, then H^(<H^>)
>>>>>>>>> Halts, so it is wrong.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Because it is true that the input to embedded_H would never
>>>>>>>> reach its final state even if an infinite number of its steps
>>>>>>>> were simulated then by the Linz definition of halting this input
>>>>>>>> never halts.
>>>>>>>>
>>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>>>
>>>>>>>
>>>>>>> That doesn't matter, as non-halting is only measured by a REAL
>>>>>>> UTM, not by your halt decider.
>>>>>>>
>>>>>> That is certainly a foolish thing to say when you are already
>>>>>> admitted that a real UTM at Ĥ.qx would also cause Ĥ applied to ⟨Ĥ⟩
>>>>>> to never stop running.
>>>>>>
>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>
>>>>>>
>>>>>
>>>>> Right, a REAL UTM would.
>>>>>
>>>>> A maybe UTM only maybe says it is non-halt (only if it never aborts)
>>>>>
>>>>> Are you claiming your H is a real UTM and never aborts?
>>>>>
>>>>
>>>> The key point that seems to be utterly beyond your intellectual
>>>> capacity is that because the input to embedded_H would never reach
>>>> its final state under any condition what-so-ever (0 to ∞ steps
>>>> simulated) this input never halts.
>>>>
>>> So, you are saying embedded_H never gets to either qn or qy?  That is
>>> the only way it never reaches its final state.
>>>
>>
>> I don't believe that are are as stupid as you are acting.
>>
>> That fact that an infinite pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches a
>> final state is the same basis that an infinite pure simulation of an
>> infinite loop would never reach a final state thus in both cases
>> complete proof that a transition to qn is correct.
>>
>
> No. IF an infinite simulation of <H^> <H^> never reaches a final state,
> then YES H^(<H^>) is in fact Non-Halting.
>
> But in your case, that isn't what is happening.
>

On 1/2/22 10:11 AM, olcott wrote:
> On 1/2/2022 6:13 AM, Richard Damon wrote:
>> On 1/1/22 11:34 PM, olcott wrote:
>>> On 1/1/2022 10:15 PM, Richard Damon wrote:
>>>> On 1/1/22 10:57 PM, olcott wrote:
>>>>> On 1/1/2022 9:46 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/1/22 10:32 PM, olcott wrote:
>>>>>>> On 1/1/2022 9:26 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/1/22 10:15 PM, olcott wrote:
>>>>>>>>> On 1/1/2022 8:59 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/1/22 9:31 PM, olcott wrote:
>>>>>>>>>>> On 1/1/2022 8:11 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/1/22 7:35 PM, olcott wrote:
>>>>>>>>>>>>> On 1/1/2022 6:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/1/22 6:02 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/1/2022 3:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/1/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/1/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 1/1/22 4:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> Showing how the Linz Ĥ can be correctly decided as
>>>>>>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria
>>>>>>>>>>>>>>>>>>> Ben's notation)
>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at
>>>>>>>>>>>>>>>>>>> Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>>>> embedded_H correctly determines that its input ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ never halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If embedded_H would never stop simulating its input
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> this input would never reach a final state and stop
>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> computation that halts
>>>>>>>>>>>>>>>>>>> ...the Turing machine will halt whenever it enters a
>>>>>>>>>>>>>>>>>>> final state (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That the pure simulation of an input would never
>>>>>>>>>>>>>>>>>>> reaches its final state conclusively proves that this
>>>>>>>>>>>>>>>>>>> input specifies a non-halting computation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This proves that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H maps
>>>>>>>>>>>>>>>>>>> to Ĥ.qn
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Peter Linz HP Proof
>>>>>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> To be bit more clear, the critera that defines Halting
>>>>>>>>>>>>>>>>>> is NOT if H needs to abort its simulation, but does a
>>>>>>>>>>>>>>>>>> UTM processing that same input, with that input
>>>>>>>>>>>>>>>>>> EXACTLY as presented, which means the H embedded in it
>>>>>>>>>>>>>>>>>> is still H and behaves like H, NOT, as you presume,
>>>>>>>>>>>>>>>>>> replaceed also with a UTM.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This is why your logic is wrong.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H(x,y) halts iff UTM(x,y) halts (reaches its final state)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, if H meets its requirements, H(x,y) -> Qy IFF
>>>>>>>>>>>>>>>> UTM(x,y) Halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> computation that halts
>>>>>>>>>>>>>>> … the Turing machine will halt whenever it enters a final
>>>>>>>>>>>>>>> state. (Linz:1990:234)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Since I just proved the the simulated input would never
>>>>>>>>>>>>>>> reach its final state that means that it never halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I generally have to tell you the same thing at least
>>>>>>>>>>>>>>> fifty times before you notice that I ever said it at
>>>>>>>>>>>>>>> least once.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, you didn't. You proved that IF H/embedded_H was
>>>>>>>>>>>>>> designed to never halt its simulation, then the H^ built
>>>>>>>>>>>>>> on THAT version of H would never halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Once you change H/embedded_H to actually abort its
>>>>>>>>>>>>>> simulation and go to H.qn, you now have a DIFFERENT H^,
>>>>>>>>>>>>>> and THAT one will Halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>>> machine to reach its final state then this machine is a non
>>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>>> include machines that reach their final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If it is the case that no amount of simulation will cause a
>>>>>>>>>>>>> machine to reach its final state then this machine is a not
>>>>>>>>>>>>> halting computation because halting computations only
>>>>>>>>>>>>> include machine that reach their final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You don't get it, do you.
>>>>>>>>>>>>
>>>>>>>>>>>> The logic of arguing about different behaviors of H is
>>>>>>>>>>>> invalid, because
>>>>>>>>>>> Not at all. H does not report that an infinite loop does not
>>>>>>>>>>> halt H reports that in infinite loop would not halt, so there
>>>>>>>>>>> are always two behaviors for every computation that would not
>>>>>>>>>>> halt.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If H reports that H^(<H^>,<H^>) does not halt, then H^(<H^>)
>>>>>>>>>> Halts, so it is wrong.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because it is true that the input to embedded_H would never
>>>>>>>>> reach its final state even if an infinite number of its steps
>>>>>>>>> were simulated then by the Linz definition of halting this
>>>>>>>>> input never halts.
>>>>>>>>>
>>>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>>>>
>>>>>>>>
>>>>>>>> That doesn't matter, as non-halting is only measured by a REAL
>>>>>>>> UTM, not by your halt decider.
>>>>>>>>
>>>>>>> That is certainly a foolish thing to say when you are already
>>>>>>> admitted that a real UTM at Ĥ.qx would also cause Ĥ applied to
>>>>>>> ⟨Ĥ⟩ to never stop running.
>>>>>>>
>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>> THERE REALLY IS NO WAY AROUND THIS.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Right, a REAL UTM would.
>>>>>>
>>>>>> A maybe UTM only maybe says it is non-halt (only if it never aborts)
>>>>>>
>>>>>> Are you claiming your H is a real UTM and never aborts?
>>>>>>
>>>>>
>>>>> The key point that seems to be utterly beyond your intellectual
>>>>> capacity is that because the input to embedded_H would never reach
>>>>> its final state under any condition what-so-ever (0 to ∞ steps
>>>>> simulated) this input never halts.
>>>>>
>>>> So, you are saying embedded_H never gets to either qn or qy?  That
>>>> is the only way it never reaches its final state.
>>>>
>>>
>>> I don't believe that are are as stupid as you are acting.
>>>
>>> That fact that an infinite pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches a
>>> final state is the same basis that an infinite pure simulation of an
>>> infinite loop would never reach a final state thus in both cases
>>> complete proof that a transition to qn is correct.
>>>
>>
>> No. IF an infinite simulation of <H^> <H^> never reaches a final
>> state, then YES H^(<H^>) is in fact Non-Halting.
>>
>> But in your case, that isn't what is happening.
>>
>
> It is the case that a pure simulation of both inputs would never reach
> their final state even if they would be simulated infinitely. Thus in
> both cases the simulation can be aborted and a transition to the qn
> reject state is correct.