Simulating Halt Decider Applied to the Halting Theorem
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

They could not understand why H(D,D)==0 and H1(D,D)==1 are both correct.

The reason the simulated input to H(D,D) correctly has different
behavior than the simulated input to H1(D,D) is that

With H(D,D) D calls H(D,D) thus putting itself in recursive simulation

With H1(D,D) D calls H(D,D) yet this does not put itself in recursive
simulation.

They maintained that every correct simulation of an input must derive
the same behavior for this input thus simply ignoring the case where an
input is defined to have a pathological relationship to its simulator.

UTM1(D,D) where D calls UTM1(D,D) will never stop running because
UTM1(D,D) remains stuck in recursive simulation.
UTM1(D,D) simulates D that calls UTM1(D,D)
that simulates D that calls UTM1(D,D)
that simulates D that calls UTM1(D,D)

UTM2(D,D) where D DOES NOT call UTM1(D,D) will never stop running
because UTM1(D,D) called by D remains stuck in recursive simulation.
UTM2(D,D) simulates D that calls UTM1(D,D)
that simulates D that calls UTM1(D,D)
that simulates D that calls UTM1(D,D)

When we change UTM1 and UTM2 to H and H1 then
H(D,D) where D calls H(D,D) remains stuck in recursive simulation until
H aborts the simulation of of D.

H1(D,D) where D calls H(D,D) stops running as soon as H(D,D) aborts the
simulation of its input.

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

On 11/7/2022 9:42 AM, olcott wrote:
> Simulating Halt Decider Applied to the Halting Theorem
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>
> They could not understand why H(D,D)==0 and H1(D,D)==1 are both correct.
>
> The reason the simulated input to H(D,D) correctly has different
> behavior than the simulated input to H1(D,D) is that
>
> With H(D,D)  D calls H(D,D) thus putting itself in recursive simulation
>
> With H1(D,D) D calls H(D,D) yet this does not put itself in recursive
> simulation.
>
> They maintained that every correct simulation of an input must derive
> the same behavior for this input thus simply ignoring the case where an
> input is defined to have a pathological relationship to its simulator.
>
> UTM1(D,D) where D calls UTM1(D,D) will never stop running because
> UTM1(D,D) remains stuck in recursive simulation.
>   UTM1(D,D) simulates D that calls UTM1(D,D)
>   that simulates D that calls UTM1(D,D)
>   that simulates D that calls UTM1(D,D)
>
> UTM2(D,D) where D DOES NOT call UTM1(D,D) will never stop running

Correction:
UTM2(D,D) where D calls UTM1(D,D) will never stop running

> because UTM1(D,D) called by D remains stuck in recursive simulation.
>   UTM2(D,D) simulates D that calls UTM1(D,D)
>   that simulates D that calls UTM1(D,D)
>   that simulates D that calls UTM1(D,D)
>
> When we change UTM1 and UTM2 to H and H1 then
> H(D,D) where D calls H(D,D) remains stuck in recursive simulation until
> H aborts the simulation of of D.
>
> H1(D,D) where D calls H(D,D) stops running as soon as H(D,D) aborts the
> simulation of its input.
>
>

--
Copyright 2022 Pete Olcott

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

Simulating Halt Decider Applied to the Halting Theorem
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

They could not understand why H(D,D)==0 and H1(D,D)==1 are both correct.

The reason the simulated input to H(D,D) correctly has different
behavior than the simulated input to H1(D,D) is that

H(D,D) D calls H(D,D) thus putting itself in recursive simulation.

H1(D,D) D calls H(D,D) yet this does not put itself in recursive simulation.

One cannot correctly simply ignore these differences and form any valid
rebuttal.

If an input specifies a pathological relationship to its simulator this
relationship must be simulated or the simulation is not correct.

They maintained that every correct simulation of an input must derive
the same behavior for this input thus simply ignoring the case where an
input is defined to have a pathological relationship to its simulator.

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

On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:

[Title: A PhD computer scientist spent three days in chat reviewing my paper]

> Simulating Halt Decider Applied to the Halting Theorem
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>
> They could not understand why H(D,D)==0 and H1(D,D)==1 are both correct.
>
> The reason the simulated input to H(D,D) correctly has different
> behavior than the simulated input to H1(D,D) is that
> H(D,D) D calls H(D,D) thus putting itself in recursive simulation.
> H1(D,D) D calls H(D,D) yet this does not put itself in recursive simulation.
> One cannot correctly simply ignore these differences and form any valid
> rebuttal.
>
> If an input specifies a pathological relationship to its simulator this
> relationship must be simulated or the simulation is not correct.
> They maintained that every correct simulation of an input must derive
> the same behavior for this input thus simply ignoring the case where an
> input is defined to have a pathological relationship to its simulator.

That seems much the same as everyone else here has been telling you. Does that mean you're beginning to accept it might be right?

On 11/8/2022 5:13 AM, Paul N wrote:
> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
>
> [Title: A PhD computer scientist spent three days in chat reviewing my paper]
>
>> Simulating Halt Decider Applied to the Halting Theorem
>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>
>> They could not understand why H(D,D)==0 and H1(D,D)==1 are both correct.
>>
>> The reason the simulated input to H(D,D) correctly has different
>> behavior than the simulated input to H1(D,D) is that
>> H(D,D) D calls H(D,D) thus putting itself in recursive simulation.
>> H1(D,D) D calls H(D,D) yet this does not put itself in recursive simulation.
>> One cannot correctly simply ignore these differences and form any valid
>> rebuttal.
>>
>> If an input specifies a pathological relationship to its simulator this
>> relationship must be simulated or the simulation is not correct.
>> They maintained that every correct simulation of an input must derive
>> the same behavior for this input thus simply ignoring the case where an
>> input is defined to have a pathological relationship to its simulator.
>
> That seems much the same as everyone else here has been telling you. Does that mean you're beginning to accept it might be right?

On 7/24/2022 6:19 PM, Paul N wrote:
> On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott wrote:
>> If a simulating halt decider continues to correctly
>> simulate its input until it correctly matches a non-halting
>> behavior pattern then this SHD is necessarily correct when
>> it aborts its simulation and reports non-halting.
>
> Yes, *If* a simulating halt decider continues to correctly
> simulate its input until it *correctly* matches a non-
> halting behaviour pattern then this SHD is correct when it
> aborts its simulation and reports non-halting.

If everyone every where agreed that 3 + 5 = 65.7 I would know they are
all liars. It is conclusively proven beyond all possible doubt that D
correctly simulated by H cannot possibly stop running unless aborted.

Ben has admitted this, and two of my friends that have masters degrees
in computer science verified this.

This is shown more clearly as PP correctly simulated by HH on pages 5-6

Simulating Halt Decider Applied to the Halting Theorem
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

When the input is defined to have a pathological relationship to its
simulator this changes the behavior of the simulated input such that its
correct simulation and its direct execution have different behavior.

A simulating halt decider need not pay attention to this difference it
only needs to compute the mapping from its input to an accept or reject
state on the basis of its correct simulation of its input.

It is verified that the simulation is correct in that there is a
line-by-line exact correspondence between the simulated lines and the
x86 source code of PP.

D simulated by UTM1(D,D) where D is defined to call UTM1(D,D) will
remain stuck in infinitely recursive simulation.

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

On 11/8/2022 5:13 AM, Paul N wrote:
> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
>
> [Title: A PhD computer scientist spent three days in chat reviewing my paper]
>
>> Simulating Halt Decider Applied to the Halting Theorem
>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>
>> They could not understand why H(D,D)==0 and H1(D,D)==1 are both correct.
>>
>> The reason the simulated input to H(D,D) correctly has different
>> behavior than the simulated input to H1(D,D) is that
>> H(D,D) D calls H(D,D) thus putting itself in recursive simulation.
>> H1(D,D) D calls H(D,D) yet this does not put itself in recursive simulation.
>> One cannot correctly simply ignore these differences and form any valid
>> rebuttal.
>>
>> If an input specifies a pathological relationship to its simulator this
>> relationship must be simulated or the simulation is not correct.
>> They maintained that every correct simulation of an input must derive
>> the same behavior for this input thus simply ignoring the case where an
>> input is defined to have a pathological relationship to its simulator.
>
> That seems much the same as everyone else here has been telling you. Does that mean you're beginning to accept it might be right?

*You already said that you agree with me*
*You already said that you agree with me*
*You already said that you agree with me*
*You already said that you agree with me*

On 6/14/2022 6:47 AM, Paul N wrote: [ in comp.lang.c++ ]
> On Monday, June 13, 2022 at 7:46:22 PM UTC+1, olcott wrote:
>> Begin Local Halt Decider Simulation Execution Trace Stored at:212352
>> // H emulates the first seven instructions of P
>> ...[00001352][0021233e][00212342] 55 push ebp // enter P
>> ...[00001353][0021233e][00212342] 8bec mov ebp,esp
>> ...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
>> ...[00001358][0021233a][00001352] 50 push eax // push P
>> ...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
>> ...[0000135c][00212336][00001352] 51 push ecx // push P
>> ...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
>>
>> // The emulated H emulates the first seven instructions of P
>> ...[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
>> ...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
>> ...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
>> ...[00001358][0025cd62][00001352] 50 push eax // push P
>> ...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
>> ...[0000135c][0025cd5e][00001352] 51 push ecx // push P
>> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> It is completely obvious that when H(P,P) correctly
>> emulates its input that it must emulate the first
>> seven instructions of P. Because the seventh instruction
>> of P repeats this process we can know with complete
>> certainty that the emulated P never reaches its final
>> “ret” instruction,thus never halts.
>
> Yes, it is clear to us humans watching it that the program is
repeating itself. Thus we can appreciate that it will never reach the
final "ret" - indeed, it won't even get to the infinite loop identified
above.

Thus you have agreed that P correctly simulated by H would never stop
running unless aborted by H.

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

On Tue, 8 Nov 2022 09:52:22 -0600
olcott <polcott2@gmail.com> wrote:

> On 11/8/2022 5:13 AM, Paul N wrote:
> > On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
> >
> > [Title: A PhD computer scientist spent three days in chat reviewing
> > my paper]
> >> Simulating Halt Decider Applied to the Halting Theorem
> >> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>
> >> They could not understand why H(D,D)==0 and H1(D,D)==1 are both
> >> correct.
> >>
> >> The reason the simulated input to H(D,D) correctly has different
> >> behavior than the simulated input to H1(D,D) is that
> >> H(D,D) D calls H(D,D) thus putting itself in recursive simulation.
> >> H1(D,D) D calls H(D,D) yet this does not put itself in recursive
> >> simulation. One cannot correctly simply ignore these differences
> >> and form any valid rebuttal.
> >>
> >> If an input specifies a pathological relationship to its simulator
> >> this relationship must be simulated or the simulation is not
> >> correct. They maintained that every correct simulation of an input
> >> must derive the same behavior for this input thus simply ignoring
> >> the case where an input is defined to have a pathological
> >> relationship to its simulator.
> >
> > That seems much the same as everyone else here has been telling
> > you. Does that mean you're beginning to accept it might be right?
>
> On 7/24/2022 6:19 PM, Paul N wrote:
> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott wrote:
> >> If a simulating halt decider continues to correctly
> >> simulate its input until it correctly matches a non-halting
> >> behavior pattern then this SHD is necessarily correct when
> >> it aborts its simulation and reports non-halting.
> >
> > Yes, *If* a simulating halt decider continues to correctly
> > simulate its input until it *correctly* matches a non-
> > halting behaviour pattern then this SHD is correct when it
> > aborts its simulation and reports non-halting.
>
> If everyone every where agreed that 3 + 5 = 65.7 I would know they
> are all liars. It is conclusively proven beyond all possible doubt
> that D correctly simulated by H cannot possibly stop running unless
> aborted.
>
> Ben has admitted this, and two of my friends that have masters
> degrees in computer science verified this.
>
> This is shown more clearly as PP correctly simulated by HH on pages
> 5-6
>
> Simulating Halt Decider Applied to the Halting Theorem
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>
>
> When the input is defined to have a pathological relationship to its
> simulator this changes the behavior of the simulated input such that
> its correct simulation and its direct execution have different
> behavior.
>
> A simulating halt decider need not pay attention to this difference
> it only needs to compute the mapping from its input to an accept or
> reject state on the basis of its correct simulation of its input.
>
> It is verified that the simulation is correct in that there is a
> line-by-line exact correspondence between the simulated lines and the
> x86 source code of PP.
>
> D simulated by UTM1(D,D) where D is defined to call UTM1(D,D) will
> remain stuck in infinitely recursive simulation.
You are correct: there is a category error in [Strachey 1965] and
associated proofs which manifests as nested simulation when the halt
decider is of the simulating type. Now what?

/Flibble

On 11/8/2022 11:24 AM, Mr Flibble wrote:
> On Tue, 8 Nov 2022 09:52:22 -0600
> olcott <polcott2@gmail.com> wrote:
>
>> On 11/8/2022 5:13 AM, Paul N wrote:
>>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
>>>
>>> [Title: A PhD computer scientist spent three days in chat reviewing
>>> my paper]
>>>> Simulating Halt Decider Applied to the Halting Theorem
>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>>
>>>> They could not understand why H(D,D)==0 and H1(D,D)==1 are both
>>>> correct.
>>>>
>>>> The reason the simulated input to H(D,D) correctly has different
>>>> behavior than the simulated input to H1(D,D) is that
>>>> H(D,D) D calls H(D,D) thus putting itself in recursive simulation.
>>>> H1(D,D) D calls H(D,D) yet this does not put itself in recursive
>>>> simulation. One cannot correctly simply ignore these differences
>>>> and form any valid rebuttal.
>>>>
>>>> If an input specifies a pathological relationship to its simulator
>>>> this relationship must be simulated or the simulation is not
>>>> correct. They maintained that every correct simulation of an input
>>>> must derive the same behavior for this input thus simply ignoring
>>>> the case where an input is defined to have a pathological
>>>> relationship to its simulator.
>>>
>>> That seems much the same as everyone else here has been telling
>>> you. Does that mean you're beginning to accept it might be right?
>>
>> On 7/24/2022 6:19 PM, Paul N wrote:
>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott wrote:
>> >> If a simulating halt decider continues to correctly
>> >> simulate its input until it correctly matches a non-halting
>> >> behavior pattern then this SHD is necessarily correct when
>> >> it aborts its simulation and reports non-halting.
>> >
>> > Yes, *If* a simulating halt decider continues to correctly
>> > simulate its input until it *correctly* matches a non-
>> > halting behaviour pattern then this SHD is correct when it
>> > aborts its simulation and reports non-halting.
>>
>> If everyone every where agreed that 3 + 5 = 65.7 I would know they
>> are all liars. It is conclusively proven beyond all possible doubt
>> that D correctly simulated by H cannot possibly stop running unless
>> aborted.
>>
>> Ben has admitted this, and two of my friends that have masters
>> degrees in computer science verified this.
>>
>> This is shown more clearly as PP correctly simulated by HH on pages
>> 5-6
>>
>> Simulating Halt Decider Applied to the Halting Theorem
>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>
>>
>> When the input is defined to have a pathological relationship to its
>> simulator this changes the behavior of the simulated input such that
>> its correct simulation and its direct execution have different
>> behavior.
>>
>> A simulating halt decider need not pay attention to this difference
>> it only needs to compute the mapping from its input to an accept or
>> reject state on the basis of its correct simulation of its input.
>>
>> It is verified that the simulation is correct in that there is a
>> line-by-line exact correspondence between the simulated lines and the
>> x86 source code of PP.
>>
>> D simulated by UTM1(D,D) where D is defined to call UTM1(D,D) will
>> remain stuck in infinitely recursive simulation.
>
> You are correct: there is a category error in [Strachey 1965] and
> associated proofs which manifests as nested simulation when the halt
> decider is of the simulating type. Now what?
>
> /Flibble
>

If a Turing computable function H can correctly recognize that its input
D correctly simulated by itself is calling itself in recursive
simulation then H can stop simulating D and correctly reject D as
non-halting. This is conclusively proven at the C level even if PhD
computer scientists disagree.

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

On Tue, 8 Nov 2022 11:40:18 -0600
olcott <polcott2@gmail.com> wrote:

> On 11/8/2022 11:24 AM, Mr Flibble wrote:
> > On Tue, 8 Nov 2022 09:52:22 -0600
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 11/8/2022 5:13 AM, Paul N wrote:
> >>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
> >>>
> >>> [Title: A PhD computer scientist spent three days in chat
> >>> reviewing my paper]
> >>>> Simulating Halt Decider Applied to the Halting Theorem
> >>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>>>
> >>>> They could not understand why H(D,D)==0 and H1(D,D)==1 are both
> >>>> correct.
> >>>>
> >>>> The reason the simulated input to H(D,D) correctly has different
> >>>> behavior than the simulated input to H1(D,D) is that
> >>>> H(D,D) D calls H(D,D) thus putting itself in recursive
> >>>> simulation. H1(D,D) D calls H(D,D) yet this does not put itself
> >>>> in recursive simulation. One cannot correctly simply ignore
> >>>> these differences and form any valid rebuttal.
> >>>>
> >>>> If an input specifies a pathological relationship to its
> >>>> simulator this relationship must be simulated or the simulation
> >>>> is not correct. They maintained that every correct simulation of
> >>>> an input must derive the same behavior for this input thus
> >>>> simply ignoring the case where an input is defined to have a
> >>>> pathological relationship to its simulator.
> >>>
> >>> That seems much the same as everyone else here has been telling
> >>> you. Does that mean you're beginning to accept it might be right?
> >>>
> >>
> >> On 7/24/2022 6:19 PM, Paul N wrote:
> >> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott wrote:
> >> >> If a simulating halt decider continues to correctly
> >> >> simulate its input until it correctly matches a non-halting
> >> >> behavior pattern then this SHD is necessarily correct when
> >> >> it aborts its simulation and reports non-halting.
> >> >
> >> > Yes, *If* a simulating halt decider continues to correctly
> >> > simulate its input until it *correctly* matches a non-
> >> > halting behaviour pattern then this SHD is correct when it
> >> > aborts its simulation and reports non-halting.
> >>
> >> If everyone every where agreed that 3 + 5 = 65.7 I would know they
> >> are all liars. It is conclusively proven beyond all possible doubt
> >> that D correctly simulated by H cannot possibly stop running unless
> >> aborted.
> >>
> >> Ben has admitted this, and two of my friends that have masters
> >> degrees in computer science verified this.
> >>
> >> This is shown more clearly as PP correctly simulated by HH on pages
> >> 5-6
> >>
> >> Simulating Halt Decider Applied to the Halting Theorem
> >> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>
> >>
> >> When the input is defined to have a pathological relationship to
> >> its simulator this changes the behavior of the simulated input
> >> such that its correct simulation and its direct execution have
> >> different behavior.
> >>
> >> A simulating halt decider need not pay attention to this difference
> >> it only needs to compute the mapping from its input to an accept or
> >> reject state on the basis of its correct simulation of its input.
> >>
> >> It is verified that the simulation is correct in that there is a
> >> line-by-line exact correspondence between the simulated lines and
> >> the x86 source code of PP.
> >>
> >> D simulated by UTM1(D,D) where D is defined to call UTM1(D,D) will
> >> remain stuck in infinitely recursive simulation.
> >
> > You are correct: there is a category error in [Strachey 1965] and
> > associated proofs which manifests as nested simulation when the halt
> > decider is of the simulating type. Now what?
> >
> > /Flibble
> >
>
> If a Turing computable function H can correctly recognize that its
> input D correctly simulated by itself is calling itself in recursive
> simulation then H can stop simulating D and correctly reject D as
> non-halting. This is conclusively proven at the C level even if PhD
> computer scientists disagree.
I still think mapping the manifestation of a category error to a
halting decision of non-halting is artificial at best. One can simply
refute the halting problem proofs by demonstrating the presence of the
category error alone.

/Flibble

On 11/8/2022 2:53 PM, Mr Flibble wrote:
> On Tue, 8 Nov 2022 11:40:18 -0600
> olcott <polcott2@gmail.com> wrote:
>
>> On 11/8/2022 11:24 AM, Mr Flibble wrote:
>>> On Tue, 8 Nov 2022 09:52:22 -0600
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 11/8/2022 5:13 AM, Paul N wrote:
>>>>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
>>>>>
>>>>> [Title: A PhD computer scientist spent three days in chat
>>>>> reviewing my paper]
>>>>>> Simulating Halt Decider Applied to the Halting Theorem
>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>>>>
>>>>>> They could not understand why H(D,D)==0 and H1(D,D)==1 are both
>>>>>> correct.
>>>>>>
>>>>>> The reason the simulated input to H(D,D) correctly has different
>>>>>> behavior than the simulated input to H1(D,D) is that
>>>>>> H(D,D) D calls H(D,D) thus putting itself in recursive
>>>>>> simulation. H1(D,D) D calls H(D,D) yet this does not put itself
>>>>>> in recursive simulation. One cannot correctly simply ignore
>>>>>> these differences and form any valid rebuttal.
>>>>>>
>>>>>> If an input specifies a pathological relationship to its
>>>>>> simulator this relationship must be simulated or the simulation
>>>>>> is not correct. They maintained that every correct simulation of
>>>>>> an input must derive the same behavior for this input thus
>>>>>> simply ignoring the case where an input is defined to have a
>>>>>> pathological relationship to its simulator.
>>>>>
>>>>> That seems much the same as everyone else here has been telling
>>>>> you. Does that mean you're beginning to accept it might be right?
>>>>>
>>>>
>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott wrote:
>>>> >> If a simulating halt decider continues to correctly
>>>> >> simulate its input until it correctly matches a non-halting
>>>> >> behavior pattern then this SHD is necessarily correct when
>>>> >> it aborts its simulation and reports non-halting.
>>>> >
>>>> > Yes, *If* a simulating halt decider continues to correctly
>>>> > simulate its input until it *correctly* matches a non-
>>>> > halting behaviour pattern then this SHD is correct when it
>>>> > aborts its simulation and reports non-halting.
>>>>
>>>> If everyone every where agreed that 3 + 5 = 65.7 I would know they
>>>> are all liars. It is conclusively proven beyond all possible doubt
>>>> that D correctly simulated by H cannot possibly stop running unless
>>>> aborted.
>>>>
>>>> Ben has admitted this, and two of my friends that have masters
>>>> degrees in computer science verified this.
>>>>
>>>> This is shown more clearly as PP correctly simulated by HH on pages
>>>> 5-6
>>>>
>>>> Simulating Halt Decider Applied to the Halting Theorem
>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>>
>>>>
>>>> When the input is defined to have a pathological relationship to
>>>> its simulator this changes the behavior of the simulated input
>>>> such that its correct simulation and its direct execution have
>>>> different behavior.
>>>>
>>>> A simulating halt decider need not pay attention to this difference
>>>> it only needs to compute the mapping from its input to an accept or
>>>> reject state on the basis of its correct simulation of its input.
>>>>
>>>> It is verified that the simulation is correct in that there is a
>>>> line-by-line exact correspondence between the simulated lines and
>>>> the x86 source code of PP.
>>>>
>>>> D simulated by UTM1(D,D) where D is defined to call UTM1(D,D) will
>>>> remain stuck in infinitely recursive simulation.
>>>
>>> You are correct: there is a category error in [Strachey 1965] and
>>> associated proofs which manifests as nested simulation when the halt
>>> decider is of the simulating type. Now what?
>>>
>>> /Flibble
>>>
>>
>> If a Turing computable function H can correctly recognize that its
>> input D correctly simulated by itself is calling itself in recursive
>> simulation then H can stop simulating D and correctly reject D as
>> non-halting. This is conclusively proven at the C level even if PhD
>> computer scientists disagree.
>
> I still think mapping the manifestation of a category error to a
> halting decision of non-halting is artificial at best. One can simply
> refute the halting problem proofs by demonstrating the presence of the
> category error alone.
>
> /Flibble
>

Any correctly simulated input that only stops running when its
simulation is aborted is non-halting by tautology.

For it to be an actual category error the correctly simulated input
would have to neither stop running nor not stop running when its
simulation is aborted.

What time is is (yes or no) ? Is a category error.

How many feet long is the color of your car? Is a category error.

What is the integer arithmetic sum of mustard and house bricks? Is a
category error.

Is this sentence true or false: "This sentence is not true." Is a
category error.

--
Copyright 2022 Pete Olcott

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

On Tue, 8 Nov 2022 15:35:06 -0600
olcott <none-ya@beez-waxes.com> wrote:

> On 11/8/2022 2:53 PM, Mr Flibble wrote:
> > On Tue, 8 Nov 2022 11:40:18 -0600
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 11/8/2022 11:24 AM, Mr Flibble wrote:
> >>> On Tue, 8 Nov 2022 09:52:22 -0600
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 11/8/2022 5:13 AM, Paul N wrote:
> >>>>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
> >>>>>
> >>>>> [Title: A PhD computer scientist spent three days in chat
> >>>>> reviewing my paper]
> >>>>>> Simulating Halt Decider Applied to the Halting Theorem
> >>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>>>>>
> >>>>>> They could not understand why H(D,D)==0 and H1(D,D)==1 are both
> >>>>>> correct.
> >>>>>>
> >>>>>> The reason the simulated input to H(D,D) correctly has
> >>>>>> different behavior than the simulated input to H1(D,D) is that
> >>>>>> H(D,D) D calls H(D,D) thus putting itself in recursive
> >>>>>> simulation. H1(D,D) D calls H(D,D) yet this does not put itself
> >>>>>> in recursive simulation. One cannot correctly simply ignore
> >>>>>> these differences and form any valid rebuttal.
> >>>>>>
> >>>>>> If an input specifies a pathological relationship to its
> >>>>>> simulator this relationship must be simulated or the simulation
> >>>>>> is not correct. They maintained that every correct simulation
> >>>>>> of an input must derive the same behavior for this input thus
> >>>>>> simply ignoring the case where an input is defined to have a
> >>>>>> pathological relationship to its simulator.
> >>>>>
> >>>>> That seems much the same as everyone else here has been telling
> >>>>> you. Does that mean you're beginning to accept it might be
> >>>>> right?
> >>>>
> >>>> On 7/24/2022 6:19 PM, Paul N wrote:
> >>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott
> >>>> > wrote:
> >>>> >> If a simulating halt decider continues to correctly
> >>>> >> simulate its input until it correctly matches a non-halting
> >>>> >> behavior pattern then this SHD is necessarily correct when
> >>>> >> it aborts its simulation and reports non-halting.
> >>>> >
> >>>> > Yes, *If* a simulating halt decider continues to correctly
> >>>> > simulate its input until it *correctly* matches a non-
> >>>> > halting behaviour pattern then this SHD is correct when it
> >>>> > aborts its simulation and reports non-halting.
> >>>>
> >>>> If everyone every where agreed that 3 + 5 = 65.7 I would know
> >>>> they are all liars. It is conclusively proven beyond all
> >>>> possible doubt that D correctly simulated by H cannot possibly
> >>>> stop running unless aborted.
> >>>>
> >>>> Ben has admitted this, and two of my friends that have masters
> >>>> degrees in computer science verified this.
> >>>>
> >>>> This is shown more clearly as PP correctly simulated by HH on
> >>>> pages 5-6
> >>>>
> >>>> Simulating Halt Decider Applied to the Halting Theorem
> >>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>>>
> >>>>
> >>>> When the input is defined to have a pathological relationship to
> >>>> its simulator this changes the behavior of the simulated input
> >>>> such that its correct simulation and its direct execution have
> >>>> different behavior.
> >>>>
> >>>> A simulating halt decider need not pay attention to this
> >>>> difference it only needs to compute the mapping from its input
> >>>> to an accept or reject state on the basis of its correct
> >>>> simulation of its input.
> >>>>
> >>>> It is verified that the simulation is correct in that there is a
> >>>> line-by-line exact correspondence between the simulated lines and
> >>>> the x86 source code of PP.
> >>>>
> >>>> D simulated by UTM1(D,D) where D is defined to call UTM1(D,D)
> >>>> will remain stuck in infinitely recursive simulation.
> >>>
> >>> You are correct: there is a category error in [Strachey 1965] and
> >>> associated proofs which manifests as nested simulation when the
> >>> halt decider is of the simulating type. Now what?
> >>>
> >>> /Flibble
> >>>
> >>
> >> If a Turing computable function H can correctly recognize that its
> >> input D correctly simulated by itself is calling itself in
> >> recursive simulation then H can stop simulating D and correctly
> >> reject D as non-halting. This is conclusively proven at the C
> >> level even if PhD computer scientists disagree.
> >
> > I still think mapping the manifestation of a category error to a
> > halting decision of non-halting is artificial at best. One can
> > simply refute the halting problem proofs by demonstrating the
> > presence of the category error alone.
> >
> > /Flibble
> >
>
> Any correctly simulated input that only stops running when its
> simulation is aborted is non-halting by tautology.
>
> For it to be an actual category error the correctly simulated input
> would have to neither stop running nor not stop running when its
> simulation is aborted.
>
> What time is is (yes or no) ? Is a category error.
>
> How many feet long is the color of your car? Is a category error.
>
> What is the integer arithmetic sum of mustard and house bricks? Is a
> category error.
>
> Is this sentence true or false: "This sentence is not true." Is a
> category error.

No. The category error is the self reference with the two categories
being the decider and the input.

/Flibble

On 11/8/2022 5:36 PM, Mr Flibble wrote:
> On Tue, 8 Nov 2022 15:35:06 -0600
> olcott <none-ya@beez-waxes.com> wrote:
>
>> On 11/8/2022 2:53 PM, Mr Flibble wrote:
>>> On Tue, 8 Nov 2022 11:40:18 -0600
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 11/8/2022 11:24 AM, Mr Flibble wrote:
>>>>> On Tue, 8 Nov 2022 09:52:22 -0600
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 11/8/2022 5:13 AM, Paul N wrote:
>>>>>>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
>>>>>>>
>>>>>>> [Title: A PhD computer scientist spent three days in chat
>>>>>>> reviewing my paper]
>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>>>>>>
>>>>>>>> They could not understand why H(D,D)==0 and H1(D,D)==1 are both
>>>>>>>> correct.
>>>>>>>>
>>>>>>>> The reason the simulated input to H(D,D) correctly has
>>>>>>>> different behavior than the simulated input to H1(D,D) is that
>>>>>>>> H(D,D) D calls H(D,D) thus putting itself in recursive
>>>>>>>> simulation. H1(D,D) D calls H(D,D) yet this does not put itself
>>>>>>>> in recursive simulation. One cannot correctly simply ignore
>>>>>>>> these differences and form any valid rebuttal.
>>>>>>>>
>>>>>>>> If an input specifies a pathological relationship to its
>>>>>>>> simulator this relationship must be simulated or the simulation
>>>>>>>> is not correct. They maintained that every correct simulation
>>>>>>>> of an input must derive the same behavior for this input thus
>>>>>>>> simply ignoring the case where an input is defined to have a
>>>>>>>> pathological relationship to its simulator.
>>>>>>>
>>>>>>> That seems much the same as everyone else here has been telling
>>>>>>> you. Does that mean you're beginning to accept it might be
>>>>>>> right?
>>>>>>
>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott
>>>>>> > wrote:
>>>>>> >> If a simulating halt decider continues to correctly
>>>>>> >> simulate its input until it correctly matches a non-halting
>>>>>> >> behavior pattern then this SHD is necessarily correct when
>>>>>> >> it aborts its simulation and reports non-halting.
>>>>>> >
>>>>>> > Yes, *If* a simulating halt decider continues to correctly
>>>>>> > simulate its input until it *correctly* matches a non-
>>>>>> > halting behaviour pattern then this SHD is correct when it
>>>>>> > aborts its simulation and reports non-halting.
>>>>>>
>>>>>> If everyone every where agreed that 3 + 5 = 65.7 I would know
>>>>>> they are all liars. It is conclusively proven beyond all
>>>>>> possible doubt that D correctly simulated by H cannot possibly
>>>>>> stop running unless aborted.
>>>>>>
>>>>>> Ben has admitted this, and two of my friends that have masters
>>>>>> degrees in computer science verified this.
>>>>>>
>>>>>> This is shown more clearly as PP correctly simulated by HH on
>>>>>> pages 5-6
>>>>>>
>>>>>> Simulating Halt Decider Applied to the Halting Theorem
>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>>>>
>>>>>>
>>>>>> When the input is defined to have a pathological relationship to
>>>>>> its simulator this changes the behavior of the simulated input
>>>>>> such that its correct simulation and its direct execution have
>>>>>> different behavior.
>>>>>>
>>>>>> A simulating halt decider need not pay attention to this
>>>>>> difference it only needs to compute the mapping from its input
>>>>>> to an accept or reject state on the basis of its correct
>>>>>> simulation of its input.
>>>>>>
>>>>>> It is verified that the simulation is correct in that there is a
>>>>>> line-by-line exact correspondence between the simulated lines and
>>>>>> the x86 source code of PP.
>>>>>>
>>>>>> D simulated by UTM1(D,D) where D is defined to call UTM1(D,D)
>>>>>> will remain stuck in infinitely recursive simulation.
>>>>>
>>>>> You are correct: there is a category error in [Strachey 1965] and
>>>>> associated proofs which manifests as nested simulation when the
>>>>> halt decider is of the simulating type. Now what?
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> If a Turing computable function H can correctly recognize that its
>>>> input D correctly simulated by itself is calling itself in
>>>> recursive simulation then H can stop simulating D and correctly
>>>> reject D as non-halting. This is conclusively proven at the C
>>>> level even if PhD computer scientists disagree.
>>>
>>> I still think mapping the manifestation of a category error to a
>>> halting decision of non-halting is artificial at best. One can
>>> simply refute the halting problem proofs by demonstrating the
>>> presence of the category error alone.
>>>
>>> /Flibble
>>>
>>
>> Any correctly simulated input that only stops running when its
>> simulation is aborted is non-halting by tautology.
>>
>> For it to be an actual category error the correctly simulated input
>> would have to neither stop running nor not stop running when its
>> simulation is aborted.
>>
>> What time is is (yes or no) ? Is a category error.
>>
>> How many feet long is the color of your car? Is a category error.
>>
>> What is the integer arithmetic sum of mustard and house bricks? Is a
>> category error.
>>
>> Is this sentence true or false: "This sentence is not true." Is a
>> category error.
>
> No. The category error is the self reference with the two categories
> being the decider and the input.
>
> /Flibble
>

A category error can only be miscategorization (putting things in the
wrong category). Saying that an animal is a category of office building
is a category error.

--
Copyright 2022 Pete Olcott

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

On Tue, 8 Nov 2022 18:13:04 -0600
olcott <none-ya@beez-waxes.com> wrote:

> On 11/8/2022 5:36 PM, Mr Flibble wrote:
> > On Tue, 8 Nov 2022 15:35:06 -0600
> > olcott <none-ya@beez-waxes.com> wrote:
> >
> >> On 11/8/2022 2:53 PM, Mr Flibble wrote:
> >>> On Tue, 8 Nov 2022 11:40:18 -0600
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 11/8/2022 11:24 AM, Mr Flibble wrote:
> >>>>> On Tue, 8 Nov 2022 09:52:22 -0600
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 11/8/2022 5:13 AM, Paul N wrote:
> >>>>>>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
> >>>>>>>
> >>>>>>> [Title: A PhD computer scientist spent three days in chat
> >>>>>>> reviewing my paper]
> >>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
> >>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>>>>>>>
> >>>>>>>> They could not understand why H(D,D)==0 and H1(D,D)==1 are
> >>>>>>>> both correct.
> >>>>>>>>
> >>>>>>>> The reason the simulated input to H(D,D) correctly has
> >>>>>>>> different behavior than the simulated input to H1(D,D) is
> >>>>>>>> that H(D,D) D calls H(D,D) thus putting itself in recursive
> >>>>>>>> simulation. H1(D,D) D calls H(D,D) yet this does not put
> >>>>>>>> itself in recursive simulation. One cannot correctly simply
> >>>>>>>> ignore these differences and form any valid rebuttal.
> >>>>>>>>
> >>>>>>>> If an input specifies a pathological relationship to its
> >>>>>>>> simulator this relationship must be simulated or the
> >>>>>>>> simulation is not correct. They maintained that every
> >>>>>>>> correct simulation of an input must derive the same behavior
> >>>>>>>> for this input thus simply ignoring the case where an input
> >>>>>>>> is defined to have a pathological relationship to its
> >>>>>>>> simulator.
> >>>>>>>
> >>>>>>> That seems much the same as everyone else here has been
> >>>>>>> telling you. Does that mean you're beginning to accept it
> >>>>>>> might be right?
> >>>>>>
> >>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
> >>>>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott
> >>>>>> > wrote:
> >>>>>> >> If a simulating halt decider continues to correctly
> >>>>>> >> simulate its input until it correctly matches a
> >>>>>> >> non-halting behavior pattern then this SHD is
> >>>>>> >> necessarily correct when it aborts its simulation and
> >>>>>> >> reports non-halting.
> >>>>>> >
> >>>>>> > Yes, *If* a simulating halt decider continues to
> >>>>>> > correctly simulate its input until it *correctly*
> >>>>>> > matches a non- halting behaviour pattern then this SHD
> >>>>>> > is correct when it aborts its simulation and reports
> >>>>>> > non-halting.
> >>>>>>
> >>>>>> If everyone every where agreed that 3 + 5 = 65.7 I would know
> >>>>>> they are all liars. It is conclusively proven beyond all
> >>>>>> possible doubt that D correctly simulated by H cannot possibly
> >>>>>> stop running unless aborted.
> >>>>>>
> >>>>>> Ben has admitted this, and two of my friends that have masters
> >>>>>> degrees in computer science verified this.
> >>>>>>
> >>>>>> This is shown more clearly as PP correctly simulated by HH on
> >>>>>> pages 5-6
> >>>>>>
> >>>>>> Simulating Halt Decider Applied to the Halting Theorem
> >>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>>>>>
> >>>>>>
> >>>>>> When the input is defined to have a pathological relationship
> >>>>>> to its simulator this changes the behavior of the simulated
> >>>>>> input such that its correct simulation and its direct
> >>>>>> execution have different behavior.
> >>>>>>
> >>>>>> A simulating halt decider need not pay attention to this
> >>>>>> difference it only needs to compute the mapping from its input
> >>>>>> to an accept or reject state on the basis of its correct
> >>>>>> simulation of its input.
> >>>>>>
> >>>>>> It is verified that the simulation is correct in that there is
> >>>>>> a line-by-line exact correspondence between the simulated
> >>>>>> lines and the x86 source code of PP.
> >>>>>>
> >>>>>> D simulated by UTM1(D,D) where D is defined to call UTM1(D,D)
> >>>>>> will remain stuck in infinitely recursive simulation.
> >>>>>
> >>>>> You are correct: there is a category error in [Strachey 1965]
> >>>>> and associated proofs which manifests as nested simulation when
> >>>>> the halt decider is of the simulating type. Now what?
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> If a Turing computable function H can correctly recognize that
> >>>> its input D correctly simulated by itself is calling itself in
> >>>> recursive simulation then H can stop simulating D and correctly
> >>>> reject D as non-halting. This is conclusively proven at the C
> >>>> level even if PhD computer scientists disagree.
> >>>
> >>> I still think mapping the manifestation of a category error to a
> >>> halting decision of non-halting is artificial at best. One can
> >>> simply refute the halting problem proofs by demonstrating the
> >>> presence of the category error alone.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Any correctly simulated input that only stops running when its
> >> simulation is aborted is non-halting by tautology.
> >>
> >> For it to be an actual category error the correctly simulated input
> >> would have to neither stop running nor not stop running when its
> >> simulation is aborted.
> >>
> >> What time is is (yes or no) ? Is a category error.
> >>
> >> How many feet long is the color of your car? Is a category error.
> >>
> >> What is the integer arithmetic sum of mustard and house bricks? Is
> >> a category error.
> >>
> >> Is this sentence true or false: "This sentence is not true." Is a
> >> category error.
> >
> > No. The category error is the self reference with the two
> > categories being the decider and the input.
> >
> > /Flibble
> >
>
> A category error can only be miscategorization (putting things in the
> wrong category). Saying that an animal is a category of office
> building is a category error.

Yes that is an example of a category error and another example of a
category error is the self reference in [Strachey 1965] and associated
proofs with the categories being the input and the decider: the input
cannot pass itself to the decider.

/Flibble

On 11/9/2022 11:19 AM, Mr Flibble wrote:
> On Tue, 8 Nov 2022 18:13:04 -0600
> olcott <none-ya@beez-waxes.com> wrote:
>
>> On 11/8/2022 5:36 PM, Mr Flibble wrote:
>>> On Tue, 8 Nov 2022 15:35:06 -0600
>>> olcott <none-ya@beez-waxes.com> wrote:
>>>
>>>> On 11/8/2022 2:53 PM, Mr Flibble wrote:
>>>>> On Tue, 8 Nov 2022 11:40:18 -0600
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 11/8/2022 11:24 AM, Mr Flibble wrote:
>>>>>>> On Tue, 8 Nov 2022 09:52:22 -0600
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 11/8/2022 5:13 AM, Paul N wrote:
>>>>>>>>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
>>>>>>>>>
>>>>>>>>> [Title: A PhD computer scientist spent three days in chat
>>>>>>>>> reviewing my paper]
>>>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
>>>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>>>>>>>>
>>>>>>>>>> They could not understand why H(D,D)==0 and H1(D,D)==1 are
>>>>>>>>>> both correct.
>>>>>>>>>>
>>>>>>>>>> The reason the simulated input to H(D,D) correctly has
>>>>>>>>>> different behavior than the simulated input to H1(D,D) is
>>>>>>>>>> that H(D,D) D calls H(D,D) thus putting itself in recursive
>>>>>>>>>> simulation. H1(D,D) D calls H(D,D) yet this does not put
>>>>>>>>>> itself in recursive simulation. One cannot correctly simply
>>>>>>>>>> ignore these differences and form any valid rebuttal.
>>>>>>>>>>
>>>>>>>>>> If an input specifies a pathological relationship to its
>>>>>>>>>> simulator this relationship must be simulated or the
>>>>>>>>>> simulation is not correct. They maintained that every
>>>>>>>>>> correct simulation of an input must derive the same behavior
>>>>>>>>>> for this input thus simply ignoring the case where an input
>>>>>>>>>> is defined to have a pathological relationship to its
>>>>>>>>>> simulator.
>>>>>>>>>
>>>>>>>>> That seems much the same as everyone else here has been
>>>>>>>>> telling you. Does that mean you're beginning to accept it
>>>>>>>>> might be right?
>>>>>>>>
>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott
>>>>>>>> > wrote:
>>>>>>>> >> If a simulating halt decider continues to correctly
>>>>>>>> >> simulate its input until it correctly matches a
>>>>>>>> >> non-halting behavior pattern then this SHD is
>>>>>>>> >> necessarily correct when it aborts its simulation and
>>>>>>>> >> reports non-halting.
>>>>>>>> >
>>>>>>>> > Yes, *If* a simulating halt decider continues to
>>>>>>>> > correctly simulate its input until it *correctly*
>>>>>>>> > matches a non- halting behaviour pattern then this SHD
>>>>>>>> > is correct when it aborts its simulation and reports
>>>>>>>> > non-halting.
>>>>>>>>
>>>>>>>> If everyone every where agreed that 3 + 5 = 65.7 I would know
>>>>>>>> they are all liars. It is conclusively proven beyond all
>>>>>>>> possible doubt that D correctly simulated by H cannot possibly
>>>>>>>> stop running unless aborted.
>>>>>>>>
>>>>>>>> Ben has admitted this, and two of my friends that have masters
>>>>>>>> degrees in computer science verified this.
>>>>>>>>
>>>>>>>> This is shown more clearly as PP correctly simulated by HH on
>>>>>>>> pages 5-6
>>>>>>>>
>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>>>>>>
>>>>>>>>
>>>>>>>> When the input is defined to have a pathological relationship
>>>>>>>> to its simulator this changes the behavior of the simulated
>>>>>>>> input such that its correct simulation and its direct
>>>>>>>> execution have different behavior.
>>>>>>>>
>>>>>>>> A simulating halt decider need not pay attention to this
>>>>>>>> difference it only needs to compute the mapping from its input
>>>>>>>> to an accept or reject state on the basis of its correct
>>>>>>>> simulation of its input.
>>>>>>>>
>>>>>>>> It is verified that the simulation is correct in that there is
>>>>>>>> a line-by-line exact correspondence between the simulated
>>>>>>>> lines and the x86 source code of PP.
>>>>>>>>
>>>>>>>> D simulated by UTM1(D,D) where D is defined to call UTM1(D,D)
>>>>>>>> will remain stuck in infinitely recursive simulation.
>>>>>>>
>>>>>>> You are correct: there is a category error in [Strachey 1965]
>>>>>>> and associated proofs which manifests as nested simulation when
>>>>>>> the halt decider is of the simulating type. Now what?
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> If a Turing computable function H can correctly recognize that
>>>>>> its input D correctly simulated by itself is calling itself in
>>>>>> recursive simulation then H can stop simulating D and correctly
>>>>>> reject D as non-halting. This is conclusively proven at the C
>>>>>> level even if PhD computer scientists disagree.
>>>>>
>>>>> I still think mapping the manifestation of a category error to a
>>>>> halting decision of non-halting is artificial at best. One can
>>>>> simply refute the halting problem proofs by demonstrating the
>>>>> presence of the category error alone.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Any correctly simulated input that only stops running when its
>>>> simulation is aborted is non-halting by tautology.
>>>>
>>>> For it to be an actual category error the correctly simulated input
>>>> would have to neither stop running nor not stop running when its
>>>> simulation is aborted.
>>>>
>>>> What time is is (yes or no) ? Is a category error.
>>>>
>>>> How many feet long is the color of your car? Is a category error.
>>>>
>>>> What is the integer arithmetic sum of mustard and house bricks? Is
>>>> a category error.
>>>>
>>>> Is this sentence true or false: "This sentence is not true." Is a
>>>> category error.
>>>
>>> No. The category error is the self reference with the two
>>> categories being the decider and the input.
>>>
>>> /Flibble
>>>
>>
>> A category error can only be miscategorization (putting things in the
>> wrong category). Saying that an animal is a category of office
>> building is a category error.
>
> Yes that is an example of a category error and another example of a
> category error is the self reference in [Strachey 1965] and associated
> proofs with the categories being the input and the decider: the input
> cannot pass itself to the decider.
>
> /Flibble
>

On Wed, 9 Nov 2022 11:24:42 -0600
olcott <polcott2@gmail.com> wrote:

> On 11/9/2022 11:19 AM, Mr Flibble wrote:
> > On Tue, 8 Nov 2022 18:13:04 -0600
> > olcott <none-ya@beez-waxes.com> wrote:
> >
> >> On 11/8/2022 5:36 PM, Mr Flibble wrote:
> >>> On Tue, 8 Nov 2022 15:35:06 -0600
> >>> olcott <none-ya@beez-waxes.com> wrote:
> >>>
> >>>> On 11/8/2022 2:53 PM, Mr Flibble wrote:
> >>>>> On Tue, 8 Nov 2022 11:40:18 -0600
> >>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>
> >>>>>> On 11/8/2022 11:24 AM, Mr Flibble wrote:
> >>>>>>> On Tue, 8 Nov 2022 09:52:22 -0600
> >>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>
> >>>>>>>> On 11/8/2022 5:13 AM, Paul N wrote:
> >>>>>>>>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
> >>>>>>>>>
> >>>>>>>>> [Title: A PhD computer scientist spent three days in chat
> >>>>>>>>> reviewing my paper]
> >>>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
> >>>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>>>>>>>>>
> >>>>>>>>>> They could not understand why H(D,D)==0 and H1(D,D)==1 are
> >>>>>>>>>> both correct.
> >>>>>>>>>>
> >>>>>>>>>> The reason the simulated input to H(D,D) correctly has
> >>>>>>>>>> different behavior than the simulated input to H1(D,D) is
> >>>>>>>>>> that H(D,D) D calls H(D,D) thus putting itself in recursive
> >>>>>>>>>> simulation. H1(D,D) D calls H(D,D) yet this does not put
> >>>>>>>>>> itself in recursive simulation. One cannot correctly simply
> >>>>>>>>>> ignore these differences and form any valid rebuttal.
> >>>>>>>>>>
> >>>>>>>>>> If an input specifies a pathological relationship to its
> >>>>>>>>>> simulator this relationship must be simulated or the
> >>>>>>>>>> simulation is not correct. They maintained that every
> >>>>>>>>>> correct simulation of an input must derive the same
> >>>>>>>>>> behavior for this input thus simply ignoring the case
> >>>>>>>>>> where an input is defined to have a pathological
> >>>>>>>>>> relationship to its simulator.
> >>>>>>>>>
> >>>>>>>>> That seems much the same as everyone else here has been
> >>>>>>>>> telling you. Does that mean you're beginning to accept it
> >>>>>>>>> might be right?
> >>>>>>>>
> >>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
> >>>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott
> >>>>>>>> > wrote:
> >>>>>>>> >> If a simulating halt decider continues to correctly
> >>>>>>>> >> simulate its input until it correctly matches a
> >>>>>>>> >> non-halting behavior pattern then this SHD is
> >>>>>>>> >> necessarily correct when it aborts its simulation and
> >>>>>>>> >> reports non-halting.
> >>>>>>>> >
> >>>>>>>> > Yes, *If* a simulating halt decider continues to
> >>>>>>>> > correctly simulate its input until it *correctly*
> >>>>>>>> > matches a non- halting behaviour pattern then this SHD
> >>>>>>>> > is correct when it aborts its simulation and reports
> >>>>>>>> > non-halting.
> >>>>>>>>
> >>>>>>>> If everyone every where agreed that 3 + 5 = 65.7 I would know
> >>>>>>>> they are all liars. It is conclusively proven beyond all
> >>>>>>>> possible doubt that D correctly simulated by H cannot
> >>>>>>>> possibly stop running unless aborted.
> >>>>>>>>
> >>>>>>>> Ben has admitted this, and two of my friends that have
> >>>>>>>> masters degrees in computer science verified this.
> >>>>>>>>
> >>>>>>>> This is shown more clearly as PP correctly simulated by HH on
> >>>>>>>> pages 5-6
> >>>>>>>>
> >>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
> >>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> When the input is defined to have a pathological relationship
> >>>>>>>> to its simulator this changes the behavior of the simulated
> >>>>>>>> input such that its correct simulation and its direct
> >>>>>>>> execution have different behavior.
> >>>>>>>>
> >>>>>>>> A simulating halt decider need not pay attention to this
> >>>>>>>> difference it only needs to compute the mapping from its
> >>>>>>>> input to an accept or reject state on the basis of its
> >>>>>>>> correct simulation of its input.
> >>>>>>>>
> >>>>>>>> It is verified that the simulation is correct in that there
> >>>>>>>> is a line-by-line exact correspondence between the simulated
> >>>>>>>> lines and the x86 source code of PP.
> >>>>>>>>
> >>>>>>>> D simulated by UTM1(D,D) where D is defined to call UTM1(D,D)
> >>>>>>>> will remain stuck in infinitely recursive simulation.
> >>>>>>>
> >>>>>>> You are correct: there is a category error in [Strachey 1965]
> >>>>>>> and associated proofs which manifests as nested simulation
> >>>>>>> when the halt decider is of the simulating type. Now what?
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> If a Turing computable function H can correctly recognize that
> >>>>>> its input D correctly simulated by itself is calling itself in
> >>>>>> recursive simulation then H can stop simulating D and correctly
> >>>>>> reject D as non-halting. This is conclusively proven at the C
> >>>>>> level even if PhD computer scientists disagree.
> >>>>>
> >>>>> I still think mapping the manifestation of a category error to a
> >>>>> halting decision of non-halting is artificial at best. One can
> >>>>> simply refute the halting problem proofs by demonstrating the
> >>>>> presence of the category error alone.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Any correctly simulated input that only stops running when its
> >>>> simulation is aborted is non-halting by tautology.
> >>>>
> >>>> For it to be an actual category error the correctly simulated
> >>>> input would have to neither stop running nor not stop running
> >>>> when its simulation is aborted.
> >>>>
> >>>> What time is is (yes or no) ? Is a category error.
> >>>>
> >>>> How many feet long is the color of your car? Is a category error.
> >>>>
> >>>> What is the integer arithmetic sum of mustard and house bricks?
> >>>> Is a category error.
> >>>>
> >>>> Is this sentence true or false: "This sentence is not true." Is a
> >>>> category error.
> >>>
> >>> No. The category error is the self reference with the two
> >>> categories being the decider and the input.
> >>>
> >>> /Flibble
> >>>
> >>
> >> A category error can only be miscategorization (putting things in
> >> the wrong category). Saying that an animal is a category of office
> >> building is a category error.
> >
> > Yes that is an example of a category error and another example of a
> > category error is the self reference in [Strachey 1965] and
> > associated proofs with the categories being the input and the
> > decider: the input cannot pass itself to the decider.
> >
> > /Flibble
> >
>
> In your case "cannot" means {should not} and thus not an actual
> category error of {it is utterly impossible} for D to call H with the
> machine description of itself.

On 11/9/2022 11:56 AM, Mr Flibble wrote:
> On Wed, 9 Nov 2022 11:24:42 -0600
> olcott <polcott2@gmail.com> wrote:
>
>> On 11/9/2022 11:19 AM, Mr Flibble wrote:
>>> On Tue, 8 Nov 2022 18:13:04 -0600
>>> olcott <none-ya@beez-waxes.com> wrote:
>>>
>>>> On 11/8/2022 5:36 PM, Mr Flibble wrote:
>>>>> On Tue, 8 Nov 2022 15:35:06 -0600
>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>
>>>>>> On 11/8/2022 2:53 PM, Mr Flibble wrote:
>>>>>>> On Tue, 8 Nov 2022 11:40:18 -0600
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 11/8/2022 11:24 AM, Mr Flibble wrote:
>>>>>>>>> On Tue, 8 Nov 2022 09:52:22 -0600
>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 11/8/2022 5:13 AM, Paul N wrote:
>>>>>>>>>>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> [Title: A PhD computer scientist spent three days in chat
>>>>>>>>>>> reviewing my paper]
>>>>>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
>>>>>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>>>>>>>>>>
>>>>>>>>>>>> They could not understand why H(D,D)==0 and H1(D,D)==1 are
>>>>>>>>>>>> both correct.
>>>>>>>>>>>>
>>>>>>>>>>>> The reason the simulated input to H(D,D) correctly has
>>>>>>>>>>>> different behavior than the simulated input to H1(D,D) is
>>>>>>>>>>>> that H(D,D) D calls H(D,D) thus putting itself in recursive
>>>>>>>>>>>> simulation. H1(D,D) D calls H(D,D) yet this does not put
>>>>>>>>>>>> itself in recursive simulation. One cannot correctly simply
>>>>>>>>>>>> ignore these differences and form any valid rebuttal.
>>>>>>>>>>>>
>>>>>>>>>>>> If an input specifies a pathological relationship to its
>>>>>>>>>>>> simulator this relationship must be simulated or the
>>>>>>>>>>>> simulation is not correct. They maintained that every
>>>>>>>>>>>> correct simulation of an input must derive the same
>>>>>>>>>>>> behavior for this input thus simply ignoring the case
>>>>>>>>>>>> where an input is defined to have a pathological
>>>>>>>>>>>> relationship to its simulator.
>>>>>>>>>>>
>>>>>>>>>>> That seems much the same as everyone else here has been
>>>>>>>>>>> telling you. Does that mean you're beginning to accept it
>>>>>>>>>>> might be right?
>>>>>>>>>>
>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott
>>>>>>>>>> > wrote:
>>>>>>>>>> >> If a simulating halt decider continues to correctly
>>>>>>>>>> >> simulate its input until it correctly matches a
>>>>>>>>>> >> non-halting behavior pattern then this SHD is
>>>>>>>>>> >> necessarily correct when it aborts its simulation and
>>>>>>>>>> >> reports non-halting.
>>>>>>>>>> >
>>>>>>>>>> > Yes, *If* a simulating halt decider continues to
>>>>>>>>>> > correctly simulate its input until it *correctly*
>>>>>>>>>> > matches a non- halting behaviour pattern then this SHD
>>>>>>>>>> > is correct when it aborts its simulation and reports
>>>>>>>>>> > non-halting.
>>>>>>>>>>
>>>>>>>>>> If everyone every where agreed that 3 + 5 = 65.7 I would know
>>>>>>>>>> they are all liars. It is conclusively proven beyond all
>>>>>>>>>> possible doubt that D correctly simulated by H cannot
>>>>>>>>>> possibly stop running unless aborted.
>>>>>>>>>>
>>>>>>>>>> Ben has admitted this, and two of my friends that have
>>>>>>>>>> masters degrees in computer science verified this.
>>>>>>>>>>
>>>>>>>>>> This is shown more clearly as PP correctly simulated by HH on
>>>>>>>>>> pages 5-6
>>>>>>>>>>
>>>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
>>>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When the input is defined to have a pathological relationship
>>>>>>>>>> to its simulator this changes the behavior of the simulated
>>>>>>>>>> input such that its correct simulation and its direct
>>>>>>>>>> execution have different behavior.
>>>>>>>>>>
>>>>>>>>>> A simulating halt decider need not pay attention to this
>>>>>>>>>> difference it only needs to compute the mapping from its
>>>>>>>>>> input to an accept or reject state on the basis of its
>>>>>>>>>> correct simulation of its input.
>>>>>>>>>>
>>>>>>>>>> It is verified that the simulation is correct in that there
>>>>>>>>>> is a line-by-line exact correspondence between the simulated
>>>>>>>>>> lines and the x86 source code of PP.
>>>>>>>>>>
>>>>>>>>>> D simulated by UTM1(D,D) where D is defined to call UTM1(D,D)
>>>>>>>>>> will remain stuck in infinitely recursive simulation.
>>>>>>>>>
>>>>>>>>> You are correct: there is a category error in [Strachey 1965]
>>>>>>>>> and associated proofs which manifests as nested simulation
>>>>>>>>> when the halt decider is of the simulating type. Now what?
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> If a Turing computable function H can correctly recognize that
>>>>>>>> its input D correctly simulated by itself is calling itself in
>>>>>>>> recursive simulation then H can stop simulating D and correctly
>>>>>>>> reject D as non-halting. This is conclusively proven at the C
>>>>>>>> level even if PhD computer scientists disagree.
>>>>>>>
>>>>>>> I still think mapping the manifestation of a category error to a
>>>>>>> halting decision of non-halting is artificial at best. One can
>>>>>>> simply refute the halting problem proofs by demonstrating the
>>>>>>> presence of the category error alone.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Any correctly simulated input that only stops running when its
>>>>>> simulation is aborted is non-halting by tautology.
>>>>>>
>>>>>> For it to be an actual category error the correctly simulated
>>>>>> input would have to neither stop running nor not stop running
>>>>>> when its simulation is aborted.
>>>>>>
>>>>>> What time is is (yes or no) ? Is a category error.
>>>>>>
>>>>>> How many feet long is the color of your car? Is a category error.
>>>>>>
>>>>>> What is the integer arithmetic sum of mustard and house bricks?
>>>>>> Is a category error.
>>>>>>
>>>>>> Is this sentence true or false: "This sentence is not true." Is a
>>>>>> category error.
>>>>>
>>>>> No. The category error is the self reference with the two
>>>>> categories being the decider and the input.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> A category error can only be miscategorization (putting things in
>>>> the wrong category). Saying that an animal is a category of office
>>>> building is a category error.
>>>
>>> Yes that is an example of a category error and another example of a
>>> category error is the self reference in [Strachey 1965] and
>>> associated proofs with the categories being the input and the
>>> decider: the input cannot pass itself to the decider.
>>>
>>> /Flibble
>>>
>>
>> In your case "cannot" means {should not} and thus not an actual
>> category error of {it is utterly impossible} for D to call H with the
>> machine description of itself.
>
> Wrong, it is a category error (self reference) which will manifest as
> nested simulation if the decider is of the simulating type.
>
>>
>> It is utterly impossible for the category of living creature {animal}
>> to be an element of the set of {office buildings}.
>
> Why do you keep giving me fucktarded examples of category errors? I know
> what a category error is but I am not sure you do, at least fully, as
> you cannot see how the self reference in [Strachey 1965] and associated
> proofs is a category error.
>
> /Flibble
>
>

On 11/9/2022 11:56 AM, Mr Flibble wrote:
> On Wed, 9 Nov 2022 11:24:42 -0600
> olcott <polcott2@gmail.com> wrote:
>
>> On 11/9/2022 11:19 AM, Mr Flibble wrote:
>>> On Tue, 8 Nov 2022 18:13:04 -0600
>>> olcott <none-ya@beez-waxes.com> wrote:
>>>
>>>> On 11/8/2022 5:36 PM, Mr Flibble wrote:
>>>>> On Tue, 8 Nov 2022 15:35:06 -0600
>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>
>>>>>> On 11/8/2022 2:53 PM, Mr Flibble wrote:
>>>>>>> On Tue, 8 Nov 2022 11:40:18 -0600
>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 11/8/2022 11:24 AM, Mr Flibble wrote:
>>>>>>>>> On Tue, 8 Nov 2022 09:52:22 -0600
>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 11/8/2022 5:13 AM, Paul N wrote:
>>>>>>>>>>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>> [Title: A PhD computer scientist spent three days in chat
>>>>>>>>>>> reviewing my paper]
>>>>>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
>>>>>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>>>>>>>>>>
>>>>>>>>>>>> They could not understand why H(D,D)==0 and H1(D,D)==1 are
>>>>>>>>>>>> both correct.
>>>>>>>>>>>>
>>>>>>>>>>>> The reason the simulated input to H(D,D) correctly has
>>>>>>>>>>>> different behavior than the simulated input to H1(D,D) is
>>>>>>>>>>>> that H(D,D) D calls H(D,D) thus putting itself in recursive
>>>>>>>>>>>> simulation. H1(D,D) D calls H(D,D) yet this does not put
>>>>>>>>>>>> itself in recursive simulation. One cannot correctly simply
>>>>>>>>>>>> ignore these differences and form any valid rebuttal.
>>>>>>>>>>>>
>>>>>>>>>>>> If an input specifies a pathological relationship to its
>>>>>>>>>>>> simulator this relationship must be simulated or the
>>>>>>>>>>>> simulation is not correct. They maintained that every
>>>>>>>>>>>> correct simulation of an input must derive the same
>>>>>>>>>>>> behavior for this input thus simply ignoring the case
>>>>>>>>>>>> where an input is defined to have a pathological
>>>>>>>>>>>> relationship to its simulator.
>>>>>>>>>>>
>>>>>>>>>>> That seems much the same as everyone else here has been
>>>>>>>>>>> telling you. Does that mean you're beginning to accept it
>>>>>>>>>>> might be right?
>>>>>>>>>>
>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott
>>>>>>>>>> > wrote:
>>>>>>>>>> >> If a simulating halt decider continues to correctly
>>>>>>>>>> >> simulate its input until it correctly matches a
>>>>>>>>>> >> non-halting behavior pattern then this SHD is
>>>>>>>>>> >> necessarily correct when it aborts its simulation and
>>>>>>>>>> >> reports non-halting.
>>>>>>>>>> >
>>>>>>>>>> > Yes, *If* a simulating halt decider continues to
>>>>>>>>>> > correctly simulate its input until it *correctly*
>>>>>>>>>> > matches a non- halting behaviour pattern then this SHD
>>>>>>>>>> > is correct when it aborts its simulation and reports
>>>>>>>>>> > non-halting.
>>>>>>>>>>
>>>>>>>>>> If everyone every where agreed that 3 + 5 = 65.7 I would know
>>>>>>>>>> they are all liars. It is conclusively proven beyond all
>>>>>>>>>> possible doubt that D correctly simulated by H cannot
>>>>>>>>>> possibly stop running unless aborted.
>>>>>>>>>>
>>>>>>>>>> Ben has admitted this, and two of my friends that have
>>>>>>>>>> masters degrees in computer science verified this.
>>>>>>>>>>
>>>>>>>>>> This is shown more clearly as PP correctly simulated by HH on
>>>>>>>>>> pages 5-6
>>>>>>>>>>
>>>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
>>>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When the input is defined to have a pathological relationship
>>>>>>>>>> to its simulator this changes the behavior of the simulated
>>>>>>>>>> input such that its correct simulation and its direct
>>>>>>>>>> execution have different behavior.
>>>>>>>>>>
>>>>>>>>>> A simulating halt decider need not pay attention to this
>>>>>>>>>> difference it only needs to compute the mapping from its
>>>>>>>>>> input to an accept or reject state on the basis of its
>>>>>>>>>> correct simulation of its input.
>>>>>>>>>>
>>>>>>>>>> It is verified that the simulation is correct in that there
>>>>>>>>>> is a line-by-line exact correspondence between the simulated
>>>>>>>>>> lines and the x86 source code of PP.
>>>>>>>>>>
>>>>>>>>>> D simulated by UTM1(D,D) where D is defined to call UTM1(D,D)
>>>>>>>>>> will remain stuck in infinitely recursive simulation.
>>>>>>>>>
>>>>>>>>> You are correct: there is a category error in [Strachey 1965]
>>>>>>>>> and associated proofs which manifests as nested simulation
>>>>>>>>> when the halt decider is of the simulating type. Now what?
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> If a Turing computable function H can correctly recognize that
>>>>>>>> its input D correctly simulated by itself is calling itself in
>>>>>>>> recursive simulation then H can stop simulating D and correctly
>>>>>>>> reject D as non-halting. This is conclusively proven at the C
>>>>>>>> level even if PhD computer scientists disagree.
>>>>>>>
>>>>>>> I still think mapping the manifestation of a category error to a
>>>>>>> halting decision of non-halting is artificial at best. One can
>>>>>>> simply refute the halting problem proofs by demonstrating the
>>>>>>> presence of the category error alone.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Any correctly simulated input that only stops running when its
>>>>>> simulation is aborted is non-halting by tautology.
>>>>>>
>>>>>> For it to be an actual category error the correctly simulated
>>>>>> input would have to neither stop running nor not stop running
>>>>>> when its simulation is aborted.
>>>>>>
>>>>>> What time is is (yes or no) ? Is a category error.
>>>>>>
>>>>>> How many feet long is the color of your car? Is a category error.
>>>>>>
>>>>>> What is the integer arithmetic sum of mustard and house bricks?
>>>>>> Is a category error.
>>>>>>
>>>>>> Is this sentence true or false: "This sentence is not true." Is a
>>>>>> category error.
>>>>>
>>>>> No. The category error is the self reference with the two
>>>>> categories being the decider and the input.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> A category error can only be miscategorization (putting things in
>>>> the wrong category). Saying that an animal is a category of office
>>>> building is a category error.
>>>
>>> Yes that is an example of a category error and another example of a
>>> category error is the self reference in [Strachey 1965] and
>>> associated proofs with the categories being the input and the
>>> decider: the input cannot pass itself to the decider.
>>>
>>> /Flibble
>>>
>>
>> In your case "cannot" means {should not} and thus not an actual
>> category error of {it is utterly impossible} for D to call H with the
>> machine description of itself.
>
> Wrong, it is a category error (self reference) which will manifest as
> nested simulation if the decider is of the simulating type.
>
>>
>> It is utterly impossible for the category of living creature {animal}
>> to be an element of the set of {office buildings}.
>
> Why do you keep giving me fucktarded examples of category errors? I know
> what a category error is but I am not sure you do, at least fully, as
> you cannot see how the self reference in [Strachey 1965] and associated
> proofs is a category error.
>
> /Flibble

On Wed, 9 Nov 2022 12:14:11 -0600
olcott <none-ya@beez-waxes.com> wrote:

> On 11/9/2022 11:56 AM, Mr Flibble wrote:
> > On Wed, 9 Nov 2022 11:24:42 -0600
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 11/9/2022 11:19 AM, Mr Flibble wrote:
> >>> On Tue, 8 Nov 2022 18:13:04 -0600
> >>> olcott <none-ya@beez-waxes.com> wrote:
> >>>
> >>>> On 11/8/2022 5:36 PM, Mr Flibble wrote:
> >>>>> On Tue, 8 Nov 2022 15:35:06 -0600
> >>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>
> >>>>>> On 11/8/2022 2:53 PM, Mr Flibble wrote:
> >>>>>>> On Tue, 8 Nov 2022 11:40:18 -0600
> >>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>
> >>>>>>>> On 11/8/2022 11:24 AM, Mr Flibble wrote:
> >>>>>>>>> On Tue, 8 Nov 2022 09:52:22 -0600
> >>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 11/8/2022 5:13 AM, Paul N wrote:
> >>>>>>>>>>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott
> >>>>>>>>>>> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>> [Title: A PhD computer scientist spent three days in chat
> >>>>>>>>>>> reviewing my paper]
> >>>>>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
> >>>>>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>>>>>>>>>>>
> >>>>>>>>>>>> They could not understand why H(D,D)==0 and H1(D,D)==1
> >>>>>>>>>>>> are both correct.
> >>>>>>>>>>>>
> >>>>>>>>>>>> The reason the simulated input to H(D,D) correctly has
> >>>>>>>>>>>> different behavior than the simulated input to H1(D,D) is
> >>>>>>>>>>>> that H(D,D) D calls H(D,D) thus putting itself in
> >>>>>>>>>>>> recursive simulation. H1(D,D) D calls H(D,D) yet this
> >>>>>>>>>>>> does not put itself in recursive simulation. One cannot
> >>>>>>>>>>>> correctly simply ignore these differences and form any
> >>>>>>>>>>>> valid rebuttal.
> >>>>>>>>>>>>
> >>>>>>>>>>>> If an input specifies a pathological relationship to its
> >>>>>>>>>>>> simulator this relationship must be simulated or the
> >>>>>>>>>>>> simulation is not correct. They maintained that every
> >>>>>>>>>>>> correct simulation of an input must derive the same
> >>>>>>>>>>>> behavior for this input thus simply ignoring the case
> >>>>>>>>>>>> where an input is defined to have a pathological
> >>>>>>>>>>>> relationship to its simulator.
> >>>>>>>>>>>
> >>>>>>>>>>> That seems much the same as everyone else here has been
> >>>>>>>>>>> telling you. Does that mean you're beginning to accept it
> >>>>>>>>>>> might be right?
> >>>>>>>>>>
> >>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
> >>>>>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1,
> >>>>>>>>>> > olcott wrote:
> >>>>>>>>>> >> If a simulating halt decider continues to
> >>>>>>>>>> >> correctly simulate its input until it correctly
> >>>>>>>>>> >> matches a non-halting behavior pattern then this
> >>>>>>>>>> >> SHD is necessarily correct when it aborts its
> >>>>>>>>>> >> simulation and reports non-halting.
> >>>>>>>>>> >
> >>>>>>>>>> > Yes, *If* a simulating halt decider continues to
> >>>>>>>>>> > correctly simulate its input until it *correctly*
> >>>>>>>>>> > matches a non- halting behaviour pattern then this
> >>>>>>>>>> > SHD is correct when it aborts its simulation and
> >>>>>>>>>> > reports non-halting.
> >>>>>>>>>>
> >>>>>>>>>> If everyone every where agreed that 3 + 5 = 65.7 I would
> >>>>>>>>>> know they are all liars. It is conclusively proven beyond
> >>>>>>>>>> all possible doubt that D correctly simulated by H cannot
> >>>>>>>>>> possibly stop running unless aborted.
> >>>>>>>>>>
> >>>>>>>>>> Ben has admitted this, and two of my friends that have
> >>>>>>>>>> masters degrees in computer science verified this.
> >>>>>>>>>>
> >>>>>>>>>> This is shown more clearly as PP correctly simulated by HH
> >>>>>>>>>> on pages 5-6
> >>>>>>>>>>
> >>>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
> >>>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> When the input is defined to have a pathological
> >>>>>>>>>> relationship to its simulator this changes the behavior of
> >>>>>>>>>> the simulated input such that its correct simulation and
> >>>>>>>>>> its direct execution have different behavior.
> >>>>>>>>>>
> >>>>>>>>>> A simulating halt decider need not pay attention to this
> >>>>>>>>>> difference it only needs to compute the mapping from its
> >>>>>>>>>> input to an accept or reject state on the basis of its
> >>>>>>>>>> correct simulation of its input.
> >>>>>>>>>>
> >>>>>>>>>> It is verified that the simulation is correct in that there
> >>>>>>>>>> is a line-by-line exact correspondence between the
> >>>>>>>>>> simulated lines and the x86 source code of PP.
> >>>>>>>>>>
> >>>>>>>>>> D simulated by UTM1(D,D) where D is defined to call
> >>>>>>>>>> UTM1(D,D) will remain stuck in infinitely recursive
> >>>>>>>>>> simulation.
> >>>>>>>>>
> >>>>>>>>> You are correct: there is a category error in [Strachey
> >>>>>>>>> 1965] and associated proofs which manifests as nested
> >>>>>>>>> simulation when the halt decider is of the simulating type.
> >>>>>>>>> Now what?
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> If a Turing computable function H can correctly recognize
> >>>>>>>> that its input D correctly simulated by itself is calling
> >>>>>>>> itself in recursive simulation then H can stop simulating D
> >>>>>>>> and correctly reject D as non-halting. This is conclusively
> >>>>>>>> proven at the C level even if PhD computer scientists
> >>>>>>>> disagree.
> >>>>>>>
> >>>>>>> I still think mapping the manifestation of a category error
> >>>>>>> to a halting decision of non-halting is artificial at best.
> >>>>>>> One can simply refute the halting problem proofs by
> >>>>>>> demonstrating the presence of the category error alone.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> Any correctly simulated input that only stops running when its
> >>>>>> simulation is aborted is non-halting by tautology.
> >>>>>>
> >>>>>> For it to be an actual category error the correctly simulated
> >>>>>> input would have to neither stop running nor not stop running
> >>>>>> when its simulation is aborted.
> >>>>>>
> >>>>>> What time is is (yes or no) ? Is a category error.
> >>>>>>
> >>>>>> How many feet long is the color of your car? Is a category
> >>>>>> error.
> >>>>>>
> >>>>>> What is the integer arithmetic sum of mustard and house bricks?
> >>>>>> Is a category error.
> >>>>>>
> >>>>>> Is this sentence true or false: "This sentence is not true."
> >>>>>> Is a category error.
> >>>>>
> >>>>> No. The category error is the self reference with the two
> >>>>> categories being the decider and the input.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> A category error can only be miscategorization (putting things in
> >>>> the wrong category). Saying that an animal is a category of
> >>>> office building is a category error.
> >>>
> >>> Yes that is an example of a category error and another example of
> >>> a category error is the self reference in [Strachey 1965] and
> >>> associated proofs with the categories being the input and the
> >>> decider: the input cannot pass itself to the decider.
> >>>
> >>> /Flibble
> >>>
> >>
> >> In your case "cannot" means {should not} and thus not an actual
> >> category error of {it is utterly impossible} for D to call H with
> >> the machine description of itself.
> >
> > Wrong, it is a category error (self reference) which will manifest
> > as nested simulation if the decider is of the simulating type.
> >
> >>
> >> It is utterly impossible for the category of living creature
> >> {animal} to be an element of the set of {office buildings}.
> >
> > Why do you keep giving me fucktarded examples of category errors? I
> > know what a category error is but I am not sure you do, at least
> > fully, as you cannot see how the self reference in [Strachey 1965]
> > and associated proofs is a category error.
> >
> > /Flibble
> >
> >
>
> It is not 100% impossible for D to call H with itself as input thus
> proving that you do not know what a category error is.

On Wed, 9 Nov 2022 12:19:37 -0600
olcott <none-ya@beez-waxes.com> wrote:

> On 11/9/2022 11:56 AM, Mr Flibble wrote:
> > On Wed, 9 Nov 2022 11:24:42 -0600
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 11/9/2022 11:19 AM, Mr Flibble wrote:
> >>> On Tue, 8 Nov 2022 18:13:04 -0600
> >>> olcott <none-ya@beez-waxes.com> wrote:
> >>>
> >>>> On 11/8/2022 5:36 PM, Mr Flibble wrote:
> >>>>> On Tue, 8 Nov 2022 15:35:06 -0600
> >>>>> olcott <none-ya@beez-waxes.com> wrote:
> >>>>>
> >>>>>> On 11/8/2022 2:53 PM, Mr Flibble wrote:
> >>>>>>> On Tue, 8 Nov 2022 11:40:18 -0600
> >>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>
> >>>>>>>> On 11/8/2022 11:24 AM, Mr Flibble wrote:
> >>>>>>>>> On Tue, 8 Nov 2022 09:52:22 -0600
> >>>>>>>>> olcott <polcott2@gmail.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 11/8/2022 5:13 AM, Paul N wrote:
> >>>>>>>>>>> On Monday, November 7, 2022 at 5:23:36 PM UTC, olcott
> >>>>>>>>>>> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>> [Title: A PhD computer scientist spent three days in chat
> >>>>>>>>>>> reviewing my paper]
> >>>>>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
> >>>>>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>>>>>>>>>>>
> >>>>>>>>>>>> They could not understand why H(D,D)==0 and H1(D,D)==1
> >>>>>>>>>>>> are both correct.
> >>>>>>>>>>>>
> >>>>>>>>>>>> The reason the simulated input to H(D,D) correctly has
> >>>>>>>>>>>> different behavior than the simulated input to H1(D,D) is
> >>>>>>>>>>>> that H(D,D) D calls H(D,D) thus putting itself in
> >>>>>>>>>>>> recursive simulation. H1(D,D) D calls H(D,D) yet this
> >>>>>>>>>>>> does not put itself in recursive simulation. One cannot
> >>>>>>>>>>>> correctly simply ignore these differences and form any
> >>>>>>>>>>>> valid rebuttal.
> >>>>>>>>>>>>
> >>>>>>>>>>>> If an input specifies a pathological relationship to its
> >>>>>>>>>>>> simulator this relationship must be simulated or the
> >>>>>>>>>>>> simulation is not correct. They maintained that every
> >>>>>>>>>>>> correct simulation of an input must derive the same
> >>>>>>>>>>>> behavior for this input thus simply ignoring the case
> >>>>>>>>>>>> where an input is defined to have a pathological
> >>>>>>>>>>>> relationship to its simulator.
> >>>>>>>>>>>
> >>>>>>>>>>> That seems much the same as everyone else here has been
> >>>>>>>>>>> telling you. Does that mean you're beginning to accept it
> >>>>>>>>>>> might be right?
> >>>>>>>>>>
> >>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
> >>>>>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM UTC+1,
> >>>>>>>>>> > olcott wrote:
> >>>>>>>>>> >> If a simulating halt decider continues to
> >>>>>>>>>> >> correctly simulate its input until it correctly
> >>>>>>>>>> >> matches a non-halting behavior pattern then this
> >>>>>>>>>> >> SHD is necessarily correct when it aborts its
> >>>>>>>>>> >> simulation and reports non-halting.
> >>>>>>>>>> >
> >>>>>>>>>> > Yes, *If* a simulating halt decider continues to
> >>>>>>>>>> > correctly simulate its input until it *correctly*
> >>>>>>>>>> > matches a non- halting behaviour pattern then this
> >>>>>>>>>> > SHD is correct when it aborts its simulation and
> >>>>>>>>>> > reports non-halting.
> >>>>>>>>>>
> >>>>>>>>>> If everyone every where agreed that 3 + 5 = 65.7 I would
> >>>>>>>>>> know they are all liars. It is conclusively proven beyond
> >>>>>>>>>> all possible doubt that D correctly simulated by H cannot
> >>>>>>>>>> possibly stop running unless aborted.
> >>>>>>>>>>
> >>>>>>>>>> Ben has admitted this, and two of my friends that have
> >>>>>>>>>> masters degrees in computer science verified this.
> >>>>>>>>>>
> >>>>>>>>>> This is shown more clearly as PP correctly simulated by HH
> >>>>>>>>>> on pages 5-6
> >>>>>>>>>>
> >>>>>>>>>> Simulating Halt Decider Applied to the Halting Theorem
> >>>>>>>>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> When the input is defined to have a pathological
> >>>>>>>>>> relationship to its simulator this changes the behavior of
> >>>>>>>>>> the simulated input such that its correct simulation and
> >>>>>>>>>> its direct execution have different behavior.
> >>>>>>>>>>
> >>>>>>>>>> A simulating halt decider need not pay attention to this
> >>>>>>>>>> difference it only needs to compute the mapping from its
> >>>>>>>>>> input to an accept or reject state on the basis of its
> >>>>>>>>>> correct simulation of its input.
> >>>>>>>>>>
> >>>>>>>>>> It is verified that the simulation is correct in that there
> >>>>>>>>>> is a line-by-line exact correspondence between the
> >>>>>>>>>> simulated lines and the x86 source code of PP.
> >>>>>>>>>>
> >>>>>>>>>> D simulated by UTM1(D,D) where D is defined to call
> >>>>>>>>>> UTM1(D,D) will remain stuck in infinitely recursive
> >>>>>>>>>> simulation.
> >>>>>>>>>
> >>>>>>>>> You are correct: there is a category error in [Strachey
> >>>>>>>>> 1965] and associated proofs which manifests as nested
> >>>>>>>>> simulation when the halt decider is of the simulating type.
> >>>>>>>>> Now what?
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> If a Turing computable function H can correctly recognize
> >>>>>>>> that its input D correctly simulated by itself is calling
> >>>>>>>> itself in recursive simulation then H can stop simulating D
> >>>>>>>> and correctly reject D as non-halting. This is conclusively
> >>>>>>>> proven at the C level even if PhD computer scientists
> >>>>>>>> disagree.
> >>>>>>>
> >>>>>>> I still think mapping the manifestation of a category error
> >>>>>>> to a halting decision of non-halting is artificial at best.
> >>>>>>> One can simply refute the halting problem proofs by
> >>>>>>> demonstrating the presence of the category error alone.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> Any correctly simulated input that only stops running when its
> >>>>>> simulation is aborted is non-halting by tautology.
> >>>>>>
> >>>>>> For it to be an actual category error the correctly simulated
> >>>>>> input would have to neither stop running nor not stop running
> >>>>>> when its simulation is aborted.
> >>>>>>
> >>>>>> What time is is (yes or no) ? Is a category error.
> >>>>>>
> >>>>>> How many feet long is the color of your car? Is a category
> >>>>>> error.
> >>>>>>
> >>>>>> What is the integer arithmetic sum of mustard and house bricks?
> >>>>>> Is a category error.
> >>>>>>
> >>>>>> Is this sentence true or false: "This sentence is not true."
> >>>>>> Is a category error.
> >>>>>
> >>>>> No. The category error is the self reference with the two
> >>>>> categories being the decider and the input.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> A category error can only be miscategorization (putting things in
> >>>> the wrong category). Saying that an animal is a category of
> >>>> office building is a category error.
> >>>
> >>> Yes that is an example of a category error and another example of
> >>> a category error is the self reference in [Strachey 1965] and
> >>> associated proofs with the categories being the input and the
> >>> decider: the input cannot pass itself to the decider.
> >>>
> >>> /Flibble
> >>>
> >>
> >> In your case "cannot" means {should not} and thus not an actual
> >> category error of {it is utterly impossible} for D to call H with
> >> the machine description of itself.
> >
> > Wrong, it is a category error (self reference) which will manifest
> > as nested simulation if the decider is of the simulating type.
> >
> >>
> >> It is utterly impossible for the category of living creature
> >> {animal} to be an element of the set of {office buildings}.
> >
> > Why do you keep giving me fucktarded examples of category errors? I
> > know what a category error is but I am not sure you do, at least
> > fully, as you cannot see how the self reference in [Strachey 1965]
> > and associated proofs is a category error.
> >
> > /Flibble
>
>
> Category mistakes are sentences such as ‘The number two is blue’,
> ‘The theory of relativity is eating breakfast’, or ‘Green ideas sleep
> furiously’. https://plato.stanford.edu/entries/category-mistakes/

On 2022-11-09 18:34:43 +0000, Mr Flibble said:

> Again with the childish examples of category errors: I KNOW WHAT A
> CATEGORY ERROR IS, DEAR.

Maybe you should prove that you know. A mere claim is not very
convincing, especially when written in all caps.

Mikko