On 9/03/24 17:00, olcott wrote:
> On 3/9/2024 1:05 AM, Richard Damon wrote:
>> On 3/8/24 10:40 PM, olcott wrote:
>>> On 3/9/2024 12:25 AM, Richard Damon wrote:
>>>> On 3/8/24 9:55 PM, olcott wrote:
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
>>>>> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> But that is the job it signed up for when it tried to call itself a
>>>> Halt Decider.
>>>>
>>>
>>> There is no correct answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly
>>> provide that corresponds to the behavior of this Ĥ ⟨Ĥ⟩.
>>> Therefore it must have a basis for its wrong answer.
>>>
>>>
>>
>> WHY?
>>
>> What is the actual grounds for that statement?
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot just sit around scratching its head it
> must do something. As soon as we have the basis for what
> it will do, then H ⟨Ĥ⟩ ⟨Ĥ⟩ has its basis to correctly
> decide halting.

H ⟨A⟩ ⟨B⟩ cannot just sit around scratching its head, it must do
something. As soon as we have the basis for what H will do, then we have
a basis to construct an Ĥ where H ⟨Ĥ⟩ ⟨Ĥ⟩ is wrong.

On 9/03/24 16:44, olcott wrote:
> On 3/9/2024 3:32 AM, Mikko wrote:
>> On 2024-03-08 21:34:30 +0000, olcott said:
>>
>>> Olcott machines are fully specified. Some of the details of the
>>> exact steps that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> would use to detect that it must
>>> abort the simulation of it input to prevent is own infinite
>>> execution must be worked out.
>>
>> What is the difference between ⟨Ĥ⟩ and <Ĥ> above and on the
>> subject line?
>>
> > [not an answer]

you forgot to answer the question

On 3/9/2024 9:36 AM, immibis wrote:
> On 9/03/24 16:12, olcott wrote:
>> On 3/9/2024 7:47 AM, immibis wrote:
>>> On 8/03/24 22:34, olcott wrote:
>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>> description is, that H can't tell that it is part of an H^
>>>>> computation that is simulating an H^ computation.
>>>>
>>>> That subject must be postponed until after the Olcott refutation
>>>> of the exact Linz proof is either fully accepted by three people
>>>> or actual errors or gaps are found that cannot be addressed or
>>>> corrected.
>>>
>>> It's accepted that the Linz proof doen't work on Olcott machines
>>> because the Linz proof is designed for Turing machines. But you can't
>>> refute the Linz-immibis proof designed for Olcott machines, where H
>>> is lied to about its own description.
>>
>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to halt
>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>
>
> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for exactly the same
> thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.

It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input.

Everyone has agreed to this yet no one besides me has ever been
able to account for this. It is like they are saying yes this
is a true fact yet in theory it is not true because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
and H ⟨Ĥ⟩ ⟨Ĥ⟩ have the same inputs their behavior must be the same.

It is a verified fact that their behavior is not the same and
verified facts supersede theories to the contrary.

--
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 1:32 AM, Mikko wrote:
> On 2024-03-08 21:34:30 +0000, olcott said:
>
>> Olcott machines are fully specified. Some of the details of the
>> exact steps that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> would use to detect that it must
>> abort the simulation of it input to prevent is own infinite
>> execution must be worked out.
>
> What is the difference between ⟨Ĥ⟩ and <Ĥ> above and on the
> subject line?
>

The <> mark the description added by the master UTM, and made different
as the tape may have a special marking to show that this is different
than just "appending" it to the tape.

Olcott defined it as having "4 spaces" on the tape before it, presumably
because he thinks no normal input will have 4 spaces in it.

On 3/9/2024 10:21 AM, immibis wrote:
> On 9/03/24 17:00, olcott wrote:
>> On 3/9/2024 1:05 AM, Richard Damon wrote:
>>> On 3/8/24 10:40 PM, olcott wrote:
>>>> On 3/9/2024 12:25 AM, Richard Damon wrote:
>>>>> On 3/8/24 9:55 PM, olcott wrote:
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>>
>>>>>> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
>>>>>> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> But that is the job it signed up for when it tried to call itself a
>>>>> Halt Decider.
>>>>>
>>>>
>>>> There is no correct answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly
>>>> provide that corresponds to the behavior of this Ĥ ⟨Ĥ⟩.
>>>> Therefore it must have a basis for its wrong answer.
>>>>
>>>>
>>>
>>> WHY?
>>>
>>> What is the actual grounds for that statement?
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot just sit around scratching its head it
>> must do something. As soon as we have the basis for what
>> it will do, then H ⟨Ĥ⟩ ⟨Ĥ⟩ has its basis to correctly
>> decide halting.
>
> H ⟨A⟩ ⟨B⟩ cannot just sit around scratching its head, it must do
> something. As soon as we have the basis for what H will do, then we have
> a basis to construct an Ĥ where H ⟨Ĥ⟩ ⟨Ĥ⟩ is wrong.
>

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can fool itself yet cannot possibly fool an external 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/9/2024 3:32 AM, Mikko wrote:
> On 2024-03-08 21:34:30 +0000, olcott said:
>
>> Olcott machines are fully specified. Some of the details of the
>> exact steps that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> would use to detect that it must
>> abort the simulation of it input to prevent is own infinite
>> execution must be worked out.
>
> What is the difference between ⟨Ĥ⟩ and <Ĥ> above and on the
> subject line?
>

⟨Ĥ⟩ is the input to Linz Ĥ and <Ĥ> is the extra input that
the Olcott UTM appends to the tape of Olcott machine Linz Ĥ.

--
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 7:12 AM, olcott wrote:
> On 3/9/2024 7:47 AM, immibis wrote:
>> On 8/03/24 22:34, olcott wrote:
>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>> description is, that H can't tell that it is part of an H^
>>>> computation that is simulating an H^ computation.
>>>
>>> That subject must be postponed until after the Olcott refutation
>>> of the exact Linz proof is either fully accepted by three people
>>> or actual errors or gaps are found that cannot be addressed or
>>> corrected.
>>
>> It's accepted that the Linz proof doen't work on Olcott machines
>> because the Linz proof is designed for Turing machines. But you can't
>> refute the Linz-immibis proof designed for Olcott machines, where H is
>> lied to about its own description.
>
> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to halt
> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>

Because if H simulates "long enough" to see the answer, that "long
enough" will turn out to be FOREVER, since H^.H will do the same thing
(BY DEFINITION)

On 3/9/24 8:41 AM, olcott wrote:
> On 3/9/2024 9:36 AM, immibis wrote:
>> On 9/03/24 16:12, olcott wrote:
>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>> On 8/03/24 22:34, olcott wrote:
>>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>>> description is, that H can't tell that it is part of an H^
>>>>>> computation that is simulating an H^ computation.
>>>>>
>>>>> That subject must be postponed until after the Olcott refutation
>>>>> of the exact Linz proof is either fully accepted by three people
>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>> corrected.
>>>>
>>>> It's accepted that the Linz proof doen't work on Olcott machines
>>>> because the Linz proof is designed for Turing machines. But you
>>>> can't refute the Linz-immibis proof designed for Olcott machines,
>>>> where H is lied to about its own description.
>>>
>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to halt
>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>
>>
>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for exactly the
>> same thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.
>
> It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input.

How?

H^.H is (H^) (H^) <H> is EXACTLY the same algorithm and data as
H (H^) (H^) <H>, so they will do exactly the sam thing.

>
> Everyone has agreed to this yet no one besides me has ever been
> able to account for this. It is like they are saying yes this
> is a true fact yet in theory it is not true because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> and H ⟨Ĥ⟩ ⟨Ĥ⟩ have the same inputs their behavior must be the same.

No, we have agreed that to meet the requirments to be a decider it must,
but then that is a requirment on the coder of H to fulfill. It doesn't
mean that

>
> It is a verified fact that their behavior is not the same and
> verified facts supersede theories to the contrary.
>

And thus it is verified that you are just a stupid ignorant pathoogical
lying idiot. because if things were what you claimed, they would act the
same.

You THINK you have verified facts, when it is all just in your
imagination, and that seems to be where you are living your life.

It sounds like perhaps you are nearing the end of the road, and when yo
get theere, you will see what Truth actually is, and likey be regreting
that you ignored it so long.

On 3/9/24 8:00 AM, olcott wrote:
> On 3/9/2024 1:05 AM, Richard Damon wrote:
>> On 3/8/24 10:40 PM, olcott wrote:
>>> On 3/9/2024 12:25 AM, Richard Damon wrote:
>>>> On 3/8/24 9:55 PM, olcott wrote:
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
>>>>> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> But that is the job it signed up for when it tried to call itself a
>>>> Halt Decider.
>>>>
>>>
>>> There is no correct answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly
>>> provide that corresponds to the behavior of this Ĥ ⟨Ĥ⟩.
>>> Therefore it must have a basis for its wrong answer.
>>>
>>>
>>
>> WHY?
>>
>> What is the actual grounds for that statement?
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot just sit around scratching its head it
> must do something. As soon as we have the basis for what
> it will do, then H ⟨Ĥ⟩ ⟨Ĥ⟩ has its basis to correctly
> decide halting.

Right, you need to define what the algorithm for H will do for all input.

Then you get the answer to both question, as it is the same algorithm in
both places.

Oh, and Defining an algorithm isn't saying what the answer is, it is
defining the step by step process used to get to that answer, each step
works just from the input and information previously derived in the
operation.

So no "Get the right answer" steps.

>
> All of the following that you said simply proves that you are
> not paying close enough attention.
>
> No one gives a rat's as that the input gets the wrong answer
> as long as H ⟨Ĥ⟩ ⟨Ĥ⟩ has some basis to get the right answer.

Maybe thats your problem, you SHOULD give a "rat's ass" about what H^.H
does, as that is an instance of your Halt Decider H, and if it gives the
wrong answer, H (and YOU) have shown that it FAILS to be a a halt Decider.

If you don't care if H gives the right answer to every case, just admit
that Halting can't be computed and go on your way. You can't say you
have "Proved" something if you "Proof" show that the thing doesn't
actually meet the requirements everywhere (as requireed), that just
proves you think lying is ok.

You are just proving that you are totally ignorant about what you are
doing with zero understand of what Computations are about.

>
>>
>> If it doesn't give the right answer, it just isn't a Halt Decider, and
>> thus isn't actually constrained by the definition of one.
>>
>> H either IS or it IS NOT a Halt Decider. Being "close" doesn't make it
>> one.
>>
>> Once you admit it isn't going to be a Halt Decider, you need to admit
>> that and then decide what you are going to try to make it to meet your
>> need. (If you have one).
>>
>> The original task for a Halt Decider was Theorem proving and Knowledge
>> gathering, where you needed to either be 100% accurate, or it didn't
>> help. (you don't prove a theorem with a 99% accuracy, only 100%)
>>
>> For the goal you have stated, you also need 100% or you have nothing.
>> If you are willing to accept approximate and slightly flawed
>> decisions, you don't need to refute the Halting Theorem, as it alread
>> allows for those to exist.
>>
>> Just like if you want to be able to refute most falsehood, you don't
>> need the Truth Predicate, as most major false statement are provably
>> false, (if the person will look at logic, and if not, having the
>> predicate wouldn't help anyway).
>

On 3/9/2024 11:08 AM, Richard Damon wrote:
> On 3/9/24 7:12 AM, olcott wrote:
>> On 3/9/2024 7:47 AM, immibis wrote:
>>> On 8/03/24 22:34, olcott wrote:
>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>> description is, that H can't tell that it is part of an H^
>>>>> computation that is simulating an H^ computation.
>>>>
>>>> That subject must be postponed until after the Olcott refutation
>>>> of the exact Linz proof is either fully accepted by three people
>>>> or actual errors or gaps are found that cannot be addressed or
>>>> corrected.
>>>
>>> It's accepted that the Linz proof doen't work on Olcott machines
>>> because the Linz proof is designed for Turing machines. But you can't
>>> refute the Linz-immibis proof designed for Olcott machines, where H
>>> is lied to about its own description.
>>
>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to halt
>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>
>
> Because if H simulates "long enough" to see the answer, that "long
> enough" will turn out to be FOREVER, since H^.H will do the same thing
> (BY DEFINITION)

It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input
and verified facts supersede all theories to the contrary.

--
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 11:12 AM, Richard Damon wrote:
> On 3/9/24 8:41 AM, olcott wrote:
>> On 3/9/2024 9:36 AM, immibis wrote:
>>> On 9/03/24 16:12, olcott wrote:
>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>>>> description is, that H can't tell that it is part of an H^
>>>>>>> computation that is simulating an H^ computation.
>>>>>>
>>>>>> That subject must be postponed until after the Olcott refutation
>>>>>> of the exact Linz proof is either fully accepted by three people
>>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>>> corrected.
>>>>>
>>>>> It's accepted that the Linz proof doen't work on Olcott machines
>>>>> because the Linz proof is designed for Turing machines. But you
>>>>> can't refute the Linz-immibis proof designed for Olcott machines,
>>>>> where H is lied to about its own description.
>>>>
>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to halt
>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>
>>>
>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for exactly the
>>> same thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.
>>
>> It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input.
>
> How?

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

When every H reports halting on the basis of its own POV then
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ rejects its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ accepts its input.

This causes Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to incorrectly report on the behavior of
Ĥ ⟨Ĥ⟩ and causes H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of Ĥ ⟨Ĥ⟩

When we can see that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of its
input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input
then the theory that identical machines on the same input must
have identical behavior is refuted or the fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
is embedded within Ĥ makes Ĥ.H not an identical machine to H.

I am going with the latter because the former seems self-evidently
correct. Identical machine on identical input must have the same
behavior. That Ĥ.H is embedded within Ĥ makes Ĥ.H a different
machine than H even though it has the exact same states in its
sub-machine portion.

--
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 8:53 AM, olcott wrote:
> On 3/9/2024 10:21 AM, immibis wrote:
>> On 9/03/24 17:00, olcott wrote:
>>> On 3/9/2024 1:05 AM, Richard Damon wrote:
>>>> On 3/8/24 10:40 PM, olcott wrote:
>>>>> On 3/9/2024 12:25 AM, Richard Damon wrote:
>>>>>> On 3/8/24 9:55 PM, olcott wrote:
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>>
>>>>>>> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
>>>>>>> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>> But that is the job it signed up for when it tried to call itself
>>>>>> a Halt Decider.
>>>>>>
>>>>>
>>>>> There is no correct answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly
>>>>> provide that corresponds to the behavior of this Ĥ ⟨Ĥ⟩.
>>>>> Therefore it must have a basis for its wrong answer.
>>>>>
>>>>>
>>>>
>>>> WHY?
>>>>
>>>> What is the actual grounds for that statement?
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot just sit around scratching its head it
>>> must do something. As soon as we have the basis for what
>>> it will do, then H ⟨Ĥ⟩ ⟨Ĥ⟩ has its basis to correctly
>>> decide halting.
>>
>> H ⟨A⟩ ⟨B⟩ cannot just sit around scratching its head, it must do
>> something. As soon as we have the basis for what H will do, then we
>> have a basis to construct an Ĥ where H ⟨Ĥ⟩ ⟨Ĥ⟩ is wrong.
>>
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can fool itself yet cannot possibly fool an external H ⟨Ĥ⟩ ⟨Ĥ⟩.
>

Why not?

Are you thinking H will just simulate until H^.H makes its decision?

We know the outcome of that, never answering, and thus failing.

On 3/9/24 9:39 AM, olcott wrote:
> On 3/9/2024 11:12 AM, Richard Damon wrote:
>> On 3/9/24 8:41 AM, olcott wrote:
>>> On 3/9/2024 9:36 AM, immibis wrote:
>>>> On 9/03/24 16:12, olcott wrote:
>>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>>>>> description is, that H can't tell that it is part of an H^
>>>>>>>> computation that is simulating an H^ computation.
>>>>>>>
>>>>>>> That subject must be postponed until after the Olcott refutation
>>>>>>> of the exact Linz proof is either fully accepted by three people
>>>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>>>> corrected.
>>>>>>
>>>>>> It's accepted that the Linz proof doen't work on Olcott machines
>>>>>> because the Linz proof is designed for Turing machines. But you
>>>>>> can't refute the Linz-immibis proof designed for Olcott machines,
>>>>>> where H is lied to about its own description.
>>>>>
>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to
>>>>> halt
>>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>>
>>>>
>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for exactly the
>>>> same thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.
>>>
>>> It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input.
>>
>> How?
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt

Comment are SPECIFICATION, not actual behavior until existance of a
conforming H is proven

>
> 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
>
> When every H reports halting on the basis of its own POV then
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ rejects its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ accepts its input.

Except it is supposed to report on the OBJECTIVE requirement of what the
machine does, so you are just admitting to LYING and all your work is
VOID for the actual Halting Problem.

>
> This causes Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to incorrectly report on the behavior of
> Ĥ ⟨Ĥ⟩ and causes H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of Ĥ ⟨Ĥ⟩

Only in the case of your LIE, so you aren't saying anything about the
actual Halting Problem

>
> When we can see that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of its
> input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input
> then the theory that identical machines on the same input must
> have identical behavior is refuted or the fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> is embedded within Ĥ makes Ĥ.H not an identical machine to H.

It "Must" to meet specifications. Not that is WILL do that.

You don't get that until you prove that an H that meed the
specifications exists.

YOu are just proving you don't understand how logic works.

>
> I am going with the latter because the former seems self-evidently
> correct. Identical machine on identical input must have the same
> behavior. That Ĥ.H is embedded within Ĥ makes Ĥ.H a different
> machine than H even though it has the exact same states in its
> sub-machine portion.
>

You can't say you "refuted" something because it doesn't allow you to
show something you want to show.

That just shows you are nothing but a pathetic ignorant pathological
lying idiot that shouldn't be trusted to know anything about anything.

On 3/9/24 9:27 AM, olcott wrote:
> On 3/9/2024 11:08 AM, Richard Damon wrote:
>> On 3/9/24 7:12 AM, olcott wrote:
>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>> On 8/03/24 22:34, olcott wrote:
>>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>>> description is, that H can't tell that it is part of an H^
>>>>>> computation that is simulating an H^ computation.
>>>>>
>>>>> That subject must be postponed until after the Olcott refutation
>>>>> of the exact Linz proof is either fully accepted by three people
>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>> corrected.
>>>>
>>>> It's accepted that the Linz proof doen't work on Olcott machines
>>>> because the Linz proof is designed for Turing machines. But you
>>>> can't refute the Linz-immibis proof designed for Olcott machines,
>>>> where H is lied to about its own description.
>>>
>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to halt
>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>
>>
>> Because if H simulates "long enough" to see the answer, that "long
>> enough" will turn out to be FOREVER, since H^.H will do the same thing
>> (BY DEFINITION)
>
> It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input
> and verified facts supersede all theories to the contrary.
>
>

Nope.

H^.H must abort to meet its specification, but that doesn't mean it does.

Your problem is that Turing Machines don't let you LIE about what is
happening, and you "proof" is based on your LYING about what is happening.

Therefore, you tried creating you Olcott machines to let you try to
cheat again, but it turns out they only let you cheat by writing in big
black letters on the backs of the cards, which everyone sees, so you
can't actually get away with your lies.

You can't "Refute" something because it makes it inconient to try to
prove somethihng.

Your claim just proves that you are totally ignorant about how Logic
actually works, so NOBODY should even think about looking at your ideas
of "Correct Reasoning" as the obviously can't actually be correct if
they produce so many lies.

Face it, you have destroyed your repuations, and will be remembersd as
just that pathetic ignorant hypocritical pahtological lying idiot you
have shown yourself to be.

If you can find a way to snap out of you gas-lighted self-brainwashing,
maybe you can recover a bit of reputation, but I don't think you have
that in you.

Sorry, you are just proving you are a MORON.

On 3/9/2024 12:31 PM, Richard Damon wrote:
> On 3/9/24 9:27 AM, olcott wrote:
>> On 3/9/2024 11:08 AM, Richard Damon wrote:
>>> On 3/9/24 7:12 AM, olcott wrote:
>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>>>> description is, that H can't tell that it is part of an H^
>>>>>>> computation that is simulating an H^ computation.
>>>>>>
>>>>>> That subject must be postponed until after the Olcott refutation
>>>>>> of the exact Linz proof is either fully accepted by three people
>>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>>> corrected.
>>>>>
>>>>> It's accepted that the Linz proof doen't work on Olcott machines
>>>>> because the Linz proof is designed for Turing machines. But you
>>>>> can't refute the Linz-immibis proof designed for Olcott machines,
>>>>> where H is lied to about its own description.
>>>>
>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to halt
>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>
>>>
>>> Because if H simulates "long enough" to see the answer, that "long
>>> enough" will turn out to be FOREVER, since H^.H will do the same
>>> thing (BY DEFINITION)
>>
>> It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input
>> and verified facts supersede all theories to the contrary.
>>
>>
>
> Nope.

Please switch over to this new post that addresses all of your
objections in advance.
[Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ 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 3/9/2024 12:22 PM, Richard Damon wrote:
> On 3/9/24 9:39 AM, olcott wrote:
>> On 3/9/2024 11:12 AM, Richard Damon wrote:
>>> On 3/9/24 8:41 AM, olcott wrote:
>>>> On 3/9/2024 9:36 AM, immibis wrote:
>>>>> On 9/03/24 16:12, olcott wrote:
>>>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>>>>>> description is, that H can't tell that it is part of an H^
>>>>>>>>> computation that is simulating an H^ computation.
>>>>>>>>
>>>>>>>> That subject must be postponed until after the Olcott refutation
>>>>>>>> of the exact Linz proof is either fully accepted by three people
>>>>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>>>>> corrected.
>>>>>>>
>>>>>>> It's accepted that the Linz proof doen't work on Olcott machines
>>>>>>> because the Linz proof is designed for Turing machines. But you
>>>>>>> can't refute the Linz-immibis proof designed for Olcott machines,
>>>>>>> where H is lied to about its own description.
>>>>>>
>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to
>>>>>> halt
>>>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>>>
>>>>>
>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for exactly the
>>>>> same thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.
>>>>
>>>> It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>>>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input.
>>>
>>> How?
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Comment are SPECIFICATION, not actual behavior until existance of a
> conforming H is proven
>

Please switch over to this new post that addresses all of your
objections in advance.
[Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ 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 3/9/2024 12:17 PM, Richard Damon wrote:
> On 3/9/24 8:53 AM, olcott wrote:
>> On 3/9/2024 10:21 AM, immibis wrote:
>>> On 9/03/24 17:00, olcott wrote:
>>>> On 3/9/2024 1:05 AM, Richard Damon wrote:
>>>>> On 3/8/24 10:40 PM, olcott wrote:
>>>>>> On 3/9/2024 12:25 AM, Richard Damon wrote:
>>>>>>> On 3/8/24 9:55 PM, olcott wrote:
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>>
>>>>>>>> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
>>>>>>>> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>
>>>>>>> But that is the job it signed up for when it tried to call itself
>>>>>>> a Halt Decider.
>>>>>>>
>>>>>>
>>>>>> There is no correct answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly
>>>>>> provide that corresponds to the behavior of this Ĥ ⟨Ĥ⟩.
>>>>>> Therefore it must have a basis for its wrong answer.
>>>>>>
>>>>>>
>>>>>
>>>>> WHY?
>>>>>
>>>>> What is the actual grounds for that statement?
>>>>
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot just sit around scratching its head it
>>>> must do something. As soon as we have the basis for what
>>>> it will do, then H ⟨Ĥ⟩ ⟨Ĥ⟩ has its basis to correctly
>>>> decide halting.
>>>
>>> H ⟨A⟩ ⟨B⟩ cannot just sit around scratching its head, it must do
>>> something. As soon as we have the basis for what H will do, then we
>>> have a basis to construct an Ĥ where H ⟨Ĥ⟩ ⟨Ĥ⟩ is wrong.
>>>
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can fool itself yet cannot possibly fool an external H ⟨Ĥ⟩
>> ⟨Ĥ⟩.
>>
>
> Why not?
>
> Are you thinking H will just simulate until H^.H makes its decision?
>
> We know the outcome of that, never answering, and thus failing.

Please switch over to this new post that addresses all of your
objections in advance.
[Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ 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 3/9/24 10:36 AM, olcott wrote:
> On 3/9/2024 12:31 PM, Richard Damon wrote:
>> On 3/9/24 9:27 AM, olcott wrote:
>>> On 3/9/2024 11:08 AM, Richard Damon wrote:
>>>> On 3/9/24 7:12 AM, olcott wrote:
>>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>>>>> description is, that H can't tell that it is part of an H^
>>>>>>>> computation that is simulating an H^ computation.
>>>>>>>
>>>>>>> That subject must be postponed until after the Olcott refutation
>>>>>>> of the exact Linz proof is either fully accepted by three people
>>>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>>>> corrected.
>>>>>>
>>>>>> It's accepted that the Linz proof doen't work on Olcott machines
>>>>>> because the Linz proof is designed for Turing machines. But you
>>>>>> can't refute the Linz-immibis proof designed for Olcott machines,
>>>>>> where H is lied to about its own description.
>>>>>
>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to
>>>>> halt
>>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>>
>>>>
>>>> Because if H simulates "long enough" to see the answer, that "long
>>>> enough" will turn out to be FOREVER, since H^.H will do the same
>>>> thing (BY DEFINITION)
>>>
>>> It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input
>>> and verified facts supersede all theories to the contrary.
>>>
>>>
>>
>> Nope.
>
> Please switch over to this new post that addresses all of your
> objections in advance.
> [Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior]
>

Then why did you post here this morning?

On 3/9/2024 12:50 PM, Richard Damon wrote:
> On 3/9/24 10:36 AM, olcott wrote:
>> On 3/9/2024 12:31 PM, Richard Damon wrote:
>>> On 3/9/24 9:27 AM, olcott wrote:
>>>> On 3/9/2024 11:08 AM, Richard Damon wrote:
>>>>> On 3/9/24 7:12 AM, olcott wrote:
>>>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>>>>>> description is, that H can't tell that it is part of an H^
>>>>>>>>> computation that is simulating an H^ computation.
>>>>>>>>
>>>>>>>> That subject must be postponed until after the Olcott refutation
>>>>>>>> of the exact Linz proof is either fully accepted by three people
>>>>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>>>>> corrected.
>>>>>>>
>>>>>>> It's accepted that the Linz proof doen't work on Olcott machines
>>>>>>> because the Linz proof is designed for Turing machines. But you
>>>>>>> can't refute the Linz-immibis proof designed for Olcott machines,
>>>>>>> where H is lied to about its own description.
>>>>>>
>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to
>>>>>> halt
>>>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>>>
>>>>>
>>>>> Because if H simulates "long enough" to see the answer, that "long
>>>>> enough" will turn out to be FOREVER, since H^.H will do the same
>>>>> thing (BY DEFINITION)
>>>>
>>>> It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>>>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input
>>>> and verified facts supersede all theories to the contrary.
>>>>
>>>>
>>>
>>> Nope.
>>
>> Please switch over to this new post that addresses all of your
>> objections in advance.
>> [Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior]
>>
>
> Then why did you post here this morning?

After reviewing all of the posts I came up with
better words that make my point more clearly.

--
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 17:41, olcott wrote:
> On 3/9/2024 9:36 AM, immibis wrote:
>> On 9/03/24 16:12, olcott wrote:
>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>> On 8/03/24 22:34, olcott wrote:
>>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>>> description is, that H can't tell that it is part of an H^
>>>>>> computation that is simulating an H^ computation.
>>>>>
>>>>> That subject must be postponed until after the Olcott refutation
>>>>> of the exact Linz proof is either fully accepted by three people
>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>> corrected.
>>>>
>>>> It's accepted that the Linz proof doen't work on Olcott machines
>>>> because the Linz proof is designed for Turing machines. But you
>>>> can't refute the Linz-immibis proof designed for Olcott machines,
>>>> where H is lied to about its own description.
>>>
>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to halt
>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>
>>
>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for exactly the
>> same thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.
>
> It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input.

It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> does exactly the same thing
that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> does, but you continue to dishonestly ignore this
verified fact because you are a liar.

On 9/03/24 17:53, olcott wrote:
> On 3/9/2024 10:21 AM, immibis wrote:
>> On 9/03/24 17:00, olcott wrote:
>>> On 3/9/2024 1:05 AM, Richard Damon wrote:
>>>> On 3/8/24 10:40 PM, olcott wrote:
>>>>> On 3/9/2024 12:25 AM, Richard Damon wrote:
>>>>>> On 3/8/24 9:55 PM, olcott wrote:
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>>
>>>>>>> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
>>>>>>> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>> But that is the job it signed up for when it tried to call itself
>>>>>> a Halt Decider.
>>>>>>
>>>>>
>>>>> There is no correct answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly
>>>>> provide that corresponds to the behavior of this Ĥ ⟨Ĥ⟩.
>>>>> Therefore it must have a basis for its wrong answer.
>>>>>
>>>>>
>>>>
>>>> WHY?
>>>>
>>>> What is the actual grounds for that statement?
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot just sit around scratching its head it
>>> must do something. As soon as we have the basis for what
>>> it will do, then H ⟨Ĥ⟩ ⟨Ĥ⟩ has its basis to correctly
>>> decide halting.
>>
>> H ⟨A⟩ ⟨B⟩ cannot just sit around scratching its head, it must do
>> something. As soon as we have the basis for what H will do, then we
>> have a basis to construct an Ĥ where H ⟨Ĥ⟩ ⟨Ĥ⟩ is wrong.
>>
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can fool itself yet cannot possibly fool an external H ⟨Ĥ⟩ ⟨Ĥ⟩.
>

If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to state qn then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ also transitions
to state H.qn. If it does not do this then you did not follow the
instructions properly when you wrote Ĥ.

On 9/03/24 19:36, olcott wrote:
>
> Please switch over to this new post that addresses all of your
> objections in advance.
> [Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior]
>

All you proved is that you want them to have different behaviour. You
didn't prove that they actually do.

On 3/9/2024 2:49 PM, immibis wrote:
> On 9/03/24 17:53, olcott wrote:
>> On 3/9/2024 10:21 AM, immibis wrote:
>>> On 9/03/24 17:00, olcott wrote:
>>>> On 3/9/2024 1:05 AM, Richard Damon wrote:
>>>>> On 3/8/24 10:40 PM, olcott wrote:
>>>>>> On 3/9/2024 12:25 AM, Richard Damon wrote:
>>>>>>> On 3/8/24 9:55 PM, olcott wrote:
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>>
>>>>>>>> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
>>>>>>>> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>
>>>>>>> But that is the job it signed up for when it tried to call itself
>>>>>>> a Halt Decider.
>>>>>>>
>>>>>>
>>>>>> There is no correct answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly
>>>>>> provide that corresponds to the behavior of this Ĥ ⟨Ĥ⟩.
>>>>>> Therefore it must have a basis for its wrong answer.
>>>>>>
>>>>>>
>>>>>
>>>>> WHY?
>>>>>
>>>>> What is the actual grounds for that statement?
>>>>
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot just sit around scratching its head it
>>>> must do something. As soon as we have the basis for what
>>>> it will do, then H ⟨Ĥ⟩ ⟨Ĥ⟩ has its basis to correctly
>>>> decide halting.
>>>
>>> H ⟨A⟩ ⟨B⟩ cannot just sit around scratching its head, it must do
>>> something. As soon as we have the basis for what H will do, then we
>>> have a basis to construct an Ĥ where H ⟨Ĥ⟩ ⟨Ĥ⟩ is wrong.
>>>
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can fool itself yet cannot possibly fool an external H ⟨Ĥ⟩
>> ⟨Ĥ⟩.
>>
>
> If H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to state qn then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ also transitions
> to state H.qn. If it does not do this then you did not follow the
> instructions properly when you wrote Ĥ.

*Please see my new post that explains these things more clearly*
[Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ 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 3/9/24 10:45 AM, olcott wrote:
> On 3/9/2024 12:17 PM, Richard Damon wrote:
>> On 3/9/24 8:53 AM, olcott wrote:
>>> On 3/9/2024 10:21 AM, immibis wrote:
>>>> On 9/03/24 17:00, olcott wrote:
>>>>> On 3/9/2024 1:05 AM, Richard Damon wrote:
>>>>>> On 3/8/24 10:40 PM, olcott wrote:
>>>>>>> On 3/9/2024 12:25 AM, Richard Damon wrote:
>>>>>>>> On 3/8/24 9:55 PM, olcott wrote:
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>> not halt
>>>>>>>>>
>>>>>>>>> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
>>>>>>>>> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>> But that is the job it signed up for when it tried to call
>>>>>>>> itself a Halt Decider.
>>>>>>>>
>>>>>>>
>>>>>>> There is no correct answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly
>>>>>>> provide that corresponds to the behavior of this Ĥ ⟨Ĥ⟩.
>>>>>>> Therefore it must have a basis for its wrong answer.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> WHY?
>>>>>>
>>>>>> What is the actual grounds for that statement?
>>>>>
>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot just sit around scratching its head it
>>>>> must do something. As soon as we have the basis for what
>>>>> it will do, then H ⟨Ĥ⟩ ⟨Ĥ⟩ has its basis to correctly
>>>>> decide halting.
>>>>
>>>> H ⟨A⟩ ⟨B⟩ cannot just sit around scratching its head, it must do
>>>> something. As soon as we have the basis for what H will do, then we
>>>> have a basis to construct an Ĥ where H ⟨Ĥ⟩ ⟨Ĥ⟩ is wrong.
>>>>
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can fool itself yet cannot possibly fool an external H
>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>
>> Why not?
>>
>> Are you thinking H will just simulate until H^.H makes its decision?
>>
>> We know the outcome of that, never answering, and thus failing.
>
> Please switch over to this new post that addresses all of your
> objections in advance.
> [Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior]
>

Then why did you post your reply here?

On 3/9/2024 2:53 PM, immibis wrote:
> On 9/03/24 19:36, olcott wrote:
>>
>> Please switch over to this new post that addresses all of your
>> objections in advance.
>> [Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior]
>>
>
> All you proved is that you want them to have different behaviour. You
> didn't prove that they actually do.

Then you could point out the specific mistake in this new post.

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