On 29/02/24 17:27, olcott wrote:
> On 2/29/2024 9:42 AM, immibis wrote:
>> On 29/02/24 15:48, olcott wrote:
>>> On 2/29/2024 4:55 AM, immibis wrote:
>>>> On 29/02/24 01:47, olcott wrote:
>>>>> In the same way that D did not contradict H1
>>>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>>>> internal copy of Ĥ.H, this has no effect on the actual H
>>>>> which has no reason to get the wrong answer.
>>>>
>>>> It is impossible for a copy of H to get a different result than H.
>>>>
>>>
>>> Because *H and Ĥ are in different memory spaces* Ĥ can only
>>> contradict itself and cannot contradict H. H and Ĥ.H always
>>> only report on what they see. Ĥ.H sees that YES is the wrong
>>> answer so it says NO by default. H sees that Ĥ said NO so it
>>> says YES.
>>>
>>
>> It is impossible for a copy of H to get a different result than H.
>
> False assumption.
> H(D,D) gets a different answer than H1(D,D) because
> H/DD has a pathological self-reference relationship
> and H1/DD does not.
>
> This is because H is in a different memory space than
> H1 the same way that Linz H is in a different memory
> space than Linz Ĥ.
> D can contradict H yet cannot contradict H1.
> Ĥ can contradict Ĥ.H yet cannot contradict Linz H.
>

Show me the first step where identical Turing machines T1 and T2 start
to compute different results on the same input.

On 3/1/24 12:17 AM, olcott wrote:
> On 2/29/2024 8:54 PM, Richard Damon wrote:
>> On 2/29/24 9:58 AM, olcott wrote:
>>> On 2/29/2024 6:32 AM, Richard Damon wrote:
>>>> On 2/28/24 11:26 PM, olcott wrote:
>>>>> On 2/28/2024 10:12 PM, Richard Damon wrote:
>>>>>> On 2/28/24 10:54 PM, olcott wrote:
>>>>>>> On 2/28/2024 9:06 PM, Richard Damon wrote:
>>>>>>>> On 2/28/24 7:47 PM, olcott wrote:
>>>>>>>>> On 2/28/2024 6:27 PM, Richard Damon wrote:
>>>>>>>>>> On 2/28/24 6:46 PM, olcott wrote:
>>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>>>>>>>>
>>>>>>>>>>> Because H is required to always halt we can know that
>>>>>>>>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>>>>>>>>> thus H merely needs to report on that.
>>>>>>>>>>>
>>>>>>>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>>>>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt
>>>>>>>>>>> decider
>>>>>>>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>>>>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>>>>>>>>> //
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn    // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>> does not halt
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>>>>>>>> returns making Ĥ self-contradictory.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, I guess you are just your bowels, which is why you are
>>>>>>>>>> always talking about your POOP.
>>>>>>>>>>
>>>>>>>>>> Ye, H^ contradicts *H* of which it has a copy as PART of itself.
>>>>>>>>>>
>>>>>>>>>> Things are ALL of themselves, not just parts.
>>>>>>>>>
>>>>>>>>> In the same way that D did not contradict H1
>>>>>>>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>>>>>>>> internal copy of Ĥ.H, this has no effect on the actual H
>>>>>>>>> which has no reason to get the wrong answer.
>>>>>>>>
>>>>>>>> No, it contraidicts ALL copies of H.
>>>>>>>>
>>>>>>>> The fact that H1 gives a different answer then H shows that it
>>>>>>>> is a different computaiton (if they are computations at all).
>>>>>>>>
>>>>>>>
>>>>>>> Ĥ only contradicts its own internal Ĥ.H and can have no effect
>>>>>>> on the external H.
>>>>>>
>>>>>> But the MUST act the same.
>>>>>>
>>>>>> If you disagree, then you are admitting that you don't understand
>>>>>> what a computation actually is.
>>>>>>
>>>>>
>>>>> The exact same way that H1 gets the correct answer on D
>>>>> even when H1 is a verbatim identical copy of H and it
>>>>> is the very same D in both cases H would get a correct
>>>>> answer for ⟨Ĥ⟩ ⟨Ĥ⟩ even though Ĥ.H cannot.
>>>>>
>>>>
>>>> Except H1 is NOT a "Verbatim Identical Copy" in the Turing Machine
>>>> Equivalent (TME) sense, in part because your H isn't a TME of the H
>>>> descirbed, becausee it takes and processes its input in an incorrect
>>>> manner.
>>>>
>>>
>>> What are all of the details of the "incorrect manner" that you are
>>> referring to?
>>
>> They use differing information that is not part of the input, namely
>> their own address.
>>
>
> I think it was Andre that said that was OK.
>
> The original design is the same as a UTM sharing
> a portion of its own tape with its simulated input
> this is always the way that this works that UTMs work.
> This aspect of the design may be moot now.

Try to do it,

The simulated machine can't know it is being simutated, or the UTM isn't
a UTM.

>
>>>
>>>>> When the machine language of H and H1 are identical and
>>>>> they both process the same machine language of D then
>>>>> the fact that H1 and H are in a different memory space
>>>>> is the same as Linz H and Ĥ.H are in a different memory
>>>>> space such that neither H1 nor Linz H can be contradicted
>>>>> by its input.
>>>>
>>>> Except they use a hidden input, and thus are not Computations.
>>>
>>> The simple fact that H and Ĥ.H are in different memory spaces makes it
>>> impossible for Ĥ to contradict H. When we hypothesize that H is based
>>> on a UTM then it can see that ⟨Ĥ⟩ ⟨Ĥ⟩ halts or fails to halt.
>>>
>>
>> Nope.
>>
>> Since BY SIMPLE PROOF, all identical copies of a computation produce
>> the same results from the same input, it just needs to contradict its
>> own copy to contradict all copies.
>>
>
> *In other word you can't understand this simple reasoning*
> *So you use dogma instead of reasoning as a rebuttal*
>
> H simply looks for whatever wrong answer that Ĥ.H
> returns and reports on the halting or not halting
> behavior of that.

And the H that tries to do this gets stuck in the infinte loop and never
answers.

You yourself proved this, which is why you say it must be ok for H to
abort its simulation to give A answer (which it can try to claim is
correct) before it can actually determine the correct answer.

>
>> THe fact that you don't understand that simple fact, that comes
>> directly from the definition of a Computation means your argument fails.
>>
>
> It is not so simply of a fact.
> Unless I saw it with my own eyes I would have believed as you believe.
> Your reasoning seems to be sound yet actual reality contradicts this.

So, show the computation that violates it.

If you saw it with your own eyes, you must have that exampe.

>
> You may not know enough about the x86 language to understand that it
> is proven that both H and H1 do simulated D correctly. I began with
> the x86 language back when it was new. Segmentation was a real pain.
> Flat address space was wonderful.

So, you think that Falsehood can be Truth.

You ARE the LIAR PARADOX.

>
>>
>> Remember, a "Computation" is a specific algorithm applied to a
>> specific finite set of data.
>>
>> The Algorithm is a finite set of specific deterministic instructions
>> whose results only depend on the data given to them.
>>
>> Two identical copies of an algorithm and data set, will always at each
>> step produce the exact same result for each step, and thus end up with
>> teh exact same answer.
>
> I believed that was true until I saw it contradicted by reality.
> Unless I made the problem 100% concrete I would never know that
> that halting problem proofs have behavior different than expected.

So show the reaity.

Go ahead, failure is proof that you are just a pathological liar.

>
> Since I know the principle that you said is correct then there
> must be some difference to explain the difference in behavior.

Then show it

>
> A key difference is that every value that Ĥ.H returns is contradicted
> and no value that H returns is contradicted. This seems to make
> them different machines.

But they are the same.

So, you thnk that two identical things can have significant differences.

LIES.

>
> Another difference is that these two computations on the same data
> are out-of-sync so that one of these two computations is in a more
> advanced state than the other. Ĥ.H is many steps ahead of H.

On 2024-02-29 22:17, olcott wrote:
> On 2/29/2024 8:54 PM, Richard Damon wrote:
>> On 2/29/24 9:58 AM, olcott wrote:

>>> What are all of the details of the "incorrect manner" that you are
>>> referring to?
>>
>> They use differing information that is not part of the input, namely
>> their own address.
>>
>
> I think it was Andre that said that was OK.

No, I said no such thing.

André

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

On 3/1/2024 10:52 AM, André G. Isaak wrote:
> On 2024-02-29 22:17, olcott wrote:
>> On 2/29/2024 8:54 PM, Richard Damon wrote:
>>> On 2/29/24 9:58 AM, olcott wrote:
>
>>>> What are all of the details of the "incorrect manner" that you are
>>>> referring to?
>>>
>>> They use differing information that is not part of the input, namely
>>> their own address.
>>>
>>
>> I think it was Andre that said that was OK.
>
> No, I said no such thing.
>
> André
>

Thanks for your feedback.
OK fine this is moot now anyway on the following basis:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

Ĥ contradicts Ĥ.H and does not contradict H, thus H
is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.

As long as some computable criteria exists for Ĥ.H to transition
to Ĥ.Hqy or Ĥ.Hqn, then H has its basis to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.

H simply looks for whatever wrong answer that Ĥ.H returns and
reports on the halting or not halting behavior of that.

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

On 3/1/24 12:46 PM, olcott wrote:
> On 3/1/2024 10:52 AM, André G. Isaak wrote:
>> On 2024-02-29 22:17, olcott wrote:
>>> On 2/29/2024 8:54 PM, Richard Damon wrote:
>>>> On 2/29/24 9:58 AM, olcott wrote:
>>
>>>>> What are all of the details of the "incorrect manner" that you are
>>>>> referring to?
>>>>
>>>> They use differing information that is not part of the input, namely
>>>> their own address.
>>>>
>>>
>>> I think it was Andre that said that was OK.
>>
>> No, I said no such thing.
>>
>> André
>>
>
> Thanks for your feedback.
> OK fine this is moot now anyway on the following basis:
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Ĥ contradicts Ĥ.H and does not contradict H, thus H
> is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> As long as some computable criteria exists for Ĥ.H to transition
> to Ĥ.Hqy or Ĥ.Hqn, then H has its basis to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> H simply looks for whatever wrong answer that Ĥ.H returns and
> reports on the halting or not halting behavior of that.
>
>

Except that Ĥ.H IS H, and acts just like it, so H can't do something
differnt unless you are lying that H is an actual Turing Machine (or
Equivalent).

The ONLY criteria that Ĥ.H can use, is the exact same criteria that H
uses, or you are just admittng that you are a LIAR.

Thus, H must be wrong, and you are proved to be a LIAR, in particular, a
PATHOLOGICAL LIAR.

On 3/1/2024 12:00 PM, Richard Damon wrote:
> On 3/1/24 12:46 PM, olcott wrote:
>> On 3/1/2024 10:52 AM, André G. Isaak wrote:
>>> On 2024-02-29 22:17, olcott wrote:
>>>> On 2/29/2024 8:54 PM, Richard Damon wrote:
>>>>> On 2/29/24 9:58 AM, olcott wrote:
>>>
>>>>>> What are all of the details of the "incorrect manner" that you are
>>>>>> referring to?
>>>>>
>>>>> They use differing information that is not part of the input,
>>>>> namely their own address.
>>>>>
>>>>
>>>> I think it was Andre that said that was OK.
>>>
>>> No, I said no such thing.
>>>
>>> André
>>>
>>
>> Thanks for your feedback.
>> OK fine this is moot now anyway on the following basis:
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Ĥ contradicts Ĥ.H and does not contradict H, thus H
>> is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> As long as some computable criteria exists for Ĥ.H to transition
>> to Ĥ.Hqy or Ĥ.Hqn, then H has its basis to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> H simply looks for whatever wrong answer that Ĥ.H returns and
>> reports on the halting or not halting behavior of that.
>>
>>
>
> Except that Ĥ.H IS H, and acts just like it, so H can't do something
> differnt unless you are lying that H is an actual Turing Machine (or
> Equivalent).

Ĥ.H that is embedded within Ĥ that contradicts every value
that Ĥ.H returns is clearly not the same machine as Linz
H where none of its return values are contradicted.

*Corrupted H is clearly not the same machine as original H*
*Corrupted H is clearly not the same machine as original H*
*Corrupted H is clearly not the same machine as original H*

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

On 3/1/24 3:29 PM, olcott wrote:
> On 3/1/2024 12:00 PM, Richard Damon wrote:
>> On 3/1/24 12:46 PM, olcott wrote:
>>> On 3/1/2024 10:52 AM, André G. Isaak wrote:
>>>> On 2024-02-29 22:17, olcott wrote:
>>>>> On 2/29/2024 8:54 PM, Richard Damon wrote:
>>>>>> On 2/29/24 9:58 AM, olcott wrote:
>>>>
>>>>>>> What are all of the details of the "incorrect manner" that you
>>>>>>> are referring to?
>>>>>>
>>>>>> They use differing information that is not part of the input,
>>>>>> namely their own address.
>>>>>>
>>>>>
>>>>> I think it was Andre that said that was OK.
>>>>
>>>> No, I said no such thing.
>>>>
>>>> André
>>>>
>>>
>>> Thanks for your feedback.
>>> OK fine this is moot now anyway on the following basis:
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Ĥ contradicts Ĥ.H and does not contradict H, thus H
>>> is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> As long as some computable criteria exists for Ĥ.H to transition
>>> to Ĥ.Hqy or Ĥ.Hqn, then H has its basis to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> H simply looks for whatever wrong answer that Ĥ.H returns and
>>> reports on the halting or not halting behavior of that.
>>>
>>>
>>
>> Except that Ĥ.H IS H, and acts just like it, so H can't do something
>> differnt unless you are lying that H is an actual Turing Machine (or
>> Equivalent).
>
> Ĥ.H that is embedded within Ĥ that contradicts every value
> that Ĥ.H returns is clearly not the same machine as Linz
> H where none of its return values are contradicted.
>
> *Corrupted H is clearly not the same machine as original H*
> *Corrupted H is clearly not the same machine as original H*
> *Corrupted H is clearly not the same machine as original H*
>

How was it corrupted?

There was no change to any step betweeh Q0 and Qy and Qn, so its
operation between those wil; not change.

YOU are the CORRUPTED one.

On 1/03/24 18:46, olcott wrote:
> On 3/1/2024 10:52 AM, André G. Isaak wrote:
>> On 2024-02-29 22:17, olcott wrote:
>>> On 2/29/2024 8:54 PM, Richard Damon wrote:
>>>> On 2/29/24 9:58 AM, olcott wrote:
>>
>>>>> What are all of the details of the "incorrect manner" that you are
>>>>> referring to?
>>>>
>>>> They use differing information that is not part of the input, namely
>>>> their own address.
>>>>
>>>
>>> I think it was Andre that said that was OK.
>>
>> No, I said no such thing.
>>
>> André
>>
>
> Thanks for your feedback.
> OK fine this is moot now anyway on the following basis:
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Ĥ contradicts Ĥ.H and does not contradict H, thus H
> is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.

It's impossible that Ĥ.H contradicts H because one is a copy of the other.

On 1/03/24 21:29, olcott wrote:
> On 3/1/2024 12:00 PM, Richard Damon wrote:
>> On 3/1/24 12:46 PM, olcott wrote:
>>> On 3/1/2024 10:52 AM, André G. Isaak wrote:
>>>> On 2024-02-29 22:17, olcott wrote:
>>>>> On 2/29/2024 8:54 PM, Richard Damon wrote:
>>>>>> On 2/29/24 9:58 AM, olcott wrote:
>>>>
>>>>>>> What are all of the details of the "incorrect manner" that you
>>>>>>> are referring to?
>>>>>>
>>>>>> They use differing information that is not part of the input,
>>>>>> namely their own address.
>>>>>>
>>>>>
>>>>> I think it was Andre that said that was OK.
>>>>
>>>> No, I said no such thing.
>>>>
>>>> André
>>>>
>>>
>>> Thanks for your feedback.
>>> OK fine this is moot now anyway on the following basis:
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Ĥ contradicts Ĥ.H and does not contradict H, thus H
>>> is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> As long as some computable criteria exists for Ĥ.H to transition
>>> to Ĥ.Hqy or Ĥ.Hqn, then H has its basis to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> H simply looks for whatever wrong answer that Ĥ.H returns and
>>> reports on the halting or not halting behavior of that.
>>>
>>>
>>
>> Except that Ĥ.H IS H, and acts just like it, so H can't do something
>> differnt unless you are lying that H is an actual Turing Machine (or
>> Equivalent).
>
> Ĥ.H that is embedded within Ĥ that contradicts every value
> that Ĥ.H returns is clearly not the same machine as Linz
> H where none of its return values are contradicted.
>
> *Corrupted H is clearly not the same machine as original H*
> *Corrupted H is clearly not the same machine as original H*
> *Corrupted H is clearly not the same machine as original H*
>
Then don't corrupt H. If you corrupted it, you did the proof wrong.

On 3/5/2024 8:00 PM, immibis wrote:
> On 1/03/24 18:46, olcott wrote:
>> On 3/1/2024 10:52 AM, André G. Isaak wrote:
>>> On 2024-02-29 22:17, olcott wrote:
>>>> On 2/29/2024 8:54 PM, Richard Damon wrote:
>>>>> On 2/29/24 9:58 AM, olcott wrote:
>>>
>>>>>> What are all of the details of the "incorrect manner" that you are
>>>>>> referring to?
>>>>>
>>>>> They use differing information that is not part of the input,
>>>>> namely their own address.
>>>>>
>>>>
>>>> I think it was Andre that said that was OK.
>>>
>>> No, I said no such thing.
>>>
>>> André
>>>
>>
>> Thanks for your feedback.
>> OK fine this is moot now anyway on the following basis:
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Ĥ contradicts Ĥ.H and does not contradict H, thus H
>> is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> It's impossible that Ĥ.H contradicts H because one is a copy of the other.

The updated view is that the infinite loop appended to Ĥ.Hqy
has no effect what-so-ever on this:

Criterion Measure
H is assumed to be a simulating termination analyzer that aborts the
simulation of any input that would cause its own non-termination and
returns NO. Otherwise H always returns YES.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

Execution trace of Ĥ applied to ⟨Ĥ⟩
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ sees that it must abort its simulation on the above
basis and H ⟨Ĥ⟩ ⟨Ĥ⟩ does not see that it must abort its simulation.

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