On Friday, April 8, 2022 at 2:49:36 PM UTC-4, olcott wrote:
> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
> > olcott <No...@NoWhere.com> writes:
> >
> >> Linz makes this difficult to understand because he simply erases key
> >> elements of the definition of Ĥ:
> >>
> >> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >
> > You have erased them. Linz specifies Ĥ properly based on what H is
> > supposed to do:
> >
> > Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
> > Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
> >
> > You have spent an inordinate amount of time over the years copying out
> > those lines and dishonestly removing the key conditions. We all know
> > why.
> >
> <Linz:1990:320>
> Now Ĥ is a Turing machine, so that it will have some description in
> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
> also be used as input string. We can therefore legitimately ask what
> would happen if Ĥ is applied to ŵ.
>
> q0ŵ ⊢* Ĥ ∞
> if Ĥ applied to ŵ halts, and
>
> q0ŵ ⊢* Ĥy1qny2
> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
> contradiction tells us that...
> </Linz:1990:320>
>
> In other words the copy of H embedded within Ĥ is incorrect to either
> reject or accept its input.

What you fail to notice is that there is more than one H and H^ in play. For example:

A: an H that always accepts
R: an H that always rejects

What the above is saying is that R / embedded_R rejecting <R^><R^> is incorrect and that A / embedded_A accepting <A^><A^> is incorrect. So not a *single* H but two *different* H's. This also means that A accepting <R^><R^> is correct and R rejecting <A^><A^> is correct.

In other words, no H can give a correct halting/non-halting answer for an H^ built from it (even though some other H could).

>
> When I show that embedded_H correctly rejects its input ⟨Ĥ⟩ ⟨Ĥ⟩ I have
> correctly refuted Linz.
>
> Because the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting when
> embedded_H rejects this input as non-halting it is necessarily correct.

On Friday, April 8, 2022 at 2:32:32 PM UTC-4, olcott wrote:
> On 4/8/2022 1:26 PM, Dennis Bush wrote:
> > On Friday, April 8, 2022 at 2:05:09 PM UTC-4, olcott wrote:
> >> On 4/8/2022 12:44 PM, André G. Isaak wrote:
> >>> On 2022-04-08 11:02, olcott wrote:
> >>>
> >>>> I asked about Ĥ0 and you answered with Ĥn which includes Ĥ[0...n].
> >>>
> >>> You need to go back to the point where Dennis defined his Ha and Hn.
> >>> They don't mean what you seem to think they mean.
> >>>
> >>> André
> >>>
> >> The fact that they do not mean embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is enough
> >> to know that they must be utterly rejected out-of-hand.
> >
> > Ha and Hn more explicitly spell out which H is being referred to, as you often intentionally switch one you're talking about when you say H (sometimes in the same sentence).
> >
> >>
> >> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
> >> that is relevant to the correctness of embedded_H rejecting this input..
> >
> > And by the same reasoning, that the input <N><5> to Ha3 is non-halting is the only thing that is relevant to the correctness of Ha3 rejecting this input.
> >
> > Agreed?
> >
> I have no idea what that gibberish means other then a deliberately
> dishonest attempt at avoiding the point at hand:
> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩

What is means is that for Ha rejecting <Ha^><Ha^> and for Ha3 rejecting <N><5>, either both are correct or both are incorrect.

Pick one.

>
> >
> >>
> >> Everything else is the God damned lie of a God damned liar.
> >>
> >> When I say "God damned" I mean in the sense of being eternally
> >> incinerated in actual Hell.
> >>
> >> Revelation 21:8 King James Version
> >> ...all liars, shall have their part in the lake which burneth with fire
> >> and brimstone: which is the second death.
> >
> > Says the guy who hides behind the ambiguous "H" to dishonestly make his point.
> >
> My H is not ambiguous:
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

On 4/8/2022 2:16 PM, Dennis Bush wrote:
> On Friday, April 8, 2022 at 2:49:36 PM UTC-4, olcott wrote:
>> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
>>> olcott <No...@NoWhere.com> writes:
>>>
>>>> Linz makes this difficult to understand because he simply erases key
>>>> elements of the definition of Ĥ:
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> You have erased them. Linz specifies Ĥ properly based on what H is
>>> supposed to do:
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>
>>> You have spent an inordinate amount of time over the years copying out
>>> those lines and dishonestly removing the key conditions. We all know
>>> why.
>>>
>> <Linz:1990:320>
>> Now Ĥ is a Turing machine, so that it will have some description in
>> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
>> also be used as input string. We can therefore legitimately ask what
>> would happen if Ĥ is applied to ŵ.
>>
>> q0ŵ ⊢* Ĥ ∞
>> if Ĥ applied to ŵ halts, and
>>
>> q0ŵ ⊢* Ĥy1qny2
>> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
>> contradiction tells us that...
>> </Linz:1990:320>
>>
>> In other words the copy of H embedded within Ĥ is incorrect to either
>> reject or accept its input.
>
> What you fail to notice is that there is more than one H and H^ in play. For example:
>
> A: an H that always accepts
> R: an H that always rejects
>
> What the above is saying is that R / embedded_R rejecting <R^><R^> is incorrect and that A / embedded_A accepting <A^><A^> is incorrect. So not a *single* H but two *different* H's. This also means that A accepting <R^><R^> is correct and R rejecting <A^><A^> is correct.
>
> In other words, no H can give a correct halting/non-halting answer for an H^ built from it (even though some other H could).

So when I show that the H embedded within Ĥ does correctly decide its
input ⟨Ĥ⟩ ⟨Ĥ⟩, Linz has been refuted.

--
Copyright 2022 Pete Olcott

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

On 4/8/2022 2:17 PM, Dennis Bush wrote:
> On Friday, April 8, 2022 at 2:32:32 PM UTC-4, olcott wrote:
>> On 4/8/2022 1:26 PM, Dennis Bush wrote:
>>> On Friday, April 8, 2022 at 2:05:09 PM UTC-4, olcott wrote:
>>>> On 4/8/2022 12:44 PM, André G. Isaak wrote:
>>>>> On 2022-04-08 11:02, olcott wrote:
>>>>>
>>>>>> I asked about Ĥ0 and you answered with Ĥn which includes Ĥ[0...n].
>>>>>
>>>>> You need to go back to the point where Dennis defined his Ha and Hn.
>>>>> They don't mean what you seem to think they mean.
>>>>>
>>>>> André
>>>>>
>>>> The fact that they do not mean embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is enough
>>>> to know that they must be utterly rejected out-of-hand.
>>>
>>> Ha and Hn more explicitly spell out which H is being referred to, as you often intentionally switch one you're talking about when you say H (sometimes in the same sentence).
>>>
>>>>
>>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
>>>> that is relevant to the correctness of embedded_H rejecting this input.
>>>
>>> And by the same reasoning, that the input <N><5> to Ha3 is non-halting is the only thing that is relevant to the correctness of Ha3 rejecting this input.
>>>
>>> Agreed?
>>>
>> I have no idea what that gibberish means other then a deliberately
>> dishonest attempt at avoiding the point at hand:
>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>
> What is means is that for Ha rejecting <Ha^><Ha^> and for Ha3 rejecting <N><5>, either both are correct or both are incorrect.
>
> Pick one.
Dennis Bush is a God damned liar that refuses to stay exactly on topic
because rebuttals are impossible when staying exactly on topic.

--
Copyright 2022 Pete Olcott

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

On Friday, April 8, 2022 at 3:22:52 PM UTC-4, olcott wrote:
> On 4/8/2022 2:17 PM, Dennis Bush wrote:
> > On Friday, April 8, 2022 at 2:32:32 PM UTC-4, olcott wrote:
> >> On 4/8/2022 1:26 PM, Dennis Bush wrote:
> >>> On Friday, April 8, 2022 at 2:05:09 PM UTC-4, olcott wrote:
> >>>> On 4/8/2022 12:44 PM, André G. Isaak wrote:
> >>>>> On 2022-04-08 11:02, olcott wrote:
> >>>>>
> >>>>>> I asked about Ĥ0 and you answered with Ĥn which includes Ĥ[0...n].
> >>>>>
> >>>>> You need to go back to the point where Dennis defined his Ha and Hn..
> >>>>> They don't mean what you seem to think they mean.
> >>>>>
> >>>>> André
> >>>>>
> >>>> The fact that they do not mean embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is enough
> >>>> to know that they must be utterly rejected out-of-hand.
> >>>
> >>> Ha and Hn more explicitly spell out which H is being referred to, as you often intentionally switch one you're talking about when you say H (sometimes in the same sentence).
> >>>
> >>>>
> >>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
> >>>> that is relevant to the correctness of embedded_H rejecting this input.
> >>>
> >>> And by the same reasoning, that the input <N><5> to Ha3 is non-halting is the only thing that is relevant to the correctness of Ha3 rejecting this input.
> >>>
> >>> Agreed?
> >>>
> >> I have no idea what that gibberish means other then a deliberately
> >> dishonest attempt at avoiding the point at hand:
> >> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
> >
> > What is means is that for Ha rejecting <Ha^><Ha^> and for Ha3 rejecting <N><5>, either both are correct or both are incorrect.
> >
> > Pick one.
> Dennis Bush is a God damned liar that refuses to stay exactly on topic
> because rebuttals are impossible when staying exactly on topic.

Translation: All I can do is throw out insults when I have no way to refute something that proves me wrong.

On Friday, April 8, 2022 at 3:20:35 PM UTC-4, olcott wrote:
> On 4/8/2022 2:16 PM, Dennis Bush wrote:
> > On Friday, April 8, 2022 at 2:49:36 PM UTC-4, olcott wrote:
> >> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
> >>> olcott <No...@NoWhere.com> writes:
> >>>
> >>>> Linz makes this difficult to understand because he simply erases key
> >>>> elements of the definition of Ĥ:
> >>>>
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>>
> >>> You have erased them. Linz specifies Ĥ properly based on what H is
> >>> supposed to do:
> >>>
> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
> >>>
> >>> You have spent an inordinate amount of time over the years copying out
> >>> those lines and dishonestly removing the key conditions. We all know
> >>> why.
> >>>
> >> <Linz:1990:320>
> >> Now Ĥ is a Turing machine, so that it will have some description in
> >> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
> >> also be used as input string. We can therefore legitimately ask what
> >> would happen if Ĥ is applied to ŵ.
> >>
> >> q0ŵ ⊢* Ĥ ∞
> >> if Ĥ applied to ŵ halts, and
> >>
> >> q0ŵ ⊢* Ĥy1qny2
> >> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
> >> contradiction tells us that...
> >> </Linz:1990:320>
> >>
> >> In other words the copy of H embedded within Ĥ is incorrect to either
> >> reject or accept its input.
> >
> > What you fail to notice is that there is more than one H and H^ in play.. For example:
> >
> > A: an H that always accepts
> > R: an H that always rejects
> >
> > What the above is saying is that R / embedded_R rejecting <R^><R^> is incorrect and that A / embedded_A accepting <A^><A^> is incorrect. So not a *single* H but two *different* H's. This also means that A accepting <R^><R^> is correct and R rejecting <A^><A^> is correct.
> >
> > In other words, no H can give a correct halting/non-halting answer for an H^ built from it (even though some other H could).
> So when I show that the H embedded within Ĥ does correctly decide its
> input ⟨Ĥ⟩ ⟨Ĥ⟩, Linz has been refuted.

But Ha (which is the same as embedded_Ha) does not correctly decided that <Ha^><Ha^> is non-halting as demonstrated by Hb simulating <Ha^><Ha^> to its final state of <Ha^.qn>

On 4/8/2022 2:36 PM, Dennis Bush wrote:
> On Friday, April 8, 2022 at 3:22:52 PM UTC-4, olcott wrote:
>> On 4/8/2022 2:17 PM, Dennis Bush wrote:
>>> On Friday, April 8, 2022 at 2:32:32 PM UTC-4, olcott wrote:
>>>> On 4/8/2022 1:26 PM, Dennis Bush wrote:
>>>>> On Friday, April 8, 2022 at 2:05:09 PM UTC-4, olcott wrote:
>>>>>> On 4/8/2022 12:44 PM, André G. Isaak wrote:
>>>>>>> On 2022-04-08 11:02, olcott wrote:
>>>>>>>
>>>>>>>> I asked about Ĥ0 and you answered with Ĥn which includes Ĥ[0...n].
>>>>>>>
>>>>>>> You need to go back to the point where Dennis defined his Ha and Hn.
>>>>>>> They don't mean what you seem to think they mean.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>> The fact that they do not mean embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is enough
>>>>>> to know that they must be utterly rejected out-of-hand.
>>>>>
>>>>> Ha and Hn more explicitly spell out which H is being referred to, as you often intentionally switch one you're talking about when you say H (sometimes in the same sentence).
>>>>>
>>>>>>
>>>>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
>>>>>> that is relevant to the correctness of embedded_H rejecting this input.
>>>>>
>>>>> And by the same reasoning, that the input <N><5> to Ha3 is non-halting is the only thing that is relevant to the correctness of Ha3 rejecting this input.
>>>>>
>>>>> Agreed?
>>>>>
>>>> I have no idea what that gibberish means other then a deliberately
>>>> dishonest attempt at avoiding the point at hand:
>>>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>
>>> What is means is that for Ha rejecting <Ha^><Ha^> and for Ha3 rejecting <N><5>, either both are correct or both are incorrect.
>>>
>>> Pick one.
>> Dennis Bush is a God damned liar that refuses to stay exactly on topic
>> because rebuttals are impossible when staying exactly on topic.
>
> Translation: All I can do is throw out insults when I have no way to refute something that proves me wrong.

That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
that is relevant to the correctness of embedded_H rejecting this input.

Can only be denied by God damned liars. Instead of directly denying it
and thus being an obvious liar to everyone Dennis dances all around it
making sure to never get to the actual point.

--
Copyright 2022 Pete Olcott

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

On 4/8/2022 2:38 PM, Dennis Bush wrote:
> On Friday, April 8, 2022 at 3:20:35 PM UTC-4, olcott wrote:
>> On 4/8/2022 2:16 PM, Dennis Bush wrote:
>>> On Friday, April 8, 2022 at 2:49:36 PM UTC-4, olcott wrote:
>>>> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
>>>>> olcott <No...@NoWhere.com> writes:
>>>>>
>>>>>> Linz makes this difficult to understand because he simply erases key
>>>>>> elements of the definition of Ĥ:
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> You have erased them. Linz specifies Ĥ properly based on what H is
>>>>> supposed to do:
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>
>>>>> You have spent an inordinate amount of time over the years copying out
>>>>> those lines and dishonestly removing the key conditions. We all know
>>>>> why.
>>>>>
>>>> <Linz:1990:320>
>>>> Now Ĥ is a Turing machine, so that it will have some description in
>>>> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
>>>> also be used as input string. We can therefore legitimately ask what
>>>> would happen if Ĥ is applied to ŵ.
>>>>
>>>> q0ŵ ⊢* Ĥ ∞
>>>> if Ĥ applied to ŵ halts, and
>>>>
>>>> q0ŵ ⊢* Ĥy1qny2
>>>> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
>>>> contradiction tells us that...
>>>> </Linz:1990:320>
>>>>
>>>> In other words the copy of H embedded within Ĥ is incorrect to either
>>>> reject or accept its input.
>>>
>>> What you fail to notice is that there is more than one H and H^ in play. For example:
>>>
>>> A: an H that always accepts
>>> R: an H that always rejects
>>>
>>> What the above is saying is that R / embedded_R rejecting <R^><R^> is incorrect and that A / embedded_A accepting <A^><A^> is incorrect. So not a *single* H but two *different* H's. This also means that A accepting <R^><R^> is correct and R rejecting <A^><A^> is correct.
>>>
>>> In other words, no H can give a correct halting/non-halting answer for an H^ built from it (even though some other H could).
>> So when I show that the H embedded within Ĥ does correctly decide its
>> input ⟨Ĥ⟩ ⟨Ĥ⟩, Linz has been refuted.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn

When Ĥ is applied to ⟨Ĥ0⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩

Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
non-halting.

--
Copyright 2022 Pete Olcott

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

On Friday, April 8, 2022 at 3:44:00 PM UTC-4, olcott wrote:
> On 4/8/2022 2:36 PM, Dennis Bush wrote:
> > On Friday, April 8, 2022 at 3:22:52 PM UTC-4, olcott wrote:
> >> On 4/8/2022 2:17 PM, Dennis Bush wrote:
> >>> On Friday, April 8, 2022 at 2:32:32 PM UTC-4, olcott wrote:
> >>>> On 4/8/2022 1:26 PM, Dennis Bush wrote:
> >>>>> On Friday, April 8, 2022 at 2:05:09 PM UTC-4, olcott wrote:
> >>>>>> On 4/8/2022 12:44 PM, André G. Isaak wrote:
> >>>>>>> On 2022-04-08 11:02, olcott wrote:
> >>>>>>>
> >>>>>>>> I asked about Ĥ0 and you answered with Ĥn which includes Ĥ[0...n].
> >>>>>>>
> >>>>>>> You need to go back to the point where Dennis defined his Ha and Hn.
> >>>>>>> They don't mean what you seem to think they mean.
> >>>>>>>
> >>>>>>> André
> >>>>>>>
> >>>>>> The fact that they do not mean embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is enough
> >>>>>> to know that they must be utterly rejected out-of-hand.
> >>>>>
> >>>>> Ha and Hn more explicitly spell out which H is being referred to, as you often intentionally switch one you're talking about when you say H (sometimes in the same sentence).
> >>>>>
> >>>>>>
> >>>>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
> >>>>>> that is relevant to the correctness of embedded_H rejecting this input.
> >>>>>
> >>>>> And by the same reasoning, that the input <N><5> to Ha3 is non-halting is the only thing that is relevant to the correctness of Ha3 rejecting this input.
> >>>>>
> >>>>> Agreed?
> >>>>>
> >>>> I have no idea what that gibberish means other then a deliberately
> >>>> dishonest attempt at avoiding the point at hand:
> >>>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
> >>>
> >>> What is means is that for Ha rejecting <Ha^><Ha^> and for Ha3 rejecting <N><5>, either both are correct or both are incorrect.
> >>>
> >>> Pick one.
> >> Dennis Bush is a God damned liar that refuses to stay exactly on topic
> >> because rebuttals are impossible when staying exactly on topic.
> >
> > Translation: All I can do is throw out insults when I have no way to refute something that proves me wrong.
>
> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
> that is relevant to the correctness of embedded_H rejecting this input.
> Can only be denied by God damned liars. Instead of directly denying it
> and thus being an obvious liar to everyone Dennis dances all around it
> making sure to never get to the actual point.

Actually, the only thing relevant to the correctness of embedded_H is: does Ĥ applied to ⟨Ĥ⟩ halt. If the answer H / embedded_H gives doesn't match this it is wrong.

When you say "the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting" what you're actually saying is "H / embedded_H is unable to simulate Ĥ applied to ⟨Ĥ⟩ to its final state, whether or not Ĥ applied to ⟨Ĥ⟩ halts". That's why Ha3 rejecting <N><5> is correct by the same reasoning: Ha3 cannot simulate N applied to <5> to its final state, whether or not N applied to <5> halts.

When you start with a definition contrary to the stipulated one, you get nonsense results. That's what Ha3 applied to <N><5> demonstrates.

On Friday, April 8, 2022 at 3:51:38 PM UTC-4, olcott wrote:
> On 4/8/2022 2:38 PM, Dennis Bush wrote:
> > On Friday, April 8, 2022 at 3:20:35 PM UTC-4, olcott wrote:
> >> On 4/8/2022 2:16 PM, Dennis Bush wrote:
> >>> On Friday, April 8, 2022 at 2:49:36 PM UTC-4, olcott wrote:
> >>>> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
> >>>>> olcott <No...@NoWhere.com> writes:
> >>>>>
> >>>>>> Linz makes this difficult to understand because he simply erases key
> >>>>>> elements of the definition of Ĥ:
> >>>>>>
> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>>>>
> >>>>> You have erased them. Linz specifies Ĥ properly based on what H is
> >>>>> supposed to do:
> >>>>>
> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
> >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
> >>>>>
> >>>>> You have spent an inordinate amount of time over the years copying out
> >>>>> those lines and dishonestly removing the key conditions. We all know
> >>>>> why.
> >>>>>
> >>>> <Linz:1990:320>
> >>>> Now Ĥ is a Turing machine, so that it will have some description in
> >>>> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
> >>>> also be used as input string. We can therefore legitimately ask what
> >>>> would happen if Ĥ is applied to ŵ.
> >>>>
> >>>> q0ŵ ⊢* Ĥ ∞
> >>>> if Ĥ applied to ŵ halts, and
> >>>>
> >>>> q0ŵ ⊢* Ĥy1qny2
> >>>> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
> >>>> contradiction tells us that...
> >>>> </Linz:1990:320>
> >>>>
> >>>> In other words the copy of H embedded within Ĥ is incorrect to either
> >>>> reject or accept its input.
> >>>
> >>> What you fail to notice is that there is more than one H and H^ in play. For example:
> >>>
> >>> A: an H that always accepts
> >>> R: an H that always rejects
> >>>
> >>> What the above is saying is that R / embedded_R rejecting <R^><R^> is incorrect and that A / embedded_A accepting <A^><A^> is incorrect. So not a *single* H but two *different* H's. This also means that A accepting <R^><R^> is correct and R rejecting <A^><A^> is correct.
> >>>
> >>> In other words, no H can give a correct halting/non-halting answer for an H^ built from it (even though some other H could).
> >> So when I show that the H embedded within Ĥ does correctly decide its
> >> input ⟨Ĥ⟩ ⟨Ĥ⟩, Linz has been refuted.
> >
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> When Ĥ is applied to ⟨Ĥ0⟩
> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
> H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
> Then these steps would keep repeating:
> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
> non-halting.

That pattern only exists in Hn^. So substituting Hn for H, the above really says:

---
Ĥn.q0 ⟨Ĥn⟩ ⊢* Hn ⟨Ĥn⟩ ⟨Ĥn⟩ ⊢* Hn.qy
Ĥn.q0 ⟨Ĥn⟩ ⊢* Hn ⟨Ĥn⟩ ⟨Ĥn⟩ ⊢* Hn.qn

When Ĥn is applied to ⟨Ĥn0⟩
Ĥn copies its input ⟨Ĥn0⟩ to ⟨Ĥn1⟩ then
Hn simulates ⟨Ĥn0⟩ ⟨Ĥn1⟩
Then these steps would keep repeating:
Ĥn0 copies its input ⟨Ĥn1⟩ to ⟨Ĥn2⟩ then Hn0 simulates ⟨Ĥn1⟩ ⟨Ĥn2⟩
Ĥn1 copies its input ⟨Ĥn2⟩ to ⟨Ĥn3⟩ then Hn1 simulates ⟨Ĥn2⟩ ⟨Ĥn3⟩

Since we can see that the simulated input: ⟨Ĥn0⟩ to embedded_Hn never
reaches its own final state of ⟨Ĥn0.qy⟩ or ⟨Ĥn0.qn⟩ we know that it is
non-halting.
---

But since Hn / embedded_Hn can't abort, it can't answer and is wrong by default.

On 4/8/2022 2:53 PM, Dennis Bush wrote:
> On Friday, April 8, 2022 at 3:44:00 PM UTC-4, olcott wrote:
>> On 4/8/2022 2:36 PM, Dennis Bush wrote:
>>> On Friday, April 8, 2022 at 3:22:52 PM UTC-4, olcott wrote:
>>>> On 4/8/2022 2:17 PM, Dennis Bush wrote:
>>>>> On Friday, April 8, 2022 at 2:32:32 PM UTC-4, olcott wrote:
>>>>>> On 4/8/2022 1:26 PM, Dennis Bush wrote:
>>>>>>> On Friday, April 8, 2022 at 2:05:09 PM UTC-4, olcott wrote:
>>>>>>>> On 4/8/2022 12:44 PM, André G. Isaak wrote:
>>>>>>>>> On 2022-04-08 11:02, olcott wrote:
>>>>>>>>>
>>>>>>>>>> I asked about Ĥ0 and you answered with Ĥn which includes Ĥ[0...n].
>>>>>>>>>
>>>>>>>>> You need to go back to the point where Dennis defined his Ha and Hn.
>>>>>>>>> They don't mean what you seem to think they mean.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>> The fact that they do not mean embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is enough
>>>>>>>> to know that they must be utterly rejected out-of-hand.
>>>>>>>
>>>>>>> Ha and Hn more explicitly spell out which H is being referred to, as you often intentionally switch one you're talking about when you say H (sometimes in the same sentence).
>>>>>>>
>>>>>>>>
>>>>>>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
>>>>>>>> that is relevant to the correctness of embedded_H rejecting this input.
>>>>>>>
>>>>>>> And by the same reasoning, that the input <N><5> to Ha3 is non-halting is the only thing that is relevant to the correctness of Ha3 rejecting this input.
>>>>>>>
>>>>>>> Agreed?
>>>>>>>
>>>>>> I have no idea what that gibberish means other then a deliberately
>>>>>> dishonest attempt at avoiding the point at hand:
>>>>>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>
>>>>> What is means is that for Ha rejecting <Ha^><Ha^> and for Ha3 rejecting <N><5>, either both are correct or both are incorrect.
>>>>>
>>>>> Pick one.
>>>> Dennis Bush is a God damned liar that refuses to stay exactly on topic
>>>> because rebuttals are impossible when staying exactly on topic.
>>>
>>> Translation: All I can do is throw out insults when I have no way to refute something that proves me wrong.
>>
>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
>> that is relevant to the correctness of embedded_H rejecting this input.
>> Can only be denied by God damned liars. Instead of directly denying it
>> and thus being an obvious liar to everyone Dennis dances all around it
>> making sure to never get to the actual point.
>
> Actually, the only thing relevant to the correctness of embedded_H is: does Ĥ applied to ⟨Ĥ⟩ halt.

If you are too stupid to know that all deciders only compute the mapping
from their actual inputs to their final accept or reject state then you
can easily make stupid mistakes such as this.

When you are tasked with watching the front door and must report
everyone entering the front door looking at the back door is incorrect.

--
Copyright 2022 Pete Olcott

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

On 4/8/2022 2:56 PM, Dennis Bush wrote:
> On Friday, April 8, 2022 at 3:51:38 PM UTC-4, olcott wrote:
>> On 4/8/2022 2:38 PM, Dennis Bush wrote:
>>> On Friday, April 8, 2022 at 3:20:35 PM UTC-4, olcott wrote:
>>>> On 4/8/2022 2:16 PM, Dennis Bush wrote:
>>>>> On Friday, April 8, 2022 at 2:49:36 PM UTC-4, olcott wrote:
>>>>>> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>
>>>>>>>> Linz makes this difficult to understand because he simply erases key
>>>>>>>> elements of the definition of Ĥ:
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> You have erased them. Linz specifies Ĥ properly based on what H is
>>>>>>> supposed to do:
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>>>
>>>>>>> You have spent an inordinate amount of time over the years copying out
>>>>>>> those lines and dishonestly removing the key conditions. We all know
>>>>>>> why.
>>>>>>>
>>>>>> <Linz:1990:320>
>>>>>> Now Ĥ is a Turing machine, so that it will have some description in
>>>>>> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
>>>>>> also be used as input string. We can therefore legitimately ask what
>>>>>> would happen if Ĥ is applied to ŵ.
>>>>>>
>>>>>> q0ŵ ⊢* Ĥ ∞
>>>>>> if Ĥ applied to ŵ halts, and
>>>>>>
>>>>>> q0ŵ ⊢* Ĥy1qny2
>>>>>> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
>>>>>> contradiction tells us that...
>>>>>> </Linz:1990:320>
>>>>>>
>>>>>> In other words the copy of H embedded within Ĥ is incorrect to either
>>>>>> reject or accept its input.
>>>>>
>>>>> What you fail to notice is that there is more than one H and H^ in play. For example:
>>>>>
>>>>> A: an H that always accepts
>>>>> R: an H that always rejects
>>>>>
>>>>> What the above is saying is that R / embedded_R rejecting <R^><R^> is incorrect and that A / embedded_A accepting <A^><A^> is incorrect. So not a *single* H but two *different* H's. This also means that A accepting <R^><R^> is correct and R rejecting <A^><A^> is correct.
>>>>>
>>>>> In other words, no H can give a correct halting/non-halting answer for an H^ built from it (even though some other H could).
>>>> So when I show that the H embedded within Ĥ does correctly decide its
>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩, Linz has been refuted.
>>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>> When Ĥ is applied to ⟨Ĥ0⟩
>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>> H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>> Then these steps would keep repeating:
>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
>> non-halting.
>
> That pattern only exists in Hn^.

Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
non-halting.

Changing the subject is lying.

--
Copyright 2022 Pete Olcott

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

On Friday, April 8, 2022 at 4:02:40 PM UTC-4, olcott wrote:
> On 4/8/2022 2:53 PM, Dennis Bush wrote:
> > On Friday, April 8, 2022 at 3:44:00 PM UTC-4, olcott wrote:
> >> On 4/8/2022 2:36 PM, Dennis Bush wrote:
> >>> On Friday, April 8, 2022 at 3:22:52 PM UTC-4, olcott wrote:
> >>>> On 4/8/2022 2:17 PM, Dennis Bush wrote:
> >>>>> On Friday, April 8, 2022 at 2:32:32 PM UTC-4, olcott wrote:
> >>>>>> On 4/8/2022 1:26 PM, Dennis Bush wrote:
> >>>>>>> On Friday, April 8, 2022 at 2:05:09 PM UTC-4, olcott wrote:
> >>>>>>>> On 4/8/2022 12:44 PM, André G. Isaak wrote:
> >>>>>>>>> On 2022-04-08 11:02, olcott wrote:
> >>>>>>>>>
> >>>>>>>>>> I asked about Ĥ0 and you answered with Ĥn which includes Ĥ[0...n].
> >>>>>>>>>
> >>>>>>>>> You need to go back to the point where Dennis defined his Ha and Hn.
> >>>>>>>>> They don't mean what you seem to think they mean.
> >>>>>>>>>
> >>>>>>>>> André
> >>>>>>>>>
> >>>>>>>> The fact that they do not mean embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is enough
> >>>>>>>> to know that they must be utterly rejected out-of-hand.
> >>>>>>>
> >>>>>>> Ha and Hn more explicitly spell out which H is being referred to, as you often intentionally switch one you're talking about when you say H (sometimes in the same sentence).
> >>>>>>>
> >>>>>>>>
> >>>>>>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
> >>>>>>>> that is relevant to the correctness of embedded_H rejecting this input.
> >>>>>>>
> >>>>>>> And by the same reasoning, that the input <N><5> to Ha3 is non-halting is the only thing that is relevant to the correctness of Ha3 rejecting this input.
> >>>>>>>
> >>>>>>> Agreed?
> >>>>>>>
> >>>>>> I have no idea what that gibberish means other then a deliberately
> >>>>>> dishonest attempt at avoiding the point at hand:
> >>>>>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
> >>>>>
> >>>>> What is means is that for Ha rejecting <Ha^><Ha^> and for Ha3 rejecting <N><5>, either both are correct or both are incorrect.
> >>>>>
> >>>>> Pick one.
> >>>> Dennis Bush is a God damned liar that refuses to stay exactly on topic
> >>>> because rebuttals are impossible when staying exactly on topic.
> >>>
> >>> Translation: All I can do is throw out insults when I have no way to refute something that proves me wrong.
> >>
> >> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
> >> that is relevant to the correctness of embedded_H rejecting this input..
> >> Can only be denied by God damned liars. Instead of directly denying it
> >> and thus being an obvious liar to everyone Dennis dances all around it
> >> making sure to never get to the actual point.
> >
> > Actually, the only thing relevant to the correctness of embedded_H is: does Ĥ applied to ⟨Ĥ⟩ halt.
> If you are too stupid to know that all deciders only compute the mapping
> from their actual inputs to their final accept or reject state then you
> can easily make stupid mistakes such as this.

And the actual input <H^><H^> is stipulated to represent H^ applied to <H^>..

If you insist on your wrong definition, that means for Ha rejecting <Ha^><Ha^> and for Ha3 rejecting <N><5>, either both are correct or both are incorrect.

Pick one.

>
> When you are tasked with watching the front door and must report
> everyone entering the front door looking at the back door is incorrect.

Except you apparently don't know your front from your back.

On Friday, April 8, 2022 at 4:04:51 PM UTC-4, olcott wrote:
> On 4/8/2022 2:56 PM, Dennis Bush wrote:
> > On Friday, April 8, 2022 at 3:51:38 PM UTC-4, olcott wrote:
> >> On 4/8/2022 2:38 PM, Dennis Bush wrote:
> >>> On Friday, April 8, 2022 at 3:20:35 PM UTC-4, olcott wrote:
> >>>> On 4/8/2022 2:16 PM, Dennis Bush wrote:
> >>>>> On Friday, April 8, 2022 at 2:49:36 PM UTC-4, olcott wrote:
> >>>>>> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
> >>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>
> >>>>>>>> Linz makes this difficult to understand because he simply erases key
> >>>>>>>> elements of the definition of Ĥ:
> >>>>>>>>
> >>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>>>>>>
> >>>>>>> You have erased them. Linz specifies Ĥ properly based on what H is
> >>>>>>> supposed to do:
> >>>>>>>
> >>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
> >>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
> >>>>>>>
> >>>>>>> You have spent an inordinate amount of time over the years copying out
> >>>>>>> those lines and dishonestly removing the key conditions. We all know
> >>>>>>> why.
> >>>>>>>
> >>>>>> <Linz:1990:320>
> >>>>>> Now Ĥ is a Turing machine, so that it will have some description in
> >>>>>> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
> >>>>>> also be used as input string. We can therefore legitimately ask what
> >>>>>> would happen if Ĥ is applied to ŵ.
> >>>>>>
> >>>>>> q0ŵ ⊢* Ĥ ∞
> >>>>>> if Ĥ applied to ŵ halts, and
> >>>>>>
> >>>>>> q0ŵ ⊢* Ĥy1qny2
> >>>>>> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
> >>>>>> contradiction tells us that...
> >>>>>> </Linz:1990:320>
> >>>>>>
> >>>>>> In other words the copy of H embedded within Ĥ is incorrect to either
> >>>>>> reject or accept its input.
> >>>>>
> >>>>> What you fail to notice is that there is more than one H and H^ in play. For example:
> >>>>>
> >>>>> A: an H that always accepts
> >>>>> R: an H that always rejects
> >>>>>
> >>>>> What the above is saying is that R / embedded_R rejecting <R^><R^> is incorrect and that A / embedded_A accepting <A^><A^> is incorrect. So not a *single* H but two *different* H's. This also means that A accepting <R^><R^> is correct and R rejecting <A^><A^> is correct.
> >>>>>
> >>>>> In other words, no H can give a correct halting/non-halting answer for an H^ built from it (even though some other H could).
> >>>> So when I show that the H embedded within Ĥ does correctly decide its
> >>>> input ⟨Ĥ⟩ ⟨Ĥ⟩, Linz has been refuted.
> >>>
> >> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> >> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> >> When Ĥ is applied to ⟨Ĥ0⟩
> >> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
> >> H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
> >> Then these steps would keep repeating:
> >> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
> >> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
> >> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
> >> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
> >> non-halting.
> >
> > That pattern only exists in Hn^.
>
> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
> non-halting.
> Changing the subject is lying.

No, hiding which H you're talking about is lying. I just used Hn to demonstrate that.

On 4/8/2022 3:08 PM, Dennis Bush wrote:
> On Friday, April 8, 2022 at 4:02:40 PM UTC-4, olcott wrote:
>> On 4/8/2022 2:53 PM, Dennis Bush wrote:
>>> On Friday, April 8, 2022 at 3:44:00 PM UTC-4, olcott wrote:
>>>> On 4/8/2022 2:36 PM, Dennis Bush wrote:
>>>>> On Friday, April 8, 2022 at 3:22:52 PM UTC-4, olcott wrote:
>>>>>> On 4/8/2022 2:17 PM, Dennis Bush wrote:
>>>>>>> On Friday, April 8, 2022 at 2:32:32 PM UTC-4, olcott wrote:
>>>>>>>> On 4/8/2022 1:26 PM, Dennis Bush wrote:
>>>>>>>>> On Friday, April 8, 2022 at 2:05:09 PM UTC-4, olcott wrote:
>>>>>>>>>> On 4/8/2022 12:44 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2022-04-08 11:02, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>> I asked about Ĥ0 and you answered with Ĥn which includes Ĥ[0...n].
>>>>>>>>>>>
>>>>>>>>>>> You need to go back to the point where Dennis defined his Ha and Hn.
>>>>>>>>>>> They don't mean what you seem to think they mean.
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>> The fact that they do not mean embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is enough
>>>>>>>>>> to know that they must be utterly rejected out-of-hand.
>>>>>>>>>
>>>>>>>>> Ha and Hn more explicitly spell out which H is being referred to, as you often intentionally switch one you're talking about when you say H (sometimes in the same sentence).
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
>>>>>>>>>> that is relevant to the correctness of embedded_H rejecting this input.
>>>>>>>>>
>>>>>>>>> And by the same reasoning, that the input <N><5> to Ha3 is non-halting is the only thing that is relevant to the correctness of Ha3 rejecting this input.
>>>>>>>>>
>>>>>>>>> Agreed?
>>>>>>>>>
>>>>>>>> I have no idea what that gibberish means other then a deliberately
>>>>>>>> dishonest attempt at avoiding the point at hand:
>>>>>>>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>
>>>>>>> What is means is that for Ha rejecting <Ha^><Ha^> and for Ha3 rejecting <N><5>, either both are correct or both are incorrect.
>>>>>>>
>>>>>>> Pick one.
>>>>>> Dennis Bush is a God damned liar that refuses to stay exactly on topic
>>>>>> because rebuttals are impossible when staying exactly on topic.
>>>>>
>>>>> Translation: All I can do is throw out insults when I have no way to refute something that proves me wrong.
>>>>
>>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
>>>> that is relevant to the correctness of embedded_H rejecting this input.
>>>> Can only be denied by God damned liars. Instead of directly denying it
>>>> and thus being an obvious liar to everyone Dennis dances all around it
>>>> making sure to never get to the actual point.
>>>
>>> Actually, the only thing relevant to the correctness of embedded_H is: does Ĥ applied to ⟨Ĥ⟩ halt.
>> If you are too stupid to know that all deciders only compute the mapping
>> from their actual inputs to their final accept or reject state then you
>> can easily make stupid mistakes such as this.
>
> And the actual input <H^><H^> is stipulated to represent H^ applied to <H^>.
>

Not exactly. The correct simulation and behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ at the
beginning of Ĥ is entirely different than the correct simulation of the
behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ in the middle of Ĥ.

You keep insisting that a cat <is> a dog because a textbook tells me so.

--
Copyright 2022 Pete Olcott

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

On 4/8/2022 3:09 PM, Dennis Bush wrote:
> On Friday, April 8, 2022 at 4:04:51 PM UTC-4, olcott wrote:
>> On 4/8/2022 2:56 PM, Dennis Bush wrote:
>>> On Friday, April 8, 2022 at 3:51:38 PM UTC-4, olcott wrote:
>>>> On 4/8/2022 2:38 PM, Dennis Bush wrote:
>>>>> On Friday, April 8, 2022 at 3:20:35 PM UTC-4, olcott wrote:
>>>>>> On 4/8/2022 2:16 PM, Dennis Bush wrote:
>>>>>>> On Friday, April 8, 2022 at 2:49:36 PM UTC-4, olcott wrote:
>>>>>>>> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> Linz makes this difficult to understand because he simply erases key
>>>>>>>>>> elements of the definition of Ĥ:
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> You have erased them. Linz specifies Ĥ properly based on what H is
>>>>>>>>> supposed to do:
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>>>>>
>>>>>>>>> You have spent an inordinate amount of time over the years copying out
>>>>>>>>> those lines and dishonestly removing the key conditions. We all know
>>>>>>>>> why.
>>>>>>>>>
>>>>>>>> <Linz:1990:320>
>>>>>>>> Now Ĥ is a Turing machine, so that it will have some description in
>>>>>>>> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
>>>>>>>> also be used as input string. We can therefore legitimately ask what
>>>>>>>> would happen if Ĥ is applied to ŵ.
>>>>>>>>
>>>>>>>> q0ŵ ⊢* Ĥ ∞
>>>>>>>> if Ĥ applied to ŵ halts, and
>>>>>>>>
>>>>>>>> q0ŵ ⊢* Ĥy1qny2
>>>>>>>> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
>>>>>>>> contradiction tells us that...
>>>>>>>> </Linz:1990:320>
>>>>>>>>
>>>>>>>> In other words the copy of H embedded within Ĥ is incorrect to either
>>>>>>>> reject or accept its input.
>>>>>>>
>>>>>>> What you fail to notice is that there is more than one H and H^ in play. For example:
>>>>>>>
>>>>>>> A: an H that always accepts
>>>>>>> R: an H that always rejects
>>>>>>>
>>>>>>> What the above is saying is that R / embedded_R rejecting <R^><R^> is incorrect and that A / embedded_A accepting <A^><A^> is incorrect. So not a *single* H but two *different* H's. This also means that A accepting <R^><R^> is correct and R rejecting <A^><A^> is correct.
>>>>>>>
>>>>>>> In other words, no H can give a correct halting/non-halting answer for an H^ built from it (even though some other H could).
>>>>>> So when I show that the H embedded within Ĥ does correctly decide its
>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩, Linz has been refuted.
>>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>> H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>> Then these steps would keep repeating:
>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
>>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
>>>> non-halting.
>>>
>>> That pattern only exists in Hn^.
>>
>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
>> non-halting.
>> Changing the subject is lying.
>
> No, hiding which H you're talking about is lying. I just used Hn to demonstrate that.

The H that I am talking about is specified above:
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn

It has no subscript. Putting a subscript on it is an act of deception.

--
Copyright 2022 Pete Olcott

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

On Friday, April 8, 2022 at 4:13:07 PM UTC-4, olcott wrote:
> On 4/8/2022 3:08 PM, Dennis Bush wrote:
> > On Friday, April 8, 2022 at 4:02:40 PM UTC-4, olcott wrote:
> >> On 4/8/2022 2:53 PM, Dennis Bush wrote:
> >>> On Friday, April 8, 2022 at 3:44:00 PM UTC-4, olcott wrote:
> >>>> On 4/8/2022 2:36 PM, Dennis Bush wrote:
> >>>>> On Friday, April 8, 2022 at 3:22:52 PM UTC-4, olcott wrote:
> >>>>>> On 4/8/2022 2:17 PM, Dennis Bush wrote:
> >>>>>>> On Friday, April 8, 2022 at 2:32:32 PM UTC-4, olcott wrote:
> >>>>>>>> On 4/8/2022 1:26 PM, Dennis Bush wrote:
> >>>>>>>>> On Friday, April 8, 2022 at 2:05:09 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 4/8/2022 12:44 PM, André G. Isaak wrote:
> >>>>>>>>>>> On 2022-04-08 11:02, olcott wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> I asked about Ĥ0 and you answered with Ĥn which includes Ĥ[0...n].
> >>>>>>>>>>>
> >>>>>>>>>>> You need to go back to the point where Dennis defined his Ha and Hn.
> >>>>>>>>>>> They don't mean what you seem to think they mean.
> >>>>>>>>>>>
> >>>>>>>>>>> André
> >>>>>>>>>>>
> >>>>>>>>>> The fact that they do not mean embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is enough
> >>>>>>>>>> to know that they must be utterly rejected out-of-hand.
> >>>>>>>>>
> >>>>>>>>> Ha and Hn more explicitly spell out which H is being referred to, as you often intentionally switch one you're talking about when you say H (sometimes in the same sentence).
> >>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
> >>>>>>>>>> that is relevant to the correctness of embedded_H rejecting this input.
> >>>>>>>>>
> >>>>>>>>> And by the same reasoning, that the input <N><5> to Ha3 is non-halting is the only thing that is relevant to the correctness of Ha3 rejecting this input.
> >>>>>>>>>
> >>>>>>>>> Agreed?
> >>>>>>>>>
> >>>>>>>> I have no idea what that gibberish means other then a deliberately
> >>>>>>>> dishonest attempt at avoiding the point at hand:
> >>>>>>>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
> >>>>>>>
> >>>>>>> What is means is that for Ha rejecting <Ha^><Ha^> and for Ha3 rejecting <N><5>, either both are correct or both are incorrect.
> >>>>>>>
> >>>>>>> Pick one.
> >>>>>> Dennis Bush is a God damned liar that refuses to stay exactly on topic
> >>>>>> because rebuttals are impossible when staying exactly on topic.
> >>>>>
> >>>>> Translation: All I can do is throw out insults when I have no way to refute something that proves me wrong.
> >>>>
> >>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
> >>>> that is relevant to the correctness of embedded_H rejecting this input.
> >>>> Can only be denied by God damned liars. Instead of directly denying it
> >>>> and thus being an obvious liar to everyone Dennis dances all around it
> >>>> making sure to never get to the actual point.
> >>>
> >>> Actually, the only thing relevant to the correctness of embedded_H is: does Ĥ applied to ⟨Ĥ⟩ halt.
> >> If you are too stupid to know that all deciders only compute the mapping
> >> from their actual inputs to their final accept or reject state then you
> >> can easily make stupid mistakes such as this.
> >
> > And the actual input <H^><H^> is stipulated to represent H^ applied to <H^>.
> >
> Not exactly. The correct simulation and behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ at the
> beginning of Ĥ is entirely different than the correct simulation of the
> behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ in the middle of Ĥ.

That would mean that H and embedded_H give different results for the same input, however you've implicitly accepted that they don't by your failure to provide an example.

So if embedded_H rejects ⟨Ĥ⟩ ⟨Ĥ⟩, then H will also reject ⟨Ĥ⟩ ⟨Ĥ⟩. And since Hn is not able to reject its input, that means that H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is Ha applied to ⟨Ĥa⟩ ⟨Ĥa⟩. And we've already shown that rejecting is incorrect because Hb accepts ⟨Ĥa⟩ ⟨Ĥa⟩.

On Friday, April 8, 2022 at 4:18:27 PM UTC-4, olcott wrote:
> On 4/8/2022 3:09 PM, Dennis Bush wrote:
> > On Friday, April 8, 2022 at 4:04:51 PM UTC-4, olcott wrote:
> >> On 4/8/2022 2:56 PM, Dennis Bush wrote:
> >>> On Friday, April 8, 2022 at 3:51:38 PM UTC-4, olcott wrote:
> >>>> On 4/8/2022 2:38 PM, Dennis Bush wrote:
> >>>>> On Friday, April 8, 2022 at 3:20:35 PM UTC-4, olcott wrote:
> >>>>>> On 4/8/2022 2:16 PM, Dennis Bush wrote:
> >>>>>>> On Friday, April 8, 2022 at 2:49:36 PM UTC-4, olcott wrote:
> >>>>>>>> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
> >>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>
> >>>>>>>>>> Linz makes this difficult to understand because he simply erases key
> >>>>>>>>>> elements of the definition of Ĥ:
> >>>>>>>>>>
> >>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>>>>>>>>
> >>>>>>>>> You have erased them. Linz specifies Ĥ properly based on what H is
> >>>>>>>>> supposed to do:
> >>>>>>>>>
> >>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
> >>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
> >>>>>>>>>
> >>>>>>>>> You have spent an inordinate amount of time over the years copying out
> >>>>>>>>> those lines and dishonestly removing the key conditions. We all know
> >>>>>>>>> why.
> >>>>>>>>>
> >>>>>>>> <Linz:1990:320>
> >>>>>>>> Now Ĥ is a Turing machine, so that it will have some description in
> >>>>>>>> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
> >>>>>>>> also be used as input string. We can therefore legitimately ask what
> >>>>>>>> would happen if Ĥ is applied to ŵ.
> >>>>>>>>
> >>>>>>>> q0ŵ ⊢* Ĥ ∞
> >>>>>>>> if Ĥ applied to ŵ halts, and
> >>>>>>>>
> >>>>>>>> q0ŵ ⊢* Ĥy1qny2
> >>>>>>>> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
> >>>>>>>> contradiction tells us that...
> >>>>>>>> </Linz:1990:320>
> >>>>>>>>
> >>>>>>>> In other words the copy of H embedded within Ĥ is incorrect to either
> >>>>>>>> reject or accept its input.
> >>>>>>>
> >>>>>>> What you fail to notice is that there is more than one H and H^ in play. For example:
> >>>>>>>
> >>>>>>> A: an H that always accepts
> >>>>>>> R: an H that always rejects
> >>>>>>>
> >>>>>>> What the above is saying is that R / embedded_R rejecting <R^><R^> is incorrect and that A / embedded_A accepting <A^><A^> is incorrect. So not a *single* H but two *different* H's. This also means that A accepting <R^><R^> is correct and R rejecting <A^><A^> is correct.
> >>>>>>>
> >>>>>>> In other words, no H can give a correct halting/non-halting answer for an H^ built from it (even though some other H could).
> >>>>>> So when I show that the H embedded within Ĥ does correctly decide its
> >>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩, Linz has been refuted.
> >>>>>
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> >>>> When Ĥ is applied to ⟨Ĥ0⟩
> >>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
> >>>> H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
> >>>> Then these steps would keep repeating:
> >>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
> >>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
> >>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
> >>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
> >>>> non-halting.
> >>>
> >>> That pattern only exists in Hn^.
> >>
> >> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
> >> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
> >> non-halting.
> >> Changing the subject is lying.
> >
> > No, hiding which H you're talking about is lying. I just used Hn to demonstrate that.
> The H that I am talking about is specified above:
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> It has no subscript. Putting a subscript on it is an act of deception.

No, deception is using "H" to pretend that this:

When Ĥn is applied to ⟨Ĥn0⟩
Ĥn copies its input ⟨Ĥn0⟩ to ⟨Ĥn1⟩ then
Hn simulates ⟨Ĥn0⟩ ⟨Ĥn1⟩
Then these steps would keep repeating:
Ĥn0 copies its input ⟨Ĥn1⟩ to ⟨Ĥn2⟩ then Hn0 simulates ⟨Ĥn1⟩ ⟨Ĥn2⟩
Ĥn1 copies its input ⟨Ĥn2⟩ to ⟨Ĥn3⟩ then Hn1 simulates ⟨Ĥn2⟩ ⟨Ĥn3⟩

Is the same as this:

When Ĥa is applied to ⟨Ĥa0⟩
Ĥa copies its input ⟨Ĥa0⟩ to ⟨Ĥa1⟩ then
Ha simulates ⟨Ĥa0⟩ ⟨Ĥa1⟩
Ha sees what it believes is an infinite behavior pattern in its simulation
Ha aborts its simulation and goes to Ha.qn
Ĥa halts and goes to Ĥa.qn

On 4/8/2022 3:33 PM, Dennis Bush wrote:
> On Friday, April 8, 2022 at 4:13:07 PM UTC-4, olcott wrote:
>> On 4/8/2022 3:08 PM, Dennis Bush wrote:
>>> On Friday, April 8, 2022 at 4:02:40 PM UTC-4, olcott wrote:
>>>> On 4/8/2022 2:53 PM, Dennis Bush wrote:
>>>>> On Friday, April 8, 2022 at 3:44:00 PM UTC-4, olcott wrote:
>>>>>> On 4/8/2022 2:36 PM, Dennis Bush wrote:
>>>>>>> On Friday, April 8, 2022 at 3:22:52 PM UTC-4, olcott wrote:
>>>>>>>> On 4/8/2022 2:17 PM, Dennis Bush wrote:
>>>>>>>>> On Friday, April 8, 2022 at 2:32:32 PM UTC-4, olcott wrote:
>>>>>>>>>> On 4/8/2022 1:26 PM, Dennis Bush wrote:
>>>>>>>>>>> On Friday, April 8, 2022 at 2:05:09 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 4/8/2022 12:44 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2022-04-08 11:02, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> I asked about Ĥ0 and you answered with Ĥn which includes Ĥ[0...n].
>>>>>>>>>>>>>
>>>>>>>>>>>>> You need to go back to the point where Dennis defined his Ha and Hn.
>>>>>>>>>>>>> They don't mean what you seem to think they mean.
>>>>>>>>>>>>>
>>>>>>>>>>>>> André
>>>>>>>>>>>>>
>>>>>>>>>>>> The fact that they do not mean embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is enough
>>>>>>>>>>>> to know that they must be utterly rejected out-of-hand.
>>>>>>>>>>>
>>>>>>>>>>> Ha and Hn more explicitly spell out which H is being referred to, as you often intentionally switch one you're talking about when you say H (sometimes in the same sentence).
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
>>>>>>>>>>>> that is relevant to the correctness of embedded_H rejecting this input.
>>>>>>>>>>>
>>>>>>>>>>> And by the same reasoning, that the input <N><5> to Ha3 is non-halting is the only thing that is relevant to the correctness of Ha3 rejecting this input.
>>>>>>>>>>>
>>>>>>>>>>> Agreed?
>>>>>>>>>>>
>>>>>>>>>> I have no idea what that gibberish means other then a deliberately
>>>>>>>>>> dishonest attempt at avoiding the point at hand:
>>>>>>>>>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>
>>>>>>>>> What is means is that for Ha rejecting <Ha^><Ha^> and for Ha3 rejecting <N><5>, either both are correct or both are incorrect.
>>>>>>>>>
>>>>>>>>> Pick one.
>>>>>>>> Dennis Bush is a God damned liar that refuses to stay exactly on topic
>>>>>>>> because rebuttals are impossible when staying exactly on topic.
>>>>>>>
>>>>>>> Translation: All I can do is throw out insults when I have no way to refute something that proves me wrong.
>>>>>>
>>>>>> That the input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is non-halting is the only thing
>>>>>> that is relevant to the correctness of embedded_H rejecting this input.
>>>>>> Can only be denied by God damned liars. Instead of directly denying it
>>>>>> and thus being an obvious liar to everyone Dennis dances all around it
>>>>>> making sure to never get to the actual point.
>>>>>
>>>>> Actually, the only thing relevant to the correctness of embedded_H is: does Ĥ applied to ⟨Ĥ⟩ halt.
>>>> If you are too stupid to know that all deciders only compute the mapping
>>>> from their actual inputs to their final accept or reject state then you
>>>> can easily make stupid mistakes such as this.
>>>
>>> And the actual input <H^><H^> is stipulated to represent H^ applied to <H^>.
>>>
>> Not exactly. The correct simulation and behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ at the
>> beginning of Ĥ is entirely different than the correct simulation of the
>> behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ in the middle of Ĥ.
>
> That would mean that H and embedded_H give different results for the same input, however you've implicitly accepted that they don't by your failure to provide an example.

That is a God damned lie. I am not willing to go down any other rabbit
holes of complexity until after I first lock on my 17 years of progress.

--
Copyright 2022 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 4/8/2022 1:29 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> Linz makes this difficult to understand because he simply erases key
>>> elements of the definition of Ĥ:
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> You have erased them. Linz specifies Ĥ properly based on what H is
>> supposed to do:
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
>> You have spent an inordinate amount of time over the years copying out
>> those lines and dishonestly removing the key conditions. We all know
>> why.
>
> <Linz:1990:320>
> Now Ĥ is a Turing machine, so that it will have some description in
> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
> also be used as input string. We can therefore legitimately ask what
> would happen if Ĥ is applied to ŵ.
>
> q0ŵ ⊢* Ĥ ∞
> if Ĥ applied to ŵ halts, and
>
> q0ŵ ⊢* Ĥy1qny2

> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
> contradiction tells us that...
> </Linz:1990:320>

I know what Linz wrote. You could have just said "yes, I should keep
the conditions in -- my mistake".

> In other words the copy of H embedded within Ĥ is incorrect to either
> reject or accept its input.

No, that is not what Linz wrote "in other words". You've toyed with
this misconception for a long time. For years you refused to agree with
the simple fact that every instance of the halting problem has a correct
yes/no answer. Even now I am not 100% sure you agree with it. But
since Linz has always known it he would never conclude (or even
contemplate) that neither answer is correct.

> When I show that embedded_H correctly rejects its input ⟨Ĥ⟩ ⟨Ĥ⟩ I have
> correctly refuted Linz.

No, and (apparently) no amount of explanation will help you. But I have
a better way! Answer my questions and even you will see that Linz (and
the rest of the world) is right. That, of course, is why you avoid
them.

You can claim and stipulate and assert and stamp you feet to insist that
something wrong is right, but if you ever want some rest just tell us:

(A) what string we must pass to H for H to tell us whether Ĥ applied to
⟨Ĥ⟩ halts or not, and

(B) what state H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to

and you will see that you are wrong. You could then go do something
fun.

--
Ben.

olcott <NoOne@NoWhere.com> writes:

> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>> It is the case that the correctly simulated input to embedded_H can
>>>>>>> never possibly reach its own final state under any condition at all.
>>>>>>> Therefore embedded_H is necessarily correct to reject its input.
>>>>>>
>>>>>> Yet you won't answer two simple questions! Why?
>>>>>
>>>>> Because I absolutely positively will not tolerate divergence from
>>>>> validating my 17 years worth of work.
>>>>
>>>> But you have no choice but to tolerate it. If someone wants to talk
>>>> about why you are wrong, they will do so.
>>>>
>>>> You are wrong (for the C version of H) because H(P,P) == false but P(P)
>>>> halts. You are wrong about your TM H because H <Ĥ> <Ĥ> transitions to
>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel free to deny
>>>> any of these facts if the mood takes you.)
>>>
>>> If you believe (against the verified facts) that the simulated ⟨Ĥ0⟩
>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>
>> I believe what you've told me: that you claim that H(P,P)==false is
>> correct despite the fact that P(P) halts. That's wrong.
>
> If the input to H(P,P) cannot possibly reach its final state then this
> input is correctly rejected and nothing in the universe can possibly
> contradict this.

Agreed facts: (1) H(P,P) == false, (2) P(P) halts. You don't dispute
either (indeed they come from you).

Your new line in waffle is just an attempt to distract attention from a
very simple claim: that the wrong answer is the right one.

> You just don't know the computer science of it.

Says the person that recently failed to specify a simple "prime" decider
TM. The same person who could not write a TM to decide even parity. Or
are you still working on it?

> H computes the mapping
> from its input to its reject state on the basis that this simulated
> input never halts.
>
> Your example keeps assuming the counter-factual that H computes the
> mapping from non-inputs. Deciders never do this !!!

What example? The facts I quote above are from you.

Deciders accept or reject inputs based on any computable property of
those inputs. Whether the input is the binary encoding of a prime
number is one such property. Whether the input is the binary encoding
of a TM that halts on an empty tape (an even simpler problem) is not
such a property.

So, tell us what string must be passed to H so that H can tell us
whether or not Ĥ applied to ⟨Ĥ⟩ halts, and what state does H ⟨Ĥ⟩ ⟨Ĥ⟩
transitions to. (Silence expected...)

--
Ben.

On 4/8/2022 3:36 PM, Dennis Bush wrote:
> On Friday, April 8, 2022 at 4:18:27 PM UTC-4, olcott wrote:
>> On 4/8/2022 3:09 PM, Dennis Bush wrote:
>>> On Friday, April 8, 2022 at 4:04:51 PM UTC-4, olcott wrote:
>>>> On 4/8/2022 2:56 PM, Dennis Bush wrote:
>>>>> On Friday, April 8, 2022 at 3:51:38 PM UTC-4, olcott wrote:
>>>>>> On 4/8/2022 2:38 PM, Dennis Bush wrote:
>>>>>>> On Friday, April 8, 2022 at 3:20:35 PM UTC-4, olcott wrote:
>>>>>>>> On 4/8/2022 2:16 PM, Dennis Bush wrote:
>>>>>>>>> On Friday, April 8, 2022 at 2:49:36 PM UTC-4, olcott wrote:
>>>>>>>>>> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> Linz makes this difficult to understand because he simply erases key
>>>>>>>>>>>> elements of the definition of Ĥ:
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> You have erased them. Linz specifies Ĥ properly based on what H is
>>>>>>>>>>> supposed to do:
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>>>>>>>
>>>>>>>>>>> You have spent an inordinate amount of time over the years copying out
>>>>>>>>>>> those lines and dishonestly removing the key conditions. We all know
>>>>>>>>>>> why.
>>>>>>>>>>>
>>>>>>>>>> <Linz:1990:320>
>>>>>>>>>> Now Ĥ is a Turing machine, so that it will have some description in
>>>>>>>>>> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
>>>>>>>>>> also be used as input string. We can therefore legitimately ask what
>>>>>>>>>> would happen if Ĥ is applied to ŵ.
>>>>>>>>>>
>>>>>>>>>> q0ŵ ⊢* Ĥ ∞
>>>>>>>>>> if Ĥ applied to ŵ halts, and
>>>>>>>>>>
>>>>>>>>>> q0ŵ ⊢* Ĥy1qny2
>>>>>>>>>> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
>>>>>>>>>> contradiction tells us that...
>>>>>>>>>> </Linz:1990:320>
>>>>>>>>>>
>>>>>>>>>> In other words the copy of H embedded within Ĥ is incorrect to either
>>>>>>>>>> reject or accept its input.
>>>>>>>>>
>>>>>>>>> What you fail to notice is that there is more than one H and H^ in play. For example:
>>>>>>>>>
>>>>>>>>> A: an H that always accepts
>>>>>>>>> R: an H that always rejects
>>>>>>>>>
>>>>>>>>> What the above is saying is that R / embedded_R rejecting <R^><R^> is incorrect and that A / embedded_A accepting <A^><A^> is incorrect. So not a *single* H but two *different* H's. This also means that A accepting <R^><R^> is correct and R rejecting <A^><A^> is correct.
>>>>>>>>>
>>>>>>>>> In other words, no H can give a correct halting/non-halting answer for an H^ built from it (even though some other H could).
>>>>>>>> So when I show that the H embedded within Ĥ does correctly decide its
>>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩, Linz has been refuted.
>>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>> H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>> Then these steps would keep repeating:
>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
>>>>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
>>>>>> non-halting.
>>>>>
>>>>> That pattern only exists in Hn^.
>>>>
>>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
>>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
>>>> non-halting.
>>>> Changing the subject is lying.
>>>
>>> No, hiding which H you're talking about is lying. I just used Hn to demonstrate that.
>> The H that I am talking about is specified above:
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>> It has no subscript. Putting a subscript on it is an act of deception.
>
> No, deception is using "H" to pretend that this:
>
> When Ĥn is applied to ⟨Ĥn0⟩
I am referring only to the unsubscripted H embedded within Ĥ shown below.
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn

The instances of H that do have subscripts have no "n", and I am not
referring to any of these.

Ĥ applied to ⟨Ĥ⟩ ⊢* H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn

--
Copyright 2022 Pete Olcott

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

On 4/8/2022 3:49 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> Linz makes this difficult to understand because he simply erases key
>>>> elements of the definition of Ĥ:
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> You have erased them. Linz specifies Ĥ properly based on what H is
>>> supposed to do:
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>> You have spent an inordinate amount of time over the years copying out
>>> those lines and dishonestly removing the key conditions. We all know
>>> why.
>>
>> <Linz:1990:320>
>> Now Ĥ is a Turing machine, so that it will have some description in
>> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
>> also be used as input string. We can therefore legitimately ask what
>> would happen if Ĥ is applied to ŵ.
>>
>> q0ŵ ⊢* Ĥ ∞
>> if Ĥ applied to ŵ halts, and
>>
>> q0ŵ ⊢* Ĥy1qny2
>
>> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
>> contradiction tells us that...
>> </Linz:1990:320>
>
> I know what Linz wrote. You could have just said "yes, I should keep
> the conditions in -- my mistake".
>
>> In other words the copy of H embedded within Ĥ is incorrect to either
>> reject or accept its input.
>
> No, that is not what Linz wrote "in other words". You've toyed with
> this misconception for a long time. For years you refused to agree with
> the simple fact that every instance of the halting problem has a correct
> yes/no answer. Even now I am not 100% sure you agree with it. But
> since Linz has always known it he would never conclude (or even
> contemplate) that neither answer is correct.

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

Linz says that when embedded_H transitions to H.qy it is wrong and when
embedded_H transitions to H.qn it is wrong.

--
Copyright 2022 Pete Olcott

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

On Friday, April 8, 2022 at 5:30:48 PM UTC-4, olcott wrote:
> On 4/8/2022 3:36 PM, Dennis Bush wrote:
> > On Friday, April 8, 2022 at 4:18:27 PM UTC-4, olcott wrote:
> >> On 4/8/2022 3:09 PM, Dennis Bush wrote:
> >>> On Friday, April 8, 2022 at 4:04:51 PM UTC-4, olcott wrote:
> >>>> On 4/8/2022 2:56 PM, Dennis Bush wrote:
> >>>>> On Friday, April 8, 2022 at 3:51:38 PM UTC-4, olcott wrote:
> >>>>>> On 4/8/2022 2:38 PM, Dennis Bush wrote:
> >>>>>>> On Friday, April 8, 2022 at 3:20:35 PM UTC-4, olcott wrote:
> >>>>>>>> On 4/8/2022 2:16 PM, Dennis Bush wrote:
> >>>>>>>>> On Friday, April 8, 2022 at 2:49:36 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
> >>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>
> >>>>>>>>>>>> Linz makes this difficult to understand because he simply erases key
> >>>>>>>>>>>> elements of the definition of Ĥ:
> >>>>>>>>>>>>
> >>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>>>>>>>>>>
> >>>>>>>>>>> You have erased them. Linz specifies Ĥ properly based on what H is
> >>>>>>>>>>> supposed to do:
> >>>>>>>>>>>
> >>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
> >>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
> >>>>>>>>>>>
> >>>>>>>>>>> You have spent an inordinate amount of time over the years copying out
> >>>>>>>>>>> those lines and dishonestly removing the key conditions. We all know
> >>>>>>>>>>> why.
> >>>>>>>>>>>
> >>>>>>>>>> <Linz:1990:320>
> >>>>>>>>>> Now Ĥ is a Turing machine, so that it will have some description in
> >>>>>>>>>> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
> >>>>>>>>>> also be used as input string. We can therefore legitimately ask what
> >>>>>>>>>> would happen if Ĥ is applied to ŵ.
> >>>>>>>>>>
> >>>>>>>>>> q0ŵ ⊢* Ĥ ∞
> >>>>>>>>>> if Ĥ applied to ŵ halts, and
> >>>>>>>>>>
> >>>>>>>>>> q0ŵ ⊢* Ĥy1qny2
> >>>>>>>>>> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
> >>>>>>>>>> contradiction tells us that...
> >>>>>>>>>> </Linz:1990:320>
> >>>>>>>>>>
> >>>>>>>>>> In other words the copy of H embedded within Ĥ is incorrect to either
> >>>>>>>>>> reject or accept its input.
> >>>>>>>>>
> >>>>>>>>> What you fail to notice is that there is more than one H and H^ in play. For example:
> >>>>>>>>>
> >>>>>>>>> A: an H that always accepts
> >>>>>>>>> R: an H that always rejects
> >>>>>>>>>
> >>>>>>>>> What the above is saying is that R / embedded_R rejecting <R^><R^> is incorrect and that A / embedded_A accepting <A^><A^> is incorrect. So not a *single* H but two *different* H's. This also means that A accepting <R^><R^> is correct and R rejecting <A^><A^> is correct.
> >>>>>>>>>
> >>>>>>>>> In other words, no H can give a correct halting/non-halting answer for an H^ built from it (even though some other H could).
> >>>>>>>> So when I show that the H embedded within Ĥ does correctly decide its
> >>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩, Linz has been refuted.
> >>>>>>>
> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> >>>>>> When Ĥ is applied to ⟨Ĥ0⟩
> >>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
> >>>>>> H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
> >>>>>> Then these steps would keep repeating:
> >>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
> >>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
> >>>>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
> >>>>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
> >>>>>> non-halting.
> >>>>>
> >>>>> That pattern only exists in Hn^.
> >>>>
> >>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
> >>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
> >>>> non-halting.
> >>>> Changing the subject is lying.
> >>>
> >>> No, hiding which H you're talking about is lying. I just used Hn to demonstrate that.
> >> The H that I am talking about is specified above:
> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> >> It has no subscript. Putting a subscript on it is an act of deception.
> >
> > No, deception is using "H" to pretend that this:
> >
> > When Ĥn is applied to ⟨Ĥn0⟩
> I am referring only to the unsubscripted H embedded within Ĥ shown below.
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> The instances of H that do have subscripts have no "n", and I am not
> referring to any of these.

Yes you are. You just don't realize it.

For an H that aborts, it rejects <H^><H^> but some other halt decider accepts <H^><H^>, so H is wrong. That's what I mean when I say Ha is wrong to reject <Ha^><Ha^> because Hb accepts <Ha^><Ha^>.

>
> Ĥ applied to ⟨Ĥ⟩ ⊢* H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

On Friday, April 8, 2022 at 5:35:46 PM UTC-4, olcott wrote:
> On 4/8/2022 3:49 PM, Ben Bacarisse wrote:
> > olcott <No...@NoWhere.com> writes:
> >
> >> On 4/8/2022 1:29 PM, Ben Bacarisse wrote:
> >>> olcott <No...@NoWhere.com> writes:
> >>>
> >>>> Linz makes this difficult to understand because he simply erases key
> >>>> elements of the definition of Ĥ:
> >>>>
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>> You have erased them. Linz specifies Ĥ properly based on what H is
> >>> supposed to do:
> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
> >>> You have spent an inordinate amount of time over the years copying out
> >>> those lines and dishonestly removing the key conditions. We all know
> >>> why.
> >>
> >> <Linz:1990:320>
> >> Now Ĥ is a Turing machine, so that it will have some description in
> >> Σ*, say ŵ. This string, in addition to being the description of Ĥ can
> >> also be used as input string. We can therefore legitimately ask what
> >> would happen if Ĥ is applied to ŵ.
> >>
> >> q0ŵ ⊢* Ĥ ∞
> >> if Ĥ applied to ŵ halts, and
> >>
> >> q0ŵ ⊢* Ĥy1qny2
> >
> >> if Ĥ applied to ŵ does not halt. This is clearly nonsense. The
> >> contradiction tells us that...
> >> </Linz:1990:320>
> >
> > I know what Linz wrote. You could have just said "yes, I should keep
> > the conditions in -- my mistake".
> >
> >> In other words the copy of H embedded within Ĥ is incorrect to either
> >> reject or accept its input.
> >
> > No, that is not what Linz wrote "in other words". You've toyed with
> > this misconception for a long time. For years you refused to agree with
> > the simple fact that every instance of the halting problem has a correct
> > yes/no answer. Even now I am not 100% sure you agree with it. But
> > since Linz has always known it he would never conclude (or even
> > contemplate) that neither answer is correct.
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> Linz says that when embedded_H transitions to H.qy it is wrong and when
> embedded_H transitions to H.qn it is wrong.

More specifically, it says (given the earlier definitions of A and R) that A is wrong to accept <A^><A^> and R is wrong to reject <R^><R^>. Two different halt deciders, two different machines, two different results.