Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn // Ȟ applied to ⟨Ȟ⟩ does not halt

Richard cannot say exactly why Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩
gets the wrong answer.

All of his answers are of the circular form that Ȟ
cannot do it because it cannot be done.

What exactly is it specifically about about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩
that prevents Ȟ from deriving an answer consistent with its own
behavior?

I say that the reason is that Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ is self-contradictory.
Richard disagrees yet cannot say what the reason is thus making his
rebuttal vacuous.

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

On 25/02/24 06:45, olcott wrote:
> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn   // Ȟ applied to ⟨Ȟ⟩ does not halt
>
> Richard cannot say exactly why Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩
> gets the wrong answer.

If H is your x86utm halting decider function and Ȟ is your x86utm
counter-example function then I can tell you exactly why it gets the
wrong answer:

Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ halts. However:
H says that Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ does not halt.
This proves that H gets the wrong answer. No further proof is needed.

> All of his answers are of the circular form that Ȟ
> cannot do it because it cannot be done.

It can be done. For example, this function gives the correct answer when
applied to ⟨Ȟ⟩ ⟨Ȟ⟩:
int H2(ptr p, ptr i) {return 1;}

However, it gets other answers wrong. H2 gives a wrong answer when
applied to ⟨Ȟ2⟩ ⟨Ȟ2⟩, and when applied to ⟨infloop⟩ ⟨complete works of
William McGonagall⟩, and when applied to many other inputs.

Every program gives at least one wrong halting answer.

> What exactly is it specifically about about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩
> that prevents Ȟ from deriving an answer consistent with its own
> behavior?

It's not prevented. See above. The only thing that's prevented is that a
halting decider gets ALL answers correct. Every halting decider gets at
least one answer wrong.

On 2/25/2024 6:31 AM, immibis wrote:
> On 25/02/24 06:45, olcott wrote:
>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn   // Ȟ applied to ⟨Ȟ⟩ does not halt
>>
>> Richard cannot say exactly why Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩
>> gets the wrong answer.
>
> If H is your x86utm halting decider function and Ȟ is your x86utm
> counter-example function then I can tell you exactly why it gets the
> wrong answer:
>
> Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ halts. However:
> H says that Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ does not halt.
> This proves that H gets the wrong answer. No further proof is needed.
>
>
>
>> All of his answers are of the circular form that Ȟ
>> cannot do it because it cannot be done.
>
> It can be done. For example, this function gives the correct answer when
> applied to ⟨Ȟ⟩ ⟨Ȟ⟩:
> int H2(ptr p, ptr i) {return 1;}
>
> However, it gets other answers wrong. H2 gives a wrong answer when
> applied to ⟨Ȟ2⟩ ⟨Ȟ2⟩, and when applied to ⟨infloop⟩ ⟨complete works of
> William McGonagall⟩, and when applied to many other inputs.
>
> Every program gives at least one wrong halting answer.
>
>> What exactly is it specifically about about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩
>> that prevents Ȟ from deriving an answer consistent with its own
>> behavior?
>
> It's not prevented. See above. The only thing that's prevented is that a
> halting decider gets ALL answers correct. Every halting decider gets at
> least one answer wrong.
>

Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn // Ȟ applied to ⟨Ȟ⟩ does not halt

What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
causes every implementation of Ȟ get the wrong answer.

I say that the reason is that Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ is
self-contradictory for Ȟ.

Any disagreement requires an alternative reason. The reason
why cannot correctly report on its own behavior cannot be no
reason and it cannot be a circular reason.

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

On 2/25/24 12:45 AM, olcott wrote:
> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn   // Ȟ applied to ⟨Ȟ⟩ does not halt
>
> Richard cannot say exactly why Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩
> gets the wrong answer.
>
> All of his answers are of the circular form that Ȟ
> cannot do it because it cannot be done.
>
> What exactly is it specifically about about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩
> that prevents Ȟ from deriving an answer consistent with its own
> behavior?
>
> I say that the reason is that Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ is self-contradictory.
> Richard disagrees yet cannot say what the reason is thus making his
> rebuttal vacuous.
>

Non-existence doesn't need a reason. It can be just a fact.

Why is there no Russel's teapot in the asteroid belts?

Can we be sure?

On 25/02/24 17:47, olcott wrote:
> On 2/25/2024 6:31 AM, immibis wrote:
>> On 25/02/24 06:45, olcott wrote:
>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn   // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>
>>> Richard cannot say exactly why Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩
>>> gets the wrong answer.
>>
>> If H is your x86utm halting decider function and Ȟ is your x86utm
>> counter-example function then I can tell you exactly why it gets the
>> wrong answer:
>>
>> Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ halts. However:
>> H says that Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ does not halt.
>> This proves that H gets the wrong answer. No further proof is needed.
>>
>>
>>
>>> All of his answers are of the circular form that Ȟ
>>> cannot do it because it cannot be done.
>>
>> It can be done. For example, this function gives the correct answer
>> when applied to ⟨Ȟ⟩ ⟨Ȟ⟩:
>> int H2(ptr p, ptr i) {return 1;}
>>
>> However, it gets other answers wrong. H2 gives a wrong answer when
>> applied to ⟨Ȟ2⟩ ⟨Ȟ2⟩, and when applied to ⟨infloop⟩ ⟨complete works of
>> William McGonagall⟩, and when applied to many other inputs.
>>
>> Every program gives at least one wrong halting answer.
>>
>>> What exactly is it specifically about about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩
>>> that prevents Ȟ from deriving an answer consistent with its own
>>> behavior?
>>
>> It's not prevented. See above. The only thing that's prevented is that
>> a halting decider gets ALL answers correct. Every halting decider gets
>> at least one answer wrong.
>>
>
> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn // Ȟ applied to ⟨Ȟ⟩ does not halt

You are mixing up two different programs here. Let me fix it:
Ȟy.q0 ⟨Ȟy⟩ ⟨Ȟy⟩ ⊢* Ȟy.qy ∞ // Ȟy applied to ⟨Ȟy⟩ ⟨Ȟy⟩ does not halt even
though it thinks it does
Ȟn.q0 ⟨Ȟn⟩ ⟨Ȟn⟩ ⊢* Ȟn.qn // Ȟn applied to ⟨Ȟn⟩ ⟨Ȟn⟩ halts even though it
thinks it does not

>
> What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
> causes every implementation of Ȟ get the wrong answer.

What is it specifically about 1-x that causes it every natural number to
not give the same value as x?