Mr Flibble wrote:
> On Fri, 16 Jul 2021 15:27:53 +0100
> Peter <peterxpercival@hotmail.com> wrote:
>
>> Mr Flibble wrote:
>>> Hi!
>>>
>>> All extant halting problem proofs appear to be predicated on a
>>
>> Since you haven't read them all, you are in no position to make such
>> a claim.
>
> Whether or not I am in a position to make such a claim has no bearing
> on whether the claim is true or false. Feel free to refute my claim,
> dear.
>
> /Flibble
>
>
Ahem... the onus is on you to prove your--utterly implausible--claim.

--
The world will little note, nor long remember what we say here
Abraham Lincoln at Gettysburg

olcott wrote:
> On 7/16/2021 9:36 AM, Mr Flibble wrote:
>> On Fri, 16 Jul 2021 15:27:53 +0100
>> Peter <peterxpercival@hotmail.com> wrote:
>>
>>> Mr Flibble wrote:
>>>> Hi!
>>>>
>>>> All extant halting problem proofs appear to be predicated on a
>>>
>>> Since you haven't read them all, you are in no position to make such
>>> a claim.
>>
>> Whether or not I am in a position to make such a claim has no bearing
>> on whether the claim is true or false.  Feel free to refute my claim,
>> dear.
>>
>> /Flibble
>>
>>
>
> On Saturday, July 10, 2021 at 12:00:56 PM UTC-5, Mr Flibble wrote:
> > I agree with Olcott that a halt decider can NOT be part of that which
>  > is being decided (see [Strachey 1965]) which, if Olcott is correct,
>  > falsifies a collection of proofs (which I don't have the time to
>  > examine) which rely on that mistake.
>  >
>  > /Flibble
>
> Our claim is that the refutation applies to all cases where the behavior
> of the halt decider is a part of that which is being decided. I named
> this the Pathological self-reference error in 2004.
>
> Now the ball is in Percival's court to dig up some very obscure paper

Why do you want an obscure paper? Surely a well-known textbook would be
more convenient, and a reference to a well-known textbook is what I
recently gave.

> that does not depend on the PSR error. The last time that he did this he
> referenced a paper that uses Gödel numbers to hide the PSR error behind
> 75 pages of nested formulas.
>
> Sipser, Linz and Kozen proofs as well as all the informal pseudo-code
> proofs utterly depend on the PSR error as their only basis.
>

--
The world will little note, nor long remember what we say here
Abraham Lincoln at Gettysburg

olcott wrote:
> On 7/16/2021 9:27 AM, Peter wrote:
>> Mr Flibble wrote:
>>> Hi!
>>>
>>> All extant halting problem proofs appear to be predicated on a
>>
>> Since you haven't read them all, you are in no position to make such a
>> claim.
>>
>
> He is objecting to all the proofs

And what about the other proofs? I recently referred to one.

> having the pathological
> self-reference(Olcott 2004) error where the input D does the opposite of
> whatever the halt decider H decides. **
>
> This includes all the informal pseudo-code proofs, Sipser, Kozen and
> Linz. I am not aware of any proofs that it excludes.
>
> ** Now we construct a new Turing machine D with H as a subroutine. This
> new TM calls H to determine what M does when the input to M is its own
> description ⟨M⟩. Once D has determined this information, it does the
> opposite. http://www.liarparadox.org/Sipser_165_167.pdf
>
>
>>> misunderstanding of the following contradiction:
>>>
>>>     Suppose T[R] is a Boolean function taking a routine
>>>     (or program) R with no formal or free variables as its
>>>     argument and that for all R, T[R] — True if R terminates
>>>     if run and that T[R] = False if R does not terminate. Consider
>>>     the routine P defined as follows
>>>
>>>         rec routine P
>>>             §L :if T[P] goto L
>>>         Return §
>>>
>>>     If T[P] = True the routine P will loop, and it will
>>>     only terminate if T[P] = False. In each case T[P] has
>>>     exactly the wrong value, and this contradiction shows
>>>     that the function T cannot exist.
>>>
>>>     [Strachey 1965]
>>>
>>> T is indeed unable to decide P but for the wrong reason: T[P] is
>>> recursive which means T can never decide if P halts because T never
>>> halts itself; this mistake appears to have been missed by Strachey as
>>> the §L <- L loop can't ever loop due to the recursion.
>>>
>>> HOWEVER
>>>
>>> Even if we ignore the error of recursion it does NOT follow that for
>>> T[Q], T cannot decide if Q halts where Q is a program that does not
>>> reference T.
>>>
>>> [Strachey 1965] shows us that a decider cannot be part of or called by
>>> that which is being decided (a pathological program) and given this it
>>> seems to be unproven that a decider for programs that don't exhibit
>>> this pathology cannot exist.
>>>
>>> /Flibble
>>>
>>>
>>
>>
>
>

--
The world will little note, nor long remember what we say here
Abraham Lincoln at Gettysburg

On 7/16/2021 4:07 PM, Peter wrote:
> Mr Flibble wrote:
>> On Fri, 16 Jul 2021 15:27:53 +0100
>> Peter <peterxpercival@hotmail.com> wrote:
>>
>>> Mr Flibble wrote:
>>>> Hi!
>>>>
>>>> All extant halting problem proofs appear to be predicated on a
>>>
>>> Since you haven't read them all, you are in no position to make such
>>> a claim.
>>
>> Whether or not I am in a position to make such a claim has no bearing
>> on whether the claim is true or false.  Feel free to refute my claim,
>> dear.
>>
>> /Flibble
>>
>>
> Ahem... the onus is on you to prove your--utterly implausible--claim.
>

He has already proved that any requirement for a program/TM to return a
halt status value to an input to does the opposite of whatever the halt
decider returns is bogus. The meaning of these words proves that such a
case has the exactly same bogus pattern as the liar paradox.

Generically this can be understood as the scientific principle that the
dependent variable of a scientific investigation is not allowed to
interfere with the independent variable.

When P interferes with H this scientific principle is violated. Flibble
spotted this error and thus has a correct basis for his claim.

On Saturday, July 10, 2021 at 12:00:56 PM UTC-5, Mr Flibble wrote:
> I agree with Olcott that a halt decider can NOT be part of that which
> is being decided (see [Strachey 1965]) which, if Olcott is correct,
> falsifies a collection of proofs (which I don't have the time to
> examine) which rely on that mistake.
>
> /Flibble

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

olcott wrote:
> On 7/16/2021 4:07 PM, Peter wrote:
>> Mr Flibble wrote:
>>> On Fri, 16 Jul 2021 15:27:53 +0100
>>> Peter <peterxpercival@hotmail.com> wrote:
>>>
>>>> Mr Flibble wrote:
>>>>> Hi!
>>>>>
>>>>> All extant halting problem proofs appear to be predicated on a
>>>>
>>>> Since you haven't read them all, you are in no position to make such
>>>> a claim.
>>>
>>> Whether or not I am in a position to make such a claim has no bearing
>>> on whether the claim is true or false.  Feel free to refute my claim,
>>> dear.
>>>
>>> /Flibble
>>>
>>>
>> Ahem... the onus is on you to prove your--utterly implausible--claim.
>>
>
> He has already proved that any requirement for a program/TM to return a

The claim that I was referring to is that he is in a position to comment
on _all_ halting problem proofs.

> halt status value to an input to does the opposite of whatever the halt
> decider returns is bogus. The meaning of these words proves that such a
> case has the exactly same bogus pattern as the liar paradox.
>
> Generically this can be understood as the scientific principle that the
> dependent variable of a scientific investigation is not allowed to
> interfere with the independent variable.
>
> When P interferes with H this scientific principle is violated. Flibble
> spotted this error and thus has a correct basis for his claim.
>
> On Saturday, July 10, 2021 at 12:00:56 PM UTC-5, Mr Flibble wrote:
>  > I agree with Olcott that a halt decider can NOT be part of that which
>  > is being decided (see [Strachey 1965]) which, if Olcott is correct,
>  > falsifies a collection of proofs (which I don't have the time to
>  > examine) which rely on that mistake.
>  >
>  > /Flibble
>

--
The world will little note, nor long remember what we say here
Abraham Lincoln at Gettysburg

On 7/16/2021 4:25 PM, Peter wrote:
> olcott wrote:
>> On 7/16/2021 4:07 PM, Peter wrote:
>>> Mr Flibble wrote:
>>>> On Fri, 16 Jul 2021 15:27:53 +0100
>>>> Peter <peterxpercival@hotmail.com> wrote:
>>>>
>>>>> Mr Flibble wrote:
>>>>>> Hi!
>>>>>>
>>>>>> All extant halting problem proofs appear to be predicated on a
>>>>>
>>>>> Since you haven't read them all, you are in no position to make such
>>>>> a claim.
>>>>
>>>> Whether or not I am in a position to make such a claim has no bearing
>>>> on whether the claim is true or false.  Feel free to refute my claim,
>>>> dear.
>>>>
>>>> /Flibble
>>>>
>>>>
>>> Ahem... the onus is on you to prove your--utterly implausible--claim.
>>>
>>
>> He has already proved that any requirement for a program/TM to return a
>
> The claim that I was referring to is that he is in a position to comment
> on _all_ halting problem proofs.
>

Apparently all the other proofs are mutually reducible to/form the
refuted ones.

>> halt status value to an input to does the opposite of whatever the
>> halt decider returns is bogus. The meaning of these words proves that
>> such a case has the exactly same bogus pattern as the liar paradox.
>>
>> Generically this can be understood as the scientific principle that
>> the dependent variable of a scientific investigation is not allowed to
>> interfere with the independent variable.
>>
>> When P interferes with H this scientific principle is violated.
>> Flibble spotted this error and thus has a correct basis for his claim.
>>
>> On Saturday, July 10, 2021 at 12:00:56 PM UTC-5, Mr Flibble wrote:
>>   > I agree with Olcott that a halt decider can NOT be part of that which
>>   > is being decided (see [Strachey 1965]) which, if Olcott is correct,
>>   > falsifies a collection of proofs (which I don't have the time to
>>   > examine) which rely on that mistake.
>>   >
>>   > /Flibble
>>
>
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

olcott <NoOne@NoWhere.com> writes:

> On 7/16/2021 8:34 AM, Ben Bacarisse wrote:
>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>
>>> All extant halting problem proofs appear to be predicated on a
>>> misunderstanding of the following contradiction:
>> I don't think you've read any actual proofs, let along all of them. Why
>> you would even say such a thing?
>>
>>> Suppose T[R] is a Boolean function taking a routine
>>> (or program) R with no formal or free variables as its
>>> argument and that for all R, T[R] — True if R terminates
>>> if run and that T[R] = False if R does not terminate. Consider
>>> the routine P defined as follows
>>>
>>> rec routine P
>>> §L :if T[P] goto L
>>> Return §
>>>
>>> If T[P] = True the routine P will loop, and it will
>>> only terminate if T[P] = False. In each case T[P] has
>>> exactly the wrong value, and this contradiction shows
>>> that the function T cannot exist.
>>>
>>> [Strachey 1965]
>>>
>>> T is indeed unable to decide P but for the wrong reason: T[P] is
>>> recursive
>> T[P] is not recursive. Maybe you don't understand what the CPL means?
>> Further, this argument must fail for any of the actual proofs that are
>> based on Turing machine because TMs have not functions, not calls and no
>> recursion.
>>
> Peter Linz Ĥ applied to the Turing machine description of itself: ⟨Ĥ⟩
>
> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
> if M applied to wM halts, and
>
> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
> if M applied to wM does not halt

Why did you not show what you said you'd show? Were afraid that the
contradiction would be too clear if really did apply Ĥ to ⟨Ĥ⟩? What you
get is this:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩⊢* Ĥ.qy ∞
if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt

!!!

The first two lines say that "Ĥ applied ⟨Ĥ⟩ does not halt if Ĥ applied
to ⟨Ĥ⟩ halts". The second two say "Ĥ applied ⟨Ĥ⟩ halts if Ĥ applied to
⟨Ĥ⟩ does not halt".

> When we hypothesize that the halt decider embedded in Ĥ is simply a
> UTM then it seems that when the Peter Linz Ĥ is applied to its own
> Turing machine description ⟨Ĥ⟩ this specifies a computation that never
> halts.

Then you enter a fantasy world because a UTM is can't be a halt decider.
But that's not really what you mean. Don't call it "the Peter Linz Ĥ"
with "the halt decider embedded in Ĥ ... a UTM". Call it what it is --
the Linz "hat" construction applied to a UTM. There's a simple notation
for that: UTM^.

The fact that UTM^([UTM^]) is a computation that never halts is
obvious. You don't need to keep going over stuff that is not in
dispute.

> Within the hypothesis that the internal halt decider embedded within Ĥ
> simulates its input Ĥ applied to its own Turing machine description
> ⟨Ĥ⟩ derives infinitely nested simulation, unless this simulation is
> aborted.

This no parse.

> Self-Evident-Truth (premise[1])
> When the pure simulation of a machine on its input never halts we know
> that the execution of this machine on its input never halts.

Again, never in doubt. A computation and the simulation of a
computation have the same halting status. But this is just window
dressing to prime the pump for your garbled "adapted" definition of
halting.

> Self-Evident-Truth (premise[2])
> The ⟨Ĥ⟩ ⟨Ĥ⟩ input to the embedded simulating halt decider at Ĥ.qx is
> pure simulation that never halts.

Not according to you. Your H (not Linz's non-existent H) is not a pure
simulator.

> ∴ Sound Deductive Conclusion
> The embedded simulating halt decider at Ĥ.qx correctly decides its
> input: ⟨Ĥ⟩ ⟨Ĥ⟩ is a computation that never halts.

We know, from before you realised that being clear was a mistake, that
you claim to have a TM (equivalent), H that rejects <[H^],[H^]> despite
the fact that H^([H^]) is a finite (halting) computation. Your desire
to reference Linz means I must assume you know that this is the wrong
answer. H is not a halt decider because is gets at least this one case
wrong.

> Ĥ.q0 ⟨Ĥ⟩ specifies an infinite chain of invocations that is terminated
> at its third invocation.

Apparently so, but you are keeping H hidden, just in case. The
statement here, along a previous confirmation and an explicit trace you
once mistakenly provided, all go to show that you know that H^([H^]) is
a finite computation. If you still want to be talking about the halting
problem, that means that H should accept the string <[H^],[H^]>. But
you tell is it does not.

17 years and you have nothing but a TM that is wrong. No doubt if I say
that you yourself are telling us it's wrong you'll call me a liar, but
with all these quotes of Linz, and so many references to the accepting
and rejecting states, how could you not know that H should accept
strings that denote halting computations are reject the others? It's
the very corner stone of what you claim to have been "working" on for 17
years.

--
Ben.

Mr Flibble <flibble@reddwarf.jmc> writes:

> On Fri, 16 Jul 2021 15:40:27 +0100
> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>
>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>
>> > On Fri, 16 Jul 2021 14:34:54 +0100
>> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>> >
>> >> Mr Flibble <flibble@reddwarf.jmc> writes:
>> >>
>> >> > All extant halting problem proofs appear to be predicated on a
>> >> > misunderstanding of the following contradiction:
>> >>
>> >> I don't think you've read any actual proofs, let along all of them.
>> >> Why you would even say such a thing?
>> >>
>> >> > Suppose T[R] is a Boolean function taking a routine
>> >> > (or program) R with no formal or free variables as its
>> >> > argument and that for all R, T[R] — True if R terminates
>> >> > if run and that T[R] = False if R does not terminate.
>> >> > Consider the routine P defined as follows
>> >> >
>> >> > rec routine P
>> >> > §L :if T[P] goto L
>> >> > Return §
>> >> >
>> >> > If T[P] = True the routine P will loop, and it will
>> >> > only terminate if T[P] = False. In each case T[P] has
>> >> > exactly the wrong value, and this contradiction shows
>> >> > that the function T cannot exist.
>> >> >
>> >> > [Strachey 1965]
>> >> >
>> >> > T is indeed unable to decide P but for the wrong reason: T[P] is
>> >> > recursive
>> >>
>> >> T[P] is not recursive. Maybe you don't understand what the CPL
>> >> means?
>> >
>> > Of course it is recursive, such is obvious even to the casual reader
>> > who is unfamiliar with the CPL language (a clue: read the paragraph
>> > before the definition of P again).
>>
>> No. T[P] /might/ be recursive, but then again it might not be. Any
>> argument based on the blank assumption that T[P] is recursive is
>> flawed. T must be permitted to make it decision based on the widest
>> possible use of it's argument or the sketch is pointlessly
>> restrictive.
>
> No. It is recursive.

I suppose if anyone else is reading this, they will just have to pick a
side!

--
Ben.

olcott wrote:
> On 7/16/2021 4:25 PM, Peter wrote:
>> olcott wrote:
>>> On 7/16/2021 4:07 PM, Peter wrote:
>>>> Mr Flibble wrote:
>>>>> On Fri, 16 Jul 2021 15:27:53 +0100
>>>>> Peter <peterxpercival@hotmail.com> wrote:
>>>>>
>>>>>> Mr Flibble wrote:
>>>>>>> Hi!
>>>>>>>
>>>>>>> All extant halting problem proofs appear to be predicated on a
>>>>>>
>>>>>> Since you haven't read them all, you are in no position to make such
>>>>>> a claim.
>>>>>
>>>>> Whether or not I am in a position to make such a claim has no bearing
>>>>> on whether the claim is true or false.  Feel free to refute my claim,
>>>>> dear.
>>>>>
>>>>> /Flibble
>>>>>
>>>>>
>>>> Ahem... the onus is on you to prove your--utterly implausible--claim.
>>>>
>>>
>>> He has already proved that any requirement for a program/TM to return a
>>
>> The claim that I was referring to is that he is in a position to
>> comment on _all_ halting problem proofs.
>>
>
> Apparently all the other proofs are mutually reducible to/form the
> refuted ones.

Why is it apparent? To whom is it apparent?
>
>>> halt status value to an input to does the opposite of whatever the
>>> halt decider returns is bogus. The meaning of these words proves that
>>> such a case has the exactly same bogus pattern as the liar paradox.
>>>
>>> Generically this can be understood as the scientific principle that
>>> the dependent variable of a scientific investigation is not allowed
>>> to interfere with the independent variable.
>>>
>>> When P interferes with H this scientific principle is violated.
>>> Flibble spotted this error and thus has a correct basis for his claim.
>>>
>>> On Saturday, July 10, 2021 at 12:00:56 PM UTC-5, Mr Flibble wrote:
>>>   > I agree with Olcott that a halt decider can NOT be part of that
>>> which
>>>   > is being decided (see [Strachey 1965]) which, if Olcott is correct,
>>>   > falsifies a collection of proofs (which I don't have the time to
>>>   > examine) which rely on that mistake.
>>>   >
>>>   > /Flibble
>>>
>>
>>
>
>

--
The world will little note, nor long remember what we say here
Abraham Lincoln at Gettysburg

On 7/16/2021 7:03 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 7/16/2021 8:34 AM, Ben Bacarisse wrote:
>>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>>
>>>> All extant halting problem proofs appear to be predicated on a
>>>> misunderstanding of the following contradiction:
>>> I don't think you've read any actual proofs, let along all of them. Why
>>> you would even say such a thing?
>>>
>>>> Suppose T[R] is a Boolean function taking a routine
>>>> (or program) R with no formal or free variables as its
>>>> argument and that for all R, T[R] — True if R terminates
>>>> if run and that T[R] = False if R does not terminate. Consider
>>>> the routine P defined as follows
>>>>
>>>> rec routine P
>>>> §L :if T[P] goto L
>>>> Return §
>>>>
>>>> If T[P] = True the routine P will loop, and it will
>>>> only terminate if T[P] = False. In each case T[P] has
>>>> exactly the wrong value, and this contradiction shows
>>>> that the function T cannot exist.
>>>>
>>>> [Strachey 1965]
>>>>
>>>> T is indeed unable to decide P but for the wrong reason: T[P] is
>>>> recursive
>>> T[P] is not recursive. Maybe you don't understand what the CPL means?
>>> Further, this argument must fail for any of the actual proofs that are
>>> based on Turing machine because TMs have not functions, not calls and no
>>> recursion.
>>>
>> Peter Linz Ĥ applied to the Turing machine description of itself: ⟨Ĥ⟩
>>
>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
>> if M applied to wM halts, and
>>
>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
>> if M applied to wM does not halt
>
> Why did you not show what you said you'd show? Were afraid that the
> contradiction would be too clear if really did apply Ĥ to ⟨Ĥ⟩? What you
> get is this:
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩⊢* Ĥ.qy ∞
> if Ĥ applied to ⟨Ĥ⟩ halts, and
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if Ĥ applied to ⟨Ĥ⟩ does not halt
>
> !!!
>
> The first two lines say that "Ĥ applied ⟨Ĥ⟩ does not halt if Ĥ applied
> to ⟨Ĥ⟩ halts". The second two say "Ĥ applied ⟨Ĥ⟩ halts if Ĥ applied to
> ⟨Ĥ⟩ does not halt".
>
>> When we hypothesize that the halt decider embedded in Ĥ is simply a
>> UTM then it seems that when the Peter Linz Ĥ is applied to its own
>> Turing machine description ⟨Ĥ⟩ this specifies a computation that never
>> halts.
>
> Then you enter a fantasy world because a UTM is can't be a halt decider.
> But that's not really what you mean. Don't call it "the Peter Linz Ĥ"
> with "the halt decider embedded in Ĥ ... a UTM". Call it what it is --
> the Linz "hat" construction applied to a UTM. There's a simple notation
> for that: UTM^.
>
> The fact that UTM^([UTM^]) is a computation that never halts is
> obvious. You don't need to keep going over stuff that is not in
> dispute.
>
>> Within the hypothesis that the internal halt decider embedded within Ĥ
>> simulates its input Ĥ applied to its own Turing machine description
>> ⟨Ĥ⟩ derives infinitely nested simulation, unless this simulation is
>> aborted.
>
> This no parse.
>
>> Self-Evident-Truth (premise[1])
>> When the pure simulation of a machine on its input never halts we know
>> that the execution of this machine on its input never halts.
>
> Again, never in doubt. A computation and the simulation of a
> computation have the same halting status. But this is just window
> dressing to prime the pump for your garbled "adapted" definition of
> halting.
>
>> Self-Evident-Truth (premise[2])
>> The ⟨Ĥ⟩ ⟨Ĥ⟩ input to the embedded simulating halt decider at Ĥ.qx is
>> pure simulation that never halts.
>
> Not according to you. Your H (not Linz's non-existent H) is not a pure
> simulator.
>
>> ∴ Sound Deductive Conclusion
>> The embedded simulating halt decider at Ĥ.qx correctly decides its
>> input: ⟨Ĥ⟩ ⟨Ĥ⟩ is a computation that never halts.
>
> We know, from before you realised that being clear was a mistake, that
> you claim to have a TM (equivalent), H that rejects <[H^],[H^]> despite
> the fact that H^([H^]) is a finite (halting) computation. Your desire
> to reference Linz means I must assume you know that this is the wrong
> answer. H is not a halt decider because is gets at least this one case
> wrong.
>
>> Ĥ.q0 ⟨Ĥ⟩ specifies an infinite chain of invocations that is terminated
>> at its third invocation.
>
> Apparently so, but you are keeping H hidden, just in case. The
> statement here, along a previous confirmation and an explicit trace you
> once mistakenly provided, all go to show that you know that H^([H^]) is
> a finite computation. If you still want to be talking about the halting
> problem, that means that H should accept the string <[H^],[H^]>. But
> you tell is it does not.
>
> 17 years and you have nothing but a TM that is wrong. No doubt if I say
> that you yourself are telling us it's wrong you'll call me a liar, but
> with all these quotes of Linz, and so many references to the accepting
> and rejecting states, how could you not know that H should accept
> strings that denote halting computations are reject the others? It's
> the very corner stone of what you claim to have been "working" on for 17
> years.
>

I only skimmed the above, I skipped most of the words.
int main() { P(P); } is computationally equivalent to Ĥ(⟨Ĥ⟩).

The key difference is that in the latter case almost all of the details
of the definitions of the TMs must be excluded as impossible to provide.
whereas in the former case a line-by-line complete execution trace of
the halt status decision is provided.

Any honest person knowing the x86 language has no need to see the
internals of how H is defined. Simply examining the four execution
traces and the description of H provides all of the relevant details.

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 7/16/2021 7:06 PM, Ben Bacarisse wrote:
> Mr Flibble <flibble@reddwarf.jmc> writes:
>
>> On Fri, 16 Jul 2021 15:40:27 +0100
>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>
>>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>>
>>>> On Fri, 16 Jul 2021 14:34:54 +0100
>>>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>>>
>>>>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>>>>
>>>>>> All extant halting problem proofs appear to be predicated on a
>>>>>> misunderstanding of the following contradiction:
>>>>>
>>>>> I don't think you've read any actual proofs, let along all of them.
>>>>> Why you would even say such a thing?
>>>>>
>>>>>> Suppose T[R] is a Boolean function taking a routine
>>>>>> (or program) R with no formal or free variables as its
>>>>>> argument and that for all R, T[R] — True if R terminates
>>>>>> if run and that T[R] = False if R does not terminate.
>>>>>> Consider the routine P defined as follows
>>>>>>
>>>>>> rec routine P
>>>>>> §L :if T[P] goto L
>>>>>> Return §
>>>>>>
>>>>>> If T[P] = True the routine P will loop, and it will
>>>>>> only terminate if T[P] = False. In each case T[P] has
>>>>>> exactly the wrong value, and this contradiction shows
>>>>>> that the function T cannot exist.
>>>>>>
>>>>>> [Strachey 1965]
>>>>>>
>>>>>> T is indeed unable to decide P but for the wrong reason: T[P] is
>>>>>> recursive
>>>>>
>>>>> T[P] is not recursive. Maybe you don't understand what the CPL
>>>>> means?
>>>>
>>>> Of course it is recursive, such is obvious even to the casual reader
>>>> who is unfamiliar with the CPL language (a clue: read the paragraph
>>>> before the definition of P again).
>>>
>>> No. T[P] /might/ be recursive, but then again it might not be. Any
>>> argument based on the blank assumption that T[P] is recursive is
>>> flawed. T must be permitted to make it decision based on the widest
>>> possible use of it's argument or the sketch is pointlessly
>>> restrictive.
>>
>> No. It is recursive.
>
> I suppose if anyone else is reading this, they will just have to pick a
> side!
>

Pathological self-reference(Olcott 2004) is an error.
When an input is defined to do that opposite of whatever its
corresponding halt decider decides this forms the exactly same
self-contradictory error of the liar paradox.

On Sunday, September 5, 2004 at 11:21:57 AM UTC-5, Peter Olcott wrote:
The Liar Paradox can be shown to be nothing more than
a incorrectly formed statement because of its pathological
self-reference. The Halting Problem can only exist because
of this same sort of pathological self-reference.

Halt deciders can be defined that correctly decide the halt status of
these otherwise pathological inputs.

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

olcott <NoOne@NoWhere.com> writes:
....
> I only skimmed the above, I skipped most of the words.

Good plan. You really don't want to know what I said! I've cut it
since you don't care about details. Let's stick with the big picture.

> int main() { P(P); } is computationally equivalent to Ĥ(⟨Ĥ⟩).

Yes. P(P) halts (according to you). H(P,P) == 0 (according to you).
That is wrong (according to everyone but you).

--
Ben.

On 7/17/2021 8:32 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> ...
>> I only skimmed the above, I skipped most of the words.
>
> Good plan. You really don't want to know what I said! I've cut it
> since you don't care about details. Let's stick with the big picture.
>
>> int main() { P(P); } is computationally equivalent to Ĥ(⟨Ĥ⟩).
>
> Yes. P(P) halts (according to you). H(P,P) == 0 (according to you).
> That is wrong (according to everyone but you).
>

Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
if M applied to wM halts, and

Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
if M applied to wM does not halt

Unless the simulating halt decider embedded at state Ĥ.qx aborts the
simulation of its input at some point its input never halts thus proving
beyond all possible doubt that the input that was aborted is correctly
decided as never halting.

When a computation only stops running because its simulation was aborted
this counts as a computation that never halts.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

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

P(P) halts (according to you). H(P,P) == 0 (according to you).
That is wrong -- even according to you.

--
Ben.

On 7/19/21 8:10 AM, olcott wrote:
> On 7/17/2021 8:32 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> ...
>>> I only skimmed the above, I skipped most of the words.
>>
>> Good plan.  You really don't want to know what I said!  I've cut it
>> since you don't care about details.  Let's stick with the big picture.
>>
>>> int main() { P(P); } is computationally equivalent to Ĥ(⟨Ĥ⟩).
>>
>> Yes.  P(P) halts (according to you).  H(P,P) == 0 (according to you).
>> That is wrong (according to everyone but you).
>>
>
> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
> if M applied to wM halts, and
>
> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
> if M applied to wM does not halt
>
> Unless the simulating halt decider embedded at state Ĥ.qx aborts the
> simulation of its input at some point its input never halts thus proving
> beyond all possible doubt that the input that was aborted is correctly
> decided as never halting.
>
> When a computation only stops running because its simulation was aborted
> this counts as a computation that never halts.
>
>

WRONG. The 'top' H^ was never aborted, but reached its terminal Halting
state and thus shows itself to be a Halting Computation.

It was a COPY of this machine that H aborted, not the original one.

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 (according to you). H(P,P) == 0 (according to you).
> That is wrong -- even according to you.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

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

--
Ben.

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.