Blocking/ignoring your reviewers means only one thing: you do not want
an honest review of your work and you are yourself dishonest.

/Flibble

On 8/27/2022 11:28 AM, Mr Flibble wrote:
> Blocking/ignoring your reviewers means only one thing: you do not want
> an honest review of your work and you are yourself dishonest.
>
> /Flibble
>

--
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 Sat, 27 Aug 2022 11:58:13 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/27/2022 11:28 AM, Mr Flibble wrote:
> > Blocking/ignoring your reviewers means only one thing: you do not
> > want an honest review of your work and you are yourself dishonest.
> >
> > /Flibble
> >
>
>

On 8/27/2022 12:12 PM, Mr Flibble wrote:
> On Sat, 27 Aug 2022 11:58:13 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>> Blocking/ignoring your reviewers means only one thing: you do not
>>> want an honest review of your work and you are yourself dishonest.
>>>
>>> /Flibble
>>>
>>
>>
>
>

--
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 8/27/22 1:15 PM, olcott wrote:
> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>> On Sat, 27 Aug 2022 11:58:13 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>> Blocking/ignoring your reviewers means only one thing: you do not
>>>> want an honest review of your work and you are yourself dishonest.
>>>>
>>>> /Flibble
>>>
>>>
>>
>>
>
>

On 8/27/2022 11:15 AM, olcott wrote:
> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>> On Sat, 27 Aug 2022 11:58:13 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>> Blocking/ignoring your reviewers means only one thing: you do not
>>>> want an honest review of your work and you are yourself dishonest.
>>>>
>>>> /Flibble
>>>
>>>
>>
>>
>
>

Fibble, I must hand it to you! The PO contributions (nothing in this
thread) are symbolic and corporally in sink!
--
Jeff Barnett

On 8/27/2022 12:29 PM, Richard Damon wrote:
> On 8/27/22 1:15 PM, olcott wrote:
>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>> Blocking/ignoring your reviewers means only one thing: you do not
>>>>> want an honest review of your work and you are yourself dishonest.
>>>>>
>>>>> /Flibble

*No one would build a complete operating system as a mere ruse*
*No one would build a complete operating system as a mere ruse*
*No one would build a complete operating system as a mere ruse*
*No one would build a complete operating system as a mere ruse*

This is the complete system:
https://www.liarparadox.org/2022_08_16.zip

Microsoft Visual Studio Community 2017
https://visualstudio.microsoft.com/vs/older-downloads/

--
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 8/27/2022 12:32 PM, Jeff Barnett wrote:
> On 8/27/2022 11:15 AM, olcott wrote:
>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>> Blocking/ignoring your reviewers means only one thing: you do not
>>>>> want an honest review of your work and you are yourself dishonest.
>>>>>
>>>>> /Flibble
>>>>
>>>>
>>>
>>>
>>
>>
>
> Fibble, I must hand it to you! The PO contributions (nothing in this
> thread) are symbolic and corporally in sink!

*No one would build a complete operating system as a mere ruse*
*No one would build a complete operating system as a mere ruse*
*No one would build a complete operating system as a mere ruse*
*No one would build a complete operating system as a mere ruse*

This is the complete system:
https://www.liarparadox.org/2022_08_16.zip

Microsoft Visual Studio Community 2017
https://visualstudio.microsoft.com/vs/older-downloads/

--
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 Sat, 27 Aug 2022 12:35:44 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/27/2022 12:29 PM, Richard Damon wrote:
> > On 8/27/22 1:15 PM, olcott wrote:
> >> On 8/27/2022 12:12 PM, Mr Flibble wrote:
> >>> On Sat, 27 Aug 2022 11:58:13 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
> >>>>> Blocking/ignoring your reviewers means only one thing: you do
> >>>>> not want an honest review of your work and you are yourself
> >>>>> dishonest.
> >>>>>
> >>>>> /Flibble
>
> *No one would build a complete operating system as a mere ruse*
> *No one would build a complete operating system as a mere ruse*
> *No one would build a complete operating system as a mere ruse*
> *No one would build a complete operating system as a mere ruse*
>
> This is the complete system:
> https://www.liarparadox.org/2022_08_16.zip
>
> Microsoft Visual Studio Community 2017
> https://visualstudio.microsoft.com/vs/older-downloads/

Ah so you are claiming to be a member of the Terry A. Davis (R.I.P)
club? It all makes sense now: you are simply a nutter.

/Flibble

On 8/27/2022 12:42 PM, Mr Flibble wrote:
> On Sat, 27 Aug 2022 12:35:44 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/27/2022 12:29 PM, Richard Damon wrote:
>>> On 8/27/22 1:15 PM, olcott wrote:
>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>>> Blocking/ignoring your reviewers means only one thing: you do
>>>>>>> not want an honest review of your work and you are yourself
>>>>>>> dishonest.
>>>>>>>
>>>>>>> /Flibble
>>
>> *No one would build a complete operating system as a mere ruse*
>> *No one would build a complete operating system as a mere ruse*
>> *No one would build a complete operating system as a mere ruse*
>> *No one would build a complete operating system as a mere ruse*
>>
>> This is the complete system:
>> https://www.liarparadox.org/2022_08_16.zip
>>
>> Microsoft Visual Studio Community 2017
>> https://visualstudio.microsoft.com/vs/older-downloads/
>
> Ah so you are claiming to be a member of the Terry A. Davis (R.I.P)
> club? It all makes sense now: you are simply a nutter.
>
> /Flibble
>

void Px(void (*x)())
{ (void) H(x, x);
return;
}

int main()
{ Output("Input_Halts = ", H(Px, Px));
}

Flibble does not understand that

when simulating halt decider H(Px,Px) correctly simulates its input the
"return" instruction of the simulated Px in unreachable by this
simulated Px.

--
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 Sat, 27 Aug 2022 12:56:31 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/27/2022 12:42 PM, Mr Flibble wrote:
> > On Sat, 27 Aug 2022 12:35:44 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/27/2022 12:29 PM, Richard Damon wrote:
> >>> On 8/27/22 1:15 PM, olcott wrote:
> >>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
> >>>>> On Sat, 27 Aug 2022 11:58:13 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
> >>>>>>> Blocking/ignoring your reviewers means only one thing: you do
> >>>>>>> not want an honest review of your work and you are yourself
> >>>>>>> dishonest.
> >>>>>>>
> >>>>>>> /Flibble
> >>
> >> *No one would build a complete operating system as a mere ruse*
> >> *No one would build a complete operating system as a mere ruse*
> >> *No one would build a complete operating system as a mere ruse*
> >> *No one would build a complete operating system as a mere ruse*
> >>
> >> This is the complete system:
> >> https://www.liarparadox.org/2022_08_16.zip
> >>
> >> Microsoft Visual Studio Community 2017
> >> https://visualstudio.microsoft.com/vs/older-downloads/
> >
> > Ah so you are claiming to be a member of the Terry A. Davis (R.I.P)
> > club? It all makes sense now: you are simply a nutter.
> >
> > /Flibble
> >
>
> void Px(void (*x)())
> {
> (void) H(x, x);
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(Px, Px));
> }
>
> Flibble does not understand that
>
> when simulating halt decider H(Px,Px) correctly simulates its input
> the "return" instruction of the simulated Px in unreachable by this
> simulated Px.

Px should always halt you nutter: your H prevents Px from correctly
halting as your H is designed incorrectly: it isn't a halt decider.

"That bloke's a nutter!"

/Flibble

On 8/27/22 1:37 PM, olcott wrote:
> On 8/27/2022 12:32 PM, Jeff Barnett wrote:
>> On 8/27/2022 11:15 AM, olcott wrote:
>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>> Blocking/ignoring your reviewers means only one thing: you do not
>>>>>> want an honest review of your work and you are yourself dishonest.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>>
>>>>
>>>>
>>>
>>>
>>
>> Fibble, I must hand it to you! The PO contributions (nothing in this
>> thread) are symbolic and corporally in sink!
>
> *No one would build a complete operating system as a mere ruse*
> *No one would build a complete operating system as a mere ruse*
> *No one would build a complete operating system as a mere ruse*
> *No one would build a complete operating system as a mere ruse*
>
> This is the complete system:
> https://www.liarparadox.org/2022_08_16.zip
>
> Microsoft Visual Studio Community 2017
> https://visualstudio.microsoft.com/vs/older-downloads/
>
>

Which isn't really an Operating System by the normal definition, as it
needs an operating system to run itself.

It is just a framework.

You are really showing your (lack of) knowledge about Computer Science
and Software Engineering.

It also is mostly someone elses code.

On 8/27/2022 12:58 PM, Mr Flibble wrote:
> On Sat, 27 Aug 2022 12:56:31 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/27/2022 12:42 PM, Mr Flibble wrote:
>>> On Sat, 27 Aug 2022 12:35:44 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
>>>>> On 8/27/22 1:15 PM, olcott wrote:
>>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>>>>> Blocking/ignoring your reviewers means only one thing: you do
>>>>>>>>> not want an honest review of your work and you are yourself
>>>>>>>>> dishonest.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>
>>>> *No one would build a complete operating system as a mere ruse*
>>>> *No one would build a complete operating system as a mere ruse*
>>>> *No one would build a complete operating system as a mere ruse*
>>>> *No one would build a complete operating system as a mere ruse*
>>>>
>>>> This is the complete system:
>>>> https://www.liarparadox.org/2022_08_16.zip
>>>>
>>>> Microsoft Visual Studio Community 2017
>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>
>>> Ah so you are claiming to be a member of the Terry A. Davis (R.I.P)
>>> club? It all makes sense now: you are simply a nutter.
>>>
>>> /Flibble
>>>
>>
>> void Px(void (*x)())
>> {
>> (void) H(x, x);
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(Px, Px));
>> }
>>
>> Flibble does not understand that
>>
>> when simulating halt decider H(Px,Px) correctly simulates its input
>> the "return" instruction of the simulated Px in unreachable by this
>> simulated Px.
>
> Px should always halt you nutter:

It is a matter of easily verified fact the Px never reaches its final
state. I have fully operational software that proves this.
All that you have is misconceptions and empty rhetoric.

> your H prevents Px from correctly
> halting as your H is designed incorrectly: it isn't a halt decider.
>
> "That bloke's a nutter!"
>
> /Flibble
>

--
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 Sat, 27 Aug 2022 13:08:42 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/27/2022 12:58 PM, Mr Flibble wrote:
> > On Sat, 27 Aug 2022 12:56:31 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/27/2022 12:42 PM, Mr Flibble wrote:
> >>> On Sat, 27 Aug 2022 12:35:44 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
> >>>>> On 8/27/22 1:15 PM, olcott wrote:
> >>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
> >>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
> >>>>>>>>> Blocking/ignoring your reviewers means only one thing: you
> >>>>>>>>> do not want an honest review of your work and you are
> >>>>>>>>> yourself dishonest.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>
> >>>> *No one would build a complete operating system as a mere ruse*
> >>>> *No one would build a complete operating system as a mere ruse*
> >>>> *No one would build a complete operating system as a mere ruse*
> >>>> *No one would build a complete operating system as a mere ruse*
> >>>>
> >>>> This is the complete system:
> >>>> https://www.liarparadox.org/2022_08_16.zip
> >>>>
> >>>> Microsoft Visual Studio Community 2017
> >>>> https://visualstudio.microsoft.com/vs/older-downloads/
> >>>
> >>> Ah so you are claiming to be a member of the Terry A. Davis
> >>> (R.I.P) club? It all makes sense now: you are simply a nutter.
> >>>
> >>> /Flibble
> >>>
> >>
> >> void Px(void (*x)())
> >> {
> >> (void) H(x, x);
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H(Px, Px));
> >> }
> >>
> >> Flibble does not understand that
> >>
> >> when simulating halt decider H(Px,Px) correctly simulates its input
> >> the "return" instruction of the simulated Px in unreachable by this
> >> simulated Px.
> >
> > Px should always halt you nutter:
>
> It is a matter of easily verified fact the Px never reaches its final
> state. I have fully operational software that proves this.
> All that you have is misconceptions and empty rhetoric.

Px halts if H is designed correctly (a valid halt decider always
returns a result to its caller) ergo H is not designed correctly.
Simple undeniable logic, dear.

/Flibble

On 8/27/22 2:08 PM, olcott wrote:
> On 8/27/2022 12:58 PM, Mr Flibble wrote:
>> On Sat, 27 Aug 2022 12:56:31 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 8/27/2022 12:42 PM, Mr Flibble wrote:
>>>> On Sat, 27 Aug 2022 12:35:44 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
>>>>>> On 8/27/22 1:15 PM, olcott wrote:
>>>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>>>>>> Blocking/ignoring your reviewers means only one thing: you do
>>>>>>>>>> not want an honest review of your work and you are yourself
>>>>>>>>>> dishonest.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>
>>>>> *No one would build a complete operating system as a mere ruse*
>>>>> *No one would build a complete operating system as a mere ruse*
>>>>> *No one would build a complete operating system as a mere ruse*
>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>
>>>>> This is the complete system:
>>>>> https://www.liarparadox.org/2022_08_16.zip
>>>>>
>>>>> Microsoft Visual Studio Community 2017
>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>
>>>> Ah so you are claiming to be a member of the Terry A. Davis (R.I.P)
>>>> club?  It all makes sense now: you are simply a nutter.
>>>>
>>>> /Flibble
>>>
>>> void Px(void (*x)())
>>> {
>>>     (void) H(x, x);
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     Output("Input_Halts = ", H(Px, Px));
>>> }
>>>
>>> Flibble does not understand that
>>>
>>> when simulating halt decider H(Px,Px) correctly simulates its input
>>> the "return" instruction of the simulated Px in unreachable by this
>>> simulated Px.
>>
>> Px should always halt you nutter:
>
> It is a matter of easily verified fact the Px never reaches its final
> state. I have fully operational software that proves this.
> All that you have is misconceptions and empty rhetoric.

Maybe you should try to actually verify that.

Show that Simulate(Px,Px) will run forever.

Note, you have published a trace of a related function that proves this
will happen. You are just are showing your incompetence, as you seem to
think that because one program aborts its simulation of an input that
the correct and complete simulation of that input, which even YOU have
agreed is the actual definition of the behavior has to stop there too.

In this case the Correct and Complete Simulation of the input will Halt,
because H(Px,Px) will abort its simulation and return.

>
>> your H prevents Px from correctly
>> halting as your H is designed incorrectly: it isn't a halt decider.
>>
>> "That bloke's a nutter!"
>>
>> /Flibble
>>
>
>

On 8/27/2022 1:12 PM, Mr Flibble wrote:
> On Sat, 27 Aug 2022 13:08:42 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/27/2022 12:58 PM, Mr Flibble wrote:
>>> On Sat, 27 Aug 2022 12:56:31 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/27/2022 12:42 PM, Mr Flibble wrote:
>>>>> On Sat, 27 Aug 2022 12:35:44 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
>>>>>>> On 8/27/22 1:15 PM, olcott wrote:
>>>>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>>>>>>> Blocking/ignoring your reviewers means only one thing: you
>>>>>>>>>>> do not want an honest review of your work and you are
>>>>>>>>>>> yourself dishonest.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>
>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>
>>>>>> This is the complete system:
>>>>>> https://www.liarparadox.org/2022_08_16.zip
>>>>>>
>>>>>> Microsoft Visual Studio Community 2017
>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>
>>>>> Ah so you are claiming to be a member of the Terry A. Davis
>>>>> (R.I.P) club? It all makes sense now: you are simply a nutter.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> void Px(void (*x)())
>>>> {
>>>> (void) H(x, x);
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(Px, Px));
>>>> }
>>>>
>>>> Flibble does not understand that
>>>>
>>>> when simulating halt decider H(Px,Px) correctly simulates its input
>>>> the "return" instruction of the simulated Px in unreachable by this
>>>> simulated Px.
>>>
>>> Px should always halt you nutter:
>>
>> It is a matter of easily verified fact the Px never reaches its final
>> state. I have fully operational software that proves this.
>> All that you have is misconceptions and empty rhetoric.
>
> Px halts if H is designed correctly (a valid halt decider always
> returns a result to its caller) ergo H is not designed correctly.
> Simple undeniable logic, dear.
>
> /Flibble
>

That is not the same as you claimed:
>>> Px should always halt you nutter:

--
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 8/27/2022 1:12 PM, Mr Flibble wrote:
> On Sat, 27 Aug 2022 13:08:42 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/27/2022 12:58 PM, Mr Flibble wrote:
>>> On Sat, 27 Aug 2022 12:56:31 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/27/2022 12:42 PM, Mr Flibble wrote:
>>>>> On Sat, 27 Aug 2022 12:35:44 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
>>>>>>> On 8/27/22 1:15 PM, olcott wrote:
>>>>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>>>>>>> Blocking/ignoring your reviewers means only one thing: you
>>>>>>>>>>> do not want an honest review of your work and you are
>>>>>>>>>>> yourself dishonest.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>
>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>
>>>>>> This is the complete system:
>>>>>> https://www.liarparadox.org/2022_08_16.zip
>>>>>>
>>>>>> Microsoft Visual Studio Community 2017
>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>
>>>>> Ah so you are claiming to be a member of the Terry A. Davis
>>>>> (R.I.P) club? It all makes sense now: you are simply a nutter.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> void Px(void (*x)())
>>>> {
>>>> (void) H(x, x);
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(Px, Px));
>>>> }
>>>>
>>>> Flibble does not understand that
>>>>
>>>> when simulating halt decider H(Px,Px) correctly simulates its input
>>>> the "return" instruction of the simulated Px in unreachable by this
>>>> simulated Px.
>>>
>>> Px should always halt you nutter:
>>
>> It is a matter of easily verified fact the Px never reaches its final
>> state. I have fully operational software that proves this.
>> All that you have is misconceptions and empty rhetoric.
>
> Px halts if H is designed correctly

INCORRECT

> (a valid halt decider always
> returns a result to its caller) ergo H is not designed correctly.

CORRECT

> Simple undeniable logic, dear.
>
> /Flibble
>

You just said that the non-halting input to a simulating halt decider
must halt, that is a contradiction.

--
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 8/27/2022 11:37 AM, olcott wrote:
> On 8/27/2022 12:32 PM, Jeff Barnett wrote:
>> On 8/27/2022 11:15 AM, olcott wrote:
>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>> Blocking/ignoring your reviewers means only one thing: you do not
>>>>>> want an honest review of your work and you are yourself dishonest.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>>
>>>>
>>>>
>>>
>>>
>>
>> Fibble, I must hand it to you! The PO contributions (nothing in this
>> thread) are symbolic and corporally in sink!
>
> *No one would build a complete operating system as a mere ruse*
> *No one would build a complete operating system as a mere ruse*
> *No one would build a complete operating system as a mere ruse*
> *No one would build a complete operating system as a mere ruse*
>
> This is the complete system:
> https://www.liarparadox.org/2022_08_16.zip
>
> Microsoft Visual Studio Community 2017
> https://visualstudio.microsoft.com/vs/older-downloads/
Who were you responding to with that infantile diatribe?
--
Jeff Barnett

On 8/27/22 2:30 PM, olcott wrote:
> On 8/27/2022 1:12 PM, Mr Flibble wrote:
>> On Sat, 27 Aug 2022 13:08:42 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 8/27/2022 12:58 PM, Mr Flibble wrote:
>>>> On Sat, 27 Aug 2022 12:56:31 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 8/27/2022 12:42 PM, Mr Flibble wrote:
>>>>>> On Sat, 27 Aug 2022 12:35:44 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
>>>>>>>> On 8/27/22 1:15 PM, olcott wrote:
>>>>>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>>>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>>>>>>>> Blocking/ignoring your reviewers means only one thing: you
>>>>>>>>>>>> do not want an honest review of your work and you are
>>>>>>>>>>>> yourself dishonest.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>
>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>
>>>>>>> This is the complete system:
>>>>>>> https://www.liarparadox.org/2022_08_16.zip
>>>>>>>
>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>
>>>>>> Ah so you are claiming to be a member of the Terry A. Davis
>>>>>> (R.I.P) club?  It all makes sense now: you are simply a nutter.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> void Px(void (*x)())
>>>>> {
>>>>>      (void) H(x, x);
>>>>>      return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>      Output("Input_Halts = ", H(Px, Px));
>>>>> }
>>>>>
>>>>> Flibble does not understand that
>>>>>
>>>>> when simulating halt decider H(Px,Px) correctly simulates its input
>>>>> the "return" instruction of the simulated Px in unreachable by this
>>>>> simulated Px.
>>>>
>>>> Px should always halt you nutter:
>>>
>>> It is a matter of easily verified fact the Px never reaches its final
>>> state. I have fully operational software that proves this.
>>> All that you have is misconceptions and empty rhetoric.
>>
>> Px halts if H is designed correctly (a valid halt decider always
>> returns a result to its caller) ergo H is not designed correctly.
>> Simple undeniable logic, dear.
>>
>> /Flibble
>>
>
> That is not the same as you claimed:
> >>> Px should always halt you nutter:
>
>

So you admit that H doesn't meet the basic requirements of a decider?

On 8/27/22 2:35 PM, olcott wrote:
> On 8/27/2022 1:12 PM, Mr Flibble wrote:
>> On Sat, 27 Aug 2022 13:08:42 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 8/27/2022 12:58 PM, Mr Flibble wrote:
>>>> On Sat, 27 Aug 2022 12:56:31 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 8/27/2022 12:42 PM, Mr Flibble wrote:
>>>>>> On Sat, 27 Aug 2022 12:35:44 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
>>>>>>>> On 8/27/22 1:15 PM, olcott wrote:
>>>>>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>>>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>>>>>>>> Blocking/ignoring your reviewers means only one thing: you
>>>>>>>>>>>> do not want an honest review of your work and you are
>>>>>>>>>>>> yourself dishonest.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>
>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>
>>>>>>> This is the complete system:
>>>>>>> https://www.liarparadox.org/2022_08_16.zip
>>>>>>>
>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>
>>>>>> Ah so you are claiming to be a member of the Terry A. Davis
>>>>>> (R.I.P) club?  It all makes sense now: you are simply a nutter.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> void Px(void (*x)())
>>>>> {
>>>>>      (void) H(x, x);
>>>>>      return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>      Output("Input_Halts = ", H(Px, Px));
>>>>> }
>>>>>
>>>>> Flibble does not understand that
>>>>>
>>>>> when simulating halt decider H(Px,Px) correctly simulates its input
>>>>> the "return" instruction of the simulated Px in unreachable by this
>>>>> simulated Px.
>>>>
>>>> Px should always halt you nutter:
>>>
>>> It is a matter of easily verified fact the Px never reaches its final
>>> state. I have fully operational software that proves this.
>>> All that you have is misconceptions and empty rhetoric.
>>
>> Px halts if H is designed correctly
>
> INCORRECT

Where does it not halt?

We aren't talking about H's simulation, but about ACTUAL EXECUTION or
COMPLETE SIMULATION.

If H(Px,Px) returns, then Px(Px) will return too.

Therefor if Px(Px) does not return, then H(Px,Px) did not return and is
not meet the requirements of a Decider.

>
>> (a valid halt decider always
>> returns a result to its caller) ergo H is not designed correctly.
>
> CORRECT

So does H(Px,Px) return and answer or not?

You just contradicted yourself.

>
>> Simple undeniable logic, dear.
>>
>> /Flibble
>>
>
> You just said that the non-halting input to a simulating halt decider
> must halt, that is a contradiction.
>
>

No, he said that the complete simulation of it will Halt if H is a
proper decider.

Either you H doesn't do a complete simulation, and thus can't use its
simulation as proof of non-halting (so we need to look at UTM(Px,Px)) or
you are admitting that H(Px,Px) doesn't return an answer.

Your problem is you have locked yourself into an incorrect and illogical
definition.

It isn't "does the complete and correct simulation done by H reach a
final state", it is "does the complete and correct simulation done by a
simulator that DOES a complete and correct simulation of its input reach
a final state".

You have been told this for YEARS, and your refusal to use the right
definition shows you are either a pathological liar or a complete idiot,
or both.

On 8/27/2022 1:51 PM, Richard Damon wrote:
>
> On 8/27/22 2:35 PM, olcott wrote:
>> On 8/27/2022 1:12 PM, Mr Flibble wrote:
>>> On Sat, 27 Aug 2022 13:08:42 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/27/2022 12:58 PM, Mr Flibble wrote:
>>>>> On Sat, 27 Aug 2022 12:56:31 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 8/27/2022 12:42 PM, Mr Flibble wrote:
>>>>>>> On Sat, 27 Aug 2022 12:35:44 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
>>>>>>>>> On 8/27/22 1:15 PM, olcott wrote:
>>>>>>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>>>>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>>>>>>>>> Blocking/ignoring your reviewers means only one thing: you
>>>>>>>>>>>>> do not want an honest review of your work and you are
>>>>>>>>>>>>> yourself dishonest.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>>
>>>>>>>> This is the complete system:
>>>>>>>> https://www.liarparadox.org/2022_08_16.zip
>>>>>>>>
>>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>
>>>>>>> Ah so you are claiming to be a member of the Terry A. Davis
>>>>>>> (R.I.P) club?  It all makes sense now: you are simply a nutter.
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> void Px(void (*x)())
>>>>>> {
>>>>>>      (void) H(x, x);
>>>>>>      return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>      Output("Input_Halts = ", H(Px, Px));
>>>>>> }
>>>>>>
>>>>>> Flibble does not understand that
>>>>>>
>>>>>> when simulating halt decider H(Px,Px) correctly simulates its input
>>>>>> the "return" instruction of the simulated Px in unreachable by this
>>>>>> simulated Px.
>>>>>
>>>>> Px should always halt you nutter:
>>>>
>>>> It is a matter of easily verified fact the Px never reaches its final
>>>> state. I have fully operational software that proves this.
>>>> All that you have is misconceptions and empty rhetoric.
>>>
>>> Px halts if H is designed correctly
>>
>> INCORRECT
>
> Where does it not halt?
>
> We aren't talking about H's simulation, but about ACTUAL EXECUTION or
> COMPLETE SIMULATION.
>
> If H(Px,Px) returns, then Px(Px) will return too.
>
> Therefor if Px(Px) does not return, then H(Px,Px) did not return and is
> not meet the requirements of a Decider.
>
>>
>>> (a valid halt decider always
>>> returns a result to its caller) ergo H is not designed correctly.
>>
>> CORRECT
>
> So does H(Px,Px) return and answer or not?
>
> You just contradicted yourself.
>
>>
>>> Simple undeniable logic, dear.
>>>
>>> /Flibble
>>>
>>
>> You just said that the non-halting input to a simulating halt decider
>> must halt, that is a contradiction.
>>
>>
>
> No, he said that the complete simulation of it will Halt if H is a
> proper decider.
>

That entails that when H0(Infinite_Loop) does a complete simulation of
Infinite_Loop that infinite_Loop reaches its final state and halts.

void Infinite_Loop()
{ HERE: goto HERE;
}

int main()
{ Output("Input_Halts = ", H0((u32)Infinite_Loop));
}

_Infinite_Loop()
[00001102](01) 55 push ebp
[00001103](02) 8bec mov ebp,esp
[00001105](02) ebfe jmp 00001105
[00001107](01) 5d pop ebp
[00001108](01) c3 ret
Size in bytes:(0007) [00001108]

--
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 Sat, 27 Aug 2022 13:35:12 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/27/2022 1:12 PM, Mr Flibble wrote:
> > On Sat, 27 Aug 2022 13:08:42 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/27/2022 12:58 PM, Mr Flibble wrote:
> >>> On Sat, 27 Aug 2022 12:56:31 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/27/2022 12:42 PM, Mr Flibble wrote:
> >>>>> On Sat, 27 Aug 2022 12:35:44 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
> >>>>>>> On 8/27/22 1:15 PM, olcott wrote:
> >>>>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
> >>>>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
> >>>>>>>>>>> Blocking/ignoring your reviewers means only one thing: you
> >>>>>>>>>>> do not want an honest review of your work and you are
> >>>>>>>>>>> yourself dishonest.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>
> >>>>>> *No one would build a complete operating system as a mere ruse*
> >>>>>> *No one would build a complete operating system as a mere ruse*
> >>>>>> *No one would build a complete operating system as a mere ruse*
> >>>>>> *No one would build a complete operating system as a mere ruse*
> >>>>>>
> >>>>>> This is the complete system:
> >>>>>> https://www.liarparadox.org/2022_08_16.zip
> >>>>>>
> >>>>>> Microsoft Visual Studio Community 2017
> >>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
> >>>>>
> >>>>> Ah so you are claiming to be a member of the Terry A. Davis
> >>>>> (R.I.P) club? It all makes sense now: you are simply a nutter.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> void Px(void (*x)())
> >>>> {
> >>>> (void) H(x, x);
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H(Px, Px));
> >>>> }
> >>>>
> >>>> Flibble does not understand that
> >>>>
> >>>> when simulating halt decider H(Px,Px) correctly simulates its
> >>>> input the "return" instruction of the simulated Px in
> >>>> unreachable by this simulated Px.
> >>>
> >>> Px should always halt you nutter:
> >>
> >> It is a matter of easily verified fact the Px never reaches its
> >> final state. I have fully operational software that proves this.
> >> All that you have is misconceptions and empty rhetoric.
> >
> > Px halts if H is designed correctly
>
> INCORRECT
>
> > (a valid halt decider always
> > returns a result to its caller) ergo H is not designed correctly.
>
> CORRECT
>
> > Simple undeniable logic, dear.
> >
> > /Flibble
> >
>
> You just said that the non-halting input to a simulating halt decider
> must halt, that is a contradiction.

No, dear, I am saying that your simulating halt decider is not a
valid halt decider as it doesn't return a result to its caller, Px,
dear. If it was a valid halt decider then it would return a value to
its caller, Px, and Px would then halt, dear.

/Flibble

On Sat, 27 Aug 2022 13:30:48 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/27/2022 1:12 PM, Mr Flibble wrote:
> > On Sat, 27 Aug 2022 13:08:42 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/27/2022 12:58 PM, Mr Flibble wrote:
> >>> On Sat, 27 Aug 2022 12:56:31 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/27/2022 12:42 PM, Mr Flibble wrote:
> >>>>> On Sat, 27 Aug 2022 12:35:44 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
> >>>>>>> On 8/27/22 1:15 PM, olcott wrote:
> >>>>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
> >>>>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
> >>>>>>>>>>> Blocking/ignoring your reviewers means only one thing: you
> >>>>>>>>>>> do not want an honest review of your work and you are
> >>>>>>>>>>> yourself dishonest.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>
> >>>>>> *No one would build a complete operating system as a mere ruse*
> >>>>>> *No one would build a complete operating system as a mere ruse*
> >>>>>> *No one would build a complete operating system as a mere ruse*
> >>>>>> *No one would build a complete operating system as a mere ruse*
> >>>>>>
> >>>>>> This is the complete system:
> >>>>>> https://www.liarparadox.org/2022_08_16.zip
> >>>>>>
> >>>>>> Microsoft Visual Studio Community 2017
> >>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
> >>>>>
> >>>>> Ah so you are claiming to be a member of the Terry A. Davis
> >>>>> (R.I.P) club? It all makes sense now: you are simply a nutter.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> void Px(void (*x)())
> >>>> {
> >>>> (void) H(x, x);
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H(Px, Px));
> >>>> }
> >>>>
> >>>> Flibble does not understand that
> >>>>
> >>>> when simulating halt decider H(Px,Px) correctly simulates its
> >>>> input the "return" instruction of the simulated Px in
> >>>> unreachable by this simulated Px.
> >>>
> >>> Px should always halt you nutter:
> >>
> >> It is a matter of easily verified fact the Px never reaches its
> >> final state. I have fully operational software that proves this.
> >> All that you have is misconceptions and empty rhetoric.
> >
> > Px halts if H is designed correctly (a valid halt decider always
> > returns a result to its caller) ergo H is not designed correctly.
> > Simple undeniable logic, dear.
> >
> > /Flibble
> >
>
> That is not the same as you claimed:
> >>> Px should always halt you nutter:

Now you seem to be unable to comprehend simple English.

/Flibble

On 8/27/22 3:00 PM, olcott wrote:
> On 8/27/2022 1:51 PM, Richard Damon wrote:
>>
>> On 8/27/22 2:35 PM, olcott wrote:
>>> On 8/27/2022 1:12 PM, Mr Flibble wrote:
>>>> On Sat, 27 Aug 2022 13:08:42 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> On 8/27/2022 12:58 PM, Mr Flibble wrote:
>>>>>> On Sat, 27 Aug 2022 12:56:31 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 8/27/2022 12:42 PM, Mr Flibble wrote:
>>>>>>>> On Sat, 27 Aug 2022 12:35:44 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
>>>>>>>>>> On 8/27/22 1:15 PM, olcott wrote:
>>>>>>>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>>>>>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>>>>>>>>>> Blocking/ignoring your reviewers means only one thing: you
>>>>>>>>>>>>>> do not want an honest review of your work and you are
>>>>>>>>>>>>>> yourself dishonest.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>>>
>>>>>>>>> This is the complete system:
>>>>>>>>> https://www.liarparadox.org/2022_08_16.zip
>>>>>>>>>
>>>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>
>>>>>>>> Ah so you are claiming to be a member of the Terry A. Davis
>>>>>>>> (R.I.P) club?  It all makes sense now: you are simply a nutter.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> void Px(void (*x)())
>>>>>>> {
>>>>>>>      (void) H(x, x);
>>>>>>>      return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>      Output("Input_Halts = ", H(Px, Px));
>>>>>>> }
>>>>>>>
>>>>>>> Flibble does not understand that
>>>>>>>
>>>>>>> when simulating halt decider H(Px,Px) correctly simulates its input
>>>>>>> the "return" instruction of the simulated Px in unreachable by this
>>>>>>> simulated Px.
>>>>>>
>>>>>> Px should always halt you nutter:
>>>>>
>>>>> It is a matter of easily verified fact the Px never reaches its final
>>>>> state. I have fully operational software that proves this.
>>>>> All that you have is misconceptions and empty rhetoric.
>>>>
>>>> Px halts if H is designed correctly
>>>
>>> INCORRECT
>>
>> Where does it not halt?
>>
>> We aren't talking about H's simulation, but about ACTUAL EXECUTION or
>> COMPLETE SIMULATION.
>>
>> If H(Px,Px) returns, then Px(Px) will return too.
>>
>> Therefor if Px(Px) does not return, then H(Px,Px) did not return and
>> is not meet the requirements of a Decider.
>>
>>>
>>>> (a valid halt decider always
>>>> returns a result to its caller) ergo H is not designed correctly.
>>>
>>> CORRECT
>>
>> So does H(Px,Px) return and answer or not?
>>
>> You just contradicted yourself.
>>
>>>
>>>> Simple undeniable logic, dear.
>>>>
>>>> /Flibble
>>>>
>>>
>>> You just said that the non-halting input to a simulating halt decider
>>> must halt, that is a contradiction.
>>>
>>>
>>
>> No, he said that the complete simulation of it will Halt if H is a
>> proper decider.
>>
>
> That entails that when H0(Infinite_Loop) does a complete simulation of
> Infinite_Loop that infinite_Loop reaches its final state and halts.

Where do you get that? The claim is Px(Px) Halts.

No one (except maybe you) made that claim about Infinite_Loop()

This is just your Red Herring / Strawman

You are just proving you don't understand logic.

And that shows you realize you logic has been broken, and can't actually
prove what you claim.

>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H0((u32)Infinite_Loop));
> }
>
> _Infinite_Loop()
> [00001102](01)  55         push ebp
> [00001103](02)  8bec       mov ebp,esp
> [00001105](02)  ebfe       jmp 00001105
> [00001107](01)  5d         pop ebp
> [00001108](01)  c3         ret
> Size in bytes:(0007) [00001108]
>
>

On 8/27/2022 2:05 PM, Mr Flibble wrote:
> On Sat, 27 Aug 2022 13:35:12 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/27/2022 1:12 PM, Mr Flibble wrote:
>>> On Sat, 27 Aug 2022 13:08:42 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/27/2022 12:58 PM, Mr Flibble wrote:
>>>>> On Sat, 27 Aug 2022 12:56:31 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/27/2022 12:42 PM, Mr Flibble wrote:
>>>>>>> On Sat, 27 Aug 2022 12:35:44 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 8/27/2022 12:29 PM, Richard Damon wrote:
>>>>>>>>> On 8/27/22 1:15 PM, olcott wrote:
>>>>>>>>>> On 8/27/2022 12:12 PM, Mr Flibble wrote:
>>>>>>>>>>> On Sat, 27 Aug 2022 11:58:13 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 8/27/2022 11:28 AM, Mr Flibble wrote:
>>>>>>>>>>>>> Blocking/ignoring your reviewers means only one thing: you
>>>>>>>>>>>>> do not want an honest review of your work and you are
>>>>>>>>>>>>> yourself dishonest.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>> *No one would build a complete operating system as a mere ruse*
>>>>>>>>
>>>>>>>> This is the complete system:
>>>>>>>> https://www.liarparadox.org/2022_08_16.zip
>>>>>>>>
>>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>
>>>>>>> Ah so you are claiming to be a member of the Terry A. Davis
>>>>>>> (R.I.P) club? It all makes sense now: you are simply a nutter.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> void Px(void (*x)())
>>>>>> {
>>>>>> (void) H(x, x);
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H(Px, Px));
>>>>>> }
>>>>>>
>>>>>> Flibble does not understand that
>>>>>>
>>>>>> when simulating halt decider H(Px,Px) correctly simulates its
>>>>>> input the "return" instruction of the simulated Px in
>>>>>> unreachable by this simulated Px.
>>>>>
>>>>> Px should always halt you nutter:
>>>>
>>>> It is a matter of easily verified fact the Px never reaches its
>>>> final state. I have fully operational software that proves this.
>>>> All that you have is misconceptions and empty rhetoric.
>>>
>>> Px halts if H is designed correctly
>>
>> INCORRECT
>>
>>> (a valid halt decider always
>>> returns a result to its caller) ergo H is not designed correctly.
>>
>> CORRECT
>>
>>> Simple undeniable logic, dear.
>>>
>>> /Flibble
>>>
>>
>> You just said that the non-halting input to a simulating halt decider
>> must halt, that is a contradiction.
>
> No, dear, I am saying that your simulating halt decider is not a
> valid halt decider as it doesn't return a result to its caller,

In other words you believe that a function called in (what is
essentially) infinite recursion must return to its caller even though it
is an axiom to no function called in infinite recursion ever returns to
its caller?

When any system of axioms has a pair of axioms that contradict each
other at most one of these axioms is correct.

(a) Deciders must always return to their caller.
(b) No function called in infinite recursion returns to its caller.

When deciders are called in infinite recursion we have contradictory
axioms.

*HERE IS WHAT ACTUALLY HAPPENS*
(a) H(P,P) simulates P(P) that calls a simulated H(P,P)
(b) that simulates P(P) that calls a simulated H(P,P)
(c) that simulates P(P) that calls a simulated H(P,P)
(d) that simulates P(P) that calls a simulated H(P,P)...
*Until H aborts its simulation*
(e) then H(P,P) returns to main()

(a) P(P) invokes H(P,P)
(b) H(P,P) simulates P(P) that calls a simulated H(P,P)
(c) that simulates P(P) that calls a simulated H(P,P)
(d) that simulates P(P) that calls a simulated H(P,P)
(e) that simulates P(P) that calls a simulated H(P,P)...
*Until H aborts its simulation*
(f) then H(P,P) returns to P(P) in main()

(a) Deciders must always return to their caller.
becomes
(a) Deciders that are not called in infinite recursion must always
return to their caller.

> Px,
> dear. If it was a valid halt decider then it would return a value to
> its caller, Px, and Px would then halt, dear.
>
> /Flibble
>

--
Copyright 2022 Pete Olcott

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