On 8/18/2022 12:08 PM, Mr Flibble wrote:
> On Thu, 18 Aug 2022 11:50:36 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/18/2022 11:30 AM, Mr Flibble wrote:
>>> On Thu, 18 Aug 2022 11:20:49 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/18/2022 11:06 AM, Mr Flibble wrote:
>>>>> On Thu, 18 Aug 2022 09:10:57 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/18/2022 3:23 AM, Mikko wrote:
>>>>>>> On 2022-08-17 14:08:50 +0000, olcott said:
>>>>>>>
>>>>>>>> On 8/17/2022 4:15 AM, Mikko wrote:
>>>>>>>>> On 2022-08-17 01:23:59 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> *Not at all. No one has disproved this statement*
>>>>>>>>>> H(P,P) does correctly predict that its correct and complete
>>>>>>>>>> x86 emulation of its input would never stop running, thus
>>>>>>>>>> does correctly reject this input as non-halting.
>>>>>>>>>
>>>>>>>>> This is not really a prediction >
>>>>>>>>
>>>>>>>> Yes it is really a prediction, otherwise H(P,P) would be
>>>>>>>> required to simulate its input forever.
>>>>>>>>
>>>>>>>>> as it is about a sitation that will
>>>>>>>>> never happen.
>>>>>>>
>>>>>>> A dictionary says that "a prediction" is 'a statement of what
>>>>>>> will happen in future'. Your statement has "would" instead of
>>>>>>> "will" so it is not a prediction.
>>>>>>>
>>>>>>> Mikko
>>>>>>>
>>>>>>
>>>>>> If you just want to play silly word games then please STFU!!! I
>>>>>> am trying to validate my legacy and everyone here only wants to
>>>>>> troll me.
>>>>>>
>>>>>> It is an axiom that when-so-ever any simulating halt decider
>>>>>> (SHD) performs a correct simulation of its input and this
>>>>>> simulation would never stop running unless this simulation is
>>>>>> aborted that this SHD is correct to reject this input as
>>>>>> non-halting.
>>>>>
>>>>> Not if P would have halted *if* H returned to P rather than
>>>>> aborting the simulation. My solution is the only credible
>>>>> solution, yours isn't because it simply doesn't work.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> This is what I mean when I say that you are incompetent at software
>>>> engineering. There is no possible way that simulating halt decider
>>>> H can correctly return to P. You apparently are totally clueless
>>>> about basic software engineering:
>>>
>>> You apparently are as obtuse as fuck and a pathological liar.
>>> Again: I have designed a simulating halt decider that does
>>> correctly return to P.
>>>>
>>>> No function called in (what is essentially) infinite recursion can
>>>> possibly correctly return to its caller.
>>>
>>> My SHD doesn't manifest any infinite recursion because it works,
>>> your does manifest it because yours doesn't work.
>>
>> You can't even specify the condition that invokes the behavior of
>> your code: {if something magical happens} then return to caller.
>> Post your link again so that everyone can see.
>
> If H is called with the same inputs a second time then it returns *both*
> halting and non-halting decisions to the caller in a forked simulation.
>
> /Flibble
>

Post your link again so that everyone can see.
Post your link again so that everyone can see.
Post your link again so that everyone can see.
Post your link again so that everyone can see.
Post your link again so that everyone can see.

--
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 Thu, 18 Aug 2022 12:21:14 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/18/2022 12:08 PM, Mr Flibble wrote:
> > On Thu, 18 Aug 2022 11:50:36 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/18/2022 11:30 AM, Mr Flibble wrote:
> >>> On Thu, 18 Aug 2022 11:20:49 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/18/2022 11:06 AM, Mr Flibble wrote:
> >>>>> On Thu, 18 Aug 2022 09:10:57 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/18/2022 3:23 AM, Mikko wrote:
> >>>>>>> On 2022-08-17 14:08:50 +0000, olcott said:
> >>>>>>>
> >>>>>>>> On 8/17/2022 4:15 AM, Mikko wrote:
> >>>>>>>>> On 2022-08-17 01:23:59 +0000, olcott said:
> >>>>>>>>>
> >>>>>>>>>> *Not at all. No one has disproved this statement*
> >>>>>>>>>> H(P,P) does correctly predict that its correct and complete
> >>>>>>>>>> x86 emulation of its input would never stop running, thus
> >>>>>>>>>> does correctly reject this input as non-halting.
> >>>>>>>>>
> >>>>>>>>> This is not really a prediction >
> >>>>>>>>
> >>>>>>>> Yes it is really a prediction, otherwise H(P,P) would be
> >>>>>>>> required to simulate its input forever.
> >>>>>>>>
> >>>>>>>>> as it is about a sitation that will
> >>>>>>>>> never happen.
> >>>>>>>
> >>>>>>> A dictionary says that "a prediction" is 'a statement of what
> >>>>>>> will happen in future'. Your statement has "would" instead of
> >>>>>>> "will" so it is not a prediction.
> >>>>>>>
> >>>>>>> Mikko
> >>>>>>>
> >>>>>>
> >>>>>> If you just want to play silly word games then please STFU!!! I
> >>>>>> am trying to validate my legacy and everyone here only wants to
> >>>>>> troll me.
> >>>>>>
> >>>>>> It is an axiom that when-so-ever any simulating halt decider
> >>>>>> (SHD) performs a correct simulation of its input and this
> >>>>>> simulation would never stop running unless this simulation is
> >>>>>> aborted that this SHD is correct to reject this input as
> >>>>>> non-halting.
> >>>>>
> >>>>> Not if P would have halted *if* H returned to P rather than
> >>>>> aborting the simulation. My solution is the only credible
> >>>>> solution, yours isn't because it simply doesn't work.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> This is what I mean when I say that you are incompetent at
> >>>> software engineering. There is no possible way that simulating
> >>>> halt decider H can correctly return to P. You apparently are
> >>>> totally clueless about basic software engineering:
> >>>
> >>> You apparently are as obtuse as fuck and a pathological liar.
> >>> Again: I have designed a simulating halt decider that does
> >>> correctly return to P.
> >>>>
> >>>> No function called in (what is essentially) infinite recursion
> >>>> can possibly correctly return to its caller.
> >>>
> >>> My SHD doesn't manifest any infinite recursion because it works,
> >>> your does manifest it because yours doesn't work.
> >>
> >> You can't even specify the condition that invokes the behavior of
> >> your code: {if something magical happens} then return to caller.
> >> Post your link again so that everyone can see.
> >
> > If H is called with the same inputs a second time then it returns
> > *both* halting and non-halting decisions to the caller in a forked
> > simulation.
> >
> > /Flibble
> >
>
> Post your link again so that everyone can see.
> Post your link again so that everyone can see.
> Post your link again so that everyone can see.
> Post your link again so that everyone can see.
> Post your link again so that everyone can see.

Why? I have posted it enough times already and I believe I have made
myself clear enough.

/Flibble

On 8/18/2022 12:23 PM, Mr Flibble wrote:
> On Thu, 18 Aug 2022 12:21:14 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/18/2022 12:08 PM, Mr Flibble wrote:
>>> On Thu, 18 Aug 2022 11:50:36 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/18/2022 11:30 AM, Mr Flibble wrote:
>>>>> On Thu, 18 Aug 2022 11:20:49 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/18/2022 11:06 AM, Mr Flibble wrote:
>>>>>>> On Thu, 18 Aug 2022 09:10:57 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 8/18/2022 3:23 AM, Mikko wrote:
>>>>>>>>> On 2022-08-17 14:08:50 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 8/17/2022 4:15 AM, Mikko wrote:
>>>>>>>>>>> On 2022-08-17 01:23:59 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> *Not at all. No one has disproved this statement*
>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete
>>>>>>>>>>>> x86 emulation of its input would never stop running, thus
>>>>>>>>>>>> does correctly reject this input as non-halting.
>>>>>>>>>>>
>>>>>>>>>>> This is not really a prediction >
>>>>>>>>>>
>>>>>>>>>> Yes it is really a prediction, otherwise H(P,P) would be
>>>>>>>>>> required to simulate its input forever.
>>>>>>>>>>
>>>>>>>>>>> as it is about a sitation that will
>>>>>>>>>>> never happen.
>>>>>>>>>
>>>>>>>>> A dictionary says that "a prediction" is 'a statement of what
>>>>>>>>> will happen in future'. Your statement has "would" instead of
>>>>>>>>> "will" so it is not a prediction.
>>>>>>>>>
>>>>>>>>> Mikko
>>>>>>>>>
>>>>>>>>
>>>>>>>> If you just want to play silly word games then please STFU!!! I
>>>>>>>> am trying to validate my legacy and everyone here only wants to
>>>>>>>> troll me.
>>>>>>>>
>>>>>>>> It is an axiom that when-so-ever any simulating halt decider
>>>>>>>> (SHD) performs a correct simulation of its input and this
>>>>>>>> simulation would never stop running unless this simulation is
>>>>>>>> aborted that this SHD is correct to reject this input as
>>>>>>>> non-halting.
>>>>>>>
>>>>>>> Not if P would have halted *if* H returned to P rather than
>>>>>>> aborting the simulation. My solution is the only credible
>>>>>>> solution, yours isn't because it simply doesn't work.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> This is what I mean when I say that you are incompetent at
>>>>>> software engineering. There is no possible way that simulating
>>>>>> halt decider H can correctly return to P. You apparently are
>>>>>> totally clueless about basic software engineering:
>>>>>
>>>>> You apparently are as obtuse as fuck and a pathological liar.
>>>>> Again: I have designed a simulating halt decider that does
>>>>> correctly return to P.
>>>>>>
>>>>>> No function called in (what is essentially) infinite recursion
>>>>>> can possibly correctly return to its caller.
>>>>>
>>>>> My SHD doesn't manifest any infinite recursion because it works,
>>>>> your does manifest it because yours doesn't work.
>>>>
>>>> You can't even specify the condition that invokes the behavior of
>>>> your code: {if something magical happens} then return to caller.
>>>> Post your link again so that everyone can see.
>>>
>>> If H is called with the same inputs a second time then it returns
>>> *both* halting and non-halting decisions to the caller in a forked
>>> simulation.
>>>
>>> /Flibble
>>>
>>
>> Post your link again so that everyone can see.
>> Post your link again so that everyone can see.
>> Post your link again so that everyone can see.
>> Post your link again so that everyone can see.
>> Post your link again so that everyone can see.
>
> Why? I have posted it enough times already and I believe I have made
> myself clear enough.
>
> /Flibble
>

OK so then by refusing to post the proof that I am correct you
implicitly admit that I am correct.

--
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/18/2022 12:27 PM, olcott wrote:
> On 8/18/2022 12:23 PM, Mr Flibble wrote:
>> On Thu, 18 Aug 2022 12:21:14 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 8/18/2022 12:08 PM, Mr Flibble wrote:
>>>> On Thu, 18 Aug 2022 11:50:36 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 8/18/2022 11:30 AM, Mr Flibble wrote:
>>>>>> On Thu, 18 Aug 2022 11:20:49 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 8/18/2022 11:06 AM, Mr Flibble wrote:
>>>>>>>> On Thu, 18 Aug 2022 09:10:57 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 8/18/2022 3:23 AM, Mikko wrote:
>>>>>>>>>> On 2022-08-17 14:08:50 +0000, olcott said:
>>>>>>>>>>> On 8/17/2022 4:15 AM, Mikko wrote:
>>>>>>>>>>>> On 2022-08-17 01:23:59 +0000, olcott said:
>>>>>>>>>>>>> *Not at all. No one has disproved this statement*
>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete
>>>>>>>>>>>>> x86 emulation of its input would never stop running, thus
>>>>>>>>>>>>> does correctly reject this input as non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>> This is not really a prediction >
>>>>>>>>>>>
>>>>>>>>>>> Yes it is really a prediction, otherwise H(P,P) would be
>>>>>>>>>>> required to simulate its input forever.
>>>>>>>>>>>> as it is about a sitation that will
>>>>>>>>>>>> never happen.
>>>>>>>>>>
>>>>>>>>>> A dictionary says that "a prediction" is 'a statement of what
>>>>>>>>>> will happen in future'. Your statement has "would" instead of
>>>>>>>>>> "will" so it is not a prediction.
>>>>>>>>>>
>>>>>>>>>> Mikko
>>>>>>>>>
>>>>>>>>> If you just want to play silly word games then please STFU!!! I
>>>>>>>>> am trying to validate my legacy and everyone here only wants to
>>>>>>>>> troll me.
>>>>>>>>>
>>>>>>>>> It is an axiom that when-so-ever any simulating halt decider
>>>>>>>>> (SHD) performs a correct simulation of its input and this
>>>>>>>>> simulation would never stop running unless this simulation is
>>>>>>>>> aborted that this SHD is correct to reject this input as
>>>>>>>>> non-halting.
>>>>>>>>
>>>>>>>> Not if P would have halted *if* H returned to P rather than
>>>>>>>> aborting the simulation.  My solution is the only credible
>>>>>>>> solution, yours isn't because it simply doesn't work.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> This is what I mean when I say that you are incompetent at
>>>>>>> software engineering. There is no possible way that simulating
>>>>>>> halt decider H can correctly return to P. You apparently are
>>>>>>> totally clueless about basic software engineering:
>>>>>>
>>>>>> You apparently are as obtuse as fuck and a pathological liar.
>>>>>> Again: I have designed a simulating halt decider that does
>>>>>> correctly return to P.
>>>>>>>
>>>>>>> No function called in (what is essentially) infinite recursion
>>>>>>> can possibly correctly return to its caller.
>>>>>>
>>>>>> My SHD doesn't manifest any infinite recursion because it works,
>>>>>> your does manifest it because yours doesn't work.
>>>>>
>>>>> You can't even specify the condition that invokes the behavior of
>>>>> your code: {if something magical happens} then return to caller.
>>>>> Post your link again so that everyone can see.
>>>>
>>>> If H is called with the same inputs a second time then it returns
>>>> *both* halting and non-halting decisions to the caller in a forked
>>>> simulation.
>>>>
>>>> /Flibble
>>>
>>> Post your link again so that everyone can see.
>>> Post your link again so that everyone can see.
>>> Post your link again so that everyone can see.
>>> Post your link again so that everyone can see.
>>> Post your link again so that everyone can see.
>>
>> Why? I have posted it enough times already and I believe I have made
>> myself clear enough.
>>
>> /Flibble
>>
>
> OK so then by refusing to post the proof that I am correct you
> implicitly admit that I am correct.
>

https://github.com/i42output/halting-problem/blob/main/README.txt

--
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/18/2022 12:38 PM, olcott wrote:
> On 8/18/2022 12:27 PM, olcott wrote:
>> On 8/18/2022 12:23 PM, Mr Flibble wrote:
>>> On Thu, 18 Aug 2022 12:21:14 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/18/2022 12:08 PM, Mr Flibble wrote:
>>>>> On Thu, 18 Aug 2022 11:50:36 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 8/18/2022 11:30 AM, Mr Flibble wrote:
>>>>>>> On Thu, 18 Aug 2022 11:20:49 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 8/18/2022 11:06 AM, Mr Flibble wrote:
>>>>>>>>> On Thu, 18 Aug 2022 09:10:57 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> On 8/18/2022 3:23 AM, Mikko wrote:
>>>>>>>>>>> On 2022-08-17 14:08:50 +0000, olcott said:
>>>>>>>>>>>> On 8/17/2022 4:15 AM, Mikko wrote:
>>>>>>>>>>>>> On 2022-08-17 01:23:59 +0000, olcott said:
>>>>>>>>>>>>>> *Not at all. No one has disproved this statement*
>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete
>>>>>>>>>>>>>> x86 emulation of its input would never stop running, thus
>>>>>>>>>>>>>> does correctly reject this input as non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is not really a prediction >
>>>>>>>>>>>>
>>>>>>>>>>>> Yes it is really a prediction, otherwise H(P,P) would be
>>>>>>>>>>>> required to simulate its input forever.
>>>>>>>>>>>>> as it is about a sitation that will
>>>>>>>>>>>>> never happen.
>>>>>>>>>>>
>>>>>>>>>>> A dictionary says that "a prediction" is 'a statement of what
>>>>>>>>>>> will happen in future'. Your statement has "would" instead of
>>>>>>>>>>> "will" so it is not a prediction.
>>>>>>>>>>>
>>>>>>>>>>> Mikko
>>>>>>>>>>
>>>>>>>>>> If you just want to play silly word games then please STFU!!! I
>>>>>>>>>> am trying to validate my legacy and everyone here only wants to
>>>>>>>>>> troll me.
>>>>>>>>>>
>>>>>>>>>> It is an axiom that when-so-ever any simulating halt decider
>>>>>>>>>> (SHD) performs a correct simulation of its input and this
>>>>>>>>>> simulation would never stop running unless this simulation is
>>>>>>>>>> aborted that this SHD is correct to reject this input as
>>>>>>>>>> non-halting.
>>>>>>>>>
>>>>>>>>> Not if P would have halted *if* H returned to P rather than
>>>>>>>>> aborting the simulation.  My solution is the only credible
>>>>>>>>> solution, yours isn't because it simply doesn't work.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> This is what I mean when I say that you are incompetent at
>>>>>>>> software engineering. There is no possible way that simulating
>>>>>>>> halt decider H can correctly return to P. You apparently are
>>>>>>>> totally clueless about basic software engineering:
>>>>>>>
>>>>>>> You apparently are as obtuse as fuck and a pathological liar.
>>>>>>> Again: I have designed a simulating halt decider that does
>>>>>>> correctly return to P.
>>>>>>>>
>>>>>>>> No function called in (what is essentially) infinite recursion
>>>>>>>> can possibly correctly return to its caller.
>>>>>>>
>>>>>>> My SHD doesn't manifest any infinite recursion because it works,
>>>>>>> your does manifest it because yours doesn't work.
>>>>>>
>>>>>> You can't even specify the condition that invokes the behavior of
>>>>>> your code: {if something magical happens} then return to caller.
>>>>>> Post your link again so that everyone can see.
>>>>>
>>>>> If H is called with the same inputs a second time then it returns
>>>>> *both* halting and non-halting decisions to the caller in a forked
>>>>> simulation.
>>>>>
>>>>> /Flibble
>>>>
>>>> Post your link again so that everyone can see.
>>>> Post your link again so that everyone can see.
>>>> Post your link again so that everyone can see.
>>>> Post your link again so that everyone can see.
>>>> Post your link again so that everyone can see.
>>>
>>> Why? I have posted it enough times already and I believe I have made
>>> myself clear enough.
>>>
>>> /Flibble
>>>
>>
>> OK so then by refusing to post the proof that I am correct you
>> implicitly admit that I am correct.
>>
>
> https://github.com/i42output/halting-problem/blob/main/README.txt
>

YOUR ARE MERELY COPYING THIS ASPECT OF MY IDEA THAT I PUBLISHED EARLIER
"When the simulator detects the call to H in P"

YOU LEAVE OUT THE CRITERION MEASURE:
If the non-halting branch is determined to halt AND the halting branch
is determined to not halt

That is like saying I have two step cure for cancer:
(1) Find a cure for cancer
(2) Now we have a cure for cancer

--
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 Thu, 18 Aug 2022 12:56:19 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/18/2022 12:38 PM, olcott wrote:
> > On 8/18/2022 12:27 PM, olcott wrote:
> >> On 8/18/2022 12:23 PM, Mr Flibble wrote:
> >>> On Thu, 18 Aug 2022 12:21:14 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/18/2022 12:08 PM, Mr Flibble wrote:
> >>>>> On Thu, 18 Aug 2022 11:50:36 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>> On 8/18/2022 11:30 AM, Mr Flibble wrote:
> >>>>>>> On Thu, 18 Aug 2022 11:20:49 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>> On 8/18/2022 11:06 AM, Mr Flibble wrote:
> >>>>>>>>> On Thu, 18 Aug 2022 09:10:57 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>> On 8/18/2022 3:23 AM, Mikko wrote:
> >>>>>>>>>>> On 2022-08-17 14:08:50 +0000, olcott said:
> >>>>>>>>>>>> On 8/17/2022 4:15 AM, Mikko wrote:
> >>>>>>>>>>>>> On 2022-08-17 01:23:59 +0000, olcott said:
> >>>>>>>>>>>>>> *Not at all. No one has disproved this statement*
> >>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and
> >>>>>>>>>>>>>> complete x86 emulation of its input would never stop
> >>>>>>>>>>>>>> running, thus does correctly reject this input as
> >>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> This is not really a prediction >
> >>>>>>>>>>>>
> >>>>>>>>>>>> Yes it is really a prediction, otherwise H(P,P) would be
> >>>>>>>>>>>> required to simulate its input forever.
> >>>>>>>>>>>>> as it is about a sitation that will
> >>>>>>>>>>>>> never happen.
> >>>>>>>>>>>
> >>>>>>>>>>> A dictionary says that "a prediction" is 'a statement of
> >>>>>>>>>>> what will happen in future'. Your statement has "would"
> >>>>>>>>>>> instead of "will" so it is not a prediction.
> >>>>>>>>>>>
> >>>>>>>>>>> Mikko
> >>>>>>>>>>
> >>>>>>>>>> If you just want to play silly word games then please
> >>>>>>>>>> STFU!!! I am trying to validate my legacy and everyone
> >>>>>>>>>> here only wants to troll me.
> >>>>>>>>>>
> >>>>>>>>>> It is an axiom that when-so-ever any simulating halt
> >>>>>>>>>> decider (SHD) performs a correct simulation of its input
> >>>>>>>>>> and this simulation would never stop running unless this
> >>>>>>>>>> simulation is aborted that this SHD is correct to reject
> >>>>>>>>>> this input as non-halting.
> >>>>>>>>>
> >>>>>>>>> Not if P would have halted *if* H returned to P rather than
> >>>>>>>>> aborting the simulation.  My solution is the only credible
> >>>>>>>>> solution, yours isn't because it simply doesn't work.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>> This is what I mean when I say that you are incompetent at
> >>>>>>>> software engineering. There is no possible way that
> >>>>>>>> simulating halt decider H can correctly return to P. You
> >>>>>>>> apparently are totally clueless about basic software
> >>>>>>>> engineering:
> >>>>>>>
> >>>>>>> You apparently are as obtuse as fuck and a pathological liar.
> >>>>>>> Again: I have designed a simulating halt decider that does
> >>>>>>> correctly return to P.
> >>>>>>>>
> >>>>>>>> No function called in (what is essentially) infinite
> >>>>>>>> recursion can possibly correctly return to its caller.
> >>>>>>>
> >>>>>>> My SHD doesn't manifest any infinite recursion because it
> >>>>>>> works, your does manifest it because yours doesn't work.
> >>>>>>
> >>>>>> You can't even specify the condition that invokes the behavior
> >>>>>> of your code: {if something magical happens} then return to
> >>>>>> caller. Post your link again so that everyone can see.
> >>>>>
> >>>>> If H is called with the same inputs a second time then it
> >>>>> returns *both* halting and non-halting decisions to the caller
> >>>>> in a forked simulation.
> >>>>>
> >>>>> /Flibble
> >>>>
> >>>> Post your link again so that everyone can see.
> >>>> Post your link again so that everyone can see.
> >>>> Post your link again so that everyone can see.
> >>>> Post your link again so that everyone can see.
> >>>> Post your link again so that everyone can see.
> >>>
> >>> Why? I have posted it enough times already and I believe I have
> >>> made myself clear enough.
> >>>
> >>> /Flibble
> >>>
> >>
> >> OK so then by refusing to post the proof that I am correct you
> >> implicitly admit that I am correct.
> >>
> >
> > https://github.com/i42output/halting-problem/blob/main/README.txt
> >
>
> YOUR ARE MERELY COPYING THIS ASPECT OF MY IDEA THAT I PUBLISHED
> EARLIER "When the simulator detects the call to H in P"

I am not copying your idea at all: my idea works, yours doesn't.

>
> YOU LEAVE OUT THE CRITERION MEASURE:
> If the non-halting branch is determined to halt AND the halting branch
> is determined to not halt
>
> That is like saying I have two step cure for cancer:
> (1) Find a cure for cancer
> (2) Now we have a cure for cancer
I have presented a sufficiently detailed design.

/Flibble

On 8/18/22 10:10 AM, olcott wrote:
> On 8/18/2022 3:23 AM, Mikko wrote:
>> On 2022-08-17 14:08:50 +0000, olcott said:
>>
>>> On 8/17/2022 4:15 AM, Mikko wrote:
>>>> On 2022-08-17 01:23:59 +0000, olcott said:
>>>>
>>>>> *Not at all. No one has disproved this statement*
>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>> emulation of its input would never stop running, thus does
>>>>> correctly reject this input as non-halting.
>>>>
>>>> This is not really a prediction >
>>>
>>> Yes it is really a prediction, otherwise H(P,P) would be required to
>>> simulate its input forever.
>>>
>>>> as it is about a sitation that will
>>>> never happen.
>>
>> A dictionary says that "a prediction" is 'a statement of what will happen
>> in future'. Your statement has "would" instead of "will" so it is not a
>> prediction.
>>
>> Mikko
>>
>
> If you just want to play silly word games then please STFU!!! I am
> trying to validate my legacy and everyone here only wants to troll me.
>
> It is an axiom that when-so-ever any simulating halt decider (SHD)
> performs a correct simulation of its input and this simulation would
> never stop running unless this simulation is aborted that this SHD is
> correct to reject this input as non-halting.
>
>

Where is that axiom from? It seem to be an invention of yours. You don't
seem to understand what an Axiom actually is.

You have established your legacy, it is of a man who thought he knew a
lot about things that he was totally ignorant of and refused to listen
to people who tried to help him.

THAT is you legacy.

On 8/18/2022 6:04 PM, Richard Damon wrote:
> On 8/18/22 10:10 AM, olcott wrote:
>> On 8/18/2022 3:23 AM, Mikko wrote:
>>> On 2022-08-17 14:08:50 +0000, olcott said:
>>>
>>>> On 8/17/2022 4:15 AM, Mikko wrote:
>>>>> On 2022-08-17 01:23:59 +0000, olcott said:
>>>>>
>>>>>> *Not at all. No one has disproved this statement*
>>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>>> emulation of its input would never stop running, thus does
>>>>>> correctly reject this input as non-halting.
>>>>>
>>>>> This is not really a prediction >
>>>>
>>>> Yes it is really a prediction, otherwise H(P,P) would be required to
>>>> simulate its input forever.
>>>>
>>>>> as it is about a sitation that will
>>>>> never happen.
>>>
>>> A dictionary says that "a prediction" is 'a statement of what will
>>> happen
>>> in future'. Your statement has "would" instead of "will" so it is not a
>>> prediction.
>>>
>>> Mikko
>>>
>>
>> If you just want to play silly word games then please STFU!!! I am
>> trying to validate my legacy and everyone here only wants to troll me.
>>
>> It is an axiom that when-so-ever any simulating halt decider (SHD)
>> performs a correct simulation of its input and this simulation would
>> never stop running unless this simulation is aborted that this SHD is
>> correct to reject this input as non-halting.
>>
>>
>
> Where is that axiom from? It seem to be an invention of yours. You don't
> seem to understand what an Axiom actually is.

*It is the definition of a simulating halt decider*
*It is the definition of a simulating halt decider*
*It is the definition of a simulating halt decider*

Simulating halt deciders correctly predict (in a finite number of steps)
that their complete and correct simulation of their input would never
terminate. They do this by matching elements of a set of infinite
behavior patterns:

(a) Infinite loop
(b) Infinite recursion
(c) Infinitely recursive simulation

-----------------------------------
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]
-----------------------------------
void Infinite_Recursion(int N)
{ Infinite_Recursion(N);
}

int main()
{ Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
}

_Infinite_Recursion()
[000010f2](01) 55 push ebp
[000010f3](02) 8bec mov ebp,esp
[000010f5](03) 8b4508 mov eax,[ebp+08]
[000010f8](01) 50 push eax
[000010f9](05) e8f4ffffff call 000010f2
[000010fe](03) 83c404 add esp,+04
[00001101](01) 5d pop ebp
[00001102](01) c3 ret
Size in bytes:(0017) [00001102]
-----------------------------------
void P(ptr x)
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

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

_P()
[00000fc2](01) 55 push ebp
[00000fc3](02) 8bec mov ebp,esp
[00000fc5](01) 51 push ecx
[00000fc6](03) 8b4508 mov eax,[ebp+08]
[00000fc9](01) 50 push eax
[00000fca](03) 8b4d08 mov ecx,[ebp+08]
[00000fcd](01) 51 push ecx
[00000fce](05) e8bffeffff call 00000e92
[00000fd3](03) 83c408 add esp,+08
[00000fd6](03) 8945fc mov [ebp-04],eax
[00000fd9](04) 837dfc00 cmp dword [ebp-04],+00
[00000fdd](02) 7402 jz 00000fe1
[00000fdf](02) ebfe jmp 00000fdf
[00000fe1](02) 8be5 mov esp,ebp
[00000fe3](01) 5d pop ebp
[00000fe4](01) c3 ret
Size in bytes:(0035) [00000fe4]

--
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/18/22 10:12 AM, olcott wrote:
> On 8/18/2022 6:36 AM, Richard Damon wrote:
>> On 8/17/22 11:43 PM, olcott wrote:
>>> *THIS IS SIMPLY OVER YOUR HEAD*
>>> It is an axiom that when-so-ever any simulating halt decider (SHD)
>>> performs a correct simulation of its input and this simulation would
>>> never stop running unless this simulation is aborted that this SHD is
>>> correct to reject this input as non-halting.
>>>
>>
>>
>> LIE.
>
> Try and prove otherwise without using double-talk.
>
>

Claiming a not established fact as an axiom IS a LIE.

Also, the DEFINION of a Halt Decider, Simulating or otherwise, is that
it must accept (call halting) any Machine/Input combination given to it
as a representaiton that when run would halt, and reject (call
non-halting) any Machine/Input combinatation given to it as a
representation that when run would NEVER halt, even after an unbounded
number of step.

THAT IS DEFINITION. (Unless you are going to say that Simulating Halt
Deciders are NOT actually Halt Deciders, then you are lying about
working on the Halting Problem).

P(P) Halts when H(P,P) returns 0.

Therefore, BY DEFININITON, that answer is WRONG.

No Double-Talk, simple definition.

YOU give double-talk.

YOU LIE.

Until you acknowledge what is actually the truth, you are DOOM to be
know as a LIAR and an IDIOT.

On 8/18/22 10:22 AM, olcott wrote:
> On 8/18/2022 6:46 AM, Richard Damon wrote:
>> On 8/17/22 11:52 PM, olcott wrote:
>>> On 8/17/2022 10:26 PM, Richard Damon wrote:
>>>> On 8/17/22 11:17 PM, olcott wrote:
>>
>>>>> The input simulated H(P,P) never halts.
>>>>>
>>>>
>>>> Grammer?
>>>>
>>>> Do you mean BY H, that has been proved to be a meaningless statement,
>>>
>>>
>>
>> So, the following reply doesn't answer the statement it appears to be
>> replying to.
>>
>> The one who will not read is no better than the one who can not read.
>>
>> Thus, you are showing yourself to be functionally illiterate.
>>
>>>
>>> *H0 correctly determines that its correct and complete*
>>> *simulation of Infinite_Loop would never halt*
>>>
>>> void Infinite_Loop()
>>> {
>>>    HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>> }
>>>
>>>
>>> *H correctly determines that its correct and complete*
>>> *simulation of Infinite_Recursion would never halt*
>>>
>>> void Infinite_Recursion(int N)
>>> {
>>>    Infinite_Recursion(N);
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>>> }
>>>
>>>
>>> *H correctly determines that its correct and complete*
>>> *simulation of P would never halt*
>>>
>>> void P(ptr x)
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ",  H(P, P));
>>> }
>>>
>>
>> Fallacy of Proof by Example, shows you failed basic logic.
>
> *Proofs of existential statements*
> In some scenarios, an argument by example may be valid if it leads from
> a singular premise to an existential conclusion (i.e. proving that a
> claim is true for at least one case, instead of for all cases). For
> example: Socrates is wise. Therefore, someone is wise.
> https://en.wikipedia.org/wiki/Proof_by_example
>
> If I prove that I can lift a specific bucket of water by lifting this
> bucket of water this is not the over-generalization of the proof by
> example.
>
> The statement that no H exists that correctly determines the halt status
> of P is refuted by a single example H that correctly determines the halt
> status of P.
>

Except that your H doesn't do what it says, so you don't get to do that.

Lifting an empty bucket doesn't prove you call lift a full bucket.

You are claiming that you H is right about problem A by showing it is
right about a much simpler problem B.

Thus, YOUR logic is unsound.

Yes, Proof of a statement of EXISTANCE can be done with an example.

Your "Rule" that you are claiming is NOT a rule of existence, but a rule
you claim always proves its conclusion.

THAT sort of thing can not be proven by example.

So, you are just digging your hole deeper.

On 8/18/2022 6:09 PM, Richard Damon wrote:
> On 8/18/22 10:12 AM, olcott wrote:
>> On 8/18/2022 6:36 AM, Richard Damon wrote:
>>> On 8/17/22 11:43 PM, olcott wrote:
>>>> *THIS IS SIMPLY OVER YOUR HEAD*
>>>> It is an axiom that when-so-ever any simulating halt decider (SHD)
>>>> performs a correct simulation of its input and this simulation would
>>>> never stop running unless this simulation is aborted that this SHD
>>>> is correct to reject this input as non-halting.
>>>>
>>>
>>>
>>> LIE.
>>
>> Try and prove otherwise without using double-talk.
>>
>>
>
> Claiming a not established fact as an axiom IS a LIE.
>
>

noun: axiom; plural noun: axioms
a statement or proposition which is regarded as being established,
accepted, or self-evidently true.

*The definition of the term [simulating halt decider] is an axiom*
A simulating halt decider
(a) examines the dynamic behavior of a program and
(b) correctly predicts that this program would never reach its final
state if this simulation was never aborted.

The SHD makes this prediction on the basis of correctly matching a
correct infinite behavior pattern.

--
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/18/22 7:08 PM, olcott wrote:
> On 8/18/2022 6:04 PM, Richard Damon wrote:
>> On 8/18/22 10:10 AM, olcott wrote:
>>> On 8/18/2022 3:23 AM, Mikko wrote:
>>>> On 2022-08-17 14:08:50 +0000, olcott said:
>>>>
>>>>> On 8/17/2022 4:15 AM, Mikko wrote:
>>>>>> On 2022-08-17 01:23:59 +0000, olcott said:
>>>>>>
>>>>>>> *Not at all. No one has disproved this statement*
>>>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>>>> emulation of its input would never stop running, thus does
>>>>>>> correctly reject this input as non-halting.
>>>>>>
>>>>>> This is not really a prediction >
>>>>>
>>>>> Yes it is really a prediction, otherwise H(P,P) would be required
>>>>> to simulate its input forever.
>>>>>
>>>>>> as it is about a sitation that will
>>>>>> never happen.
>>>>
>>>> A dictionary says that "a prediction" is 'a statement of what will
>>>> happen
>>>> in future'. Your statement has "would" instead of "will" so it is not a
>>>> prediction.
>>>>
>>>> Mikko
>>>>
>>>
>>> If you just want to play silly word games then please STFU!!! I am
>>> trying to validate my legacy and everyone here only wants to troll me.
>>>
>>> It is an axiom that when-so-ever any simulating halt decider (SHD)
>>> performs a correct simulation of its input and this simulation would
>>> never stop running unless this simulation is aborted that this SHD is
>>> correct to reject this input as non-halting.
>>>
>>>
>>
>> Where is that axiom from? It seem to be an invention of yours. You
>> don't seem to understand what an Axiom actually is.
>
> *It is the definition of a simulating halt decider*
> *It is the definition of a simulating halt decider*
> *It is the definition of a simulating halt decider*

So it IS an invention of yours. Glad you admit it.

Isn't one of your premsises that no one has actually looked at th before.

Now, of course, your problem is that you are using a WRONG definition of
a Simulating Halt Decider, because it doesn't ACTUALLY match the
required definition

Your SHD are just POOP deciders, not Halt Deciders.

>
> Simulating halt deciders correctly predict (in a finite number of steps)
> that their complete and correct simulation of their input would never
> terminate. They do this by matching elements of a set of infinite
> behavior patterns:
>
> (a) Infinite loop
> (b) Infinite recursion
> (c) Infinitely recursive simulation
>
> -----------------------------------
> 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]
> -----------------------------------
> void Infinite_Recursion(int N)
> {
>   Infinite_Recursion(N);
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
> }
>
> _Infinite_Recursion()
> [000010f2](01)  55         push ebp
> [000010f3](02)  8bec       mov ebp,esp
> [000010f5](03)  8b4508     mov eax,[ebp+08]
> [000010f8](01)  50         push eax
> [000010f9](05)  e8f4ffffff call 000010f2
> [000010fe](03)  83c404     add esp,+04
> [00001101](01)  5d         pop ebp
> [00001102](01)  c3         ret
> Size in bytes:(0017) [00001102]
> -----------------------------------
> void P(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ",  H(P, P));
> }
>
> _P()
> [00000fc2](01)  55             push ebp
> [00000fc3](02)  8bec           mov ebp,esp
> [00000fc5](01)  51             push ecx
> [00000fc6](03)  8b4508         mov eax,[ebp+08]
> [00000fc9](01)  50             push eax
> [00000fca](03)  8b4d08         mov ecx,[ebp+08]
> [00000fcd](01)  51             push ecx
> [00000fce](05)  e8bffeffff     call 00000e92
> [00000fd3](03)  83c408         add esp,+08
> [00000fd6](03)  8945fc         mov [ebp-04],eax
> [00000fd9](04)  837dfc00       cmp dword [ebp-04],+00
> [00000fdd](02)  7402           jz 00000fe1
> [00000fdf](02)  ebfe           jmp 00000fdf
> [00000fe1](02)  8be5           mov esp,ebp
> [00000fe3](01)  5d             pop ebp
> [00000fe4](01)  c3             ret
> Size in bytes:(0035) [00000fe4]
>
>
>
>

On 8/18/22 7:21 PM, olcott wrote:
> On 8/18/2022 6:09 PM, Richard Damon wrote:
>> On 8/18/22 10:12 AM, olcott wrote:
>>> On 8/18/2022 6:36 AM, Richard Damon wrote:
>>>> On 8/17/22 11:43 PM, olcott wrote:
>>>>> *THIS IS SIMPLY OVER YOUR HEAD*
>>>>> It is an axiom that when-so-ever any simulating halt decider (SHD)
>>>>> performs a correct simulation of its input and this simulation
>>>>> would never stop running unless this simulation is aborted that
>>>>> this SHD is correct to reject this input as non-halting.
>>>>>
>>>>
>>>>
>>>> LIE.
>>>
>>> Try and prove otherwise without using double-talk.
>>>
>>>
>>
>> Claiming a not established fact as an axiom IS a LIE.
>>
>>
>
> noun: axiom; plural noun: axioms
> a statement or proposition which is regarded as being established,
> accepted, or self-evidently true.

Right, "regarded", that means by the COMMUNITY, not just an individual.

Note, in a FORMAL system, the only Axioms avaiable are those that are
the formation of the system. After that you need to actually PROVE your
statements from the Axioms and other proven statements.

>
> *The definition of the term [simulating halt decider] is an axiom*
> A simulating halt decider
> (a) examines the dynamic behavior of a program and
> (b) correctly predicts that this program would never reach its final
> state if this simulation was never aborted.
>
> The SHD makes this prediction on the basis of correctly matching a
> correct infinite behavior pattern.
>
>

So, your SHD is NOT a Halt Decider because it doesn't answer the actual
question that a Halt Decider needs to answer, so you have just spent 18
your developing your POOP.

DEFINITION.

You are just showing that you don't understand how logic works.

On 8/18/2022 6:21 PM, olcott wrote:
> On 8/18/2022 6:09 PM, Richard Damon wrote:
>> On 8/18/22 10:12 AM, olcott wrote:
>>> On 8/18/2022 6:36 AM, Richard Damon wrote:
>>>> On 8/17/22 11:43 PM, olcott wrote:
>>>>> *THIS IS SIMPLY OVER YOUR HEAD*
>>>>> It is an axiom that when-so-ever any simulating halt decider (SHD)
>>>>> performs a correct simulation of its input and this simulation
>>>>> would never stop running unless this simulation is aborted that
>>>>> this SHD is correct to reject this input as non-halting.
>>>>>
>>>>
>>>>
>>>> LIE.
>>>
>>> Try and prove otherwise without using double-talk.
>>>
>>>
>>
>> Claiming a not established fact as an axiom IS a LIE.
>>
>>
>
> noun: axiom; plural noun: axioms
> a statement or proposition which is regarded as being established,
> accepted, or self-evidently true.
>

*THE MEANING OF THESE WORDS PROVES THAT THE SHD IS CORRECT*
Simulating halt deciders correctly simulate their input until they
correctly match correct infinite behavior patterns.

*A simulating halt decider*
(a) Simulates its first argument
(b) Examines the dynamic behavior of this simulated input
(c) to determine if this behavior correctly matches correct infinite
behavior patterns.

When the behavior does correctly match A correct infinite behavior
pattern then this proves that the simulated input would never reach its
final state if this simulation was never aborted.

--
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/18/2022 6:44 PM, Richard Damon wrote:
>
> On 8/18/22 7:21 PM, olcott wrote:
>> On 8/18/2022 6:09 PM, Richard Damon wrote:
>>> On 8/18/22 10:12 AM, olcott wrote:
>>>> On 8/18/2022 6:36 AM, Richard Damon wrote:
>>>>> On 8/17/22 11:43 PM, olcott wrote:
>>>>>> *THIS IS SIMPLY OVER YOUR HEAD*
>>>>>> It is an axiom that when-so-ever any simulating halt decider (SHD)
>>>>>> performs a correct simulation of its input and this simulation
>>>>>> would never stop running unless this simulation is aborted that
>>>>>> this SHD is correct to reject this input as non-halting.
>>>>>>
>>>>>
>>>>>
>>>>> LIE.
>>>>
>>>> Try and prove otherwise without using double-talk.
>>>>
>>>>
>>>
>>> Claiming a not established fact as an axiom IS a LIE.
>>>
>>>
>>
>> noun: axiom; plural noun: axioms
>> a statement or proposition which is regarded as being established,
>> accepted, or self-evidently true.
>
> Right, "regarded", that means by the COMMUNITY, not just an individual.
>
> Note, in a FORMAL system, the only Axioms avaiable are those that are
> the formation of the system. After that you need to actually PROVE your
> statements from the Axioms and other proven statements.
>
>>
>> *The definition of the term [simulating halt decider] is an axiom*
>> A simulating halt decider
>> (a) examines the dynamic behavior of a program and
>> (b) correctly predicts that this program would never reach its final
>> state if this simulation was never aborted.
>>
>> The SHD makes this prediction on the basis of correctly matching a
>> correct infinite behavior pattern.
>>
>>
>
> So, your SHD is NOT a Halt Decider because it doesn't answer the actual
> question that a Halt Decider needs to answer, so you have just spent 18
> your developing your POOP.
>
>
> DEFINITION.
>
> You are just showing that you don't understand how logic works.

My system is correct from a software engineering point of view.
H does correctly determine that the actual behavior of its actual input
specifies a sequence of instructions that never reach their final state.

Once this is accepted as true THENN (then and only then) we can begin
examining why computer science disgrees with software engineering.

--
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 Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
> My system is correct from a software engineering point of view.
> H does correctly determine that the actual behavior of its actual input
> specifies a sequence of instructions that never reach their final state.
Your program doesn't determine that the input NEVER (key word!!!) reach their final state.

Your program determines that input doesn't reach its final state within N number of CPU cycles.

You've implemented nothing other than a timeout exception. Wait 10 seconds. If not done - terminate.

That's not a proof of NEVER.
That's a proof of NEVER (within the 10 seconds of observation.)

> Once this is accepted as true THENN (then and only then) we can begin
> examining why computer science disgrees with software engineering.
There's no disagreement. There is only your misunderstanding.

Detecting loops only works if your functions are deterministic.
Calling the same function with the same parameters doesn't mean the function is going to perform the same computation every time.

There's all kinds of non-determinism lurking everywhere.

On 8/18/2022 7:05 PM, Skep Dick wrote:
> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>> My system is correct from a software engineering point of view.
>> H does correctly determine that the actual behavior of its actual input
>> specifies a sequence of instructions that never reach their final state.
> Your program doesn't determine that the input NEVER (key word!!!) reach their final state.
>
> Your program determines that input doesn't reach its final state within N number of CPU cycles.
>

When-so-ever the partial simulation of a machine description correctly
matches a correct infinite behavior pattern then it is certain that this
machine description specifies infinite behavior.

--
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/18/22 7:51 PM, olcott wrote:
> On 8/18/2022 6:44 PM, Richard Damon wrote:
>>
>> On 8/18/22 7:21 PM, olcott wrote:
>>> On 8/18/2022 6:09 PM, Richard Damon wrote:
>>>> On 8/18/22 10:12 AM, olcott wrote:
>>>>> On 8/18/2022 6:36 AM, Richard Damon wrote:
>>>>>> On 8/17/22 11:43 PM, olcott wrote:
>>>>>>> *THIS IS SIMPLY OVER YOUR HEAD*
>>>>>>> It is an axiom that when-so-ever any simulating halt decider
>>>>>>> (SHD) performs a correct simulation of its input and this
>>>>>>> simulation would never stop running unless this simulation is
>>>>>>> aborted that this SHD is correct to reject this input as
>>>>>>> non-halting.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> LIE.
>>>>>
>>>>> Try and prove otherwise without using double-talk.
>>>>>
>>>>>
>>>>
>>>> Claiming a not established fact as an axiom IS a LIE.
>>>>
>>>>
>>>
>>> noun: axiom; plural noun: axioms
>>> a statement or proposition which is regarded as being established,
>>> accepted, or self-evidently true.
>>
>> Right, "regarded", that means by the COMMUNITY, not just an individual.
>>
>> Note, in a FORMAL system, the only Axioms avaiable are those that are
>> the formation of the system. After that you need to actually PROVE
>> your statements from the Axioms and other proven statements.
>>
>>>
>>> *The definition of the term [simulating halt decider] is an axiom*
>>> A simulating halt decider
>>> (a) examines the dynamic behavior of a program and
>>> (b) correctly predicts that this program would never reach its final
>>> state if this simulation was never aborted.
>>>
>>> The SHD makes this prediction on the basis of correctly matching a
>>> correct infinite behavior pattern.
>>>
>>>
>>
>> So, your SHD is NOT a Halt Decider because it doesn't answer the
>> actual question that a Halt Decider needs to answer, so you have just
>> spent 18 your developing your POOP.
>>
>>
>> DEFINITION.
>>
>> You are just showing that you don't understand how logic works.
>
> My system is correct from a software engineering point of view.
> H does correctly determine that the actual behavior of its actual input
> specifies a sequence of instructions that never reach their final state.
>
> Once this is accepted as true THENN (then and only then) we can begin
> examining why computer science disgrees with software engineering.
>

No, it doesn't. The problem is you don't use the right definitions, so
you don't get the right answer.

Since P calls H(P,P) to ask about P(P), that must be the meaning of the
call to H(P,P), and that IS what the input actually represents, and what
the CORRECT x86 emulation of that input would show.

You use wrong, and inconsistent, definitions to make you claim, so you
answer are just wrong when compared to the CORRECT question with the
CORRECT definitions.

I probably have a better Software Engineering background than you do, so
don't try that stuff on me.

On 8/18/2022 7:15 PM, Richard Damon wrote:
> On 8/18/22 7:51 PM, olcott wrote:
>> On 8/18/2022 6:44 PM, Richard Damon wrote:
>>>
>>> On 8/18/22 7:21 PM, olcott wrote:
>>>> On 8/18/2022 6:09 PM, Richard Damon wrote:
>>>>> On 8/18/22 10:12 AM, olcott wrote:
>>>>>> On 8/18/2022 6:36 AM, Richard Damon wrote:
>>>>>>> On 8/17/22 11:43 PM, olcott wrote:
>>>>>>>> *THIS IS SIMPLY OVER YOUR HEAD*
>>>>>>>> It is an axiom that when-so-ever any simulating halt decider
>>>>>>>> (SHD) performs a correct simulation of its input and this
>>>>>>>> simulation would never stop running unless this simulation is
>>>>>>>> aborted that this SHD is correct to reject this input as
>>>>>>>> non-halting.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> LIE.
>>>>>>
>>>>>> Try and prove otherwise without using double-talk.
>>>>>>
>>>>>>
>>>>>
>>>>> Claiming a not established fact as an axiom IS a LIE.
>>>>>
>>>>>
>>>>
>>>> noun: axiom; plural noun: axioms
>>>> a statement or proposition which is regarded as being established,
>>>> accepted, or self-evidently true.
>>>
>>> Right, "regarded", that means by the COMMUNITY, not just an individual.
>>>
>>> Note, in a FORMAL system, the only Axioms avaiable are those that are
>>> the formation of the system. After that you need to actually PROVE
>>> your statements from the Axioms and other proven statements.
>>>
>>>>
>>>> *The definition of the term [simulating halt decider] is an axiom*
>>>> A simulating halt decider
>>>> (a) examines the dynamic behavior of a program and
>>>> (b) correctly predicts that this program would never reach its final
>>>> state if this simulation was never aborted.
>>>>
>>>> The SHD makes this prediction on the basis of correctly matching a
>>>> correct infinite behavior pattern.
>>>>
>>>>
>>>
>>> So, your SHD is NOT a Halt Decider because it doesn't answer the
>>> actual question that a Halt Decider needs to answer, so you have just
>>> spent 18 your developing your POOP.
>>>
>>>
>>> DEFINITION.
>>>
>>> You are just showing that you don't understand how logic works.
>>
>> My system is correct from a software engineering point of view.
>> H does correctly determine that the actual behavior of its actual
>> input specifies a sequence of instructions that never reach their
>> final state.
>>
>> Once this is accepted as true THENN (then and only then) we can begin
>> examining why computer science disgrees with software engineering.
>>
>
> No, it doesn't. The problem is you don't use the right definitions, so
> you don't get the right answer.
>

When-so-ever the correct partial simulation of a machine description
correctly matches a correct infinite behavior pattern then it is certain
that this machine description specifies infinite behavior.

--
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 Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
> On 8/18/2022 7:05 PM, Skep Dick wrote:
> > On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
> >> My system is correct from a software engineering point of view.
> >> H does correctly determine that the actual behavior of its actual input
> >> specifies a sequence of instructions that never reach their final state.
> > Your program doesn't determine that the input NEVER (key word!!!) reach their final state.
> >
> > Your program determines that input doesn't reach its final state within N number of CPU cycles.
> >
> When-so-ever the partial simulation of a machine description correctly
> matches a correct infinite behavior pattern then it is certain that this
> machine description specifies infinite behavior.

You can correctly put as correct many correct uses of the correct word correct but correct is not correct to be correct correct correct correct.

You are incorrect.

On Friday, 19 August 2022 at 02:28:01 UTC+2, olcott wrote:
> When-so-ever the correct partial simulation of a machine description
> correctly matches a correct infinite behavior pattern then it is certain
> that this machine description specifies infinite behavior.
You are incorrect about being correct.

On 8/18/2022 8:04 PM, Skep Dick wrote:
> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>> My system is correct from a software engineering point of view.
>>>> H does correctly determine that the actual behavior of its actual input
>>>> specifies a sequence of instructions that never reach their final state.
>>> Your program doesn't determine that the input NEVER (key word!!!) reach their final state.
>>>
>>> Your program determines that input doesn't reach its final state within N number of CPU cycles.
>>>
>> When-so-ever the partial simulation of a machine description correctly
>> matches a correct infinite behavior pattern then it is certain that this
>> machine description specifies infinite behavior.
>
> You can correctly put as correct many correct uses of the correct word correct but correct is not correct to be correct correct correct correct.
>
> You are incorrect.

*Since there are no mistakes no one can point out any mistakes*
*Since there are no mistakes no one can point out any mistakes*
*Since there are no mistakes no one can point out any mistakes*

(a) The correct partial simulation of a machine description
(b) Correctly matches
(c) A correct infinite behavior pattern
(d) Then this machine description specifies infinite behavior.

(a)(b)(c) premises that are verified to be true
(d) logically follows from (a)(b)(c)

--
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 Friday, 19 August 2022 at 03:20:56 UTC+2, olcott wrote:
> On 8/18/2022 8:04 PM, Skep Dick wrote:
> > On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
> >> On 8/18/2022 7:05 PM, Skep Dick wrote:
> >>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
> >>>> My system is correct from a software engineering point of view.
> >>>> H does correctly determine that the actual behavior of its actual input
> >>>> specifies a sequence of instructions that never reach their final state.
> >>> Your program doesn't determine that the input NEVER (key word!!!) reach their final state.
> >>>
> >>> Your program determines that input doesn't reach its final state within N number of CPU cycles.
> >>>
> >> When-so-ever the partial simulation of a machine description correctly
> >> matches a correct infinite behavior pattern then it is certain that this
> >> machine description specifies infinite behavior.
> >
> > You can correctly put as correct many correct uses of the correct word correct but correct is not correct to be correct correct correct correct.
> >
> > You are incorrect.
> *Since there are no mistakes no one can point out any mistakes*
> *Since there are no mistakes no one can point out any mistakes*
> *Since there are no mistakes no one can point out any mistakes*

The mistake is obvious. You terminated the program prematurely thus denying it an opportunity to halt (in due time and on its own terms).

But you won't accept that.

> (a) The correct partial simulation of a machine description
The simulation is partial, and thus its "correctness" or "incorrectness" are in doubt.

> (d) logically follows from (a)(b)(c)
Nope.

You are incorrect about being correct.

Q.E.D

On 8/18/2022 8:28 PM, Skep Dick wrote:
> On Friday, 19 August 2022 at 03:20:56 UTC+2, olcott wrote:
>> On 8/18/2022 8:04 PM, Skep Dick wrote:
>>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>>>> My system is correct from a software engineering point of view.
>>>>>> H does correctly determine that the actual behavior of its actual input
>>>>>> specifies a sequence of instructions that never reach their final state.
>>>>> Your program doesn't determine that the input NEVER (key word!!!) reach their final state.
>>>>>
>>>>> Your program determines that input doesn't reach its final state within N number of CPU cycles.
>>>>>
>>>> When-so-ever the partial simulation of a machine description correctly
>>>> matches a correct infinite behavior pattern then it is certain that this
>>>> machine description specifies infinite behavior.
>>>
>>> You can correctly put as correct many correct uses of the correct word correct but correct is not correct to be correct correct correct correct.
>>>
>>> You are incorrect.
>> *Since there are no mistakes no one can point out any mistakes*
>> *Since there are no mistakes no one can point out any mistakes*
>> *Since there are no mistakes no one can point out any mistakes*
>
> The mistake is obvious. You terminated the program prematurely thus denying it an opportunity to halt (in due time and on its own terms).
>

*THAT WAS A DISHONEST DODGE AND YOU KNOW IT*
*YOU CAN'T FREAKING CHANGE THE SUBJECT AND COUNT THAT AS A REBUTTAL*

(a) The correct partial simulation of a machine description
(b) Correctly matches
(c) A correct infinite behavior pattern
(d) Then this machine description specifies infinite behavior.

(a)(b)(c) premises that are verified to be true
(d) logically follows from (a)(b)(c)

*YOU MUST PROVE THAT*
(1) At least one of the premises is false
OR
(2) The conclusion does not logically follow from the premises.

--
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/18/22 9:20 PM, olcott wrote:
> On 8/18/2022 8:04 PM, Skep Dick wrote:
>> On Friday, 19 August 2022 at 02:12:26 UTC+2, olcott wrote:
>>> On 8/18/2022 7:05 PM, Skep Dick wrote:
>>>> On Friday, 19 August 2022 at 01:51:13 UTC+2, olcott wrote:
>>>>> My system is correct from a software engineering point of view.
>>>>> H does correctly determine that the actual behavior of its actual
>>>>> input
>>>>> specifies a sequence of instructions that never reach their final
>>>>> state.
>>>> Your program doesn't determine that the input NEVER (key word!!!)
>>>> reach their final state.
>>>>
>>>> Your program determines that input doesn't reach its final state
>>>> within N number of CPU cycles.
>>>>
>>> When-so-ever the partial simulation of a machine description correctly
>>> matches a correct infinite behavior pattern then it is certain that this
>>> machine description specifies infinite behavior.
>>
>> You can correctly put as correct many correct uses of the correct word
>> correct but correct is not correct to be correct correct correct correct.
>>
>> You are incorrect.
>
> *Since there are no mistakes no one can point out any mistakes*
> *Since there are no mistakes no one can point out any mistakes*
> *Since there are no mistakes no one can point out any mistakes*

People HAVE pointed out the mistakes, but you are apparently too dumb to
understand the problem.

>
> (a) The correct partial simulation of a machine description
> (b) Correctly matches
> (c) A correct infinite behavior pattern

But the pattern you suggest is NOT corrct.

> (d) Then this machine description specifies infinite behavior.
>
> (a)(b)(c) premises that are verified to be true

But they are NOT

> (d) logically follows from (a)(b)(c)
>

So (d) does not follow.