*Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*

Ĥ.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
*This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*

*This is a verified fact*
When simulating halt deciders always report on the behavior of
their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
transitions to Ĥ.Hqn it is correct from its own POV.

*This is a verified fact*
When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
its own POV.

When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.

*Verified facts*
(a) It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the
simulation of its input to prevent its own infinite execution.

(b) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see that it
must abort its simulation then it would transition to Ĥ.Hqn
to reject this input as non-halting from its own POV.

(c) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot see that it
must abort its simulation then it would transition to Ĥ.Hqy
and loop.

(d) (b) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qy.
(e) (c) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qn.

Because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ seem to be identical machines
on identical input that have different behavior we must
somehow explain how they are not identical machines with
identical inputs.

--
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/9/24 10:33 AM, olcott wrote:
> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt

Specifications, not actual behavior until the existance of such an H is
shown.

IF taken as actual behavior, then it is conditional on such an H existing.

>
> 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
> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*

It NEEDS to in order to meet its specification

It DOESN'T unless its algorithm says it does,

If it just fails to answer, then it has failed to be a correct Halt Decider.

The fact that you reach this conflict in actions, is the reason Halt
Deciding is uncomputable.

>
> *This is a verified fact*
> When simulating halt deciders always report on the behavior of
> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> transitions to Ĥ.Hqn it is correct from its own POV.

In other words, you are admitting to changing the question, and thus
LYING that you are working on the actual original problem.

>
> *This is a verified fact*
> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
> its own POV.

Which just means you are LYING that this apply to an actual Halt Decider
per the Halting Theory,

>
> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.

And thus you are admitting that the H in H^.H is WRONG and thus H is not
a correct Halt Decider, because it gets some cases wrong.

>
> *Verified facts*
> (a) It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the
> simulation of its input to prevent its own infinite execution.

Nope.

It may NEED to in order to meet its specification, but it only DOES so
if that is what the algorithm says it does.

>
> (b) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see that it
> must abort its simulation then it would transition to Ĥ.Hqn
> to reject this input as non-halting from its own POV.

Only if you show HOW it "sees" this fact.

Algorithms are step by step descriptive, not based on the assumption of
knowing the answer.

>
> (c) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot see that it
> must abort its simulation then it would transition to Ĥ.Hqy
> and loop.

Only if you show HOW it "sees" this fact.

Algorithms are step by step descriptive, not based on the assumption of
knowing the answer.

>
> (d) (b) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qy.

Only if you show HOW it "sees" this fact.

Algorithms are step by step descriptive, not based on the assumption of
knowing the answer.

> (e) (c) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qn.

Only if you show HOW it "sees" this fact.

Algorithms are step by step descriptive, not based on the assumption of
knowing the answer.

>
> Because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ seem to be identical machines
> on identical input that have different behavior we must
> somehow explain how they are not identical machines with
> identical inputs.
>
>
>

Right, and that is your problem, which is caused by you assuming that
they can get the answer you want.

You need to figure out the algorithm that it will use, and it must be
the same algorithm for both, and with the same data, they WILL both do
the same thing.

On 3/9/2024 3:17 PM, Richard Damon wrote:
> On 3/9/24 10:33 AM, olcott wrote:
>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Specifications, not actual behavior until the existance of such an H is
> shown.
>
> IF taken as actual behavior, then it is conditional on such an H existing.
>
>>
>> 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
>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>
> It NEEDS to in order to meet its specification
>
Yes. (Notice that I am agreeing with you, yet never do that with me)

> It DOESN'T unless its algorithm says it does,
>
Yes. (Notice that I am agreeing with you, yet never do that with me)

> If it just fails to answer, then it has failed to be a correct Halt
> Decider.
>
Yes. (Notice that I am agreeing with you, yet never do that with me)

> The fact that you reach this conflict in actions, is the reason Halt
> Deciding is uncomputable.

*No. We know that Ĥ ⟨Ĥ⟩ either halts or fails to halt*

If it halts then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn.
If it fails to halt then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ either transitioned
to Ĥ.Hqy or it loops.

--
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/9/2024 3:17 PM, Richard Damon wrote:
> On 3/9/24 10:33 AM, olcott wrote:
>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Specifications, not actual behavior until the existance of such an H is
> shown.
>
> IF taken as actual behavior, then it is conditional on such an H existing.
>
>>
>> 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
>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>
> It NEEDS to in order to meet its specification
>
> It DOESN'T unless its algorithm says it does,
>
> If it just fails to answer, then it has failed to be a correct Halt
> Decider.
>
> The fact that you reach this conflict in actions, is the reason Halt
> Deciding is uncomputable.
>
>>
>> *This is a verified fact*
>> When simulating halt deciders always report on the behavior of
>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>> transitions to Ĥ.Hqn it is correct from its own POV.
>
> In other words, you are admitting to changing the question, and thus
> LYING that you are working on the actual original problem.

This must just be over your head. It is very very difficult.

What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
wrong answer to provide?

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

On 9/03/24 19:33, olcott wrote:
> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*

It is only verified that you would like them to have different
behaviour, not that they actually do.

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

∞ means it doesn't 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

> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*

I DON'T CARE what it MUST do, only what it ACTUALLY does. You fail to
realize this or you are dishonestly ignoring this.

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does abort its simulation. This is a verified fact.
Ĥ ⟨Ĥ⟩ halts. This is a verified fact.

> *This is a verified fact*
> When simulating halt deciders always report on the behavior of
> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> transitions to Ĥ.Hqn it is correct from its own POV.

Nobody cares about POV. There is no POV in the halting problem. The
program halts, or it doesn't halt. End of story.

Ĥ ⟨Ĥ⟩ halts. This is a verified fact.

> *This is a verified fact*
> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
> its own POV.

Nobody cares about POV. There is no POV in the halting problem. The
program halts, or it doesn't halt. End of story.

Ĥ ⟨Ĥ⟩ halts. This is a verified fact.

> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the same thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ reports. This is a
verified fact.

> *Verified facts*
> (a) It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the
> simulation of its input to prevent its own infinite execution.

I DON'T CARE what it MUST do, only what it ACTUALLY does. You fail to
realize this or you are dishonestly ignoring this.

> (b) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see that it
> must abort its simulation then it would transition to Ĥ.Hqn
> to reject this input as non-halting from its own POV.

Nobody cares about POV. There is no POV in the halting problem. The
program halts, or it doesn't halt. End of story.

Ĥ ⟨Ĥ⟩ halts. This is a verified fact.

> (c) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot see that it
> must abort its simulation then it would transition to Ĥ.Hqy
> and loop
Nobody cares about POV. There is no POV in the halting problem. The
program halts, or it doesn't halt. End of story.

Ĥ ⟨Ĥ⟩ halts. This is a verified fact.

> (d) (b) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qy.
> (e) (c) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qn.

I DON'T CARE what the BASIS is, only what it ACTUALLY does. You fail to
realize this or you are dishonestly ignoring this.

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn. This is a verified fact.
Ĥ ⟨Ĥ⟩ halts. This is a verified fact.

> Because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ seem to be identical machines
> on identical input that have different behavior we must
> somehow explain how they are not identical machines with
> identical inputs.

I agree. But please understand: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ are stipulated
to be identical because they are Turing machines, and identical Turing
machines with identical input always produce identical output. The Linz
proof does not work for other types of machines.

The halting problem is uncomputable with Olcott machines, but the proof
is different. In the Olcott machine version of the Linz proof, Ĥ.H isn't
an identical copy of H, but it does compute identical output when the
input is identical.

On 9/03/24 22:30, olcott wrote:
> On 3/9/2024 3:17 PM, Richard Damon wrote:
>> On 3/9/24 10:33 AM, olcott wrote:
>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Specifications, not actual behavior until the existance of such an H
>> is shown.
>>
>> IF taken as actual behavior, then it is conditional on such an H
>> existing.
>>
>>>
>>> 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
>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>
>> It NEEDS to in order to meet its specification
>>
> Yes. (Notice that I am agreeing with you, yet never do that with me)
>
>> It DOESN'T unless its algorithm says it does,
>>
> Yes. (Notice that I am agreeing with you, yet never do that with me)
>
>> If it just fails to answer, then it has failed to be a correct Halt
>> Decider.
>>
> Yes. (Notice that I am agreeing with you, yet never do that with me)
>
>> The fact that you reach this conflict in actions, is the reason Halt
>> Deciding is uncomputable.
>
> *No. We know that Ĥ ⟨Ĥ⟩ either halts or fails to halt*
>
> If it halts then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn.

If Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn then H ⟨Ĥ⟩ transitioned to H.qn or
else Ĥ is the wrong Ĥ or you can't read instructions.

On 9/03/24 22:34, olcott wrote:
> On 3/9/2024 3:17 PM, Richard Damon wrote:
>> On 3/9/24 10:33 AM, olcott wrote:
>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Specifications, not actual behavior until the existance of such an H
>> is shown.
>>
>> IF taken as actual behavior, then it is conditional on such an H
>> existing.
>>
>>>
>>> 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
>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>
>> It NEEDS to in order to meet its specification
>>
>> It DOESN'T unless its algorithm says it does,
>>
>> If it just fails to answer, then it has failed to be a correct Halt
>> Decider.
>>
>> The fact that you reach this conflict in actions, is the reason Halt
>> Deciding is uncomputable.
>>
>>>
>>> *This is a verified fact*
>>> When simulating halt deciders always report on the behavior of
>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>
>> In other words, you are admitting to changing the question, and thus
>> LYING that you are working on the actual original problem.
>
> This must just be over your head. It is very very difficult.
>
> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
> wrong answer to provide?
>

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria that
H ⟨Ĥ⟩ uses.

On 3/9/2024 3:17 PM, Richard Damon wrote:
> On 3/9/24 10:33 AM, olcott wrote:
>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Specifications, not actual behavior until the existance of such an H is
> shown.
>
> IF taken as actual behavior, then it is conditional on such an H existing.
>
>>
>> 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
>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>
> It NEEDS to in order to meet its specification
>
> It DOESN'T unless its algorithm says it does,
>
> If it just fails to answer, then it has failed to be a correct Halt
> Decider.
>
> The fact that you reach this conflict in actions, is the reason Halt
> Deciding is uncomputable.
>
>>
>> *This is a verified fact*
>> When simulating halt deciders always report on the behavior of
>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>> transitions to Ĥ.Hqn it is correct from its own POV.
>
> In other words, you are admitting to changing the question, and thus
> LYING that you are working on the actual original problem.
>
>>
>> *This is a verified fact*
>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>> its own POV.
>
> Which just means you are LYING that this apply to an actual Halt Decider
> per the Halting Theory,
>
>>
>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>
> And thus you are admitting that the H in H^.H is WRONG and thus H is not
> a correct Halt Decider, because it gets some cases wrong.

It is a verified fact that when H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meet this
criteria that H gets the right answer and Ĥ.H gets the wrong answer.

What it not a verified fact is whether or not Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can meet
this criteria as a Turing machine.

If it cannot meet this criteria as a Turing machine then it is
still that case that Ĥ ⟨Ĥ⟩ either halts or fails to halt.

It may fail to halt by looping without ever transitioning to
Ĥ.Hqy or Ĥ.Hqn. I see no reason why H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot see this.

I generally agree that a pair of identical machines
must have the same behavior on the same input.

This may not apply when these machines having identical
states and identical inputs:

(a) Are out-of-sync by a whole execution trace or

(b) When one of the machines is embedded within another machine
that would cause this embedded machine to have recursive
simulation that the non-embedded machine cannot possibly have.

*I think that the actual difference is the latter case because*
*we have the exact same issue when the infinite loop is removed*

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive 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 9/03/24 22:55, olcott wrote:
> On 3/9/2024 3:17 PM, Richard Damon wrote:
>> On 3/9/24 10:33 AM, olcott wrote:
>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Specifications, not actual behavior until the existance of such an H
>> is shown.
>>
>> IF taken as actual behavior, then it is conditional on such an H
>> existing.
>>
>>>
>>> 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
>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>
>> It NEEDS to in order to meet its specification
>>
>> It DOESN'T unless its algorithm says it does,
>>
>> If it just fails to answer, then it has failed to be a correct Halt
>> Decider.
>>
>> The fact that you reach this conflict in actions, is the reason Halt
>> Deciding is uncomputable.
>>
>>>
>>> *This is a verified fact*
>>> When simulating halt deciders always report on the behavior of
>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>
>> In other words, you are admitting to changing the question, and thus
>> LYING that you are working on the actual original problem.
>>
>>>
>>> *This is a verified fact*
>>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>>> its own POV.
>>
>> Which just means you are LYING that this apply to an actual Halt
>> Decider per the Halting Theory,
>>
>>>
>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>>
>> And thus you are admitting that the H in H^.H is WRONG and thus H is
>> not a correct Halt Decider, because it gets some cases wrong.
>
> It is a verified fact that when H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meet this
> criteria that H gets the right answer and Ĥ.H gets the wrong answer.

It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
to both meet this criteria if you honestly followed the Linz proof (for
Turing machines).

It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩
⟨Ĥ⟩ <H> to both meet this criteria if you honestly followed the modified
Linz proof (for Olcott machines).

On 3/9/2024 3:39 PM, immibis wrote:
> On 9/03/24 19:33, olcott wrote:
>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>
> It is only verified that you would like them to have different
> behaviour, not that they actually do.
>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> ∞ means it doesn't 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
>
>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>
> I DON'T CARE what it MUST do, only what it ACTUALLY does. You fail to
> realize this or you are dishonestly ignoring this.
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does abort its simulation. This is a verified fact.

As Richard correctly pointed out this is not a verified fact.
The only verified fact here is that when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meets is
spec then it aborts its simulation.

> Ĥ ⟨Ĥ⟩ halts. This is a verified fact.
>
Only within the assumption that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meets its spec.

>> *This is a verified fact*
>> When simulating halt deciders always report on the behavior of
>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>> transitions to Ĥ.Hqn it is correct from its own POV.
>
> Nobody cares about POV. There is no POV in the halting problem. The
> program halts, or it doesn't halt. End of story.
>
This criteria is the only criteria where Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
wrong answer to provide that enables H ⟨Ĥ⟩ ⟨Ĥ⟩ to provide the
correct answer. Historically Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would simply loop and
never reach either Ĥ.Hqy or Ĥ.Hqn.

> Ĥ ⟨Ĥ⟩ halts. This is a verified fact.
>
Not it is not. It only halts if Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meets its design spec
and a Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ might not be able to do that.

<snip issues already addressed>

>> Because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ seem to be identical machines
>> on identical input that have different behavior we must
>> somehow explain how they are not identical machines with
>> identical inputs.
>
> I agree. But please understand: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ are stipulated
> to be identical because they are Turing machines, and identical Turing
> machines with identical input always produce identical output. The Linz
> proof does not work for other types of machines.
>

I generally agree that a pair of identical machines
must have the same behavior on the same input.

This may not apply when these machines having identical
states and identical inputs:

(a) Are out-of-sync by a whole execution trace or

(b) When one of the machines is embedded within another machine
that would cause this embedded machine to have recursive
simulation that the non-embedded machine cannot possibly have.

*I think that the actual difference is the latter case because*
*we have the exact same issue when the infinite loop is removed*

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.

> The halting problem is uncomputable with Olcott machines, but the proof
> is different. In the Olcott machine version of the Linz proof, Ĥ.H isn't
> an identical copy of H, but it does compute identical output when the
> input is identical.

If Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot meet this criteria as a Turing machine then
it is still that case that Ĥ ⟨Ĥ⟩ either halts or fails to halt.

It may fail to halt by looping without ever transitioning to
Ĥ.Hqy or Ĥ.Hqn. I see no reason why H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot see this.

--
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/9/2024 3:49 PM, immibis wrote:
> On 9/03/24 22:30, olcott wrote:
>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>> On 3/9/24 10:33 AM, olcott wrote:
>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Specifications, not actual behavior until the existance of such an H
>>> is shown.
>>>
>>> IF taken as actual behavior, then it is conditional on such an H
>>> existing.
>>>
>>>>
>>>> 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
>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>
>>> It NEEDS to in order to meet its specification
>>>
>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>
>>> It DOESN'T unless its algorithm says it does,
>>>
>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>
>>> If it just fails to answer, then it has failed to be a correct Halt
>>> Decider.
>>>
>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>
>>> The fact that you reach this conflict in actions, is the reason Halt
>>> Deciding is uncomputable.
>>
>> *No. We know that Ĥ ⟨Ĥ⟩ either halts or fails to halt*
>>
>> If it halts then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn.
>
> If Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn then H ⟨Ĥ⟩ transitioned to H.qn or
> else Ĥ is the wrong Ĥ or you can't read instructions.
>

I generally agree that a pair of identical machines
must have the same behavior on the same input.

This may not apply when these machines having identical
states and identical inputs:

(a) Are out-of-sync by a whole execution trace or

(b) When one of the machines is embedded within another machine
that would cause this embedded machine to have recursive
simulation that the non-embedded machine cannot possibly have.

*I think that the actual difference is the latter case because*
*we have the exact same issue when the infinite loop is removed*

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.

*The above two behaviors are different for identical*
*machines with identical inputs*

--
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/9/2024 3:50 PM, immibis wrote:
> On 9/03/24 22:34, olcott wrote:
>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>> On 3/9/24 10:33 AM, olcott wrote:
>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Specifications, not actual behavior until the existance of such an H
>>> is shown.
>>>
>>> IF taken as actual behavior, then it is conditional on such an H
>>> existing.
>>>
>>>>
>>>> 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
>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>
>>> It NEEDS to in order to meet its specification
>>>
>>> It DOESN'T unless its algorithm says it does,
>>>
>>> If it just fails to answer, then it has failed to be a correct Halt
>>> Decider.
>>>
>>> The fact that you reach this conflict in actions, is the reason Halt
>>> Deciding is uncomputable.
>>>
>>>>
>>>> *This is a verified fact*
>>>> When simulating halt deciders always report on the behavior of
>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>
>>> In other words, you are admitting to changing the question, and thus
>>> LYING that you are working on the actual original problem.
>>
>> This must just be over your head. It is very very difficult.
>>
>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>> wrong answer to provide?
>>
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria that
> H ⟨Ĥ⟩ uses.

Simulating halt deciders must make sure that they themselves
do not get stuck in infinite execution. This means that they
must abort every simulation that cannot possibly otherwise halt.

This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
its simulation.

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
does not simulate itself in recursive 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/9/2024 3:59 PM, immibis wrote:
> On 9/03/24 22:55, olcott wrote:
>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>> On 3/9/24 10:33 AM, olcott wrote:
>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Specifications, not actual behavior until the existance of such an H
>>> is shown.
>>>
>>> IF taken as actual behavior, then it is conditional on such an H
>>> existing.
>>>
>>>>
>>>> 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
>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>
>>> It NEEDS to in order to meet its specification
>>>
>>> It DOESN'T unless its algorithm says it does,
>>>
>>> If it just fails to answer, then it has failed to be a correct Halt
>>> Decider.
>>>
>>> The fact that you reach this conflict in actions, is the reason Halt
>>> Deciding is uncomputable.
>>>
>>>>
>>>> *This is a verified fact*
>>>> When simulating halt deciders always report on the behavior of
>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>
>>> In other words, you are admitting to changing the question, and thus
>>> LYING that you are working on the actual original problem.
>>>
>>>>
>>>> *This is a verified fact*
>>>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>>>> its own POV.
>>>
>>> Which just means you are LYING that this apply to an actual Halt
>>> Decider per the Halting Theory,
>>>
>>>>
>>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>>>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>>>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>>>
>>> And thus you are admitting that the H in H^.H is WRONG and thus H is
>>> not a correct Halt Decider, because it gets some cases wrong.
>>
>> It is a verified fact that when H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meet this
>> criteria that H gets the right answer and Ĥ.H gets the wrong answer.
>
> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> to both meet this criteria if you honestly followed the Linz proof (for
> Turing machines).

This has nothing to do with the Linz proof it only pertains to whether
or not Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can meet this criteria as a Turing machine. If it can
then there is no need for Olcott machines.

> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩
> ⟨Ĥ⟩ <H> to both meet this criteria if you honestly followed the modified
> Linz proof (for Olcott machines).
>

It is still the case that the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will
(a) Transition to Ĥ.Hqn and halt
(b) Transition to Ĥ.Hqy and loop
(c) Loop without transitioning to Ĥ.Hqn or Ĥ.Hqy

Because Linz H only contradicts itself that means that it
does not contradict Linz H.

Thus the only reason why anyone is saying that Linz H cannot get
the right answer is because they assume that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and Linz
H ⟨Ĥ⟩ ⟨Ĥ⟩ are the same computation when I proved otherwise:

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive 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/9/2024 12:33 PM, olcott wrote:
> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>
> Ĥ.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
> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>
> *This is a verified fact*
> When simulating halt deciders always report on the behavior of
> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> transitions to Ĥ.Hqn it is correct from its own POV.
>
> *This is a verified fact*
> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
> its own POV.
>
> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>
> *Verified facts*
> (a) It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the
> simulation of its input to prevent its own infinite execution.
>
> (b) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see that it
> must abort its simulation then it would transition to Ĥ.Hqn
> to reject this input as non-halting from its own POV.
>
> (c) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot see that it
> must abort its simulation then it would transition to Ĥ.Hqy
> and loop.
>
> (d) (b) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qy.
> (e) (c) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qn.
>
> Because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ seem to be identical machines
> on identical input that have different behavior we must
> somehow explain how they are not identical machines with
> identical inputs.

Because Linz H only contradicts itself that means that it
does not contradict Linz H.

Thus the only reason why anyone is saying that Linz H cannot get
the right answer is because they assume that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and Linz
H ⟨Ĥ⟩ ⟨Ĥ⟩ are the same computation when I proved otherwise:

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ *can possibly get stuck in recursive simulation*
and
H ⟨Ĥ⟩ ⟨Ĥ⟩ *cannot possibly get stuck in recursive 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 9/03/24 23:10, olcott wrote:
> On 3/9/2024 3:39 PM, immibis wrote:
>> On 9/03/24 19:33, olcott wrote:
>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>
>> It is only verified that you would like them to have different
>> behaviour, not that they actually do.
>>

you ignored this

>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> ∞ means it doesn't halt

you ignored this

>>> 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
>>
>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>
>> I DON'T CARE what it MUST do, only what it ACTUALLY does. You fail to
>> realize this or you are dishonestly ignoring this.
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does abort its simulation. This is a verified fact.
>
> As Richard correctly pointed out this is not a verified fact.
> The only verified fact here is that when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meets is
> spec then it aborts its simulation.

I am assuming that you are talking about an H similar to the one in
x86utm, which does abort its simulation.

I DO NOT CARE what its specification is, only what it ACTUALLY does.

>> Ĥ ⟨Ĥ⟩ halts. This is a verified fact.
>>
> Only within the assumption that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meets its spec.

You showed us all an Ĥ program which halts. Are you now talking about a
different program?

>>> *This is a verified fact*
>>> When simulating halt deciders always report on the behavior of
>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>
>> Nobody cares about POV. There is no POV in the halting problem. The
>> program halts, or it doesn't halt. End of story.
>>
> This criteria is the only criteria where Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
> wrong answer to provide that enables H ⟨Ĥ⟩ ⟨Ĥ⟩ to provide the
> correct answer. Historically Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would simply loop and
> never reach either Ĥ.Hqy or Ĥ.Hqn.

I DO NOT CARE what the criteria are, only what it ACTUALLY does.

>> Ĥ ⟨Ĥ⟩ halts. This is a verified fact.
>>
> Not it is not. It only halts if Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meets its design spec
> and a Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ might not be able to do that.

x86utm Ĥ halts under absolutely all circumstances. Are you talking about
a different Ĥ?

>>> Because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ seem to be identical machines
>>> on identical input that have different behavior we must
>>> somehow explain how they are not identical machines with
>>> identical inputs.
>>
>> I agree. But please understand: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ are
>> stipulated to be identical because they are Turing machines, and
>> identical Turing machines with identical input always produce
>> identical output. The Linz proof does not work for other types of
>> machines.
>>
>
> I generally agree that a pair of identical machines
> must have the same behavior on the same input >
> This may not apply when these machines having identical
> states and identical inputs:
>
> (a) Are out-of-sync by a whole execution trace or

This sentence does not make any sense. Identical states and identical
states means IDENTICAL STATES and IDENTICAL INPUTS. If states or inputs
are "out-of-sync" then how are they identical?

> (b) When one of the machines is embedded within another machine
> that would cause this embedded machine to have recursive
> simulation that the non-embedded machine cannot possibly have.

There is no such thing as a machine embedded in another machine. All
machines are standalone.

We can talk about an embedded copy of a machine, but that is not a whole
machine, just a part of one. I might have used imprecise terms in the past.

> *I think that the actual difference is the latter case because*
> *we have the exact same issue when the infinite loop is removed*
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.

Because they are stipulated to have identical behaviour, THEY HAVE
IDENTICAL BEHAVIOUR. This is non-negotiable. If they do not have
identical behaviour, THEN YOU FUCKED UP and your Ĥ is NOT the one from
the Linz proof.

>> The halting problem is uncomputable with Olcott machines, but the
>> proof is different. In the Olcott machine version of the Linz proof,
>> Ĥ.H isn't an identical copy of H, but it does compute identical output
>> when the input is identical.
>
> If Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot meet this criteria as a Turing machine then
> it is still that case that Ĥ ⟨Ĥ⟩ either halts or fails to halt.
>
> It may fail to halt by looping without ever transitioning to
> Ĥ.Hqy or Ĥ.Hqn. I see no reason why H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot see this.

I don't see the relevance between what I wrote (and you quoted) and what
you wrote.

Ĥ.H and H are stipulated to have IDENTICAL BEHAVIOUR, that also means if
one of them doesn't halt they both don't halt.

On 9/03/24 23:22, olcott wrote:
> On 3/9/2024 3:50 PM, immibis wrote:
>> On 9/03/24 22:34, olcott wrote:
>>>
>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>> wrong answer to provide?
>>>
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>> that H ⟨Ĥ⟩ uses.
>
> Simulating halt deciders must make sure that they themselves
> do not get stuck in infinite execution. This means that they
> must abort every simulation that cannot possibly otherwise halt.
>
> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
> its simulation.
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
> does not simulate itself in recursive simulation.
>

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria that
H ⟨Ĥ⟩ uses.

On 9/03/24 23:39, olcott wrote:
> On 3/9/2024 3:59 PM, immibis wrote:
>> On 9/03/24 22:55, olcott wrote:
>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Specifications, not actual behavior until the existance of such an H
>>>> is shown.
>>>>
>>>> IF taken as actual behavior, then it is conditional on such an H
>>>> existing.
>>>>
>>>>>
>>>>> 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
>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>
>>>> It NEEDS to in order to meet its specification
>>>>
>>>> It DOESN'T unless its algorithm says it does,
>>>>
>>>> If it just fails to answer, then it has failed to be a correct Halt
>>>> Decider.
>>>>
>>>> The fact that you reach this conflict in actions, is the reason Halt
>>>> Deciding is uncomputable.
>>>>
>>>>>
>>>>> *This is a verified fact*
>>>>> When simulating halt deciders always report on the behavior of
>>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>>
>>>> In other words, you are admitting to changing the question, and thus
>>>> LYING that you are working on the actual original problem.
>>>>
>>>>>
>>>>> *This is a verified fact*
>>>>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>>>>> its own POV.
>>>>
>>>> Which just means you are LYING that this apply to an actual Halt
>>>> Decider per the Halting Theory,
>>>>
>>>>>
>>>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>>>>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>>>>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>>>>
>>>> And thus you are admitting that the H in H^.H is WRONG and thus H is
>>>> not a correct Halt Decider, because it gets some cases wrong.
>>>
>>> It is a verified fact that when H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meet this
>>> criteria that H gets the right answer and Ĥ.H gets the wrong answer.
>>
>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩
>> ⟨Ĥ⟩ to both meet this criteria if you honestly followed the Linz proof
>> (for Turing machines).
>
> This has nothing to do with the Linz proof it only pertains to whether
> or not Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can meet this criteria as a Turing machine.

It can't.

> If it can
> then there is no need for Olcott machines.

In Olcott machines, it still can't, but the proof is different, because
Linz's proof is for Turing machines.

>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H
>> ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to both meet this criteria if you honestly followed the
>> modified Linz proof (for Olcott machines).
>>
>
> It is still the case that the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will
> (a) Transition to Ĥ.Hqn and halt
> (b) Transition to Ĥ.Hqy and loop
> (c) Loop without transitioning to Ĥ.Hqn or Ĥ.Hqy

> Because Linz H only contradicts itself that means that it
> does not contradict Linz H.

Linz Ĥ.H is stipulated to have IDENTICAL BEHAVIOUR to Linz H.

It is the case that
(a) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqn and halt AND the Linz
H ⟨Ĥ⟩ will transition to H.qn and halt.
(b) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqy and halt AND the Linz
H ⟨Ĥ⟩ will transition to H.qy and halt.
(c) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will loop without transitioning to Ĥ.Hqn or
Ĥ.Hqy AND the Linz H ⟨Ĥ⟩ will loop without transitioning to H.qn or H.qy

THIS IS BECAUASE THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.

> Thus the only reason why anyone is saying that Linz H cannot get
> the right answer is because they assume that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and Linz
> H ⟨Ĥ⟩ ⟨Ĥ⟩ are the same computation when I proved otherwise:

Richard Damon is the one who keeps using the word "computation" even
though his explanation did not work the first time, and I think he is
stupid for repeating it over and over even though it didn't work.

> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.

THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.

On 3/9/2024 5:10 PM, immibis wrote:
> On 9/03/24 23:10, olcott wrote:
>> On 3/9/2024 3:39 PM, immibis wrote:
>>> On 9/03/24 19:33, olcott wrote:
>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>
>>> It is only verified that you would like them to have different
>>> behaviour, not that they actually do.
>>>
>
> you ignored this
>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> ∞ means it doesn't halt
>
> you ignored this
>
>>>> 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
>>>
>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>
>>> I DON'T CARE what it MUST do, only what it ACTUALLY does. You fail to
>>> realize this or you are dishonestly ignoring this.
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does abort its simulation. This is a verified fact.
>>
>> As Richard correctly pointed out this is not a verified fact.
>> The only verified fact here is that when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meets is
>> spec then it aborts its simulation.
>
> I am assuming that you are talking about an H similar to the one in
> x86utm, which does abort its simulation.
>
> I DO NOT CARE what its specification is, only what it ACTUALLY does.
>
>>> Ĥ ⟨Ĥ⟩ halts. This is a verified fact.
>>>
>> Only within the assumption that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meets its spec.
>
> You showed us all an Ĥ program which halts. Are you now talking about a
> different program?

Whenever I refer to Ĥ it is only the Linz Turing machine.
When I refer to my own c code it is always H(D,D).

--
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/9/2024 5:10 PM, immibis wrote:
> On 9/03/24 23:22, olcott wrote:
>> On 3/9/2024 3:50 PM, immibis wrote:
>>> On 9/03/24 22:34, olcott wrote:
>>>>
>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>> wrong answer to provide?
>>>>
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>>> that H ⟨Ĥ⟩ uses.
>>
>> Simulating halt deciders must make sure that they themselves
>> do not get stuck in infinite execution. This means that they
>> must abort every simulation that cannot possibly otherwise halt.
>>
>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>> its simulation.
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>> does not simulate itself in recursive simulation.
>>
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria that
> H ⟨Ĥ⟩ uses.
>

*Only because Ĥ.H is embedded within Ĥ and H is not*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive 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/9/2024 5:14 PM, immibis wrote:
> On 9/03/24 23:39, olcott wrote:
>> On 3/9/2024 3:59 PM, immibis wrote:
>>> On 9/03/24 22:55, olcott wrote:
>>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different
>>>>>> behavior*
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>
>>>>> Specifications, not actual behavior until the existance of such an
>>>>> H is shown.
>>>>>
>>>>> IF taken as actual behavior, then it is conditional on such an H
>>>>> existing.
>>>>>
>>>>>>
>>>>>> 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
>>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>>
>>>>> It NEEDS to in order to meet its specification
>>>>>
>>>>> It DOESN'T unless its algorithm says it does,
>>>>>
>>>>> If it just fails to answer, then it has failed to be a correct Halt
>>>>> Decider.
>>>>>
>>>>> The fact that you reach this conflict in actions, is the reason
>>>>> Halt Deciding is uncomputable.
>>>>>
>>>>>>
>>>>>> *This is a verified fact*
>>>>>> When simulating halt deciders always report on the behavior of
>>>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>>>
>>>>> In other words, you are admitting to changing the question, and
>>>>> thus LYING that you are working on the actual original problem.
>>>>>
>>>>>>
>>>>>> *This is a verified fact*
>>>>>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>>>>>> its own POV.
>>>>>
>>>>> Which just means you are LYING that this apply to an actual Halt
>>>>> Decider per the Halting Theory,
>>>>>
>>>>>>
>>>>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>>>>>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>>>>>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>>>>>
>>>>> And thus you are admitting that the H in H^.H is WRONG and thus H
>>>>> is not a correct Halt Decider, because it gets some cases wrong.
>>>>
>>>> It is a verified fact that when H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meet this
>>>> criteria that H gets the right answer and Ĥ.H gets the wrong answer.
>>>
>>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩
>>> ⟨Ĥ⟩ to both meet this criteria if you honestly followed the Linz
>>> proof (for Turing machines).
>>
>> This has nothing to do with the Linz proof it only pertains to whether
>> or not Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can meet this criteria as a Turing machine.
>
> It can't.
>
>> If it can
>> then there is no need for Olcott machines.
>
> In Olcott machines, it still can't, but the proof is different, because
> Linz's proof is for Turing machines.
>
>>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H
>>> ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to both meet this criteria if you honestly followed the
>>> modified Linz proof (for Olcott machines).
>>>
>>
>> It is still the case that the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will
>> (a) Transition to Ĥ.Hqn and halt
>> (b) Transition to Ĥ.Hqy and loop
>> (c) Loop without transitioning to Ĥ.Hqn or Ĥ.Hqy
>
>
>> Because Linz H only contradicts itself that means that it
>> does not contradict Linz H.
>
> Linz Ĥ.H is stipulated to have IDENTICAL BEHAVIOUR to Linz H.
>
> It is the case that
> (a) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqn and halt AND the Linz
> H ⟨Ĥ⟩ will transition to H.qn and halt.
> (b) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqy and halt AND the Linz
> H ⟨Ĥ⟩ will transition to H.qy and halt.
> (c) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will loop without transitioning to Ĥ.Hqn or
> Ĥ.Hqy AND the Linz H ⟨Ĥ⟩ will loop without transitioning to H.qn or H.qy
>
> THIS IS BECAUASE THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.
>
>> Thus the only reason why anyone is saying that Linz H cannot get
>> the right answer is because they assume that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and Linz
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ are the same computation when I proved otherwise:
>
> Richard Damon is the one who keeps using the word "computation" even
> though his explanation did not work the first time, and I think he is
> stupid for repeating it over and over even though it didn't work.
>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>
> THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.
>

*Only because Ĥ.H is embedded within Ĥ and H is not*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
*This conclusively proves that they have different behavior*

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

On 10/03/24 00:26, olcott wrote:
> On 3/9/2024 5:10 PM, immibis wrote:
>> On 9/03/24 23:22, olcott wrote:
>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>> On 9/03/24 22:34, olcott wrote:
>>>>>
>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>> wrong answer to provide?
>>>>>
>>>>
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>>>> that H ⟨Ĥ⟩ uses.
>>>
>>> Simulating halt deciders must make sure that they themselves
>>> do not get stuck in infinite execution. This means that they
>>> must abort every simulation that cannot possibly otherwise halt.
>>>
>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>> its simulation.
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> does not simulate itself in recursive simulation.
>>>
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective criteria
>> that H ⟨Ĥ⟩ uses.
>>
>
> *Only because Ĥ.H is embedded within Ĥ and H is not*
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>

You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.

On 10/03/24 00:30, olcott wrote:
> On 3/9/2024 5:14 PM, immibis wrote:
>> On 9/03/24 23:39, olcott wrote:
>>> On 3/9/2024 3:59 PM, immibis wrote:
>>>> On 9/03/24 22:55, olcott wrote:
>>>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different
>>>>>>> behavior*
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>
>>>>>> Specifications, not actual behavior until the existance of such an
>>>>>> H is shown.
>>>>>>
>>>>>> IF taken as actual behavior, then it is conditional on such an H
>>>>>> existing.
>>>>>>
>>>>>>>
>>>>>>> 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
>>>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>>>
>>>>>> It NEEDS to in order to meet its specification
>>>>>>
>>>>>> It DOESN'T unless its algorithm says it does,
>>>>>>
>>>>>> If it just fails to answer, then it has failed to be a correct
>>>>>> Halt Decider.
>>>>>>
>>>>>> The fact that you reach this conflict in actions, is the reason
>>>>>> Halt Deciding is uncomputable.
>>>>>>
>>>>>>>
>>>>>>> *This is a verified fact*
>>>>>>> When simulating halt deciders always report on the behavior of
>>>>>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>>>>>
>>>>>> In other words, you are admitting to changing the question, and
>>>>>> thus LYING that you are working on the actual original problem.
>>>>>>
>>>>>>>
>>>>>>> *This is a verified fact*
>>>>>>> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
>>>>>>> its own POV.
>>>>>>
>>>>>> Which just means you are LYING that this apply to an actual Halt
>>>>>> Decider per the Halting Theory,
>>>>>>
>>>>>>>
>>>>>>> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
>>>>>>> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
>>>>>>> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.
>>>>>>
>>>>>> And thus you are admitting that the H in H^.H is WRONG and thus H
>>>>>> is not a correct Halt Decider, because it gets some cases wrong.
>>>>>
>>>>> It is a verified fact that when H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ meet this
>>>>> criteria that H gets the right answer and Ĥ.H gets the wrong answer.
>>>>
>>>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩
>>>> ⟨Ĥ⟩ to both meet this criteria if you honestly followed the Linz
>>>> proof (for Turing machines).
>>>
>>> This has nothing to do with the Linz proof it only pertains to whether
>>> or not Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can meet this criteria as a Turing machine.
>>
>> It can't.
>>
>>> If it can
>>> then there is no need for Olcott machines.
>>
>> In Olcott machines, it still can't, but the proof is different,
>> because Linz's proof is for Turing machines.
>>
>>>> It is a verified fact that it's impossible for H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to both meet this criteria if you honestly followed the
>>>> modified Linz proof (for Olcott machines).
>>>>
>>>
>>> It is still the case that the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will
>>> (a) Transition to Ĥ.Hqn and halt
>>> (b) Transition to Ĥ.Hqy and loop
>>> (c) Loop without transitioning to Ĥ.Hqn or Ĥ.Hqy
>>
>>
>>> Because Linz H only contradicts itself that means that it
>>> does not contradict Linz H.
>>
>> Linz Ĥ.H is stipulated to have IDENTICAL BEHAVIOUR to Linz H.
>>
>> It is the case that
>> (a) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqn and halt AND the
>> Linz H ⟨Ĥ⟩ will transition to H.qn and halt.
>> (b) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will transition to Ĥ.Hqy and halt AND the
>> Linz H ⟨Ĥ⟩ will transition to H.qy and halt.
>> (c) the Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ will loop without transitioning to Ĥ.Hqn or
>> Ĥ.Hqy AND the Linz H ⟨Ĥ⟩ will loop without transitioning to H.qn or H.qy
>>
>> THIS IS BECAUASE THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.
>>
>>> Thus the only reason why anyone is saying that Linz H cannot get
>>> the right answer is because they assume that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and Linz
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ are the same computation when I proved otherwise:
>>
>> Richard Damon is the one who keeps using the word "computation" even
>> though his explanation did not work the first time, and I think he is
>> stupid for repeating it over and over even though it didn't work.
>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>
>> THEY ARE STIPULATED TO HAVE IDENTICAL BEHAVIOUR.
>>
>
> *Only because Ĥ.H is embedded within Ĥ and H is not*
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
> *This conclusively proves that they have different behavior*
>
This is what you WANT the behaviour to be. It is not the ACTUAL
behaviour. The ACTUAL behaviour IS STIPULATED TO BE PRECISELY IDENTICAL
WITH ABSOLUTELY NO EXCEPTIONS. If the actual behaviour is not precisely
identical with absolutely no exceptions THEN YOU ARE BEING DISHONEST.

On 3/9/24 1:34 PM, olcott wrote:
> On 3/9/2024 3:17 PM, Richard Damon wrote:
>> On 3/9/24 10:33 AM, olcott wrote:
>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Specifications, not actual behavior until the existance of such an H
>> is shown.
>>
>> IF taken as actual behavior, then it is conditional on such an H
>> existing.
>>
>>>
>>> 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
>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>
>> It NEEDS to in order to meet its specification
>>
>> It DOESN'T unless its algorithm says it does,
>>
>> If it just fails to answer, then it has failed to be a correct Halt
>> Decider.
>>
>> The fact that you reach this conflict in actions, is the reason Halt
>> Deciding is uncomputable.
>>
>>>
>>> *This is a verified fact*
>>> When simulating halt deciders always report on the behavior of
>>> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> transitions to Ĥ.Hqn it is correct from its own POV.
>>
>> In other words, you are admitting to changing the question, and thus
>> LYING that you are working on the actual original problem.
>
> This must just be over your head. It is very very difficult.
>
> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
> wrong answer to provide?
>

That's YOUR problem!

You are the one saying you have an H that does something.

The most likely result is needing to use some faulty condition which
falsely presumes the simulation will be non-halting and the going to qn.

The problem is coming up with a reasonable criteria to be wrong here,
and not in too many other spots.

Of course, the big problem is that your whole design was based on H
detecting that the program being simulated was using a copy of H, but
maybe now you know that doesn't work.

On 3/9/24 2:15 PM, olcott wrote:
> On 3/9/2024 3:49 PM, immibis wrote:
>> On 9/03/24 22:30, olcott wrote:
>>> On 3/9/2024 3:17 PM, Richard Damon wrote:
>>>> On 3/9/24 10:33 AM, olcott wrote:
>>>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Specifications, not actual behavior until the existance of such an H
>>>> is shown.
>>>>
>>>> IF taken as actual behavior, then it is conditional on such an H
>>>> existing.
>>>>
>>>>>
>>>>> 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
>>>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>>>
>>>> It NEEDS to in order to meet its specification
>>>>
>>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>>
>>>> It DOESN'T unless its algorithm says it does,
>>>>
>>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>>
>>>> If it just fails to answer, then it has failed to be a correct Halt
>>>> Decider.
>>>>
>>> Yes. (Notice that I am agreeing with you, yet never do that with me)
>>>
>>>> The fact that you reach this conflict in actions, is the reason Halt
>>>> Deciding is uncomputable.
>>>
>>> *No. We know that Ĥ ⟨Ĥ⟩ either halts or fails to halt*
>>>
>>> If it halts then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn.
>>
>> If Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn then H ⟨Ĥ⟩ transitioned to H.qn
>> or else Ĥ is the wrong Ĥ or you can't read instructions.
>>
>
> I generally agree that a pair of identical machines
> must have the same behavior on the same input.
>
> This may not apply when these machines having identical
> states and identical inputs:
>
> (a) Are out-of-sync by a whole execution trace or

Nope, the machine execute INDEPENDENTLY of each other,

The only thing that shows this "sync" issue is that the simulation of
machines, where one machine simulating another might be at different stages.

You keep on confusing the simulation of the machine with the actual
behavior of the

>
> (b) When one of the machines is embedded within another machine
> that would cause this embedded machine to have recursive
> simulation that the non-embedded machine cannot possibly have.

Nope.

Not posssible.

Please try to show how this can happen.

ACTUAL INSTRUCTION that differ in path.

You seem to NEED for this to be true, but it isn't

>
> *I think that the actual difference is the latter case because*
> *we have the exact same issue when the infinite loop is removed*
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.

Why not? H -> H^ ... H^.H -> H^ ... H^.H is getting stuck in a recusive
simulation.

Just like if F1 calls f2, and f2 calls f2, then f1 will get stuck in a
"infinite recursive call loop" even though f1 isn't part of the loop
>
> *The above two behaviors are different for identical*
> *machines with identical inputs*
>

Which just shows you don't understand what you are saying.

On 3/9/24 1:30 PM, olcott wrote:
> On 3/9/2024 3:17 PM, Richard Damon wrote:
>> On 3/9/24 10:33 AM, olcott wrote:
>>> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Specifications, not actual behavior until the existance of such an H
>> is shown.
>>
>> IF taken as actual behavior, then it is conditional on such an H
>> existing.
>>
>>>
>>> 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
>>> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*
>>
>> It NEEDS to in order to meet its specification
>>
> Yes. (Notice that I am agreeing with you, yet never do that with me)
>
>> It DOESN'T unless its algorithm says it does,
>>
> Yes. (Notice that I am agreeing with you, yet never do that with me)
>
>> If it just fails to answer, then it has failed to be a correct Halt
>> Decider.
>>
> Yes. (Notice that I am agreeing with you, yet never do that with me)
>
>> The fact that you reach this conflict in actions, is the reason Halt
>> Deciding is uncomputable.
>
> *No. We know that Ĥ ⟨Ĥ⟩ either halts or fails to halt*
>
> If it halts then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioned to Ĥ.Hqn.
> If it fails to halt then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ either transitioned
> to Ĥ.Hqy or it loops.
>

So?

Doesn't say that H (H^) (H^) and H^.H (H^) (H^) can act differently.

You just agreed that the only reason it does, is because it is
programmed that way, which means BOTH machine will do the say, and thus
neither know the behavior of the machine they are simulating.

And, whatever they say, the machine will do the other, as ITS copy of H
will say the same thing.

So, your initial claim that they can act differently has no support.

You agree that the aborting is what the programming said it will do, so
since H and H^.H have the same programming it will do the same, and
abort its simuation before seeing what that machine will do, just like
H^.H did.