On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> When a computation only stops running because its simulation was
>>>> aborted this counts as a computation that never halts.
>>> Me: Every computation that halts, for whatever reason, is a halting
>>> computation.
>>> You: OK
>>
>> A computation having its simulation aborted never halts even though it
>> stops running. Only computation that stop running without having their
>> simulation aborted are halting computations.
>
> P(P) halts. Stop trying to hide that fact in waffle.

"This sentence is not true. Is indeed not true, yet the fact
that its assertion is satisfied does not make the sentence
true. This seems over your head.

The fact that Ȟ either halts or fails to halt
Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn // Ȟ applied to ⟨Ȟ⟩ does not halt

Does not make this a correct question for Ȟ:
Do you halt on your own Turing Machine description ?

> I know you've
> realised that it was a mistake to be clear, but you can't obscure a fact
> you were once clear about.
>
>>> P(P) halts (according to you). H(P,P) == 0 (according to you).
>>> That is wrong -- even according to you.
>

--
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/24/24 4:27 PM, olcott wrote:
> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> When a computation only stops running because its simulation was
>>>>> aborted this counts as a computation that never halts.
>>>> Me: Every computation that halts, for whatever reason, is a halting
>>>>       computation.
>>>> You: OK
>>>
>>> A computation having its simulation aborted never halts even though it
>>> stops running. Only computation that stop running without having their
>>> simulation aborted are halting computations.
>>
>> P(P) halts.  Stop trying to hide that fact in waffle.
>
> "This sentence is not true. Is indeed not true, yet the fact
> that its assertion is satisfied does not make the sentence
> true. This seems over your head.
>
> The fact that Ȟ either halts or fails to halt
> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn     // Ȟ applied to ⟨Ȟ⟩ does not halt

Except that Ȟ WILL either Halt or not based on what TURING MACHINE you
make H to be.

You can't do the above until H has been fixed to a specific machine, and
when you do, Ȟ (Ȟ) will either Halt or Not and make H (Ȟ) (Ȟ) wrong.

>
> Does not make this a correct question for Ȟ:
> Do you halt on your own Turing Machine description ?
>
>> I know you've
>> realised that it was a mistake to be clear, but you can't obscure a fact
>> you were once clear about.
>>
>>>> P(P) halts (according to you).  H(P,P) == 0 (according to you).
>>>> That is wrong -- even according to you.
>>
>

On 2/24/2024 3:34 PM, Richard Damon wrote:
> On 2/24/24 4:27 PM, olcott wrote:
>> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> When a computation only stops running because its simulation was
>>>>>> aborted this counts as a computation that never halts.
>>>>> Me: Every computation that halts, for whatever reason, is a halting
>>>>>       computation.
>>>>> You: OK
>>>>
>>>> A computation having its simulation aborted never halts even though it
>>>> stops running. Only computation that stop running without having their
>>>> simulation aborted are halting computations.
>>>
>>> P(P) halts.  Stop trying to hide that fact in waffle.
>>
>> "This sentence is not true. Is indeed not true, yet the fact
>> that its assertion is satisfied does not make the sentence
>> true. This seems over your head.
>>
>> The fact that Ȟ either halts or fails to halt
>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn     // Ȟ applied to ⟨Ȟ⟩ does not halt
>
> Except that Ȟ WILL either Halt or not based on what TURING MACHINE you
> make H to be.
>

And "This sentence is not true." is indeed not true
yet you cannot understand how that does not make it true.

When one is under the naive impression that when-so-ever
the assertion of a statement is satisfied then that always
makes the expression true, they get these things incorrectly.

"This sentence is not true." is indeed not true thus
fully satisfying the assertion made by LP, yet this
still does not make the LP true.

The fact that Ȟ halts or fails to halt is isomorphic
to the Liar Paradox actually being untrue. Even though
the Liar Paradox is actually untrue it remains neither
true nor false.

--
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/24/24 4:46 PM, olcott wrote:
> On 2/24/2024 3:34 PM, Richard Damon wrote:
>> On 2/24/24 4:27 PM, olcott wrote:
>>> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> When a computation only stops running because its simulation was
>>>>>>> aborted this counts as a computation that never halts.
>>>>>> Me: Every computation that halts, for whatever reason, is a halting
>>>>>>       computation.
>>>>>> You: OK
>>>>>
>>>>> A computation having its simulation aborted never halts even though it
>>>>> stops running. Only computation that stop running without having their
>>>>> simulation aborted are halting computations.
>>>>
>>>> P(P) halts.  Stop trying to hide that fact in waffle.
>>>
>>> "This sentence is not true. Is indeed not true, yet the fact
>>> that its assertion is satisfied does not make the sentence
>>> true. This seems over your head.
>>>
>>> The fact that Ȟ either halts or fails to halt
>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn     // Ȟ applied to ⟨Ȟ⟩ does not halt
>>
>> Except that Ȟ WILL either Halt or not based on what TURING MACHINE you
>> make H to be.
>>
>
> And "This sentence is not true." is indeed not true
> yet you cannot understand how that does not make it true.

And a meaningless red herring since we are talking about program behavior.

>
> When one is under the naive impression that when-so-ever
> the assertion of a statement is satisfied then that always
> makes the expression true, they get these things incorrectly.
>
> "This sentence is not true." is indeed not true thus
> fully satisfying the assertion made by LP, yet this
> still does not make the LP true.
>
> The fact that Ȟ halts or fails to halt is isomorphic
> to the Liar Paradox actually being untrue. Even though
> the Liar Paradox is actually untrue it remains neither
> true nor false.
>
>

Nope. Since to even ask the question about Ȟ, we first needed to define
it, which mean we first needed to define which H we are using.

Thus Ȟ (Ȟ) is a specific computation with a specific behavior and thus
the specific question has an exact right answer.

The H that Ȟ was built on, just doesn't give it.

The actual Halting Question has no "self-reference" (or any form of
reference) in it.

Your "Isomorphism" isn't actually an Isomorphism, but an attempt to ask
a DIFFERENT question, about what would need to be done to create a
machine to answer the question. The fact that you hit a contradiction on
that question doesn't make the original one invalid, it makes it
uncomputable.

Your inability to see the difference, just shows your ignorance of the
subject.

On 2/24/2024 3:58 PM, Richard Damon wrote:
> On 2/24/24 4:46 PM, olcott wrote:
>> On 2/24/2024 3:34 PM, Richard Damon wrote:
>>> On 2/24/24 4:27 PM, olcott wrote:
>>>> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> When a computation only stops running because its simulation was
>>>>>>>> aborted this counts as a computation that never halts.
>>>>>>> Me: Every computation that halts, for whatever reason, is a halting
>>>>>>>       computation.
>>>>>>> You: OK
>>>>>>
>>>>>> A computation having its simulation aborted never halts even
>>>>>> though it
>>>>>> stops running. Only computation that stop running without having
>>>>>> their
>>>>>> simulation aborted are halting computations.
>>>>>
>>>>> P(P) halts.  Stop trying to hide that fact in waffle.
>>>>
>>>> "This sentence is not true. Is indeed not true, yet the fact
>>>> that its assertion is satisfied does not make the sentence
>>>> true. This seems over your head.
>>>>
>>>> The fact that Ȟ either halts or fails to halt
>>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn     // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>
>>> Except that Ȟ WILL either Halt or not based on what TURING MACHINE
>>> you make H to be.
>>>
>>
>> And "This sentence is not true." is indeed not true
>> yet you cannot understand how that does not make it true.
>
> And a meaningless red herring since we are talking about program behavior.
>
>>
>> When one is under the naive impression that when-so-ever
>> the assertion of a statement is satisfied then that always
>> makes the expression true, they get these things incorrectly.
>>
>> "This sentence is not true." is indeed not true thus
>> fully satisfying the assertion made by LP, yet this
>> still does not make the LP true.
>>
>> The fact that Ȟ halts or fails to halt is isomorphic
>> to the Liar Paradox actually being untrue. Even though
>> the Liar Paradox is actually untrue it remains neither
>> true nor false.
>>
>>
>
> Nope. Since to even ask the question about Ȟ, we first needed to define
> it, which mean we first needed to define which H we are using.
>
> Thus Ȟ (Ȟ) is a specific computation with a specific behavior and thus
> the specific question has an exact right answer.

Objective and Subjective Specifications
https://www.cs.toronto.edu/~hehner/OSS.pdf

Carol's question proves otherwise and only
your ignorance that the context of who is asked
a question does sometimes totally change the
meaning of this question says otherwise.

You caught the loophole in Carol's question and
I told professor Hehner about this.

Both yes and no are the wrong answer
to the question of: Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩

*Unless the question is rephrased as*
Can you correctly determine that your input halts?

An answer of NO means that there is something wrong with the input.
(a) Syntactically incorrect
(b) Self-contradictory
(c) Infinite execution

Then the solution that I came up with years ago and you
recently affirmed solves the problem.

--
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/24/24 5:32 PM, olcott wrote:
> On 2/24/2024 3:58 PM, Richard Damon wrote:
>> On 2/24/24 4:46 PM, olcott wrote:
>>> On 2/24/2024 3:34 PM, Richard Damon wrote:
>>>> On 2/24/24 4:27 PM, olcott wrote:
>>>>> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> When a computation only stops running because its simulation was
>>>>>>>>> aborted this counts as a computation that never halts.
>>>>>>>> Me: Every computation that halts, for whatever reason, is a halting
>>>>>>>>       computation.
>>>>>>>> You: OK
>>>>>>>
>>>>>>> A computation having its simulation aborted never halts even
>>>>>>> though it
>>>>>>> stops running. Only computation that stop running without having
>>>>>>> their
>>>>>>> simulation aborted are halting computations.
>>>>>>
>>>>>> P(P) halts.  Stop trying to hide that fact in waffle.
>>>>>
>>>>> "This sentence is not true. Is indeed not true, yet the fact
>>>>> that its assertion is satisfied does not make the sentence
>>>>> true. This seems over your head.
>>>>>
>>>>> The fact that Ȟ either halts or fails to halt
>>>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>>>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn     // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>
>>>> Except that Ȟ WILL either Halt or not based on what TURING MACHINE
>>>> you make H to be.
>>>>
>>>
>>> And "This sentence is not true." is indeed not true
>>> yet you cannot understand how that does not make it true.
>>
>> And a meaningless red herring since we are talking about program
>> behavior.
>>
>>>
>>> When one is under the naive impression that when-so-ever
>>> the assertion of a statement is satisfied then that always
>>> makes the expression true, they get these things incorrectly.
>>>
>>> "This sentence is not true." is indeed not true thus
>>> fully satisfying the assertion made by LP, yet this
>>> still does not make the LP true.
>>>
>>> The fact that Ȟ halts or fails to halt is isomorphic
>>> to the Liar Paradox actually being untrue. Even though
>>> the Liar Paradox is actually untrue it remains neither
>>> true nor false.
>>>
>>>
>>
>> Nope. Since to even ask the question about Ȟ, we first needed to
>> define it, which mean we first needed to define which H we are using.
>>
>> Thus Ȟ (Ȟ) is a specific computation with a specific behavior and thus
>> the specific question has an exact right answer.
>
> Objective and Subjective Specifications
> https://www.cs.toronto.edu/~hehner/OSS.pdf

And our specification is OBJECTIVE

And you are trying to change the question to be subjective while LYING
that it is the same quesiton.

But you have been caugght in your lie.

>
> Carol's question proves otherwise and only
> your ignorance that the context of who is asked
> a question does sometimes totally change the
> meaning of this question says otherwise.
>
> You caught the loophole in Carol's question and
> I told professor Hehner about this.
>
> Both yes and no are the wrong answer
> to the question of: Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩

Nope, because Ȟ has been specifid BEFORE you can ask the question, so
one of the answers is correct

>
> *Unless the question is rephrased as*
> Can you correctly determine that your input halts?

In other words, when you LIE about the question, you can try to make
your other lie seem more reasonable.

>
> An answer of NO means that there is something wrong with the input.
> (a) Syntactically incorrect
> (b) Self-contradictory
> (c) Infinite execution
>
> Then the solution that I came up with years ago and you
> recently affirmed solves the problem.
>

But there is nothing wrong with the actual input.

It specifies a SPECIFIC computation that Halts (for your defined H) or
not (if you use a different H that answers Halting).

You are just PROVING your utter stupidty.

You don't even seem to understand any of the basic words you are using.

You have proven you don't know what a Turing Machine is.

On 2/24/2024 6:49 PM, Richard Damon wrote:
> On 2/24/24 5:32 PM, olcott wrote:
>> On 2/24/2024 3:58 PM, Richard Damon wrote:
>>> On 2/24/24 4:46 PM, olcott wrote:
>>>> On 2/24/2024 3:34 PM, Richard Damon wrote:
>>>>> On 2/24/24 4:27 PM, olcott wrote:
>>>>>> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> When a computation only stops running because its simulation was
>>>>>>>>>> aborted this counts as a computation that never halts.
>>>>>>>>> Me: Every computation that halts, for whatever reason, is a
>>>>>>>>> halting
>>>>>>>>>       computation.
>>>>>>>>> You: OK
>>>>>>>>
>>>>>>>> A computation having its simulation aborted never halts even
>>>>>>>> though it
>>>>>>>> stops running. Only computation that stop running without having
>>>>>>>> their
>>>>>>>> simulation aborted are halting computations.
>>>>>>>
>>>>>>> P(P) halts.  Stop trying to hide that fact in waffle.
>>>>>>
>>>>>> "This sentence is not true. Is indeed not true, yet the fact
>>>>>> that its assertion is satisfied does not make the sentence
>>>>>> true. This seems over your head.
>>>>>>
>>>>>> The fact that Ȟ either halts or fails to halt
>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>>>>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn     // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>
>>>>> Except that Ȟ WILL either Halt or not based on what TURING MACHINE
>>>>> you make H to be.
>>>>>
>>>>
>>>> And "This sentence is not true." is indeed not true
>>>> yet you cannot understand how that does not make it true.
>>>
>>> And a meaningless red herring since we are talking about program
>>> behavior.
>>>
>>>>
>>>> When one is under the naive impression that when-so-ever
>>>> the assertion of a statement is satisfied then that always
>>>> makes the expression true, they get these things incorrectly.
>>>>
>>>> "This sentence is not true." is indeed not true thus
>>>> fully satisfying the assertion made by LP, yet this
>>>> still does not make the LP true.
>>>>
>>>> The fact that Ȟ halts or fails to halt is isomorphic
>>>> to the Liar Paradox actually being untrue. Even though
>>>> the Liar Paradox is actually untrue it remains neither
>>>> true nor false.
>>>>
>>>>
>>>
>>> Nope. Since to even ask the question about Ȟ, we first needed to
>>> define it, which mean we first needed to define which H we are using.
>>>
>>> Thus Ȟ (Ȟ) is a specific computation with a specific behavior and
>>> thus the specific question has an exact right answer.
>>
>> Objective and Subjective Specifications
>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>
> And our specification is OBJECTIVE
>

The specification <is> Not Hehner(objective)

A specification is subjective if the specified behavior
varies depending on the agent that performs it. (Hehner:2017)

That H applied to ⟨Ȟ⟩ ⟨Ȟ⟩ derives a correct answer
and Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ cannot possibly derive a
correct answer conclusively proves that the halting
problem specification <is> Hehner(subjective).

You are trying to get away with the claim that the input
to Ȟ is not self-contradictory.

This entails that there must be some other reason that
Ȟ does not answer correctly.

Are you claiming that Ȟ cannot answer because it is in
a bad mood?

What is the non-circular reason why Ȟ cannot answer correctly?

A circular reason is that Ȟ cannot answer correctly
because a halt decider does not exist and a halt
decider does not exist because Ȟ cannot answer correctly.

*Do you have a better answer than this*
Ȟ cannot return a value consistent with the behavior of
itself because Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ is self-contradictory for Ȟ.

*If you disagree then this disagreement is either a despicable*
*lie or you have alternative sound reasoning why Ȟ cannot*
*answer correctly*

--
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/24/24 8:27 PM, olcott wrote:
> On 2/24/2024 6:49 PM, Richard Damon wrote:
>> On 2/24/24 5:32 PM, olcott wrote:
>>> On 2/24/2024 3:58 PM, Richard Damon wrote:
>>>> On 2/24/24 4:46 PM, olcott wrote:
>>>>> On 2/24/2024 3:34 PM, Richard Damon wrote:
>>>>>> On 2/24/24 4:27 PM, olcott wrote:
>>>>>>> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> When a computation only stops running because its simulation was
>>>>>>>>>>> aborted this counts as a computation that never halts.
>>>>>>>>>> Me: Every computation that halts, for whatever reason, is a
>>>>>>>>>> halting
>>>>>>>>>>       computation.
>>>>>>>>>> You: OK
>>>>>>>>>
>>>>>>>>> A computation having its simulation aborted never halts even
>>>>>>>>> though it
>>>>>>>>> stops running. Only computation that stop running without
>>>>>>>>> having their
>>>>>>>>> simulation aborted are halting computations.
>>>>>>>>
>>>>>>>> P(P) halts.  Stop trying to hide that fact in waffle.
>>>>>>>
>>>>>>> "This sentence is not true. Is indeed not true, yet the fact
>>>>>>> that its assertion is satisfied does not make the sentence
>>>>>>> true. This seems over your head.
>>>>>>>
>>>>>>> The fact that Ȟ either halts or fails to halt
>>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>>>>>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn     // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>>
>>>>>> Except that Ȟ WILL either Halt or not based on what TURING MACHINE
>>>>>> you make H to be.
>>>>>>
>>>>>
>>>>> And "This sentence is not true." is indeed not true
>>>>> yet you cannot understand how that does not make it true.
>>>>
>>>> And a meaningless red herring since we are talking about program
>>>> behavior.
>>>>
>>>>>
>>>>> When one is under the naive impression that when-so-ever
>>>>> the assertion of a statement is satisfied then that always
>>>>> makes the expression true, they get these things incorrectly.
>>>>>
>>>>> "This sentence is not true." is indeed not true thus
>>>>> fully satisfying the assertion made by LP, yet this
>>>>> still does not make the LP true.
>>>>>
>>>>> The fact that Ȟ halts or fails to halt is isomorphic
>>>>> to the Liar Paradox actually being untrue. Even though
>>>>> the Liar Paradox is actually untrue it remains neither
>>>>> true nor false.
>>>>>
>>>>>
>>>>
>>>> Nope. Since to even ask the question about Ȟ, we first needed to
>>>> define it, which mean we first needed to define which H we are using.
>>>>
>>>> Thus Ȟ (Ȟ) is a specific computation with a specific behavior and
>>>> thus the specific question has an exact right answer.
>>>
>>> Objective and Subjective Specifications
>>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>
>> And our specification is OBJECTIVE
>>
>
> The specification <is> Not Hehner(objective)
>
> A specification is subjective if the specified behavior
> varies depending on the agent that performs it. (Hehner:2017)

But Halting is INDEPENDENT of who is doing it.

The ACTUAL QUESTION for Halting is:

Does the Computation Described by this input Halt when run.

For the proof input is the description of the computation H^ (H^), given
as (H^) (H^) for a specific H^ built on a specific H

It doesn't matter WHAT Halt Decider you give it to, the correct answer
wil always be the same. IF H (H^) (H^) goes to qy, then H^ (H^) will go
to qy and perform an infinite loop and never halt, so a correct halt
decider should go to qn. If H (H^) (H^) goes to qn, then H^ (H^) also
goes to qn, and halts, so a correct halt decier will go to qy.

In neither case, was H correct, and the correct answer is invariant of
who you ask .

Note, H^ is NOT built on what ever H you ask to decide it, but the
specific H that it was designed to confound. (as such, your x86utm model
is incorrect, as has been pointed out to you).

>
> That H applied to ⟨Ȟ⟩ ⟨Ȟ⟩ derives a correct answer
> and Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ cannot possibly derive a
> correct answer conclusively proves that the halting
> problem specification <is> Hehner(subjective).

If the inputs are the exact same, and actually represent computations,
then the CORRECT ANSWER (which is what matters) doesn't change. The fact
that one machie doesn't give it (not "can't" as a given machine only can
give one specific answer for one specific input) doesn't make the
question subjective.

>
> You are trying to get away with the claim that the input
> to Ȟ is not self-contradictory.

It isn't.

Because it CAN'T Be.

Turing Machine do not "reference" things, not even themselves.

Your "self-reference" argument is based on incorrect meta-logic.

Turing machines always have definite behavior.

>
> This entails that there must be some other reason that
> Ȟ does not answer correctly.
>

Because you are doing to wrong, and you have admitted you are too stupid
to understand how to do it right.

> Are you claiming that Ȟ cannot answer because it is in
> a bad mood?

Nope, maybe YOU think that.

>
> What is the non-circular reason why Ȟ cannot answer correctly?

because the Halting Question is not computable.

>
> A circular reason is that Ȟ cannot answer correctly
> because a halt decider does not exist and a halt
> decider does not exist because Ȟ cannot answer correctly.

No, a Halt Decider can not exist because the problem turns out to be
non-computable.

>
> *Do you have a better answer than this*
> Ȟ cannot return a value consistent with the behavior of
> itself because Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ is self-contradictory for Ȟ.

You continue to get your terms mixed up. And I think are even misusing
your nomeclature again.

In Linz proof. H^ is not "Contradictory", but H-Contradictory, and it
can be that, because H has to be defined first.

You confuse yourself by being sloppy with your nomenclature, and perhaps
this is accentuated by the fact that you don't understand proof by
contradiction.

The whole proof is condition on an initial assumption, If an H exists
that meets the requirements, then the following will happen.

The fact that it is impossible for an H^ to exist that does what H
predicts shows that this assumption is false, and thus, no H can exist.

>
> *If you disagree then this disagreement is either a despicable*
> *lie or you have alternative sound reasoning why Ȟ cannot*
> *answer correctly*
>

Halt Deciding is impossible to do in the general case, because the
decider needs to be able to handle EVERY case, even cases where the
input can be specially crafted based on the design of that decider.

It sort of like trying to play poker, where there is a TV screen behind
you behind you showing what cards you have.

On 2/24/2024 8:36 PM, Richard Damon wrote:
> On 2/24/24 8:27 PM, olcott wrote:

>> *If you disagree then this disagreement is either a despicable*
>> *lie or you have alternative sound reasoning why Ȟ cannot*
>> *answer correctly*
>>
>
> Halt Deciding is impossible to do in the general case, because the
> decider needs to be able to handle EVERY case, even cases where the
> input can be specially crafted based on the design of that decider.
>

What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
causes none of the infinite set of implementations of Ȟ
to derive an answer consistent with the behavior of Ȟ?

*That halting cannot be computed because halting is not*
*computable and every other isomorphic answer is rejected*
*in advance as circular*

--
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/24/24 10:14 PM, olcott wrote:
> On 2/24/2024 8:36 PM, Richard Damon wrote:
>> On 2/24/24 8:27 PM, olcott wrote:
>
>>> *If you disagree then this disagreement is either a despicable*
>>> *lie or you have alternative sound reasoning why Ȟ cannot*
>>> *answer correctly*
>>>
>>
>> Halt Deciding is impossible to do in the general case, because the
>> decider needs to be able to handle EVERY case, even cases where the
>> input can be specially crafted based on the design of that decider.
>>
>
> What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
> causes none of the infinite set of implementations of Ȟ
> to derive an answer consistent with the behavior of Ȟ?
>
> *That halting cannot be computed because halting is not*
> *computable and every other isomorphic answer is rejected*
> *in advance as circular*
>

Great.

YOU NOW AGREE THAT HALTING IS NON-COMPUTABLE.

That is EXACTLY the result of the Halting Theorem.

What took you so long to get that answer.

Note, being Non-computable doesn't mean it is an invalid question.

Wanting to know if a computation will halt is a valuable peace of
information.

I presume that means that you also are now accepting all the related
things like most formal logic system are incomplete, becuase there
exists True Statments in them that are not Provable.

(one proof of that follows from the Halting Theorem).

It also means that a computable Truth Predicate can not exist, as such a
thing could be a Halt Decider, which you just admitted can't exist.

I wonder if you reaize what you just admitted, or are you going to pull
at Trump and say that isn't what you were saying.

On 2/24/2024 9:20 PM, Richard Damon wrote:
> On 2/24/24 10:14 PM, olcott wrote:
>> On 2/24/2024 8:36 PM, Richard Damon wrote:
>>> On 2/24/24 8:27 PM, olcott wrote:
>>
>>>> *If you disagree then this disagreement is either a despicable*
>>>> *lie or you have alternative sound reasoning why Ȟ cannot*
>>>> *answer correctly*
>>>>
>>>
>>> Halt Deciding is impossible to do in the general case, because the
>>> decider needs to be able to handle EVERY case, even cases where the
>>> input can be specially crafted based on the design of that decider.
>>>
>>
>> What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
>> causes none of the infinite set of implementations of Ȟ
>> to derive an answer consistent with the behavior of Ȟ?
>>
>> *That halting cannot be computed because halting is not*
>> *computable and every other isomorphic answer is rejected*
>> *in advance as circular*
>>
>
> Great.
>
>
> YOU NOW AGREE THAT HALTING IS NON-COMPUTABLE.

*SO THAT YOUR ADD CAN PAY ATTENTION*
*SO THAT YOUR ADD CAN PAY ATTENTION*
*SO THAT YOUR ADD CAN PAY ATTENTION*

What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
causes none of the infinite set of implementations of Ȟ
to derive an answer consistent with the behavior of Ȟ?

What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
causes none of the infinite set of implementations of Ȟ
to derive an answer consistent with the behavior of Ȟ?

What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
causes none of the infinite set of implementations of Ȟ
to derive an answer consistent with the behavior of Ȟ?

What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
causes none of the infinite set of implementations of Ȟ
to derive an answer consistent with the behavior of Ȟ?

What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
causes none of the infinite set of implementations of Ȟ
to derive an answer consistent with the behavior of Ȟ?

What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
causes none of the infinite set of implementations of Ȟ
to derive an answer consistent with the behavior of Ȟ?

What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
causes none of the infinite set of implementations of Ȟ
to derive an answer consistent with the behavior of Ȟ?

--
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/24/24 10:27 PM, olcott wrote:
> On 2/24/2024 9:20 PM, Richard Damon wrote:
>> On 2/24/24 10:14 PM, olcott wrote:
>>> On 2/24/2024 8:36 PM, Richard Damon wrote:
>>>> On 2/24/24 8:27 PM, olcott wrote:
>>>
>>>>> *If you disagree then this disagreement is either a despicable*
>>>>> *lie or you have alternative sound reasoning why Ȟ cannot*
>>>>> *answer correctly*
>>>>>
>>>>
>>>> Halt Deciding is impossible to do in the general case, because the
>>>> decider needs to be able to handle EVERY case, even cases where the
>>>> input can be specially crafted based on the design of that decider.
>>>>
>>>
>>> What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
>>> causes none of the infinite set of implementations of Ȟ
>>> to derive an answer consistent with the behavior of Ȟ?
>>>
>>> *That halting cannot be computed because halting is not*
>>> *computable and every other isomorphic answer is rejected*
>>> *in advance as circular*
>>>
>>
>> Great.
>>
>>
>> YOU NOW AGREE THAT HALTING IS NON-COMPUTABLE.
>
> *SO THAT YOUR ADD CAN PAY ATTENTION*
> *SO THAT YOUR ADD CAN PAY ATTENTION*
> *SO THAT YOUR ADD CAN PAY ATTENTION*
>
> What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
> causes none of the infinite set of implementations of Ȟ
> to derive an answer consistent with the behavior of Ȟ?
>
> What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
> causes none of the infinite set of implementations of Ȟ
> to derive an answer consistent with the behavior of Ȟ?
>
> What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
> causes none of the infinite set of implementations of Ȟ
> to derive an answer consistent with the behavior of Ȟ?
>
> What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
> causes none of the infinite set of implementations of Ȟ
> to derive an answer consistent with the behavior of Ȟ?
>
> What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
> causes none of the infinite set of implementations of Ȟ
> to derive an answer consistent with the behavior of Ȟ?
>
> What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
> causes none of the infinite set of implementations of Ȟ
> to derive an answer consistent with the behavior of Ȟ?
>
> What is it specifically about Ȟ applied to ⟨Ȟ⟩ ⟨Ȟ⟩ that
> causes none of the infinite set of implementations of Ȟ
> to derive an answer consistent with the behavior of Ȟ?
>

Why do you need to know?

You sound like a 2 year old.

You have admitted that we can't build an acual Halt Decider.

Why do you need to know why a particular one failed?

On 25/02/24 02:27, olcott wrote:
> On 2/24/2024 6:49 PM, Richard Damon wrote:
>> On 2/24/24 5:32 PM, olcott wrote:
>>> On 2/24/2024 3:58 PM, Richard Damon wrote:
>>>> On 2/24/24 4:46 PM, olcott wrote:
>>>>> On 2/24/2024 3:34 PM, Richard Damon wrote:
>>>>>> On 2/24/24 4:27 PM, olcott wrote:
>>>>>>> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> When a computation only stops running because its simulation was
>>>>>>>>>>> aborted this counts as a computation that never halts.
>>>>>>>>>> Me: Every computation that halts, for whatever reason, is a
>>>>>>>>>> halting
>>>>>>>>>>       computation.
>>>>>>>>>> You: OK
>>>>>>>>>
>>>>>>>>> A computation having its simulation aborted never halts even
>>>>>>>>> though it
>>>>>>>>> stops running. Only computation that stop running without
>>>>>>>>> having their
>>>>>>>>> simulation aborted are halting computations.
>>>>>>>>
>>>>>>>> P(P) halts.  Stop trying to hide that fact in waffle.
>>>>>>>
>>>>>>> "This sentence is not true. Is indeed not true, yet the fact
>>>>>>> that its assertion is satisfied does not make the sentence
>>>>>>> true. This seems over your head.
>>>>>>>
>>>>>>> The fact that Ȟ either halts or fails to halt
>>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>>>>>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn     // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>>
>>>>>> Except that Ȟ WILL either Halt or not based on what TURING MACHINE
>>>>>> you make H to be.
>>>>>>
>>>>>
>>>>> And "This sentence is not true." is indeed not true
>>>>> yet you cannot understand how that does not make it true.
>>>>
>>>> And a meaningless red herring since we are talking about program
>>>> behavior.
>>>>
>>>>>
>>>>> When one is under the naive impression that when-so-ever
>>>>> the assertion of a statement is satisfied then that always
>>>>> makes the expression true, they get these things incorrectly.
>>>>>
>>>>> "This sentence is not true." is indeed not true thus
>>>>> fully satisfying the assertion made by LP, yet this
>>>>> still does not make the LP true.
>>>>>
>>>>> The fact that Ȟ halts or fails to halt is isomorphic
>>>>> to the Liar Paradox actually being untrue. Even though
>>>>> the Liar Paradox is actually untrue it remains neither
>>>>> true nor false.
>>>>>
>>>>>
>>>>
>>>> Nope. Since to even ask the question about Ȟ, we first needed to
>>>> define it, which mean we first needed to define which H we are using.
>>>>
>>>> Thus Ȟ (Ȟ) is a specific computation with a specific behavior and
>>>> thus the specific question has an exact right answer.
>>>
>>> Objective and Subjective Specifications
>>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>
>> And our specification is OBJECTIVE
>>
>
> The specification <is> Not Hehner(objective)

Hehner agrees that the Turing machine halting problem is an objective
specification.

On 2/25/2024 7:58 AM, immibis wrote:
> On 25/02/24 02:27, olcott wrote:
>> On 2/24/2024 6:49 PM, Richard Damon wrote:
>>> On 2/24/24 5:32 PM, olcott wrote:
>>>> On 2/24/2024 3:58 PM, Richard Damon wrote:
>>>>> On 2/24/24 4:46 PM, olcott wrote:
>>>>>> On 2/24/2024 3:34 PM, Richard Damon wrote:
>>>>>>> On 2/24/24 4:27 PM, olcott wrote:
>>>>>>>> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> When a computation only stops running because its simulation
>>>>>>>>>>>> was
>>>>>>>>>>>> aborted this counts as a computation that never halts.
>>>>>>>>>>> Me: Every computation that halts, for whatever reason, is a
>>>>>>>>>>> halting
>>>>>>>>>>>       computation.
>>>>>>>>>>> You: OK
>>>>>>>>>>
>>>>>>>>>> A computation having its simulation aborted never halts even
>>>>>>>>>> though it
>>>>>>>>>> stops running. Only computation that stop running without
>>>>>>>>>> having their
>>>>>>>>>> simulation aborted are halting computations.
>>>>>>>>>
>>>>>>>>> P(P) halts.  Stop trying to hide that fact in waffle.
>>>>>>>>
>>>>>>>> "This sentence is not true. Is indeed not true, yet the fact
>>>>>>>> that its assertion is satisfied does not make the sentence
>>>>>>>> true. This seems over your head.
>>>>>>>>
>>>>>>>> The fact that Ȟ either halts or fails to halt
>>>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>>>>>>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn     // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>>>
>>>>>>> Except that Ȟ WILL either Halt or not based on what TURING
>>>>>>> MACHINE you make H to be.
>>>>>>>
>>>>>>
>>>>>> And "This sentence is not true." is indeed not true
>>>>>> yet you cannot understand how that does not make it true.
>>>>>
>>>>> And a meaningless red herring since we are talking about program
>>>>> behavior.
>>>>>
>>>>>>
>>>>>> When one is under the naive impression that when-so-ever
>>>>>> the assertion of a statement is satisfied then that always
>>>>>> makes the expression true, they get these things incorrectly.
>>>>>>
>>>>>> "This sentence is not true." is indeed not true thus
>>>>>> fully satisfying the assertion made by LP, yet this
>>>>>> still does not make the LP true.
>>>>>>
>>>>>> The fact that Ȟ halts or fails to halt is isomorphic
>>>>>> to the Liar Paradox actually being untrue. Even though
>>>>>> the Liar Paradox is actually untrue it remains neither
>>>>>> true nor false.
>>>>>>
>>>>>>
>>>>>
>>>>> Nope. Since to even ask the question about Ȟ, we first needed to
>>>>> define it, which mean we first needed to define which H we are using.
>>>>>
>>>>> Thus Ȟ (Ȟ) is a specific computation with a specific behavior and
>>>>> thus the specific question has an exact right answer.
>>>>
>>>> Objective and Subjective Specifications
>>>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>>
>>> And our specification is OBJECTIVE
>>>
>>
>> The specification <is> Not Hehner(objective)
>
> Hehner agrees that the Turing machine halting problem is an objective
> specification.

*He does not*
A specification is subjective if the specified behavior
varies depending on the agent that performs it. (Hehner:2017)

Objective and Subjective Specifications
https://www.cs.toronto.edu/~hehner/OSS.pdf

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

On 2/25/24 11:30 AM, olcott wrote:
> On 2/25/2024 7:58 AM, immibis wrote:
>> On 25/02/24 02:27, olcott wrote:
>>> On 2/24/2024 6:49 PM, Richard Damon wrote:
>>>> On 2/24/24 5:32 PM, olcott wrote:
>>>>> On 2/24/2024 3:58 PM, Richard Damon wrote:
>>>>>> On 2/24/24 4:46 PM, olcott wrote:
>>>>>>> On 2/24/2024 3:34 PM, Richard Damon wrote:
>>>>>>>> On 2/24/24 4:27 PM, olcott wrote:
>>>>>>>>> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> When a computation only stops running because its
>>>>>>>>>>>>> simulation was
>>>>>>>>>>>>> aborted this counts as a computation that never halts.
>>>>>>>>>>>> Me: Every computation that halts, for whatever reason, is a
>>>>>>>>>>>> halting
>>>>>>>>>>>>       computation.
>>>>>>>>>>>> You: OK
>>>>>>>>>>>
>>>>>>>>>>> A computation having its simulation aborted never halts even
>>>>>>>>>>> though it
>>>>>>>>>>> stops running. Only computation that stop running without
>>>>>>>>>>> having their
>>>>>>>>>>> simulation aborted are halting computations.
>>>>>>>>>>
>>>>>>>>>> P(P) halts.  Stop trying to hide that fact in waffle.
>>>>>>>>>
>>>>>>>>> "This sentence is not true. Is indeed not true, yet the fact
>>>>>>>>> that its assertion is satisfied does not make the sentence
>>>>>>>>> true. This seems over your head.
>>>>>>>>>
>>>>>>>>> The fact that Ȟ either halts or fails to halt
>>>>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>>>>>>>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn     // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>>>>
>>>>>>>> Except that Ȟ WILL either Halt or not based on what TURING
>>>>>>>> MACHINE you make H to be.
>>>>>>>>
>>>>>>>
>>>>>>> And "This sentence is not true." is indeed not true
>>>>>>> yet you cannot understand how that does not make it true.
>>>>>>
>>>>>> And a meaningless red herring since we are talking about program
>>>>>> behavior.
>>>>>>
>>>>>>>
>>>>>>> When one is under the naive impression that when-so-ever
>>>>>>> the assertion of a statement is satisfied then that always
>>>>>>> makes the expression true, they get these things incorrectly.
>>>>>>>
>>>>>>> "This sentence is not true." is indeed not true thus
>>>>>>> fully satisfying the assertion made by LP, yet this
>>>>>>> still does not make the LP true.
>>>>>>>
>>>>>>> The fact that Ȟ halts or fails to halt is isomorphic
>>>>>>> to the Liar Paradox actually being untrue. Even though
>>>>>>> the Liar Paradox is actually untrue it remains neither
>>>>>>> true nor false.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Nope. Since to even ask the question about Ȟ, we first needed to
>>>>>> define it, which mean we first needed to define which H we are using.
>>>>>>
>>>>>> Thus Ȟ (Ȟ) is a specific computation with a specific behavior and
>>>>>> thus the specific question has an exact right answer.
>>>>>
>>>>> Objective and Subjective Specifications
>>>>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>>>
>>>> And our specification is OBJECTIVE
>>>>
>>>
>>> The specification <is> Not Hehner(objective)
>>
>> Hehner agrees that the Turing machine halting problem is an objective
>> specification.
>
> *He does not*
>    A specification is subjective if the specified behavior
>    varies depending on the agent that performs it. (Hehner:2017)
>
> Objective and Subjective Specifications
> https://www.cs.toronto.edu/~hehner/OSS.pdf
>

And what about the "Behavior of the specific compuation described by the
input" is depending on the agent looking at it?

Remember, The Computation is built on a Turing Machine appied to a tape,
and the Turing Machine has a SPECIFIC set of steps encoded in it.

The machine Ȟ is defined on a SPECIFIC H, independent on what H you are
giving it to, and thus independent of which H you give it to.

Your STRAWMAN where Ȟ isn't an actual Computation, but just a template
that changes based on who it is gien to, isn't a valid target of the
Halting Question. IT needs to be connected to a SPECIFIC H, at which
point it is, and that result can be given to ANY prospective Halt Decider.

Note, your x86UTM example, by your own words, can't do that, so is
proved to not be a Turing Machine Equivalent system.

On 25/02/24 17:30, olcott wrote:
> On 2/25/2024 7:58 AM, immibis wrote:
>> On 25/02/24 02:27, olcott wrote:
>>> On 2/24/2024 6:49 PM, Richard Damon wrote:
>>>> On 2/24/24 5:32 PM, olcott wrote:
>>>>> On 2/24/2024 3:58 PM, Richard Damon wrote:
>>>>>> On 2/24/24 4:46 PM, olcott wrote:
>>>>>>> On 2/24/2024 3:34 PM, Richard Damon wrote:
>>>>>>>> On 2/24/24 4:27 PM, olcott wrote:
>>>>>>>>> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> When a computation only stops running because its
>>>>>>>>>>>>> simulation was
>>>>>>>>>>>>> aborted this counts as a computation that never halts.
>>>>>>>>>>>> Me: Every computation that halts, for whatever reason, is a
>>>>>>>>>>>> halting
>>>>>>>>>>>>       computation.
>>>>>>>>>>>> You: OK
>>>>>>>>>>>
>>>>>>>>>>> A computation having its simulation aborted never halts even
>>>>>>>>>>> though it
>>>>>>>>>>> stops running. Only computation that stop running without
>>>>>>>>>>> having their
>>>>>>>>>>> simulation aborted are halting computations.
>>>>>>>>>>
>>>>>>>>>> P(P) halts.  Stop trying to hide that fact in waffle.
>>>>>>>>>
>>>>>>>>> "This sentence is not true. Is indeed not true, yet the fact
>>>>>>>>> that its assertion is satisfied does not make the sentence
>>>>>>>>> true. This seems over your head.
>>>>>>>>>
>>>>>>>>> The fact that Ȟ either halts or fails to halt
>>>>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>>>>>>>> H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn     // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>>>>
>>>>>>>> Except that Ȟ WILL either Halt or not based on what TURING
>>>>>>>> MACHINE you make H to be.
>>>>>>>>
>>>>>>>
>>>>>>> And "This sentence is not true." is indeed not true
>>>>>>> yet you cannot understand how that does not make it true.
>>>>>>
>>>>>> And a meaningless red herring since we are talking about program
>>>>>> behavior.
>>>>>>
>>>>>>>
>>>>>>> When one is under the naive impression that when-so-ever
>>>>>>> the assertion of a statement is satisfied then that always
>>>>>>> makes the expression true, they get these things incorrectly.
>>>>>>>
>>>>>>> "This sentence is not true." is indeed not true thus
>>>>>>> fully satisfying the assertion made by LP, yet this
>>>>>>> still does not make the LP true.
>>>>>>>
>>>>>>> The fact that Ȟ halts or fails to halt is isomorphic
>>>>>>> to the Liar Paradox actually being untrue. Even though
>>>>>>> the Liar Paradox is actually untrue it remains neither
>>>>>>> true nor false.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Nope. Since to even ask the question about Ȟ, we first needed to
>>>>>> define it, which mean we first needed to define which H we are using.
>>>>>>
>>>>>> Thus Ȟ (Ȟ) is a specific computation with a specific behavior and
>>>>>> thus the specific question has an exact right answer.
>>>>>
>>>>> Objective and Subjective Specifications
>>>>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>>>
>>>> And our specification is OBJECTIVE
>>>>
>>>
>>> The specification <is> Not Hehner(objective)
>>
>> Hehner agrees that the Turing machine halting problem is an objective
>> specification.
>
> *He does not*
>    A specification is subjective if the specified behavior
>    varies depending on the agent that performs it. (Hehner:2017)

I asked him. He agrees that the Turing machine halting problem is an
objective specification. His papers are only talking about other similar
problems which might be subjective.

On 24/02/24 22:27, olcott wrote:
> On 7/20/2021 7:28 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 7/19/2021 7:35 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> When a computation only stops running because its simulation was
>>>>> aborted this counts as a computation that never halts.
>>>> Me: Every computation that halts, for whatever reason, is a halting
>>>>       computation.
>>>> You: OK
>>>
>>> A computation having its simulation aborted never halts even though it
>>> stops running. Only computation that stop running without having their
>>> simulation aborted are halting computations.
>>
>> P(P) halts.  Stop trying to hide that fact in waffle.
>
> "This sentence is not true. Is indeed not true, yet the fact
> that its assertion is satisfied does not make the sentence
> true. This seems over your head.

Wrong. A sentence whose assertion is satisfied is true. That is what
"true" means. It is like saying that 1+1 does not equal 2.