This reminded me of Olcott

<https://xkcd.com/2566/>

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 2/28/2022 4:08 PM, André G. Isaak wrote:
> This reminded me of Olcott
>
> <https://xkcd.com/2566/>
>
> André
>

You still have not shown that I am incorrect.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

It is the case than unless embedded_H aborts the simulation of its input
that this input would never stop running.

It is also the case that the fact that this
IS A REASONABLE MEASURE THAT THIS INPUT SPECIFIES A NON HALTING SEQUENCE
OF CONFIGURATIONS.

The above two facts taken together prove that the essence of my idea is
correct.

--
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 2/28/22 5:47 PM, olcott wrote:
> On 2/28/2022 4:08 PM, André G. Isaak wrote:
>> This reminded me of Olcott
>>
>> <https://xkcd.com/2566/>
>>
>> André
>>
>
> You still have not shown that I am incorrect.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> It is the case than unless embedded_H aborts the simulation of its input
> that this input would never stop running.
>
> It is also the case that the fact that this
> IS A REASONABLE MEASURE THAT THIS INPUT SPECIFIES A NON HALTING SEQUENCE
> OF CONFIGURATIONS.
>
> The above two facts taken together prove that the essence of my idea is
> correct.
>

It is only a reasonable measure if H NEVER aborts its simulation (not
unless, NEVER).

This is because the ONLY DEFINITION is:

H <M> w -> H.Qy iff M w Halts, and -> H.Qn if M w never Halts.

and M w Halting can be alternately tested by UTM <M> w,

and a UTM is a simulation that NEVER aborts its simulation until it
reachs a final state.

Thus, all you have shown is that H can perhaps detect that H^ applied to
<H^> is non-halting if H never aborts, and then H can DIE in its
infinite loop and become a FAILED decider (just like you are being).

Once H is changed to abort is simulation, any reference to that proof
based on the H that never aborted is simulation is just a blatent LIE
and yields UNSOUND proofs.

Thus, your argument has FAILED.

On 2/28/2022 6:06 PM, Richard Damon wrote:
>
> On 2/28/22 5:47 PM, olcott wrote:
>> On 2/28/2022 4:08 PM, André G. Isaak wrote:
>>> This reminded me of Olcott
>>>
>>> <https://xkcd.com/2566/>
>>>
>>> André
>>>
>>
>> You still have not shown that I am incorrect.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> It is the case than unless embedded_H aborts the simulation of its
>> input that this input would never stop running.
>>
>> It is also the case that the fact that this
>> IS A REASONABLE MEASURE THAT THIS INPUT SPECIFIES A NON HALTING
>> SEQUENCE OF CONFIGURATIONS.
>>
>> The above two facts taken together prove that the essence of my idea
>> is correct.
>>
>
> It is only a reasonable measure if H NEVER aborts its simulation (not
> unless, NEVER).
It is known to be a reasonable measure on the basis of the meaning of
its words. The meaning of these words are simply over your head.

For every type of non-halting sequence of configurations:
(a) Infinite loop
(b) Infinite Recursion
(c) Infinitely nested simulation
(d) Pathological self-reference

As long as the simulation would never stop running unless the simulating
halt decider H aborted its simulation H is necessarily always correct to
reject this input.

--
Copyright 2021 Pete Olcott

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

On 2/28/22 7:17 PM, olcott wrote:
> On 2/28/2022 6:06 PM, Richard Damon wrote:
>>
>> On 2/28/22 5:47 PM, olcott wrote:
>>> On 2/28/2022 4:08 PM, André G. Isaak wrote:
>>>> This reminded me of Olcott
>>>>
>>>> <https://xkcd.com/2566/>
>>>>
>>>> André
>>>>
>>>
>>> You still have not shown that I am incorrect.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> It is the case than unless embedded_H aborts the simulation of its
>>> input that this input would never stop running.
>>>
>>> It is also the case that the fact that this
>>> IS A REASONABLE MEASURE THAT THIS INPUT SPECIFIES A NON HALTING
>>> SEQUENCE OF CONFIGURATIONS.
>>>
>>> The above two facts taken together prove that the essence of my idea
>>> is correct.
>>>
>>
>> It is only a reasonable measure if H NEVER aborts its simulation (not
>> unless, NEVER).
> It is known to be a reasonable measure on the basis of the meaning of
> its words. The meaning of these words are simply over your head.

Nope. Maybe to someone who doesn't understand the REAL meaning.

Since we HAVE an actual definition, and you have even shown you KNOW it,
the fact that you don't use it just shows you are a pathological liar.

BY DEFINITION:

H <M> w needs to -> H.Qy if M w Halts and -> H.Qn if M w never halts.
Thus H <H^> <H^> needs to go to H.Qy if H^ <H^> Halts.

Since you claim that H <H^> <H^> is correct in going to H.Qn we know
that it does this, and we also know by the rules of construction of H^
that the H^ that this copy of H was put into when applied to <H^> will
use that H to see that H -> H.Qn, so H^ -> H^.Qn and Halts.

Since if H^ applied to <H^> Halts, we know that for H to have been
correct, it needed to go to H.Qy not H.Qn, so BY DEFINTION H was wrong,
and any claim otherwise is just a LIE.

Maybe these words are just over your head, if so, you need to stop
lyiing and making claims you know something about this.

FAIL.

>
> For every type of non-halting sequence of configurations:
> (a) Infinite loop
> (b) Infinite Recursion
> (c) Infinitely nested simulation
> (d) Pathological self-reference

except it doesn't work for (d) as shown above.
>
> As long as the simulation would never stop running unless the simulating
> halt decider H aborted its simulation H is necessarily always correct to
> reject this input.
>

Fallicy of proof by example.

The counter example you your proof by example is H^, where the
dependency of the machine on the decider breaks your logic, because you
are using the wrong definiton

You have PROVED, by your own admission, that you don't understand even
the basics of Computation Theory (you don't even know what a Computation
actually is).

Therefore, the reliance of YOUR understanding of the words is bad logic.

YOU HAVE FAILED.

YOU ARE WRONG, by the DEFINITION of the actual words as used in the Theory.

You are also GUILTY of no even obeying your own concept of Truth, so you
are shown to be just a lying hypocrite who is doomed for an eternity of
ridicule.

You are just digging your grave deeper and making it harder for you to
change your direction and make something out of your life.

YOU HAVE JUST FAILED.

All you have proven is your POOP.

On 2/28/2022 6:31 PM, Richard Damon wrote:
>
> On 2/28/22 7:17 PM, olcott wrote:
>> On 2/28/2022 6:06 PM, Richard Damon wrote:
>>>
>>> On 2/28/22 5:47 PM, olcott wrote:
>>>> On 2/28/2022 4:08 PM, André G. Isaak wrote:
>>>>> This reminded me of Olcott
>>>>>
>>>>> <https://xkcd.com/2566/>
>>>>>
>>>>> André
>>>>>
>>>>
>>>> You still have not shown that I am incorrect.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> It is the case than unless embedded_H aborts the simulation of its
>>>> input that this input would never stop running.
>>>>
>>>> It is also the case that the fact that this
>>>> IS A REASONABLE MEASURE THAT THIS INPUT SPECIFIES A NON HALTING
>>>> SEQUENCE OF CONFIGURATIONS.
>>>>
>>>> The above two facts taken together prove that the essence of my idea
>>>> is correct.
>>>>
>>>
>>> It is only a reasonable measure if H NEVER aborts its simulation (not
>>> unless, NEVER).
>> It is known to be a reasonable measure on the basis of the meaning of
>> its words. The meaning of these words are simply over your head.
>
> Nope. Maybe to someone who doesn't understand the REAL meaning.
>
> Since we HAVE an actual definition, and you have even shown you KNOW it,
> the fact that you don't use it just shows you are a pathological liar.
>
> BY DEFINITION:
>
> H <M> w needs to -> H.Qy if M w Halts and -> H.Qn if M w never halts.
> Thus H <H^> <H^> needs to go to H.Qy if H^ <H^> Halts.
>
> Since you claim that H <H^> <H^> is correct in going to H.Qn we know
> that it does this, and we also know by the rules of construction of H^
> that the H^ that this copy of H was put into when applied to <H^> will
> use that H to see that H -> H.Qn, so H^ -> H^.Qn and Halts.
>
> Since if H^ applied to <H^> Halts, we know that for H to have been
> correct, it needed to go to H.Qy not H.Qn, so BY DEFINTION H was wrong,
> and any claim otherwise is just a LIE.
>

The actual behavior of the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H proves
that I am right.

When someone smashes a Boston cream pie in your face denying that this
is not possible "in theory" does not stop the pie from dripping from
your face.

> Maybe these words are just over your head, if so, you need to stop
> lyiing and making claims you know something about this.
>
> FAIL.
>
>>
>> For every type of non-halting sequence of configurations:
>> (a) Infinite loop
>> (b) Infinite Recursion
>> (c) Infinitely nested simulation
>> (d) Pathological self-reference
>
> except it doesn't work for (d) as shown above.

It does work for (d) you are merely having a break from reality.

It is the case that unless embedded_H aborts the simulation of its input
that this simulation never stops. You know and acknowledge that this is
true.

A reasonable mind (not yours) would comprehend that this means that the
input to embedded_H specifies a sequence of configurations that never
halt in the same way that an infinite loop specifies a sequence of
configurations that never halt. It is the exact same principle in both
cases.

You keep saying that if H aborts its simulation that the infinitely
nested simulation no longer exists. This is exactly the same as when H
aborts its simulation of an infinite loop, the loop stops running
because it has been aborted.

Aborting the simulation of an otherwise infinite sequence of
configurations does not magically transform them into halting computations.

--
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 2/28/22 7:55 PM, olcott wrote:
> On 2/28/2022 6:31 PM, Richard Damon wrote:
>>
>> On 2/28/22 7:17 PM, olcott wrote:
>>> On 2/28/2022 6:06 PM, Richard Damon wrote:
>>>>
>>>> On 2/28/22 5:47 PM, olcott wrote:
>>>>> On 2/28/2022 4:08 PM, André G. Isaak wrote:
>>>>>> This reminded me of Olcott
>>>>>>
>>>>>> <https://xkcd.com/2566/>
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> You still have not shown that I am incorrect.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> It is the case than unless embedded_H aborts the simulation of its
>>>>> input that this input would never stop running.
>>>>>
>>>>> It is also the case that the fact that this
>>>>> IS A REASONABLE MEASURE THAT THIS INPUT SPECIFIES A NON HALTING
>>>>> SEQUENCE OF CONFIGURATIONS.
>>>>>
>>>>> The above two facts taken together prove that the essence of my
>>>>> idea is correct.
>>>>>
>>>>
>>>> It is only a reasonable measure if H NEVER aborts its simulation
>>>> (not unless, NEVER).
>>> It is known to be a reasonable measure on the basis of the meaning of
>>> its words. The meaning of these words are simply over your head.
>>
>> Nope. Maybe to someone who doesn't understand the REAL meaning.
>>
>> Since we HAVE an actual definition, and you have even shown you KNOW
>> it, the fact that you don't use it just shows you are a pathological
>> liar.
>>
>> BY DEFINITION:
>>
>> H <M> w needs to -> H.Qy if M w Halts and -> H.Qn if M w never halts.
>> Thus H <H^> <H^> needs to go to H.Qy if H^ <H^> Halts.
>>
>> Since you claim that H <H^> <H^> is correct in going to H.Qn we know
>> that it does this, and we also know by the rules of construction of H^
>> that the H^ that this copy of H was put into when applied to <H^> will
>> use that H to see that H -> H.Qn, so H^ -> H^.Qn and Halts.
>>
>> Since if H^ applied to <H^> Halts, we know that for H to have been
>> correct, it needed to go to H.Qy not H.Qn, so BY DEFINTION H was
>> wrong, and any claim otherwise is just a LIE.
>>
>
> The actual behavior of the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H proves
> that I am right.

WHICH embedded_H?

The one that doesn't abort, and thus is wrong because it never gives an
anwswer, or

The one that does abort, and gives the wrong answer becuase the H^ built
on it does halts (you only show the behavior of the H^ built on the
embedded_H that doesn't).
>
> When someone smashes a Boston cream pie in your face denying that this
> is not possible "in theory" does not stop the pie from dripping from
> your face.
>

Red Herring, but perhaps just shows how silly you look when you push the
cream pie into your own face as you show how little you understand even
the basic concepts.

>> Maybe these words are just over your head, if so, you need to stop
>> lyiing and making claims you know something about this.
>>
>> FAIL.
>>
>>>
>>> For every type of non-halting sequence of configurations:
>>> (a) Infinite loop
>>> (b) Infinite Recursion
>>> (c) Infinitely nested simulation
>>> (d) Pathological self-reference
>>
>> except it doesn't work for (d) as shown above.
>
> It does work for (d) you are merely having a break from reality.

Try to refute this prove that is doesn't:

DEFINITION of the correct answer for H:

1) H <M> w needs to -> H.Qy iff M w Halts, and -> H.Qn iff M w never halts

Thus

2) H <H^> <H^> needs -> H.Qy iff H^ <H^> Halts, and -> H.Qn if H^ <H^>
never Halts.

3) You claim that H <H^> <H^> is correct in going to H.Qn, so if H for
this to possibly be true, H <H^> <H^> -> H.Qn.

4) We know by the construction of H^ that H^ w uses H w w and goes to
its corresponding state H.Qy / H^.Qy and H.Qn / H^.Qn

5) With w = <H^> we have that

6) H^ <H^> uses H <H^> <H^> and from above we have that this goes to
H.Qn, so H^ goes to H^.Qn and then HALTS by construciton.

7) Thus H^ <H^> HALTS.

8) Thus by the requrieents in 2, H <H^> <H^> NEEDED to go to H.Qy to be
correct, but by 3 it went to H.Qn

9) Since H.Qy is not H.Qn, H gave the wrong answer.

FAILURE TO POINT OUT AN ERROR IS AN ADMISSION THAT YOU DON'T HAVE A
REBUTTAL.

>
> It is the case that unless embedded_H aborts the simulation of its input
> that this simulation never stops. You know and acknowledge that this is
> true.

But that isn't the definition. So FAIL.

>
> A reasonable mind (not yours) would comprehend that this means that the
> input to embedded_H specifies a sequence of configurations that never
> halt in the same way that an infinite loop specifies a sequence of
> configurations that never halt. It is the exact same principle in both
> cases.

Nope all you have shown is that you are an idiot and a half wit because
you don't complete your logic.

>
> You keep saying that if H aborts its simulation that the infinitely
> nested simulation no longer exists. This  is exactly the same as when H
> aborts its simulation of an infinite loop, the loop stops running
> because it has been aborted.
>
> Aborting the simulation of an otherwise infinite sequence of
> configurations does not magically transform them into halting computations.
>

No, the fact that H will abort its simulation means tha tH^ never was a
non-halting computaiton.

THe magic was when you had an H that would NEVER abort it simulation
transform into a machine that does.

THAT is the Fairy Dust Powered Unicorn, and where you FAIL.

On 2/28/2022 7:18 PM, Richard Damon wrote:
> On 2/28/22 7:55 PM, olcott wrote:
>> On 2/28/2022 6:31 PM, Richard Damon wrote:
>>>
>>> On 2/28/22 7:17 PM, olcott wrote:
>>>> On 2/28/2022 6:06 PM, Richard Damon wrote:
>>>>>
>>>>> On 2/28/22 5:47 PM, olcott wrote:
>>>>>> On 2/28/2022 4:08 PM, André G. Isaak wrote:
>>>>>>> This reminded me of Olcott
>>>>>>>
>>>>>>> <https://xkcd.com/2566/>
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> You still have not shown that I am incorrect.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> It is the case than unless embedded_H aborts the simulation of its
>>>>>> input that this input would never stop running.
>>>>>>
>>>>>> It is also the case that the fact that this
>>>>>> IS A REASONABLE MEASURE THAT THIS INPUT SPECIFIES A NON HALTING
>>>>>> SEQUENCE OF CONFIGURATIONS.
>>>>>>
>>>>>> The above two facts taken together prove that the essence of my
>>>>>> idea is correct.
>>>>>>
>>>>>
>>>>> It is only a reasonable measure if H NEVER aborts its simulation
>>>>> (not unless, NEVER).
>>>> It is known to be a reasonable measure on the basis of the meaning
>>>> of its words. The meaning of these words are simply over your head.
>>>
>>> Nope. Maybe to someone who doesn't understand the REAL meaning.
>>>
>>> Since we HAVE an actual definition, and you have even shown you KNOW
>>> it, the fact that you don't use it just shows you are a pathological
>>> liar.
>>>
>>> BY DEFINITION:
>>>
>>> H <M> w needs to -> H.Qy if M w Halts and -> H.Qn if M w never halts.
>>> Thus H <H^> <H^> needs to go to H.Qy if H^ <H^> Halts.
>>>
>>> Since you claim that H <H^> <H^> is correct in going to H.Qn we know
>>> that it does this, and we also know by the rules of construction of
>>> H^ that the H^ that this copy of H was put into when applied to <H^>
>>> will use that H to see that H -> H.Qn, so H^ -> H^.Qn and Halts.
>>>
>>> Since if H^ applied to <H^> Halts, we know that for H to have been
>>> correct, it needed to go to H.Qy not H.Qn, so BY DEFINTION H was
>>> wrong, and any claim otherwise is just a LIE.
>>>
>>
>> The actual behavior of the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H proves
>> that I am right.
>
> WHICH embedded_H?
>
> The one that doesn't abort, and thus is wrong because it never gives an
> anwswer, or
>
> The one that does abort, and gives the wrong answer becuase the H^ built
> on it does halts (you only show the behavior of the H^ built on the
> embedded_H that doesn't).
>>
>> When someone smashes a Boston cream pie in your face denying that this
>> is not possible "in theory" does not stop the pie from dripping from
>> your face.
>>
>
> Red Herring, but perhaps just shows how silly you look when you push the
> cream pie into your own face as you show how little you understand even
> the basic concepts.
>
>>> Maybe these words are just over your head, if so, you need to stop
>>> lyiing and making claims you know something about this.
>>>
>>> FAIL.
>>>
>>>>
>>>> For every type of non-halting sequence of configurations:
>>>> (a) Infinite loop
>>>> (b) Infinite Recursion
>>>> (c) Infinitely nested simulation
>>>> (d) Pathological self-reference
>>>
>>> except it doesn't work for (d) as shown above.
>>
>> It does work for (d) you are merely having a break from reality.
>
>
> Try to refute this prove that is doesn't:
>
> DEFINITION of the correct answer for H:
>
> 1) H <M> w needs to -> H.Qy iff M w Halts, and -> H.Qn iff M w never halts
>
> Thus
>
> 2) H <H^> <H^> needs -> H.Qy iff H^ <H^> Halts, and -> H.Qn if H^ <H^>
> never Halts.
>

The above is misleading syntax, Linz confused himself by using
misleading syntax.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

You must use only the above syntax and you must refer to the copy of H
embedded at Ĥ.qx as embedded_H.

> 3) You claim that H <H^> <H^> is correct in going to H.Qn, so if H for
> this to possibly be true, H <H^> <H^> -> H.Qn.
>

This is off topic, I am only discussing embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩

> 4) We know by the construction of H^ that H^ w uses H w w and goes to
> its corresponding state H.Qy / H^.Qy and H.Qn / H^.Qn

w is off topic you must use the stipulated syntax.

>
> 5) With w = <H^> we have that
>
> 6) H^ <H^> uses H <H^> <H^> and from above we have that this goes to
> H.Qn, so H^ goes to H^.Qn and then HALTS by construciton.
>
> 7) Thus H^ <H^> HALTS.
>
> 8) Thus by the requrieents in 2, H <H^> <H^> NEEDED to go to H.Qy to be
> correct, but by 3 it went to H.Qn
>
> 9) Since H.Qy is not H.Qn, H gave the wrong answer.
>
>
> FAILURE TO POINT OUT AN ERROR IS AN ADMISSION THAT YOU DON'T HAVE A
> REBUTTAL.
>
>>
>> It is the case that unless embedded_H aborts the simulation of its
>> input that this simulation never stops. You know and acknowledge that
>> this is true.
>
> But that isn't the definition. So FAIL.
>
>
>>
>> A reasonable mind (not yours) would comprehend that this means that
>> the input to embedded_H specifies a sequence of configurations that
>> never halt in the same way that an infinite loop specifies a sequence
>> of configurations that never halt. It is the exact same principle in
>> both cases.
>
> Nope all you have shown is that you are an idiot and a half wit because
> you don't complete your logic.
>
>>
>> You keep saying that if H aborts its simulation that the infinitely
>> nested simulation no longer exists. This  is exactly the same as when
>> H aborts its simulation of an infinite loop, the loop stops running
>> because it has been aborted.
>>
>> Aborting the simulation of an otherwise infinite sequence of
>> configurations does not magically transform them into halting
>> computations.
>>
>
> No, the fact that H will abort its simulation means tha tH^ never was a
> non-halting computaiton.
>

That is the same freaking moronic thing as saying that an infinite loop
is not an infinite loop when its simulating halt decider aborts it.

> THe magic was when you had an H that would NEVER abort it simulation
> transform into a machine that does.
>
> THAT is the Fairy Dust Powered Unicorn, and where you FAIL.

--
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 2/28/22 8:47 PM, olcott wrote:
> On 2/28/2022 7:18 PM, Richard Damon wrote:
>> On 2/28/22 7:55 PM, olcott wrote:
>>> On 2/28/2022 6:31 PM, Richard Damon wrote:
>>>>
>>>> On 2/28/22 7:17 PM, olcott wrote:
>>>>> On 2/28/2022 6:06 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 2/28/22 5:47 PM, olcott wrote:
>>>>>>> On 2/28/2022 4:08 PM, André G. Isaak wrote:
>>>>>>>> This reminded me of Olcott
>>>>>>>>
>>>>>>>> <https://xkcd.com/2566/>
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> You still have not shown that I am incorrect.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> It is the case than unless embedded_H aborts the simulation of
>>>>>>> its input that this input would never stop running.
>>>>>>>
>>>>>>> It is also the case that the fact that this
>>>>>>> IS A REASONABLE MEASURE THAT THIS INPUT SPECIFIES A NON HALTING
>>>>>>> SEQUENCE OF CONFIGURATIONS.
>>>>>>>
>>>>>>> The above two facts taken together prove that the essence of my
>>>>>>> idea is correct.
>>>>>>>
>>>>>>
>>>>>> It is only a reasonable measure if H NEVER aborts its simulation
>>>>>> (not unless, NEVER).
>>>>> It is known to be a reasonable measure on the basis of the meaning
>>>>> of its words. The meaning of these words are simply over your head.
>>>>
>>>> Nope. Maybe to someone who doesn't understand the REAL meaning.
>>>>
>>>> Since we HAVE an actual definition, and you have even shown you KNOW
>>>> it, the fact that you don't use it just shows you are a pathological
>>>> liar.
>>>>
>>>> BY DEFINITION:
>>>>
>>>> H <M> w needs to -> H.Qy if M w Halts and -> H.Qn if M w never halts.
>>>> Thus H <H^> <H^> needs to go to H.Qy if H^ <H^> Halts.
>>>>
>>>> Since you claim that H <H^> <H^> is correct in going to H.Qn we know
>>>> that it does this, and we also know by the rules of construction of
>>>> H^ that the H^ that this copy of H was put into when applied to <H^>
>>>> will use that H to see that H -> H.Qn, so H^ -> H^.Qn and Halts.
>>>>
>>>> Since if H^ applied to <H^> Halts, we know that for H to have been
>>>> correct, it needed to go to H.Qy not H.Qn, so BY DEFINTION H was
>>>> wrong, and any claim otherwise is just a LIE.
>>>>
>>>
>>> The actual behavior of the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H proves
>>> that I am right.
>>
>> WHICH embedded_H?
>>
>> The one that doesn't abort, and thus is wrong because it never gives
>> an anwswer, or
>>
>> The one that does abort, and gives the wrong answer becuase the H^
>> built on it does halts (you only show the behavior of the H^ built on
>> the embedded_H that doesn't).
>>>
>>> When someone smashes a Boston cream pie in your face denying that
>>> this is not possible "in theory" does not stop the pie from dripping
>>> from your face.
>>>
>>
>> Red Herring, but perhaps just shows how silly you look when you push
>> the cream pie into your own face as you show how little you understand
>> even the basic concepts.
>>
>>>> Maybe these words are just over your head, if so, you need to stop
>>>> lyiing and making claims you know something about this.
>>>>
>>>> FAIL.
>>>>
>>>>>
>>>>> For every type of non-halting sequence of configurations:
>>>>> (a) Infinite loop
>>>>> (b) Infinite Recursion
>>>>> (c) Infinitely nested simulation
>>>>> (d) Pathological self-reference
>>>>
>>>> except it doesn't work for (d) as shown above.
>>>
>>> It does work for (d) you are merely having a break from reality.
>>
>>
>> Try to refute this prove that is doesn't:
>>
>> DEFINITION of the correct answer for H:
>>
>> 1) H <M> w needs to -> H.Qy iff M w Halts, and -> H.Qn iff M w never
>> halts
>>
>> Thus
>>
>> 2) H <H^> <H^> needs -> H.Qy iff H^ <H^> Halts, and -> H.Qn if H^ <H^>
>> never Halts.
>>
>
> The above is misleading syntax, Linz confused himself by using
> misleading syntax.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> You must use only the above syntax and you must refer to the copy of H
> embedded at Ĥ.qx as embedded_H.

Why, because it is INCORRECT!

SO, I guess you are just admitting that you are talking about your POOP.

The first two lines are missing the conditions on them, and thus are
defective.

If embedded_H isn't an exact copy of H, then H^ is built wrong.

>
>> 3) You claim that H <H^> <H^> is correct in going to H.Qn, so if H for
>> this to possibly be true, H <H^> <H^> -> H.Qn.
>>
>
> This is off topic, I am only discussing embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩

And if embedded_H isn't an identical copy of H, then you aren't working
on the Halting problem, so I guess you are back to just talking about
your POOP.

>
>> 4) We know by the construction of H^ that H^ w uses H w w and goes to
>> its corresponding state H.Qy / H^.Qy and H.Qn / H^.Qn
>
> w is off topic you must use the stipulated syntax.

WHY? That is the syntax used in the DEFINITION!!!

So, again, proof that you are not working on the Halting Problem

So your only 'rebuttal' is to claim that the actual definitions don't
apply which means that you are just a pathological liar to claim to be
working on the Halting Problem.

Good luck at your finals.

>
>>
>> 5) With w = <H^> we have that
>>
>> 6) H^ <H^> uses H <H^> <H^> and from above we have that this goes to
>> H.Qn, so H^ goes to H^.Qn and then HALTS by construciton.
>>
>> 7) Thus H^ <H^> HALTS.
>>
>> 8) Thus by the requrieents in 2, H <H^> <H^> NEEDED to go to H.Qy to
>> be correct, but by 3 it went to H.Qn
>>
>> 9) Since H.Qy is not H.Qn, H gave the wrong answer.
>>
>>
>> FAILURE TO POINT OUT AN ERROR IS AN ADMISSION THAT YOU DON'T HAVE A
>> REBUTTAL.
>>
>>>
>>> It is the case that unless embedded_H aborts the simulation of its
>>> input that this simulation never stops. You know and acknowledge that
>>> this is true.
>>
>> But that isn't the definition. So FAIL.
>>
>>
>>>
>>> A reasonable mind (not yours) would comprehend that this means that
>>> the input to embedded_H specifies a sequence of configurations that
>>> never halt in the same way that an infinite loop specifies a sequence
>>> of configurations that never halt. It is the exact same principle in
>>> both cases.
>>
>> Nope all you have shown is that you are an idiot and a half wit
>> because you don't complete your logic.
>>
>>>
>>> You keep saying that if H aborts its simulation that the infinitely
>>> nested simulation no longer exists. This  is exactly the same as when
>>> H aborts its simulation of an infinite loop, the loop stops running
>>> because it has been aborted.
>>>
>>> Aborting the simulation of an otherwise infinite sequence of
>>> configurations does not magically transform them into halting
>>> computations.
>>>
>>
>> No, the fact that H will abort its simulation means tha tH^ never was
>> a non-halting computaiton.
>>
>
> That is the same freaking moronic thing as saying that an infinite loop
> is not an infinite loop when its simulating halt decider aborts it.

On 2/28/2022 8:28 PM, Richard Damon wrote:
> On 2/28/22 8:47 PM, olcott wrote:
>> On 2/28/2022 7:18 PM, Richard Damon wrote:
>>> On 2/28/22 7:55 PM, olcott wrote:
>>>> On 2/28/2022 6:31 PM, Richard Damon wrote:
>>>>>
>>>>> On 2/28/22 7:17 PM, olcott wrote:
>>>>>> On 2/28/2022 6:06 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 2/28/22 5:47 PM, olcott wrote:
>>>>>>>> On 2/28/2022 4:08 PM, André G. Isaak wrote:
>>>>>>>>> This reminded me of Olcott
>>>>>>>>>
>>>>>>>>> <https://xkcd.com/2566/>
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> You still have not shown that I am incorrect.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> It is the case than unless embedded_H aborts the simulation of
>>>>>>>> its input that this input would never stop running.
>>>>>>>>
>>>>>>>> It is also the case that the fact that this
>>>>>>>> IS A REASONABLE MEASURE THAT THIS INPUT SPECIFIES A NON HALTING
>>>>>>>> SEQUENCE OF CONFIGURATIONS.
>>>>>>>>
>>>>>>>> The above two facts taken together prove that the essence of my
>>>>>>>> idea is correct.
>>>>>>>>
>>>>>>>
>>>>>>> It is only a reasonable measure if H NEVER aborts its simulation
>>>>>>> (not unless, NEVER).
>>>>>> It is known to be a reasonable measure on the basis of the meaning
>>>>>> of its words. The meaning of these words are simply over your head.
>>>>>
>>>>> Nope. Maybe to someone who doesn't understand the REAL meaning.
>>>>>
>>>>> Since we HAVE an actual definition, and you have even shown you
>>>>> KNOW it, the fact that you don't use it just shows you are a
>>>>> pathological liar.
>>>>>
>>>>> BY DEFINITION:
>>>>>
>>>>> H <M> w needs to -> H.Qy if M w Halts and -> H.Qn if M w never halts.
>>>>> Thus H <H^> <H^> needs to go to H.Qy if H^ <H^> Halts.
>>>>>
>>>>> Since you claim that H <H^> <H^> is correct in going to H.Qn we
>>>>> know that it does this, and we also know by the rules of
>>>>> construction of H^ that the H^ that this copy of H was put into
>>>>> when applied to <H^> will use that H to see that H -> H.Qn, so H^
>>>>> -> H^.Qn and Halts.
>>>>>
>>>>> Since if H^ applied to <H^> Halts, we know that for H to have been
>>>>> correct, it needed to go to H.Qy not H.Qn, so BY DEFINTION H was
>>>>> wrong, and any claim otherwise is just a LIE.
>>>>>
>>>>
>>>> The actual behavior of the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>> proves that I am right.
>>>
>>> WHICH embedded_H?
>>>
>>> The one that doesn't abort, and thus is wrong because it never gives
>>> an anwswer, or
>>>
>>> The one that does abort, and gives the wrong answer becuase the H^
>>> built on it does halts (you only show the behavior of the H^ built on
>>> the embedded_H that doesn't).
>>>>
>>>> When someone smashes a Boston cream pie in your face denying that
>>>> this is not possible "in theory" does not stop the pie from dripping
>>>> from your face.
>>>>
>>>
>>> Red Herring, but perhaps just shows how silly you look when you push
>>> the cream pie into your own face as you show how little you
>>> understand even the basic concepts.
>>>
>>>>> Maybe these words are just over your head, if so, you need to stop
>>>>> lyiing and making claims you know something about this.
>>>>>
>>>>> FAIL.
>>>>>
>>>>>>
>>>>>> For every type of non-halting sequence of configurations:
>>>>>> (a) Infinite loop
>>>>>> (b) Infinite Recursion
>>>>>> (c) Infinitely nested simulation
>>>>>> (d) Pathological self-reference
>>>>>
>>>>> except it doesn't work for (d) as shown above.
>>>>
>>>> It does work for (d) you are merely having a break from reality.
>>>
>>>
>>> Try to refute this prove that is doesn't:
>>>
>>> DEFINITION of the correct answer for H:
>>>
>>> 1) H <M> w needs to -> H.Qy iff M w Halts, and -> H.Qn iff M w never
>>> halts
>>>
>>> Thus
>>>
>>> 2) H <H^> <H^> needs -> H.Qy iff H^ <H^> Halts, and -> H.Qn if H^
>>> <H^> never Halts.
>>>
>>
>> The above is misleading syntax, Linz confused himself by using
>> misleading syntax.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> You must use only the above syntax and you must refer to the copy of H
>> embedded at Ĥ.qx as embedded_H.
>
> Why, because it is INCORRECT!
>
> SO, I guess you are just admitting that you are talking about your POOP.
>
> The first two lines are missing the conditions on them, and thus are
> defective.
>
> If embedded_H isn't an exact copy of H, then H^ is built wrong.
>
>
>>
>>> 3) You claim that H <H^> <H^> is correct in going to H.Qn, so if H
>>> for this to possibly be true, H <H^> <H^> -> H.Qn.
>>>
>>
>> This is off topic, I am only discussing embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>
> And if embedded_H isn't an identical copy of H, then you aren't working
> on the Halting problem, so I guess you are back to just talking about
> your POOP.
>
>>
>>> 4) We know by the construction of H^ that H^ w uses H w w and goes to
>>> its corresponding state H.Qy / H^.Qy and H.Qn / H^.Qn
>>
>> w is off topic you must use the stipulated syntax.
>
> WHY? That is the syntax used in the DEFINITION!!!
>
> So, again, proof that you are not working on the Halting Problem
>
>
> So your only 'rebuttal' is to claim that the actual definitions don't
> apply which means that you are just a pathological liar to claim to be
> working on the Halting Problem.
>
> Good luck at your finals.
>
>>
>>>
>>> 5) With w = <H^> we have that
>>>
>>> 6) H^ <H^> uses H <H^> <H^> and from above we have that this goes to
>>> H.Qn, so H^ goes to H^.Qn and then HALTS by construciton.
>>>
>>> 7) Thus H^ <H^> HALTS.
>>>
>>> 8) Thus by the requrieents in 2, H <H^> <H^> NEEDED to go to H.Qy to
>>> be correct, but by 3 it went to H.Qn
>>>
>>> 9) Since H.Qy is not H.Qn, H gave the wrong answer.
>>>
>>>
>>> FAILURE TO POINT OUT AN ERROR IS AN ADMISSION THAT YOU DON'T HAVE A
>>> REBUTTAL.
>>>
>>>>
>>>> It is the case that unless embedded_H aborts the simulation of its
>>>> input that this simulation never stops. You know and acknowledge
>>>> that this is true.
>>>
>>> But that isn't the definition. So FAIL.
>>>
>>>
>>>>
>>>> A reasonable mind (not yours) would comprehend that this means that
>>>> the input to embedded_H specifies a sequence of configurations that
>>>> never halt in the same way that an infinite loop specifies a
>>>> sequence of configurations that never halt. It is the exact same
>>>> principle in both cases.
>>>
>>> Nope all you have shown is that you are an idiot and a half wit
>>> because you don't complete your logic.
>>>
>>>>
>>>> You keep saying that if H aborts its simulation that the infinitely
>>>> nested simulation no longer exists. This  is exactly the same as
>>>> when H aborts its simulation of an infinite loop, the loop stops
>>>> running because it has been aborted.
>>>>
>>>> Aborting the simulation of an otherwise infinite sequence of
>>>> configurations does not magically transform them into halting
>>>> computations.
>>>>
>>>
>>> No, the fact that H will abort its simulation means tha tH^ never was
>>> a non-halting computaiton.
>>>
>>
>> That is the same freaking moronic thing as saying that an infinite
>> loop is not an infinite loop when its simulating halt decider aborts it.
>
> Nope, that statements just shows how stupid you are.
>
> You sure to like your Herring red.
>

On 2/28/22 9:39 PM, olcott wrote:
> On 2/28/2022 8:28 PM, Richard Damon wrote:
>> On 2/28/22 8:47 PM, olcott wrote:
>>> On 2/28/2022 7:18 PM, Richard Damon wrote:
>>>> On 2/28/22 7:55 PM, olcott wrote:
>>>>> On 2/28/2022 6:31 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 2/28/22 7:17 PM, olcott wrote:
>>>>>>> On 2/28/2022 6:06 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 2/28/22 5:47 PM, olcott wrote:
>>>>>>>>> On 2/28/2022 4:08 PM, André G. Isaak wrote:
>>>>>>>>>> This reminded me of Olcott
>>>>>>>>>>
>>>>>>>>>> <https://xkcd.com/2566/>
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You still have not shown that I am incorrect.
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> It is the case than unless embedded_H aborts the simulation of
>>>>>>>>> its input that this input would never stop running.
>>>>>>>>>
>>>>>>>>> It is also the case that the fact that this
>>>>>>>>> IS A REASONABLE MEASURE THAT THIS INPUT SPECIFIES A NON HALTING
>>>>>>>>> SEQUENCE OF CONFIGURATIONS.
>>>>>>>>>
>>>>>>>>> The above two facts taken together prove that the essence of my
>>>>>>>>> idea is correct.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is only a reasonable measure if H NEVER aborts its simulation
>>>>>>>> (not unless, NEVER).
>>>>>>> It is known to be a reasonable measure on the basis of the
>>>>>>> meaning of its words. The meaning of these words are simply over
>>>>>>> your head.
>>>>>>
>>>>>> Nope. Maybe to someone who doesn't understand the REAL meaning.
>>>>>>
>>>>>> Since we HAVE an actual definition, and you have even shown you
>>>>>> KNOW it, the fact that you don't use it just shows you are a
>>>>>> pathological liar.
>>>>>>
>>>>>> BY DEFINITION:
>>>>>>
>>>>>> H <M> w needs to -> H.Qy if M w Halts and -> H.Qn if M w never halts.
>>>>>> Thus H <H^> <H^> needs to go to H.Qy if H^ <H^> Halts.
>>>>>>
>>>>>> Since you claim that H <H^> <H^> is correct in going to H.Qn we
>>>>>> know that it does this, and we also know by the rules of
>>>>>> construction of H^ that the H^ that this copy of H was put into
>>>>>> when applied to <H^> will use that H to see that H -> H.Qn, so H^
>>>>>> -> H^.Qn and Halts.
>>>>>>
>>>>>> Since if H^ applied to <H^> Halts, we know that for H to have been
>>>>>> correct, it needed to go to H.Qy not H.Qn, so BY DEFINTION H was
>>>>>> wrong, and any claim otherwise is just a LIE.
>>>>>>
>>>>>
>>>>> The actual behavior of the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>> proves that I am right.
>>>>
>>>> WHICH embedded_H?
>>>>
>>>> The one that doesn't abort, and thus is wrong because it never gives
>>>> an anwswer, or
>>>>
>>>> The one that does abort, and gives the wrong answer becuase the H^
>>>> built on it does halts (you only show the behavior of the H^ built
>>>> on the embedded_H that doesn't).
>>>>>
>>>>> When someone smashes a Boston cream pie in your face denying that
>>>>> this is not possible "in theory" does not stop the pie from
>>>>> dripping from your face.
>>>>>
>>>>
>>>> Red Herring, but perhaps just shows how silly you look when you push
>>>> the cream pie into your own face as you show how little you
>>>> understand even the basic concepts.
>>>>
>>>>>> Maybe these words are just over your head, if so, you need to stop
>>>>>> lyiing and making claims you know something about this.
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>>>
>>>>>>> For every type of non-halting sequence of configurations:
>>>>>>> (a) Infinite loop
>>>>>>> (b) Infinite Recursion
>>>>>>> (c) Infinitely nested simulation
>>>>>>> (d) Pathological self-reference
>>>>>>
>>>>>> except it doesn't work for (d) as shown above.
>>>>>
>>>>> It does work for (d) you are merely having a break from reality.
>>>>
>>>>
>>>> Try to refute this prove that is doesn't:
>>>>
>>>> DEFINITION of the correct answer for H:
>>>>
>>>> 1) H <M> w needs to -> H.Qy iff M w Halts, and -> H.Qn iff M w never
>>>> halts
>>>>
>>>> Thus
>>>>
>>>> 2) H <H^> <H^> needs -> H.Qy iff H^ <H^> Halts, and -> H.Qn if H^
>>>> <H^> never Halts.
>>>>
>>>
>>> The above is misleading syntax, Linz confused himself by using
>>> misleading syntax.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> You must use only the above syntax and you must refer to the copy of
>>> H embedded at Ĥ.qx as embedded_H.
>>
>> Why, because it is INCORRECT!
>>
>> SO, I guess you are just admitting that you are talking about your POOP.
>>
>> The first two lines are missing the conditions on them, and thus are
>> defective.
>>
>> If embedded_H isn't an exact copy of H, then H^ is built wrong.
>>
>>
>>>
>>>> 3) You claim that H <H^> <H^> is correct in going to H.Qn, so if H
>>>> for this to possibly be true, H <H^> <H^> -> H.Qn.
>>>>
>>>
>>> This is off topic, I am only discussing embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>
>> And if embedded_H isn't an identical copy of H, then you aren't
>> working on the Halting problem, so I guess you are back to just
>> talking about your POOP.
>>
>>>
>>>> 4) We know by the construction of H^ that H^ w uses H w w and goes
>>>> to its corresponding state H.Qy / H^.Qy and H.Qn / H^.Qn
>>>
>>> w is off topic you must use the stipulated syntax.
>>
>> WHY? That is the syntax used in the DEFINITION!!!
>>
>> So, again, proof that you are not working on the Halting Problem
>>
>>
>> So your only 'rebuttal' is to claim that the actual definitions don't
>> apply which means that you are just a pathological liar to claim to be
>> working on the Halting Problem.
>>
>> Good luck at your finals.
>>
>>>
>>>>
>>>> 5) With w = <H^> we have that
>>>>
>>>> 6) H^ <H^> uses H <H^> <H^> and from above we have that this goes to
>>>> H.Qn, so H^ goes to H^.Qn and then HALTS by construciton.
>>>>
>>>> 7) Thus H^ <H^> HALTS.
>>>>
>>>> 8) Thus by the requrieents in 2, H <H^> <H^> NEEDED to go to H.Qy to
>>>> be correct, but by 3 it went to H.Qn
>>>>
>>>> 9) Since H.Qy is not H.Qn, H gave the wrong answer.
>>>>
>>>>
>>>> FAILURE TO POINT OUT AN ERROR IS AN ADMISSION THAT YOU DON'T HAVE A
>>>> REBUTTAL.
>>>>
>>>>>
>>>>> It is the case that unless embedded_H aborts the simulation of its
>>>>> input that this simulation never stops. You know and acknowledge
>>>>> that this is true.
>>>>
>>>> But that isn't the definition. So FAIL.
>>>>
>>>>
>>>>>
>>>>> A reasonable mind (not yours) would comprehend that this means that
>>>>> the input to embedded_H specifies a sequence of configurations that
>>>>> never halt in the same way that an infinite loop specifies a
>>>>> sequence of configurations that never halt. It is the exact same
>>>>> principle in both cases.
>>>>
>>>> Nope all you have shown is that you are an idiot and a half wit
>>>> because you don't complete your logic.
>>>>
>>>>>
>>>>> You keep saying that if H aborts its simulation that the infinitely
>>>>> nested simulation no longer exists. This  is exactly the same as
>>>>> when H aborts its simulation of an infinite loop, the loop stops
>>>>> running because it has been aborted.
>>>>>
>>>>> Aborting the simulation of an otherwise infinite sequence of
>>>>> configurations does not magically transform them into halting
>>>>> computations.
>>>>>
>>>>
>>>> No, the fact that H will abort its simulation means tha tH^ never
>>>> was a non-halting computaiton.
>>>>
>>>
>>> That is the same freaking moronic thing as saying that an infinite
>>> loop is not an infinite loop when its simulating halt decider aborts it.
>>
>> Nope, that statements just shows how stupid you are.
>>
>> You sure to like your Herring red.
>>
>
> Because you cannot possibly explain how the infinite loop reporting and
> the infinitely nested simulation reporting diverge from the single
> simulating halt deciding principle of rejecting all inputs that would
> never stop running unless their simulation was aborted it is you that
> have proven to be the ignoramus.
>

On 2022-02-28 22:47:44 +0000, olcott said:

> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

These two lines contradict each other,
so at least one of them is false,
possibly both.

Mikko

Mikko <mikko.levanto@iki.fi> writes:

> On 2022-02-28 22:47:44 +0000, olcott said:
>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> These two lines contradict each other,
> so at least one of them is false,
> possibly both.

PO makes a habit of omitting the key conditions under which each line
applies. This has been pointed out so often that it must be
deliberate. The trouble is that the conditions are what shows PO to be
wrong so he's spent some time trying to find words for his own
conditions that make it sound a bit like he is still talking about a
halt decider. The conditions are

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if H applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if H applied to ⟨Ĥ⟩ does not halt.

--
Ben.

On 3/1/22 7:02 AM, Ben Bacarisse wrote:
> Mikko <mikko.levanto@iki.fi> writes:
>
>> On 2022-02-28 22:47:44 +0000, olcott said:
>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> These two lines contradict each other,
>> so at least one of them is false,
>> possibly both.
>
> PO makes a habit of omitting the key conditions under which each line
> applies. This has been pointed out so often that it must be
> deliberate. The trouble is that the conditions are what shows PO to be
> wrong so he's spent some time trying to find words for his own
> conditions that make it sound a bit like he is still talking about a
> halt decider. The conditions are
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if H applied to ⟨Ĥ⟩ halts, and
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if H applied to ⟨Ĥ⟩ does not halt.
>

Actually , there are TWO sets of conditions that can be applied, the set
you provide (slightly correct below, its Ĥ, not H applied to (Ĥ) ) are
the final concluding conditions, that need to hold for H to be correct.

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

The set of conditons that I think are more important are:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ goes to H.qy

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ goes to H.qn

The problem with the first set of conditions is that they show the
contradiction, and that clearly something is wrong, which PO assigns the
error to the problem definition, as he doesn't understand the basis of
(dis)proof by contradiction.

The construction rule allows us to take his H (which doesn't meet the
requirements of the H in Linz, and thus Ĥ doesn't meet those first
conditions) must be wrong.

Since we are dealing with broken logic, we need to work with things that
don't depend on the logic being correct.

On 3/1/2022 3:27 AM, Mikko wrote:
> On 2022-02-28 22:47:44 +0000, olcott said:
>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> These two lines contradict each other,
> so at least one of them is false,
> possibly both.
>
> Mikko
>

It is a paraphrase of Linz bottom of page 319.
https://www.liarparadox.org/Peter_Linz_HP_317-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 3/1/2022 6:02 AM, Ben Bacarisse wrote:
> Mikko <mikko.levanto@iki.fi> writes:
>
>> On 2022-02-28 22:47:44 +0000, olcott said:
>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> These two lines contradict each other,
>> so at least one of them is false,
>> possibly both.
>
> PO makes a habit of omitting the key conditions under which each line
> applies. This has been pointed out so often that it must be
> deliberate. The trouble is that the conditions are what shows PO to be
> wrong so he's spent some time trying to find words for his own
> conditions that make it sound a bit like he is still talking about a
> halt decider. The conditions are
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if H applied to ⟨Ĥ⟩ halts, and
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if H applied to ⟨Ĥ⟩ does not halt.
>

Those are not the conditions.
The copy of the simulating halt decider H embedded at Ĥ.qx will be
called embedded_H

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ determines that its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ will
halt without aborting the simulation of its input

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ determines that its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ will NOT
halt without aborting the simulation of its input

--
Copyright 2021 Pete Olcott

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

Richard Damon <Richard@Damon-Family.org> writes:

> On 3/1/22 7:02 AM, Ben Bacarisse wrote:
>> Mikko <mikko.levanto@iki.fi> writes:
>>
>>> On 2022-02-28 22:47:44 +0000, olcott said:
>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> These two lines contradict each other,
>>> so at least one of them is false,
>>> possibly both.
>> PO makes a habit of omitting the key conditions under which each line
>> applies. This has been pointed out so often that it must be
>> deliberate. The trouble is that the conditions are what shows PO to be
>> wrong so he's spent some time trying to find words for his own
>> conditions that make it sound a bit like he is still talking about a
>> halt decider. The conditions are
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if H applied to ⟨Ĥ⟩ halts, and
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if H applied to ⟨Ĥ⟩ does not halt.
>
> Actually , there are TWO sets of conditions that can be applied, the
> set you provide (slightly correct below, its Ĥ, not H applied to (Ĥ) )

Thanks. Typo. I wish PO had adopted my ASCII-friendly notation, but
that ship has sailed.

> are the final concluding conditions, that need to hold for H to be
> correct.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.

--
Ben.

olcott <NoOne@NoWhere.com> writes:

> On 3/1/2022 6:02 AM, Ben Bacarisse wrote:
>> Mikko <mikko.levanto@iki.fi> writes:
>>
>>> On 2022-02-28 22:47:44 +0000, olcott said:
>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> These two lines contradict each other,
>>> so at least one of them is false,
>>> possibly both.
>> PO makes a habit of omitting the key conditions under which each line
>> applies. This has been pointed out so often that it must be
>> deliberate. The trouble is that the conditions are what shows PO to be
>> wrong so he's spent some time trying to find words for his own
>> conditions that make it sound a bit like he is still talking about a
>> halt decider. The conditions are
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if H applied to ⟨Ĥ⟩ halts, and
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if H applied to ⟨Ĥ⟩ does not halt.
>
> Those are not the conditions.

Indeed they are not. I made a typo. You, however, cannot give the
correct ones because they show you to be wrong. Instead you must pile
on the verbiage:

> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ determines that its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ will
> halt without aborting the simulation of its input
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ determines that its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ will
> NOT halt without aborting the simulation of its input

If these were same as those in Linz you would use the far simpler
conditions from Linz, but in actual fact you are re-defining what
halting means hoping that you won't be called out on it.

I'll call you out on it: you have not changed your stance since you made
the fatal mistake of being crystal clear:

Me: do you still assert that H(P,P) == false is the "correct" answer
even though P(P) halts?

You: Yes that is the correct answer even though P(P) halts.

Until to accept that this is simply wrong, everything you say on the
topic is just hot air.

--
Ben.

On 3/1/2022 10:04 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/1/2022 6:02 AM, Ben Bacarisse wrote:
>>> Mikko <mikko.levanto@iki.fi> writes:
>>>
>>>> On 2022-02-28 22:47:44 +0000, olcott said:
>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> These two lines contradict each other,
>>>> so at least one of them is false,
>>>> possibly both.
>>> PO makes a habit of omitting the key conditions under which each line
>>> applies. This has been pointed out so often that it must be
>>> deliberate. The trouble is that the conditions are what shows PO to be
>>> wrong so he's spent some time trying to find words for his own
>>> conditions that make it sound a bit like he is still talking about a
>>> halt decider. The conditions are
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if H applied to ⟨Ĥ⟩ halts, and
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if H applied to ⟨Ĥ⟩ does not halt.
>>
>> Those are not the conditions.
>
> Indeed they are not. I made a typo. You, however, cannot give the
> correct ones because they show you to be wrong. Instead you must pile
> on the verbiage:
>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ determines that its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ will
>> halt without aborting the simulation of its input
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ determines that its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ will
>> NOT halt without aborting the simulation of its input
>
> If these were same as those in Linz you would use the far simpler
> conditions from Linz, but in actual fact you are re-defining what
> halting means hoping that you won't be called out on it.
>
> I'll call you out on it: you have not changed your stance since you made
> the fatal mistake of being crystal clear:
>
> Me: do you still assert that H(P,P) == false is the "correct" answer
> even though P(P) halts?
>
> You: Yes that is the correct answer even though P(P) halts.
>
> Until to accept that this is simply wrong, everything you say on the
> topic is just hot air.
>

I explain your mistake about this in terms of Turing machine deciders:
On 2/28/2022 11:59 AM, olcott wrote:
Concise refutation of halting problem proofs V63 [ Linz Proof ][ Ben's
mistake ]

--
Copyright 2021 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

olcott <polcott2@gmail.com> writes:

> I explain your mistake about this in terms of Turing machine deciders:
> On 2/28/2022 11:59 AM, olcott wrote:
> Concise refutation of halting problem proofs V63 [ Linz Proof ][ Ben's
> mistake ]

You can't even be bothered to learn how to cite a Usenet post (it's not
hard).

But that suits me fine. You appear to want to talk forever, whereas all
I want to do is remind readers that you are not addressing the halting
problem, and that you have been 100% clear about this in the past:

Me: do you still assert that H(P,P) == false is the "correct" answer
even though P(P) halts?
You: Yes that is the correct answer even though P(P) halts.

--
Ben.

On 3/1/2022 5:57 PM, Ben Bacarisse wrote:
> olcott <polcott2@gmail.com> writes:
>
>> I explain your mistake about this in terms of Turing machine deciders:
>> On 2/28/2022 11:59 AM, olcott wrote:
>> Concise refutation of halting problem proofs V63 [ Linz Proof ][ Ben's
>> mistake ]
>
> You can't even be bothered to learn how to cite a Usenet post (it's not
> hard).
>
> But that suits me fine. You appear to want to talk forever, whereas all
> I want to do is remind readers that you are not addressing the halting
> problem,

I pointed out your mistake On 2/28/2022 11:59 AM
Concise refutation of halting problem proofs V63 [ Linz Proof ][ Ben's
mistake ]

> and that you have been 100% clear about this in the past:
>
> Me: do you still assert that H(P,P) == false is the "correct" answer
> even though P(P) halts?
> You: Yes that is the correct answer even though P(P) halts.
>

I have not been talking about H(P,P) for many months.
I point out your mistake in terms of Linz.

You apparently don't really know how deciders work, otherwise you would
not have made this mistake.

--
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 3/1/22 10:11 AM, olcott wrote:
> On 3/1/2022 6:02 AM, Ben Bacarisse wrote:
>> Mikko <mikko.levanto@iki.fi> writes:
>>
>>> On 2022-02-28 22:47:44 +0000, olcott said:
>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> These two lines contradict each other,
>>> so at least one of them is false,
>>> possibly both.
>>
>> PO makes a habit of omitting the key conditions under which each line
>> applies.  This has been pointed out so often that it must be
>> deliberate.  The trouble is that the conditions are what shows PO to be
>> wrong so he's spent some time trying to find words for his own
>> conditions that make it sound a bit like he is still talking about a
>> halt decider.  The conditions are
>>
>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞   if H applied to ⟨Ĥ⟩ halts, and
>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn     if H applied to ⟨Ĥ⟩ does not
>> halt.
>>
>
> Those are not the conditions.
> The copy of the simulating halt decider H embedded at Ĥ.qx will be
> called embedded_H
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ determines that its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ will
> halt without aborting the simulation of its input
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ determines that its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ will NOT
> halt without aborting the simulation of its input
>
>

THen you aren't talking about the Halting Problem but just your POOP.

FAIL.

On 2022-03-01 14:58:36 +0000, olcott said:

> On 3/1/2022 3:27 AM, Mikko wrote:
>> On 2022-02-28 22:47:44 +0000, olcott said:
>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> These two lines contradict each other,
>> so at least one of them is false,
>> possibly both.
>>
>> Mikko
>>
>
> It is a paraphrase of Linz bottom of page 319.
> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

Linz doesn't say that both are true, just one, and that
M and w determe which one.

Mikko

On 3/2/2022 10:53 AM, Mikko wrote:
> On 2022-03-01 14:58:36 +0000, olcott said:
>
>> On 3/1/2022 3:27 AM, Mikko wrote:
>>> On 2022-02-28 22:47:44 +0000, olcott said:
>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> These two lines contradict each other,
>>> so at least one of them is false,
>>> possibly both.
>>>
>>> Mikko
>>>
>>
>> It is a paraphrase of Linz bottom of page 319.
>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>
> Linz doesn't say that both are true, just one, and that
> M and w determe which one.
>
> Mikko
>

Linz confuses himself my making the TM descriptions less than a clear as
possible.

--
Copyright 2021 Pete Olcott

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

olcott <NoOne@NoWhere.com> writes:

> On 3/2/2022 10:53 AM, Mikko wrote:
>> On 2022-03-01 14:58:36 +0000, olcott said:
>>
>>> On 3/1/2022 3:27 AM, Mikko wrote:
>>>> On 2022-02-28 22:47:44 +0000, olcott said:
>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> These two lines contradict each other,
>>>> so at least one of them is false,
>>>> possibly both.
>>>>
>>>> Mikko
>>>>
>>>
>>> It is a paraphrase of Linz bottom of page 319.
>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>> Linz doesn't say that both are true, just one, and that
>>
>> M and w determe which one.
>> Mikko
>
> Linz confuses himself my making the TM descriptions less than a clear
> as possible.

Have you looked at Linz's actual proof yet? It's theorem 12.2, a page
further on from the one you seem to be obsessed by.

--
Ben.