The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer

H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt

*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
*The same execution trace occurs even when the infinite loop is removed*

It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.

When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria then Ĥ.H
⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy

*No one has refuted any of the above reasoning*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

--
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/5/24 11:47 PM, olcott wrote:
> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>
> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> *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
> *The same execution trace occurs even when the infinite loop is removed*
>
> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>
> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria then Ĥ.H
> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy
>
> *No one has refuted any of the above reasoning*
> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>
>

Sure we have.

You have just been too stupid to understand it, becaue you think
programs can do just whatever they want, and are not constrained to do
what they are programmed for.

That, or you have just be blantantly lying that you did your
contstruction by the requirements, including starting with an H that is
a compuatation.

Remember, you have already agreed that you have just been lying about
all of this, and that you haven't been following the rules, so calling
you out for lying is just agreeing with what you have said.

On 3/6/2024 12:28 AM, Richard Damon wrote:
> On 3/5/24 11:47 PM, olcott wrote:
>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> *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
>> *The same execution trace occurs even when the infinite loop is removed*
>>
>> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
>> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
>> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>>
>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria then
>> Ĥ.H
>> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy
>>
>> *No one has refuted any of the above reasoning*
>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>
>>
>
>
> Sure we have.
>
> You have just been too stupid to understand it, becaue you think
> programs can do just whatever they want, and are not constrained to do
> what they are programmed for.
>
> That, or you have just be blantantly lying that you did your
> contstruction by the requirements, including starting with an H that is
> a compuatation.
>
> Remember, you have already agreed that you have just been lying about
> all of this, and that you haven't been following the rules, so calling
> you out for lying is just agreeing with what you have said.

*You already point by point agreed with most of the above*

--
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/6/2024 12:28 AM, Richard Damon wrote:
> On 3/5/24 11:47 PM, olcott wrote:
>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> *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
>> *The same execution trace occurs even when the infinite loop is removed*
>>
>> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
>> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
>> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>>
>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria then
>> Ĥ.H
>> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy
>>
>> *No one has refuted any of the above reasoning*
>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>
>>
>
>
> Sure we have.

*You already point by point agreed with most of the above*
*You already point by point agreed with most of the above*
*You already point by point agreed with most of the above*

--
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/6/2024 12:28 AM, Richard Damon wrote:
> On 3/5/24 11:47 PM, olcott wrote:
>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> *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
>> *The same execution trace occurs even when the infinite loop is removed*
>>
>> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
>> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
>> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>>
>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria then
>> Ĥ.H
>> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy
>>
>> *No one has refuted any of the above reasoning*
>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>
>>
>
>
> Sure we have.

*You already point by point agreed with most of the above*
*You already point by point agreed with most of the above*
*You already point by point agreed with most of the above*

--
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/6/2024 12:28 AM, Richard Damon wrote:
> On 3/5/24 11:47 PM, olcott wrote:
>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> *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
>> *The same execution trace occurs even when the infinite loop is removed*
>>
>> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
>> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
>> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>>
>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria then
>> Ĥ.H
>> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy
>>
>> *No one has refuted any of the above reasoning*
>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>
>>
>
>
> Sure we have.

*You already point by point agreed with most of the above*
*You already point by point agreed with most of the above*
*You already point by point agreed with most of the above*

--
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/6/2024 12:28 AM, Richard Damon wrote:
> On 3/5/24 11:47 PM, olcott wrote:
>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> *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
>> *The same execution trace occurs even when the infinite loop is removed*
>>
>> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
>> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
>> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>>
>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria then
>> Ĥ.H
>> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy
>>
>> *No one has refuted any of the above reasoning*
>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>
>>
>
>
> Sure we have.

*You already point by point agreed with most of the above*
*You already point by point agreed with most of the above*
*You already point by point agreed with most of the above*
--
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/6/2024 12:28 AM, Richard Damon wrote:
> On 3/5/24 11:47 PM, olcott wrote:
>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> *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
>> *The same execution trace occurs even when the infinite loop is removed*
>>
>> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
>> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
>> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>>
>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria then
>> Ĥ.H
>> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy
>>
>> *No one has refuted any of the above reasoning*
>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>
>>
>
>
> Sure we have.

*You already point by point agreed with most of the above*
*You already point by point agreed with most of the above*
*You already point by point agreed with most of the above*
--
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/5/24 10:38 PM, olcott wrote:
> On 3/6/2024 12:28 AM, Richard Damon wrote:
>> On 3/5/24 11:47 PM, olcott wrote:
>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>>
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> *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
>>> *The same execution trace occurs even when the infinite loop is removed*
>>>
>>> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
>>> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
>>> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>>>
>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria
>>> then Ĥ.H
>>> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy
>>>
>>> *No one has refuted any of the above reasoning*
>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>
>>>
>>
>>
>> Sure we have.
>>
>> You have just been too stupid to understand it, becaue you think
>> programs can do just whatever they want, and are not constrained to do
>> what they are programmed for.
>>
>> That, or you have just be blantantly lying that you did your
>> contstruction by the requirements, including starting with an H that
>> is a compuatation.
>>
>> Remember, you have already agreed that you have just been lying about
>> all of this, and that you haven't been following the rules, so calling
>> you out for lying is just agreeing with what you have said.
>
> *You already point by point agreed with most of the above*
>

But not the conclusion or the application. Your thought process shows
your stupidity and total lack of understanding.

Yes, H must abort its simulation to give an answer, but it ends up not
getting the right answer to the right question

If you make the two copies act differently you have just confirmed that
you have been a LIAR, so nothing you say matters.

So, all you are doing is proving your utter stupidity.

On 3/6/2024 10:15 AM, Richard Damon wrote:
> On 3/5/24 10:38 PM, olcott wrote:
>> On 3/6/2024 12:28 AM, Richard Damon wrote:
>>> On 3/5/24 11:47 PM, olcott wrote:
>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer

H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt

*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
*The same execution trace occurs even when the infinite loop is removed*

It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.

When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria then Ĥ.H
⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy

> But not the conclusion or the application.

*The last line shown above <is> the conclusion of this proof*

> Your thought process shows
> your stupidity and total lack of understanding.
>

*That only shows your bias against an honest dialogue*
*The reason that you cannot point out any specific errors*
*is that you already agreed to the above point by point*

> Yes, H must abort its simulation

Wrong. You can't even get a single specific point correctly.
I suspect that all of those words above has overwhelmed your ADD.

--
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/6/24 8:34 AM, olcott wrote:
> On 3/6/2024 10:15 AM, Richard Damon wrote:
>> On 3/5/24 10:38 PM, olcott wrote:
>>> On 3/6/2024 12:28 AM, Richard Damon wrote:
>>>> On 3/5/24 11:47 PM, olcott wrote:
>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>
> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> *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.

In other words, you are admitting to NOT actually working on the actual
Halting Problem but lying about it by using a Strawman alternative.

GOOD JOB.

>
> Ĥ.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
> *The same execution trace occurs even when the infinite loop is removed*

>
> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.

H^.H must stops its simulation and transition to SOME final state to
prevent its own infinite execution.

That doesn't mean the answer that it goes to is the right answer for the
actual question that it is supposed to be answering.

>
> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria then Ĥ.H
> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy

That might be the "right answer" but it can't go there if H and H^.H are
actually copies of the same computaition.

Thus, you are just admitting that you are LYING about what you are
actually doing.

>
>> But not the conclusion or the application.
>
> *The last line shown above <is> the conclusion of this proof*

And I have never said that H could do that.

You just don't understand the meaning of real words.

>
>> Your thought process shows your stupidity and total lack of
>> understanding.
>>
>
> *That only shows your bias against an honest dialogue*
> *The reason that you cannot point out any specific errors*
> *is that you already agreed to the above point by point*

No, it shows your utter stupidity that reads anything said through your
brown colored lens of your gas-light mind.

You are just proving yourself to be a utterly ignorant pathological
lying idiot.

>
>> Yes, H must abort its simulation
>
> Wrong. You can't even get a single specific point correctly.
> I suspect that all of those words above has overwhelmed your ADD.
>

Nope.

Maybe I don't understand what you are trying to say because you are
using the wrongs words to say it because logic has no words to express
your illogic.

When you statements are clear contradictions to the meaning of other
parts of your statement it is clear that you logic system has totally
fallen appart.

You clearly don't understand what a Computation is, and thus what a
Decider actuall is.

You don't know what a Turing machine actually is or how they do there work.

You don't understand the basics of program design and operation,
thinking you can just "define" the results that a program is to generate
an not to need to figure out if it CAN generate that.

You are just proving you utter stupidity.

On 3/6/2024 11:20 AM, Richard Damon wrote:
> On 3/6/24 8:34 AM, olcott wrote:
>> On 3/6/2024 10:15 AM, Richard Damon wrote:
>>> On 3/5/24 10:38 PM, olcott wrote:
>>>> On 3/6/2024 12:28 AM, Richard Damon wrote:
>>>>> On 3/5/24 11:47 PM, olcott wrote:
>>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> *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.
>
> In other words, you are admitting to NOT actually working on the actual
> Halting Problem but lying about it by using a Strawman alternative.
>

H.q0 ⟨M⟩ ⟨M⟩ ⊢* H.qy // M applied to ⟨M⟩ halts
H.q0 ⟨M⟩ ⟨M⟩ ⊢* Hqn // M applied to ⟨M⟩ does not halt

Your failure to understand that the Linz wildcard ⊢* state transition
sequence expressly allows any criterion measure what-so-ever as long
as this criterion measure causes H ⟨M⟩ ⟨M⟩ to get the correct answer.

> GOOD JOB.
>
>>
>> Ĥ.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
>> *The same execution trace occurs even when the infinite loop is removed*
>
>
>
>>
>> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
>> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
>> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>
> H^.H must stops its simulation and transition to SOME final state to
> prevent its own infinite execution.
>
> That doesn't mean the answer that it goes to is the right answer for the
> actual question that it is supposed to be answering.
>
>>
>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria then
>> Ĥ.H
>> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy
>
> That might be the "right answer" but it can't go there if H and H^.H are
> actually copies of the same computaition.

All of the prior proofs showed that no right answer exists.

*To sum up your agreement and disagreement*
You agree that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn is correct.
You agree that H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy is correct.

You disagree that those state transitions can be made.

Since all of the prior proofs showed that H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot
possibly have any correct answer this seems to be progress.

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

On 6/03/24 17:34, olcott wrote:
> 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.

What does "cause its own non-termination" actually mean?

The reason that Ĥ ⟨Ĥ⟩ doesn't terminate is that its instructions never
tell it to terminate. It's the same reason that a "subtract two until
zero" program never terminates if its input is an odd number. If you
wanted it to terminate, then you should have written different instructions.

On 3/6/24 9:39 AM, olcott wrote:
> On 3/6/2024 11:20 AM, Richard Damon wrote:
>> On 3/6/24 8:34 AM, olcott wrote:
>>> On 3/6/2024 10:15 AM, Richard Damon wrote:
>>>> On 3/5/24 10:38 PM, olcott wrote:
>>>>> On 3/6/2024 12:28 AM, Richard Damon wrote:
>>>>>> On 3/5/24 11:47 PM, olcott wrote:
>>>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>>
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> *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.
>>
>> In other words, you are admitting to NOT actually working on the
>> actual Halting Problem but lying about it by using a Strawman
>> alternative.
>>
>
> H.q0 ⟨M⟩ ⟨M⟩ ⊢* H.qy // M applied to ⟨M⟩ halts
> H.q0 ⟨M⟩ ⟨M⟩ ⊢* Hqn  // M applied to ⟨M⟩ does not halt
>
> Your failure to understand that the Linz wildcard ⊢* state transition
> sequence expressly allows any criterion measure what-so-ever as long
> as this criterion measure causes H ⟨M⟩ ⟨M⟩ to get the correct answer.

Nope.

It allows any ALGORITHM.

The CRITERIA is the conditions at the END.

You are just admitting to being a LIAR.

>
>> GOOD JOB.
>>
>>>
>>> Ĥ.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
>>> *The same execution trace occurs even when the infinite loop is removed*
>>
>>
>>
>>>
>>> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
>>> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
>>> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>>
>> H^.H must stops its simulation and transition to SOME final state to
>> prevent its own infinite execution.
>>
>> That doesn't mean the answer that it goes to is the right answer for
>> the actual question that it is supposed to be answering.
>>
>>>
>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria
>>> then Ĥ.H
>>> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy
>>
>> That might be the "right answer" but it can't go there if H and H^.H
>> are actually copies of the same computaition.
>
> All of the prior proofs showed that no right answer exists.

No COMPUTABLE answer exists.

The Right Answer to the actual question exists.

>
> *To sum up your agreement and disagreement*
> You agree that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn is correct.

Nope.

H^.H (H^) (H^) needs to go to H^.Hqn if and only if H^ (H^) does not
halt, but if it does go to H^.Hqn then that machine halts, so the answer
is wrong.

> You agree that H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy is correct.

Nope, As if H (H^) (H^) goes to H.qy, that is correct if and only if the
computation H^ (H^) does halts, but if H (H^) (H^)

>
> You disagree that those state transitions can be made.

They PAIRING can't exist if H and H^.H are the same algorithm.

>
> Since all of the prior proofs showed that H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot
> possibly have any correct answer this seems to be progress.
>

It still can't, not a be the same algorithm as H^H as it needs to be for
the proof.

If H^.H isn't the same algorithm, you built H^ wrong, and are just lying.

On 3/6/2024 1:07 PM, immibis wrote:
> On 6/03/24 17:34, olcott wrote:
>> 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.
>
> What does "cause its own non-termination" actually mean?

Whenever simulating termination analyzer H is simulating an
infinite loop or infinite recursion is must abort the simulation
of this input or itself will fail to halt.

The same thing occurs with Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩

Ĥ.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

> The reason that Ĥ ⟨Ĥ⟩ doesn't terminate
False assumption: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn causes Ĥ ⟨Ĥ⟩ to halt
Whenever Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see (a)(b)(c)

> is that its instructions never
> tell it to terminate. It's the same reason that a "subtract two until
> zero" program never terminates if its input is an odd number. If you
> wanted it to terminate, then you should have written different
> instructions.
>

--
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/6/2024 1:26 PM, Richard Damon wrote:
> On 3/6/24 9:39 AM, olcott wrote:
>> On 3/6/2024 11:20 AM, Richard Damon wrote:
>>> On 3/6/24 8:34 AM, olcott wrote:
>>>> On 3/6/2024 10:15 AM, Richard Damon wrote:
>>>>> On 3/5/24 10:38 PM, olcott wrote:
>>>>>> On 3/6/2024 12:28 AM, Richard Damon wrote:
>>>>>>> On 3/5/24 11:47 PM, olcott wrote:
>>>>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>>>
>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> *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.
>>>
>>> In other words, you are admitting to NOT actually working on the
>>> actual Halting Problem but lying about it by using a Strawman
>>> alternative.
>>>
>>
>> H.q0 ⟨M⟩ ⟨M⟩ ⊢* H.qy // M applied to ⟨M⟩ halts
>> H.q0 ⟨M⟩ ⟨M⟩ ⊢* Hqn  // M applied to ⟨M⟩ does not halt
>>
>> Your failure to understand that the Linz wildcard ⊢* state transition
>> sequence expressly allows any criterion measure what-so-ever as long
>> as this criterion measure causes H ⟨M⟩ ⟨M⟩ to get the correct answer.
>
> Nope.
>
> It allows any ALGORITHM.
>

That is more precisely correct. Good job !

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

If a Turing Machine can see (a)(b)(c) then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see
that the above criteria have been met. Otherwise an Olcott
machine can see that the above criteria have been met.

An Olcott machine is exactly the same as a Turing Machine
except that it can see its own machine description.

> The CRITERIA is the conditions at the END.
>
> You are just admitting to being a LIAR.

No merely that my words were not as precisely
correct as yours. I stand correct on this.

>>
>>> GOOD JOB.
>>>
>>>>
>>>> Ĥ.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
>>>> *The same execution trace occurs even when the infinite loop is
>>>> removed*
>>>
>>>
>>>
>>>>
>>>> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its own
>>>> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This entails
>>>> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>>>
>>> H^.H must stops its simulation and transition to SOME final state to
>>> prevent its own infinite execution.
>>>
>>> That doesn't mean the answer that it goes to is the right answer for
>>> the actual question that it is supposed to be answering.
>>>
>>>>
>>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria
>>>> then Ĥ.H
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to
>>>> H.qy
>>>
>>> That might be the "right answer" but it can't go there if H and H^.H
>>> are actually copies of the same computaition.
>>
>> All of the prior proofs showed that no right answer exists.
>
> No COMPUTABLE answer exists.
>
> The Right Answer to the actual question exists.

For Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ no correct answer exists.

For H ⟨Ĥ⟩ ⟨Ĥ⟩ the correct answer of H.qy
exists when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ answers Ĥ.Hqn

>>
>> *To sum up your agreement and disagreement*
>> You agree that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn is correct.
>
> Nope.

It is correct according to its own criteria of correct.

For halt deciders to be correct or do the best that they
can do it turns out that they must focus on preventing
their own non-termination as their only criterion measure.

The side-effect of this is that we can know in advance
that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn. Which causes
Ĥ ⟨Ĥ⟩ to terminate. Which causes Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy to be
a correct answer to the halt status of its input.

> H^.H (H^) (H^) needs to go to H^.Hqn if and only if H^ (H^) does not
> halt,

Not according to the actual criterion measure of H. That H ⟨Ĥ⟩ ⟨Ĥ⟩
correctly determines the halt status of its input is a side-effect
of H following its own criterion measure.

> but if it does go to H^.Hqn then that machine halts, so the answer
> is wrong.
>
>> You agree that H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy is correct.
>
> Nope, As if H (H^) (H^) goes to H.qy, that is correct if and only if the
> computation H^ (H^) does halts, but if H (H^) (H^)
>

When we know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn then
we know that H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy is correct.

>>
>> You disagree that those state transitions can be made.
>
> They PAIRING can't exist if H and H^.H are the same algorithm.
>

When Turing Machine correctly implements the *Criterion Measure*
for both Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ then the latter correctly determines
the halts status of its input on the basis that the former halts.

If a Turing Machine cannot correctly implement the *Criterion Measure*
for both Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ then an Olcott machine can and
Church-Turing is refuted.

>>
>> Since all of the prior proofs showed that H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot
>> possibly have any correct answer this seems to be progress.
>>
>
> It still can't, not a be the same algorithm as H^H as it needs to be for
> the proof.

This is merely a lack of understanding on your part.

As long as Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can somehow correctly determine
that it must abort its simulation to prevent its own
infinite execution an transitions to Ĥ.Hqn then we
know that Ĥ ⟨Ĥ⟩ halts making ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy a correct
answer even if H does not know it.

Disagreeing with both execution traces of D for H1(D,D)
and H(D,D) when D calls H(D,D) is the same as disagreeing
with arithmetic.

It is clear that H(D,D) must abort its simulation and
that H1(D,D) need not abort its simulation.

If what H(D,D) sees is not Turing computable then that does not
mean that I am wrong, it means that the Church-Turing thesis is wrong.

H(D,D) sees that itself is about to be called with its same inputs.
An Olcott machine would see that an identical copy of itself
about to be called with an identical copy of its inputs.

>
> If H^.H isn't the same algorithm, you built H^ wrong, and are just lying.

--
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/6/24 1:31 PM, olcott wrote:
> On 3/6/2024 1:26 PM, Richard Damon wrote:
>> On 3/6/24 9:39 AM, olcott wrote:
>>> On 3/6/2024 11:20 AM, Richard Damon wrote:
>>>> On 3/6/24 8:34 AM, olcott wrote:
>>>>> On 3/6/2024 10:15 AM, Richard Damon wrote:
>>>>>> On 3/5/24 10:38 PM, olcott wrote:
>>>>>>> On 3/6/2024 12:28 AM, Richard Damon wrote:
>>>>>>>> On 3/5/24 11:47 PM, olcott wrote:
>>>>>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>>>>
>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> *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.
>>>>
>>>> In other words, you are admitting to NOT actually working on the
>>>> actual Halting Problem but lying about it by using a Strawman
>>>> alternative.
>>>>
>>>
>>> H.q0 ⟨M⟩ ⟨M⟩ ⊢* H.qy // M applied to ⟨M⟩ halts
>>> H.q0 ⟨M⟩ ⟨M⟩ ⊢* Hqn  // M applied to ⟨M⟩ does not halt
>>>
>>> Your failure to understand that the Linz wildcard ⊢* state transition
>>> sequence expressly allows any criterion measure what-so-ever as long
>>> as this criterion measure causes H ⟨M⟩ ⟨M⟩ to get the correct answer.
>>
>> Nope.
>>
>> It allows any ALGORITHM.
>>
>
> That is more precisely correct. Good job !
>
> 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
>
> If a Turing Machine can see (a)(b)(c) then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see
> that the above criteria have been met. Otherwise an Olcott
> machine can see that the above criteria have been met.
>
> An Olcott machine is exactly the same as a Turing Machine
> except that it can see its own machine description.

HOW? And Olcott machines don't exist yet, so you are just lying.

There isn't a unique description for a given Turing Machine, so you are
just showing you don't understand what Turing Machines are.

And, until you actually figure out how to DEFINE an Olcott machine, I
will just keep pointing out that tey don't exist , and any talk about
them is just a LIE.

And, if you are calling H to be a "Halt Decider" then the criteria it is
to be measured against, and the ONLY valid criteria is does the machine
described by its input HALT.

Anything thing else is just a LIE.

And, if H^.H (H^) (H^) decides to go to qn, then that copy, and thus all
copies of H (assuming it is a compuation) is proven wrong, as H^ (H^)
which started this process will end up going through qn and then halt,
but any H going to qn says that its input represents a non-halting
computation, and thus it was WRONG.

And you are caught in your LIE again.

>
>> The CRITERIA is the conditions at the END.
>>
>> You are just admitting to being a LIAR.
>
> No merely that my words were not as precisely
> correct as yours. I stand correct on this.

Nope, you are still LYING.

>
>>>
>>>> GOOD JOB.
>>>>
>>>>>
>>>>> Ĥ.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
>>>>> *The same execution trace occurs even when the infinite loop is
>>>>> removed*
>>>>
>>>>
>>>>
>>>>>
>>>>> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent its
>>>>> own
>>>>> infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt. This
>>>>> entails
>>>>> that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
>>>>
>>>> H^.H must stops its simulation and transition to SOME final state to
>>>> prevent its own infinite execution.
>>>>
>>>> That doesn't mean the answer that it goes to is the right answer for
>>>> the actual question that it is supposed to be answering.
>>>>
>>>>>
>>>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria
>>>>> then Ĥ.H
>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to
>>>>> H.qy
>>>>
>>>> That might be the "right answer" but it can't go there if H and H^.H
>>>> are actually copies of the same computaition.
>>>
>>> All of the prior proofs showed that no right answer exists.
>>
>> No COMPUTABLE answer exists.
>>
>> The Right Answer to the actual question exists.
>
> For Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ no correct answer exists.

H^ is a DEFINED machine, based on a DEFINED H, and thus the only answer
it CAN give is the one its programming will generate.

The OTHER answer will be correct.

>
> For H ⟨Ĥ⟩ ⟨Ĥ⟩ the correct answer of H.qy
> exists when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ answers Ĥ.Hqn

Yes, but H (H^) (H^) MUST go to the same final state as H^.H (H^) (H^)
or you are just admitting that you are a LIAR about H being a computation.

So, H has a right answer that it should have gone to, but didn't.

>
>>>
>>> *To sum up your agreement and disagreement*
>>> You agree that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn is correct.
>>
>> Nope.
>
> It is correct according to its own criteria of correct.

You mean your LIES?

>
> For halt deciders to be correct or do the best that they
> can do it turns out that they must focus on preventing
> their own non-termination as their only criterion measure.

In other words, you AGREE that they can't give the right answer, but are
trying to say they can some how be "Correct" giving a WRONG answer.

In otherwords, sometimes the FALSE answer is TRUE.

In otherwords, the Liar Paradox is a valid statememt.

In otherwords, you are just a LIAR.

>
> The side-effect of this is that we can know in advance
> that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn. Which causes
> Ĥ ⟨Ĥ⟩ to terminate. Which causes Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy to be
> a correct answer to the halt status of its input.

In other words, we know that you LIE, and postulate that the impossible
will happen in your fantasy world.

You are just proving your utter ignorance of what is actually TRUE about
these sorts of things.

>
>> H^.H (H^) (H^) needs to go to H^.Hqn if and only if H^ (H^) does not
>> halt,
>
> Not according to the actual criterion measure of H. That H ⟨Ĥ⟩ ⟨Ĥ⟩
> correctly determines the halt status of its input is a side-effect
> of H following its own criterion measure.

So, you are just admitting to LYING.

Show us the code for this H that CORRECTLY answers the ACTUAL Halting
Problem for the H^ that has been correctly built from it.

Note, that means that the copy of H put inside H^ must behave EXACTLY
LIKE the H that is deciding on it.

>
>> but if it does go to H^.Hqn then that machine halts, so the answer is
>> wrong.
>>
>>> You agree that H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy is correct.
>>
>> Nope, As if H (H^) (H^) goes to H.qy, that is correct if and only if
>> the computation H^ (H^) does halts, but if H (H^) (H^)
>>
>
> When we know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn then
> we know that H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy is correct.

Right, but then H (H^) (H^) actually will go to H.qn and thus is wrong.

To do otherwise just proves that you LIED about building H^ by the rules
or that H is actually a Computation as required by the definition of a
Decider.

On 3/6/24 12:37 PM, olcott wrote:
> On 3/6/2024 1:07 PM, immibis wrote:
>> On 6/03/24 17:34, olcott wrote:
>>> 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.
>>
>> What does "cause its own non-termination" actually mean?
>
> Whenever simulating termination analyzer H is simulating an
> infinite loop or infinite recursion is must abort the simulation
> of this input or itself will fail to halt.

Right, but it still must get the right answer to the question of does
the input halt.

If it can't you must conceed that Halting in non-computable.

>
> The same thing occurs with Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>
> Ĥ.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
>
>> The reason that Ĥ ⟨Ĥ⟩ doesn't terminate
> False assumption: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn causes Ĥ ⟨Ĥ⟩ to halt
> Whenever Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see (a)(b)(c)

So, it first needs to be able to actually DETECT (c), which is actually
non-computable when you actually express the input description as a FULL
description of the input machine, including it having its own copy of H.

Then, it needs to figure out if the result SHOULD go to qy or qn without
knowing the final answer, since that depends on what the machine will do
after it gets the answer that we can't simulate forward to see what will
happen.

This is where the alternate decider which, assuming you could handle the
detecting (c) case, then did two different continuations to see if one
of them led to a correct answer.

At least that machine handles correct the non-Decider-Contradictory
version and finds the right asnwer.

It also knows when the input has been intentionally
Decider-contradictory and can't give the right answer. While it can't
give the right answer, it can at least be less-wrong by answering that
it can't give a correct answer.

>
>> is that its instructions never tell it to terminate. It's the same
>> reason that a "subtract two until zero" program never terminates if
>> its input is an odd number. If you wanted it to terminate, then you
>> should have written different instructions.
>>
>

On 3/6/2024 4:51 PM, Richard Damon wrote:
> On 3/6/24 1:31 PM, olcott wrote:
>> On 3/6/2024 1:26 PM, Richard Damon wrote:
>>> On 3/6/24 9:39 AM, olcott wrote:
>>>> On 3/6/2024 11:20 AM, Richard Damon wrote:
>>>>> On 3/6/24 8:34 AM, olcott wrote:
>>>>>> On 3/6/2024 10:15 AM, Richard Damon wrote:
>>>>>>> On 3/5/24 10:38 PM, olcott wrote:
>>>>>>>> On 3/6/2024 12:28 AM, Richard Damon wrote:
>>>>>>>>> On 3/5/24 11:47 PM, olcott wrote:
>>>>>>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>>>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>>>>>
>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>>
>>>>>> *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.
>>>>>
>>>>> In other words, you are admitting to NOT actually working on the
>>>>> actual Halting Problem but lying about it by using a Strawman
>>>>> alternative.
>>>>>
>>>>
>>>> H.q0 ⟨M⟩ ⟨M⟩ ⊢* H.qy // M applied to ⟨M⟩ halts
>>>> H.q0 ⟨M⟩ ⟨M⟩ ⊢* Hqn  // M applied to ⟨M⟩ does not halt
>>>>
>>>> Your failure to understand that the Linz wildcard ⊢* state transition
>>>> sequence expressly allows any criterion measure what-so-ever as long
>>>> as this criterion measure causes H ⟨M⟩ ⟨M⟩ to get the correct answer.
>>>
>>> Nope.
>>>
>>> It allows any ALGORITHM.
>>>
>>
>> That is more precisely correct. Good job !
>>
>> 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
>>
>> If a Turing Machine can see (a)(b)(c) then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see
>> that the above criteria have been met. Otherwise an Olcott
>> machine can see that the above criteria have been met.
>>
>> An Olcott machine is exactly the same as a Turing Machine
>> except that it can see its own machine description.
>
> HOW? And Olcott machines don't exist yet, so you are just lying.

Turing machines never physically existed either, yet when an
Olcott machine is merely a UTM combined with an arbitrary
Turing Machine description then Olcott machines exist to the
exact same degree that Turing Machines exist.

>
> There isn't a unique description for a given Turing Machine, so you are
> just showing you don't understand what Turing Machines are.
>
> And, until you actually figure out how to DEFINE an Olcott machine, I
> will just keep pointing out that tey don't exist , and any talk about
> them is just a LIE.
>
> And, if you are calling H to be a "Halt Decider" then the criteria it is
> to be measured against, and the ONLY valid criteria is does the machine
> described by its input HALT.

I am calling H a termination analyzer the gets the correct
answer on ⟨Ĥ⟩ ⟨Ĥ⟩.

>
> Anything thing else is just a LIE.
>
> And, if H^.H (H^) (H^) decides to go to qn, then that copy, and thus all
> copies of H (assuming it is a compuation) is proven wrong, as H^ (H^)
> which started this process will end up going through qn and then halt,
> but any H going to qn says that its input represents a non-halting
> computation, and thus it was WRONG.
>

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

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
Correctly reports that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation.

H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Correctly reports that H ⟨Ĥ⟩ ⟨Ĥ⟩ need not 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

On 6/03/24 22:31, olcott wrote:
> 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

Execution trace of Ĥ applied to ⟨Ĥ⟩
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) *EXACTLY MIRRORS THE DIRECT
EXECUTION OF H APPLIED TO ⟨Ĥ⟩ ⟨Ĥ⟩ UNDER ALL CIRCUMSTANCES BECAUSE IT WAS
CREATED TO DO THAT*

On 7/03/24 00:55, olcott wrote:
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
> Correctly reports that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation.
>
> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> Correctly reports that H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation.

What are the exact steps which the exact same program with the exact
same input uses to get two different results?

I saw x86utm. In x86utm there is a mistake because Ĥ.H is not defined to
do exactly the same steps as H, which means you failed to do the Linz
procedure.

On 3/6/2024 5:58 PM, immibis wrote:
> On 6/03/24 22:31, olcott wrote:
>> 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
>
> Execution trace of Ĥ applied to ⟨Ĥ⟩
> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) *EXACTLY MIRRORS THE DIRECT
> EXECUTION OF H APPLIED TO ⟨Ĥ⟩ ⟨Ĥ⟩ UNDER ALL CIRCUMSTANCES BECAUSE IT WAS
> CREATED TO DO THAT*
>

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

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
Correctly reports that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation.

H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Correctly reports that H ⟨Ĥ⟩ ⟨Ĥ⟩ need not 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

On 3/6/2024 5:59 PM, immibis wrote:
> On 7/03/24 00:55, olcott wrote:
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
>> Correctly reports that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation.
>>
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>> Correctly reports that H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation.
>
> What are the exact steps which the exact same program with the exact
> same input uses to get two different results?
> I saw x86utm. In x86utm there is a mistake because Ĥ.H is not defined to
> do exactly the same steps as H, which means you failed to do the Linz
> procedure.

Both H(D,D) and H1(D,D) answer the exact same question:
Can I continue to simulate my input without ever aborting it?

--
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/6/2024 5:03 PM, Richard Damon wrote:
> On 3/6/24 12:37 PM, olcott wrote:
>> On 3/6/2024 1:07 PM, immibis wrote:
>>> On 6/03/24 17:34, olcott wrote:
>>>> 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.
>>>
>>> What does "cause its own non-termination" actually mean?
>>
>> Whenever simulating termination analyzer H is simulating an
>> infinite loop or infinite recursion is must abort the simulation
>> of this input or itself will fail to halt.
>
> Right, but it still must get the right answer to the question of does
> the input halt.
>
> If it can't you must conceed that Halting in non-computable.
>
>>
>> The same thing occurs with Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>
>> Ĥ.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
>>
>>> The reason that Ĥ ⟨Ĥ⟩ doesn't terminate
>> False assumption: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn causes Ĥ ⟨Ĥ⟩ to halt
>> Whenever Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see (a)(b)(c)
>
> So, it first needs to be able to actually DETECT (c), which is actually
> non-computable when you actually express the input description as a FULL
> description of the input machine, including it having its own copy of H.

*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.

Since we know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn is correct for
*Criterion Measure*

Thus we also know that H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy is correct for
*Criterion Measure*

Thus we know that both answers for *Criterion Measure* exist and
that H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy is the correct halt status of Ĥ ⟨Ĥ⟩ that is
obtains by correctly matching *Criterion Measure*

It is not the case that both YES and NO are the wrong to
the halting question for 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/6/24 3:55 PM, olcott wrote:
> On 3/6/2024 4:51 PM, Richard Damon wrote:
>> On 3/6/24 1:31 PM, olcott wrote:
>>> On 3/6/2024 1:26 PM, Richard Damon wrote:
>>>> On 3/6/24 9:39 AM, olcott wrote:
>>>>> On 3/6/2024 11:20 AM, Richard Damon wrote:
>>>>>> On 3/6/24 8:34 AM, olcott wrote:
>>>>>>> On 3/6/2024 10:15 AM, Richard Damon wrote:
>>>>>>>> On 3/5/24 10:38 PM, olcott wrote:
>>>>>>>>> On 3/6/2024 12:28 AM, Richard Damon wrote:
>>>>>>>>>> On 3/5/24 11:47 PM, olcott wrote:
>>>>>>>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>>>>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>>>>>>
>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>>>
>>>>>>> *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.
>>>>>>
>>>>>> In other words, you are admitting to NOT actually working on the
>>>>>> actual Halting Problem but lying about it by using a Strawman
>>>>>> alternative.
>>>>>>
>>>>>
>>>>> H.q0 ⟨M⟩ ⟨M⟩ ⊢* H.qy // M applied to ⟨M⟩ halts
>>>>> H.q0 ⟨M⟩ ⟨M⟩ ⊢* Hqn  // M applied to ⟨M⟩ does not halt
>>>>>
>>>>> Your failure to understand that the Linz wildcard ⊢* state transition
>>>>> sequence expressly allows any criterion measure what-so-ever as long
>>>>> as this criterion measure causes H ⟨M⟩ ⟨M⟩ to get the correct answer.
>>>>
>>>> Nope.
>>>>
>>>> It allows any ALGORITHM.
>>>>
>>>
>>> That is more precisely correct. Good job !
>>>
>>> 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
>>>
>>> If a Turing Machine can see (a)(b)(c) then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see
>>> that the above criteria have been met. Otherwise an Olcott
>>> machine can see that the above criteria have been met.
>>>
>>> An Olcott machine is exactly the same as a Turing Machine
>>> except that it can see its own machine description.
>>
>> HOW? And Olcott machines don't exist yet, so you are just lying.
>
> Turing machines never physically existed either, yet when an
> Olcott machine is merely a UTM combined with an arbitrary
> Turing Machine description then Olcott machines exist to the
> exact same degree that Turing Machines exist.

Depend on what you mean.

They form a well defined mathematical field.

Your Olcott machines don't.

We can build actual usable models of Turing Machines and see how and
what they can do.

Since Olcott machines don't have a defined mechanics that meet there
specifications, we can't do that.

Thus, your statement is just proven to be a LIE>.

>
>>
>> There isn't a unique description for a given Turing Machine, so you
>> are just showing you don't understand what Turing Machines are.
>>
>> And, until you actually figure out how to DEFINE an Olcott machine, I
>> will just keep pointing out that tey don't exist , and any talk about
>> them is just a LIE.
>>
>> And, if you are calling H to be a "Halt Decider" then the criteria it
>> is to be measured against, and the ONLY valid criteria is does the
>> machine described by its input HALT.
>
> I am calling H a termination analyzer the gets the correct
> answer on ⟨Ĥ⟩ ⟨Ĥ⟩.

So, why do you say it refutes Linz then.

I just you are just showing that you are a pathological liar.

You don't care what the truth is, just what statements can you twist to
make it sound like you are coming up with something.

>
>>
>> Anything thing else is just a LIE.
>>
>> And, if H^.H (H^) (H^) decides to go to qn, then that copy, and thus
>> all copies of H (assuming it is a compuation) is proven wrong, as H^
>> (H^) which started this process will end up going through qn and then
>> halt, but any H going to qn says that its input represents a
>> non-halting computation, and thus it was WRONG.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
> Correctly reports that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation.
>
> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> Correctly reports that H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation.
>