Message-ID:

win-nt from the people who invented edlin. -- MaDsen Wikholm, mwikholm@at8.abo.fi

devel / comp.theory / Re: Simulating Halt Deciders

Simulating Halt Deciders

<Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>

https://www.novabbs.com/devel/article-flat.php?id=37383&group=comp.theory#37383

by: olcott - Fri, 12 Aug 2022 15:45 UTC

A simulating halt decider simulates its input until it correctly proves
that this simulation would never stop unless aborted.

typedef void (*ptr)();
int H(ptr p, ptr i); // simulating halt decider

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));
}

(a) I believe that most computer scientists would agree that a halt
decider must compute the mapping from its inputs to an accept or reject
state on the basis of the actual behavior specified by this input.

(b) Furthermore ALL computer scientists would agree that the correct
simulation of a machine description does derive the correct behavior
specified by this machine description.

This logically entails that when H(P,P) simulates its input until the
behavior of this input essentially matches the infinite recursion
behavior pattern, then H has correctly determined the halt status of P.

(a) The invoked 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)...
Until H aborts the simulation of its input

*Halting problem proofs refuted on the basis of software engineering* ?
https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_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 Fri, 12 Aug 2022 10:45:34 -0500
olcott <NoOne@NoWhere.com> wrote:

> A simulating halt decider simulates its input until it correctly
> proves that this simulation would never stop unless aborted.
>
> typedef void (*ptr)();
> int H(ptr p, ptr i); // simulating halt decider
>
> 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));
> }
>
> (a) I believe that most computer scientists would agree that a halt
> decider must compute the mapping from its inputs to an accept or
> reject state on the basis of the actual behavior specified by this
> input.
>
> (b) Furthermore ALL computer scientists would agree that the correct
> simulation of a machine description does derive the correct behavior
> specified by this machine description.
>
> This logically entails that when H(P,P) simulates its input until the
> behavior of this input essentially matches the infinite recursion
> behavior pattern, then H has correctly determined the halt status of
> P.
>
> (a) The invoked 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)...
> Until H aborts the simulation of its input

Nope. I have shown that a simulating halt decider needn't be recursive
in nature and you are incorrect to map your erroneous infinite recursion
to non-halting if P actually halts when run.

/Flibble

Re: Simulating Halt Deciders

<lsycnUVFCrw-FWv_nZ2dnZfqlJ9g4p2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=37396&group=comp.theory#37396

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 12 Aug 2022 17:06:43 +0000
Date: Fri, 12 Aug 2022 12:07:03 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Simulating Halt Deciders
Content-Language: en-US
Newsgroups: comp.theory
References: <Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812172225.00007d90@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220812172225.00007d90@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <lsycnUVFCrw-FWv_nZ2dnZfqlJ9g4p2d@giganews.com>
Lines: 69
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Xi1WPD0f83hgAET1vfyJJxsJHNHAaCUHyBQAwKUiGuo/ycUMa/5C808r4HdUDjTgstYaKqzCIyqfIei!v+pXTTvkKBlTPIREuZl6p1hf8OftHu/7f/xwEu39knmfyV01hwiWe2e9aKhE1a5Ps+upr7/f4+E8!zA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40

by: olcott - Fri, 12 Aug 2022 17:07 UTC

On 8/12/2022 11:22 AM, Mr Flibble wrote:
> On Fri, 12 Aug 2022 10:45:34 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> A simulating halt decider simulates its input until it correctly
>> proves that this simulation would never stop unless aborted.
>>
>> typedef void (*ptr)();
>> int H(ptr p, ptr i); // simulating halt decider
>>
>> 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));
>> }
>>
>> (a) I believe that most computer scientists would agree that a halt
>> decider must compute the mapping from its inputs to an accept or
>> reject state on the basis of the actual behavior specified by this
>> input.
>>
>> (b) Furthermore ALL computer scientists would agree that the correct
>> simulation of a machine description does derive the correct behavior
>> specified by this machine description.
>>
>> This logically entails that when H(P,P) simulates its input until the
>> behavior of this input essentially matches the infinite recursion
>> behavior pattern, then H has correctly determined the halt status of
>> P.
>>
>> (a) The invoked 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)...
>> Until H aborts the simulation of its input
>
> Nope. I have shown that a simulating halt decider needn't be recursive
> in nature and you are incorrect to map your erroneous infinite recursion
> to non-halting if P actually halts when run.
>
> /Flibble
>

A simulating halt decider is never recursive in nature unless its input
is recursive:

void Infinite_Recursion(int N)
{ Infinite_Recursion(N);
}

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

--
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 Fri, 12 Aug 2022 12:07:03 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/12/2022 11:22 AM, Mr Flibble wrote:
> > On Fri, 12 Aug 2022 10:45:34 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> A simulating halt decider simulates its input until it correctly
> >> proves that this simulation would never stop unless aborted.
> >>
> >> typedef void (*ptr)();
> >> int H(ptr p, ptr i); // simulating halt decider
> >>
> >> 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));
> >> }
> >>
> >> (a) I believe that most computer scientists would agree that a halt
> >> decider must compute the mapping from its inputs to an accept or
> >> reject state on the basis of the actual behavior specified by this
> >> input.
> >>
> >> (b) Furthermore ALL computer scientists would agree that the
> >> correct simulation of a machine description does derive the
> >> correct behavior specified by this machine description.
> >>
> >> This logically entails that when H(P,P) simulates its input until
> >> the behavior of this input essentially matches the infinite
> >> recursion behavior pattern, then H has correctly determined the
> >> halt status of P.
> >>
> >> (a) The invoked 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)...
> >> Until H aborts the simulation of its input
> >
> > Nope. I have shown that a simulating halt decider needn't be
> > recursive in nature and you are incorrect to map your erroneous
> > infinite recursion to non-halting if P actually halts when run.
> >
> > /Flibble
> >
>
> A simulating halt decider is never recursive in nature unless its
> input is recursive:
>
> void Infinite_Recursion(int N)
> {
> Infinite_Recursion(N);
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
> }

P calling H does not mean that P is recursive in nature, it means your
decider is recursive in nature.

/Flibble

Re: Simulating Halt Deciders

<3NGdnZX7zN03E2v_nZ2dnZfqlJxh4p2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=37400&group=comp.theory#37400

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 12 Aug 2022 17:32:26 +0000
Date: Fri, 12 Aug 2022 12:32:41 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Simulating Halt Deciders
Content-Language: en-US
Newsgroups: comp.theory
References: <Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812172225.00007d90@reddwarf.jmc.corp>
<lsycnUVFCrw-FWv_nZ2dnZfqlJ9g4p2d@giganews.com>
<20220812181455.00003b76@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220812181455.00003b76@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <3NGdnZX7zN03E2v_nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 82
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-uSJBHAl/xITXOTowYJ5/rK1vG8GEuXBWMlZ9r3TN/HIyfUxwEuQYq4WDqD2mS07Iop6S0/OjeUNYGHA!zxX2XLto1Y0l8dhLrBSrxLcgkTkLtw/M7VQ2xZUltmm20qRi/zyh+oXn79q8cciajv4StCHcXExc!BA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40

by: olcott - Fri, 12 Aug 2022 17:32 UTC

On 8/12/2022 12:14 PM, Mr Flibble wrote:
> On Fri, 12 Aug 2022 12:07:03 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/12/2022 11:22 AM, Mr Flibble wrote:
>>> On Fri, 12 Aug 2022 10:45:34 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> A simulating halt decider simulates its input until it correctly
>>>> proves that this simulation would never stop unless aborted.
>>>>
>>>> typedef void (*ptr)();
>>>> int H(ptr p, ptr i); // simulating halt decider
>>>>
>>>> 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));
>>>> }
>>>>
>>>> (a) I believe that most computer scientists would agree that a halt
>>>> decider must compute the mapping from its inputs to an accept or
>>>> reject state on the basis of the actual behavior specified by this
>>>> input.
>>>>
>>>> (b) Furthermore ALL computer scientists would agree that the
>>>> correct simulation of a machine description does derive the
>>>> correct behavior specified by this machine description.
>>>>
>>>> This logically entails that when H(P,P) simulates its input until
>>>> the behavior of this input essentially matches the infinite
>>>> recursion behavior pattern, then H has correctly determined the
>>>> halt status of P.
>>>>
>>>> (a) The invoked 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)...
>>>> Until H aborts the simulation of its input
>>>
>>> Nope. I have shown that a simulating halt decider needn't be
>>> recursive in nature and you are incorrect to map your erroneous
>>> infinite recursion to non-halting if P actually halts when run.
>>>
>>> /Flibble
>>>
>>
>> A simulating halt decider is never recursive in nature unless its
>> input is recursive:
>>
>> void Infinite_Recursion(int N)
>> {
>> Infinite_Recursion(N);
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>> }
>
> P calling H does not mean that P is recursive in nature, it means your
> decider is recursive in nature.
>
> /Flibble
>
>

A simulating halt decider always only simulates the behavior that its
input specifies.

--
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 Fri, 12 Aug 2022 12:32:41 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/12/2022 12:14 PM, Mr Flibble wrote:
> > On Fri, 12 Aug 2022 12:07:03 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/12/2022 11:22 AM, Mr Flibble wrote:
> >>> On Fri, 12 Aug 2022 10:45:34 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> A simulating halt decider simulates its input until it correctly
> >>>> proves that this simulation would never stop unless aborted.
> >>>>
> >>>> typedef void (*ptr)();
> >>>> int H(ptr p, ptr i); // simulating halt decider
> >>>>
> >>>> 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));
> >>>> }
> >>>>
> >>>> (a) I believe that most computer scientists would agree that a
> >>>> halt decider must compute the mapping from its inputs to an
> >>>> accept or reject state on the basis of the actual behavior
> >>>> specified by this input.
> >>>>
> >>>> (b) Furthermore ALL computer scientists would agree that the
> >>>> correct simulation of a machine description does derive the
> >>>> correct behavior specified by this machine description.
> >>>>
> >>>> This logically entails that when H(P,P) simulates its input until
> >>>> the behavior of this input essentially matches the infinite
> >>>> recursion behavior pattern, then H has correctly determined the
> >>>> halt status of P.
> >>>>
> >>>> (a) The invoked 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)...
> >>>> Until H aborts the simulation of its input
> >>>
> >>> Nope. I have shown that a simulating halt decider needn't be
> >>> recursive in nature and you are incorrect to map your erroneous
> >>> infinite recursion to non-halting if P actually halts when run.
> >>>
> >>> /Flibble
> >>>
> >>
> >> A simulating halt decider is never recursive in nature unless its
> >> input is recursive:
> >>
> >> void Infinite_Recursion(int N)
> >> {
> >> Infinite_Recursion(N);
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
> >> }
> >
> > P calling H does not mean that P is recursive in nature, it means
> > your decider is recursive in nature.
> >
> > /Flibble
> >
> >
>
> A simulating halt decider always only simulates the behavior that its
> input specifies.
>

Again: H calling P calling H calling P does NOT mean that P is
recursive, it means H is recursive.

/Flibble

Re: Simulating Halt Deciders

<q96dnSSGIqlOC2v_nZ2dnZfqlJxh4p2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=37410&group=comp.theory#37410

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 12 Aug 2022 18:07:15 +0000
Date: Fri, 12 Aug 2022 13:07:30 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Simulating Halt Deciders
Content-Language: en-US
Newsgroups: comp.theory
References: <Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812172225.00007d90@reddwarf.jmc.corp>
<lsycnUVFCrw-FWv_nZ2dnZfqlJ9g4p2d@giganews.com>
<20220812181455.00003b76@reddwarf.jmc.corp>
<3NGdnZX7zN03E2v_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812184621.00006447@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220812184621.00006447@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <q96dnSSGIqlOC2v_nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 96
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ePXLS8K0dKsXGpfP9GIKXmikUb37Swv8i/5wcOdKzYGtFXoaIP4V4wFLkXLvzZDWl4IMDxx0i2waUX2!Lk3ZwpUCUVDQtGtOnHL1LzdGYk9Ck02mqyXWT212e9pq++l0R6NsD9HMenm1rynDbPfYTeE/kANd!uQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40

by: olcott - Fri, 12 Aug 2022 18:07 UTC

On 8/12/2022 12:46 PM, Mr Flibble wrote:
> On Fri, 12 Aug 2022 12:32:41 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/12/2022 12:14 PM, Mr Flibble wrote:
>>> On Fri, 12 Aug 2022 12:07:03 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/12/2022 11:22 AM, Mr Flibble wrote:
>>>>> On Fri, 12 Aug 2022 10:45:34 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> A simulating halt decider simulates its input until it correctly
>>>>>> proves that this simulation would never stop unless aborted.
>>>>>>
>>>>>> typedef void (*ptr)();
>>>>>> int H(ptr p, ptr i); // simulating halt decider
>>>>>>
>>>>>> 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));
>>>>>> }
>>>>>>
>>>>>> (a) I believe that most computer scientists would agree that a
>>>>>> halt decider must compute the mapping from its inputs to an
>>>>>> accept or reject state on the basis of the actual behavior
>>>>>> specified by this input.
>>>>>>
>>>>>> (b) Furthermore ALL computer scientists would agree that the
>>>>>> correct simulation of a machine description does derive the
>>>>>> correct behavior specified by this machine description.
>>>>>>
>>>>>> This logically entails that when H(P,P) simulates its input until
>>>>>> the behavior of this input essentially matches the infinite
>>>>>> recursion behavior pattern, then H has correctly determined the
>>>>>> halt status of P.
>>>>>>
>>>>>> (a) The invoked 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)...
>>>>>> Until H aborts the simulation of its input
>>>>>
>>>>> Nope. I have shown that a simulating halt decider needn't be
>>>>> recursive in nature and you are incorrect to map your erroneous
>>>>> infinite recursion to non-halting if P actually halts when run.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> A simulating halt decider is never recursive in nature unless its
>>>> input is recursive:
>>>>
>>>> void Infinite_Recursion(int N)
>>>> {
>>>> Infinite_Recursion(N);
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>>>> }
>>>
>>> P calling H does not mean that P is recursive in nature, it means
>>> your decider is recursive in nature.
>>>
>>> /Flibble
>>>
>>>
>>
>> A simulating halt decider always only simulates the behavior that its
>> input specifies.
>>
>
> Again: H calling P calling H calling P does NOT mean that P is
> recursive, it means H is recursive.
>
> /Flibble
>

Because H merely simulates whatever behavior that its input specifies
then it is P and *NOT* H that is recursive.

--
Copyright 2022 Pete Olcott

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

Re: Simulating Halt Deciders

<20220812191252.00000f2b@reddwarf.jmc.corp>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=37411&group=comp.theory#37411

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx06.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Simulating Halt Deciders
Message-ID: <20220812191252.00000f2b@reddwarf.jmc.corp>
References: <Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812172225.00007d90@reddwarf.jmc.corp>
<lsycnUVFCrw-FWv_nZ2dnZfqlJ9g4p2d@giganews.com>
<20220812181455.00003b76@reddwarf.jmc.corp>
<3NGdnZX7zN03E2v_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812184621.00006447@reddwarf.jmc.corp>
<q96dnSSGIqlOC2v_nZ2dnZfqlJxh4p2d@giganews.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 100
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 12 Aug 2022 18:12:53 UTC
Date: Fri, 12 Aug 2022 19:12:52 +0100
X-Received-Bytes: 4483

by: Mr Flibble - Fri, 12 Aug 2022 18:12 UTC

On Fri, 12 Aug 2022 13:07:30 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/12/2022 12:46 PM, Mr Flibble wrote:
> > On Fri, 12 Aug 2022 12:32:41 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/12/2022 12:14 PM, Mr Flibble wrote:
> >>> On Fri, 12 Aug 2022 12:07:03 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/12/2022 11:22 AM, Mr Flibble wrote:
> >>>>> On Fri, 12 Aug 2022 10:45:34 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> A simulating halt decider simulates its input until it
> >>>>>> correctly proves that this simulation would never stop unless
> >>>>>> aborted.
> >>>>>>
> >>>>>> typedef void (*ptr)();
> >>>>>> int H(ptr p, ptr i); // simulating halt decider
> >>>>>>
> >>>>>> 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));
> >>>>>> }
> >>>>>>
> >>>>>> (a) I believe that most computer scientists would agree that a
> >>>>>> halt decider must compute the mapping from its inputs to an
> >>>>>> accept or reject state on the basis of the actual behavior
> >>>>>> specified by this input.
> >>>>>>
> >>>>>> (b) Furthermore ALL computer scientists would agree that the
> >>>>>> correct simulation of a machine description does derive the
> >>>>>> correct behavior specified by this machine description.
> >>>>>>
> >>>>>> This logically entails that when H(P,P) simulates its input
> >>>>>> until the behavior of this input essentially matches the
> >>>>>> infinite recursion behavior pattern, then H has correctly
> >>>>>> determined the halt status of P.
> >>>>>>
> >>>>>> (a) The invoked 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)...
> >>>>>> Until H aborts the simulation of its input
> >>>>>
> >>>>> Nope. I have shown that a simulating halt decider needn't be
> >>>>> recursive in nature and you are incorrect to map your erroneous
> >>>>> infinite recursion to non-halting if P actually halts when run.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> A simulating halt decider is never recursive in nature unless its
> >>>> input is recursive:
> >>>>
> >>>> void Infinite_Recursion(int N)
> >>>> {
> >>>> Infinite_Recursion(N);
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
> >>>> }
> >>>
> >>> P calling H does not mean that P is recursive in nature, it means
> >>> your decider is recursive in nature.
> >>>
> >>> /Flibble
> >>>
> >>>
> >>
> >> A simulating halt decider always only simulates the behavior that
> >> its input specifies.
> >>
> >
> > Again: H calling P calling H calling P does NOT mean that P is
> > recursive, it means H is recursive.
> >
> > /Flibble
> >
>
> Because H merely simulates whatever behavior that its input specifies
> then it is P and *NOT* H that is recursive.

WRONG. H is recursive not P, P is oblivious to how H decides P's
halting status, it is an implementation detail of *your* decider to
recursively call P and my SHD has no such recursion to "abort".

/Flibble

Re: Simulating Halt Deciders

<KLedndgHTqwGOGv_nZ2dnZfqlJxh4p2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=37413&group=comp.theory#37413

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 12 Aug 2022 19:10:19 +0000
Date: Fri, 12 Aug 2022 14:10:34 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Simulating Halt Deciders
Content-Language: en-US
Newsgroups: comp.theory
References: <Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812172225.00007d90@reddwarf.jmc.corp>
<lsycnUVFCrw-FWv_nZ2dnZfqlJ9g4p2d@giganews.com>
<20220812181455.00003b76@reddwarf.jmc.corp>
<3NGdnZX7zN03E2v_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812184621.00006447@reddwarf.jmc.corp>
<q96dnSSGIqlOC2v_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812191252.00000f2b@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220812191252.00000f2b@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <KLedndgHTqwGOGv_nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 117
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-7mhbHnmruGPO5TqcD0fx1YSLVQAjAy5TBEPFqktq90+pwzsC6kDfItArKPkZfTPhMgfwYK0WPM4olpl!TrntzM6BSLe4Yet0TJc/L7ymXI0OO5qvwuzMu5e/976p1rv9e6LBH5TId883SRcZmMwm1W/9KHRu!kA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40

by: olcott - Fri, 12 Aug 2022 19:10 UTC

On 8/12/2022 1:12 PM, Mr Flibble wrote:
> On Fri, 12 Aug 2022 13:07:30 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/12/2022 12:46 PM, Mr Flibble wrote:
>>> On Fri, 12 Aug 2022 12:32:41 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/12/2022 12:14 PM, Mr Flibble wrote:
>>>>> On Fri, 12 Aug 2022 12:07:03 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/12/2022 11:22 AM, Mr Flibble wrote:
>>>>>>> On Fri, 12 Aug 2022 10:45:34 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> A simulating halt decider simulates its input until it
>>>>>>>> correctly proves that this simulation would never stop unless
>>>>>>>> aborted.
>>>>>>>>
>>>>>>>> typedef void (*ptr)();
>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
>>>>>>>>
>>>>>>>> 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));
>>>>>>>> }
>>>>>>>>
>>>>>>>> (a) I believe that most computer scientists would agree that a
>>>>>>>> halt decider must compute the mapping from its inputs to an
>>>>>>>> accept or reject state on the basis of the actual behavior
>>>>>>>> specified by this input.
>>>>>>>>
>>>>>>>> (b) Furthermore ALL computer scientists would agree that the
>>>>>>>> correct simulation of a machine description does derive the
>>>>>>>> correct behavior specified by this machine description.
>>>>>>>>
>>>>>>>> This logically entails that when H(P,P) simulates its input
>>>>>>>> until the behavior of this input essentially matches the
>>>>>>>> infinite recursion behavior pattern, then H has correctly
>>>>>>>> determined the halt status of P.
>>>>>>>>
>>>>>>>> (a) The invoked 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)...
>>>>>>>> Until H aborts the simulation of its input
>>>>>>>
>>>>>>> Nope. I have shown that a simulating halt decider needn't be
>>>>>>> recursive in nature and you are incorrect to map your erroneous
>>>>>>> infinite recursion to non-halting if P actually halts when run.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> A simulating halt decider is never recursive in nature unless its
>>>>>> input is recursive:
>>>>>>
>>>>>> void Infinite_Recursion(int N)
>>>>>> {
>>>>>> Infinite_Recursion(N);
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H((u32)Infinite_Recursion, 0x777));
>>>>>> }
>>>>>
>>>>> P calling H does not mean that P is recursive in nature, it means
>>>>> your decider is recursive in nature.
>>>>>
>>>>> /Flibble
>>>>>
>>>>>
>>>>
>>>> A simulating halt decider always only simulates the behavior that
>>>> its input specifies.
>>>>
>>>
>>> Again: H calling P calling H calling P does NOT mean that P is
>>> recursive, it means H is recursive.
>>>
>>> /Flibble
>>>
>>
>> Because H merely simulates whatever behavior that its input specifies
>> then it is P and *NOT* H that is recursive.
>
> WRONG. H is recursive not P, P is oblivious to how H decides P's
> halting status,

Because P calls H(P,P) that makes the simulated P the source of the
recursion.

> it is an implementation detail of *your* decider to

Always correctly simulate the behavior specified by its inputs.

> recursively call P and my SHD has no such recursion to "abort".
>
> /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

Re: Simulating Halt Deciders

<20220812202137.00007243@reddwarf.jmc.corp>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=37414&group=comp.theory#37414

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx03.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Simulating Halt Deciders
Message-ID: <20220812202137.00007243@reddwarf.jmc.corp>
References: <Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812172225.00007d90@reddwarf.jmc.corp>
<lsycnUVFCrw-FWv_nZ2dnZfqlJ9g4p2d@giganews.com>
<20220812181455.00003b76@reddwarf.jmc.corp>
<3NGdnZX7zN03E2v_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812184621.00006447@reddwarf.jmc.corp>
<q96dnSSGIqlOC2v_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812191252.00000f2b@reddwarf.jmc.corp>
<KLedndgHTqwGOGv_nZ2dnZfqlJxh4p2d@giganews.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 132
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 12 Aug 2022 19:21:38 UTC
Date: Fri, 12 Aug 2022 20:21:37 +0100
X-Received-Bytes: 5492

by: Mr Flibble - Fri, 12 Aug 2022 19:21 UTC

On Fri, 12 Aug 2022 14:10:34 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/12/2022 1:12 PM, Mr Flibble wrote:
> > On Fri, 12 Aug 2022 13:07:30 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/12/2022 12:46 PM, Mr Flibble wrote:
> >>> On Fri, 12 Aug 2022 12:32:41 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/12/2022 12:14 PM, Mr Flibble wrote:
> >>>>> On Fri, 12 Aug 2022 12:07:03 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/12/2022 11:22 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 12 Aug 2022 10:45:34 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> A simulating halt decider simulates its input until it
> >>>>>>>> correctly proves that this simulation would never stop unless
> >>>>>>>> aborted.
> >>>>>>>>
> >>>>>>>> typedef void (*ptr)();
> >>>>>>>> int H(ptr p, ptr i); // simulating halt decider
> >>>>>>>>
> >>>>>>>> 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));
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> (a) I believe that most computer scientists would agree that
> >>>>>>>> a halt decider must compute the mapping from its inputs to an
> >>>>>>>> accept or reject state on the basis of the actual behavior
> >>>>>>>> specified by this input.
> >>>>>>>>
> >>>>>>>> (b) Furthermore ALL computer scientists would agree that the
> >>>>>>>> correct simulation of a machine description does derive the
> >>>>>>>> correct behavior specified by this machine description.
> >>>>>>>>
> >>>>>>>> This logically entails that when H(P,P) simulates its input
> >>>>>>>> until the behavior of this input essentially matches the
> >>>>>>>> infinite recursion behavior pattern, then H has correctly
> >>>>>>>> determined the halt status of P.
> >>>>>>>>
> >>>>>>>> (a) The invoked 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)...
> >>>>>>>> Until H aborts the simulation of its input
> >>>>>>>
> >>>>>>> Nope. I have shown that a simulating halt decider needn't be
> >>>>>>> recursive in nature and you are incorrect to map your
> >>>>>>> erroneous infinite recursion to non-halting if P actually
> >>>>>>> halts when run.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> A simulating halt decider is never recursive in nature unless
> >>>>>> its input is recursive:
> >>>>>>
> >>>>>> void Infinite_Recursion(int N)
> >>>>>> {
> >>>>>> Infinite_Recursion(N);
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H((u32)Infinite_Recursion,
> >>>>>> 0x777)); }
> >>>>>
> >>>>> P calling H does not mean that P is recursive in nature, it
> >>>>> means your decider is recursive in nature.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>>
> >>>>
> >>>> A simulating halt decider always only simulates the behavior that
> >>>> its input specifies.
> >>>>
> >>>
> >>> Again: H calling P calling H calling P does NOT mean that P is
> >>> recursive, it means H is recursive.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Because H merely simulates whatever behavior that its input
> >> specifies then it is P and *NOT* H that is recursive.
> >
> > WRONG. H is recursive not P, P is oblivious to how H decides P's
> > halting status,
>
> Because P calls H(P,P) that makes the simulated P the source of the
> recursion.

Nope, it is an implementation detail of H to recursively call P in the
following sequence:

H calls P calls H calls P

Not all deciders are SHDs and it is for that reason that it is
incorrect to say that P is the source of the recursion: your H is the
source of the recursion.

>
> > it is an implementation detail of *your* decider to
>
> Always correctly simulate the behavior specified by its inputs.

Which your H doesn't do if P is defined as:

void P(ptr x)
{ int Halt_Status = H(x, x);
(void)Halt_Status;
return;
}

This P halts even though it references H.

/Flibble

Re: Simulating Halt Deciders

<t-ednQ2gQN2SN2v_nZ2dnZfqlJzNnZ2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=37415&group=comp.theory#37415

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 12 Aug 2022 19:29:19 +0000
Date: Fri, 12 Aug 2022 14:29:34 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Simulating Halt Deciders
Content-Language: en-US
Newsgroups: comp.theory
References: <Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812172225.00007d90@reddwarf.jmc.corp>
<lsycnUVFCrw-FWv_nZ2dnZfqlJ9g4p2d@giganews.com>
<20220812181455.00003b76@reddwarf.jmc.corp>
<3NGdnZX7zN03E2v_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812184621.00006447@reddwarf.jmc.corp>
<q96dnSSGIqlOC2v_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812191252.00000f2b@reddwarf.jmc.corp>
<KLedndgHTqwGOGv_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812202137.00007243@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220812202137.00007243@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <t-ednQ2gQN2SN2v_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 146
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-leDR854ztAHIjioKncItmv6QmuOELVTn7oXXWn2l49sxH2DwzHpCkDcJQzbnYrOrUo94TauFYUlO07k!b8ZyKPhJeQfNYMC9tqHAEF57BhBDM1LkL/cMGnXJGVa36vfgs3dlV60+Zd+IkpYdACgqJAgrulku!vA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40

by: olcott - Fri, 12 Aug 2022 19:29 UTC

On 8/12/2022 2:21 PM, Mr Flibble wrote:
> On Fri, 12 Aug 2022 14:10:34 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/12/2022 1:12 PM, Mr Flibble wrote:
>>> On Fri, 12 Aug 2022 13:07:30 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/12/2022 12:46 PM, Mr Flibble wrote:
>>>>> On Fri, 12 Aug 2022 12:32:41 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/12/2022 12:14 PM, Mr Flibble wrote:
>>>>>>> On Fri, 12 Aug 2022 12:07:03 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 8/12/2022 11:22 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 12 Aug 2022 10:45:34 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> A simulating halt decider simulates its input until it
>>>>>>>>>> correctly proves that this simulation would never stop unless
>>>>>>>>>> aborted.
>>>>>>>>>>
>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
>>>>>>>>>>
>>>>>>>>>> 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));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> (a) I believe that most computer scientists would agree that
>>>>>>>>>> a halt decider must compute the mapping from its inputs to an
>>>>>>>>>> accept or reject state on the basis of the actual behavior
>>>>>>>>>> specified by this input.
>>>>>>>>>>
>>>>>>>>>> (b) Furthermore ALL computer scientists would agree that the
>>>>>>>>>> correct simulation of a machine description does derive the
>>>>>>>>>> correct behavior specified by this machine description.
>>>>>>>>>>
>>>>>>>>>> This logically entails that when H(P,P) simulates its input
>>>>>>>>>> until the behavior of this input essentially matches the
>>>>>>>>>> infinite recursion behavior pattern, then H has correctly
>>>>>>>>>> determined the halt status of P.
>>>>>>>>>>
>>>>>>>>>> (a) The invoked 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)...
>>>>>>>>>> Until H aborts the simulation of its input
>>>>>>>>>
>>>>>>>>> Nope. I have shown that a simulating halt decider needn't be
>>>>>>>>> recursive in nature and you are incorrect to map your
>>>>>>>>> erroneous infinite recursion to non-halting if P actually
>>>>>>>>> halts when run.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> A simulating halt decider is never recursive in nature unless
>>>>>>>> its input is recursive:
>>>>>>>>
>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>> {
>>>>>>>> Infinite_Recursion(N);
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H((u32)Infinite_Recursion,
>>>>>>>> 0x777)); }
>>>>>>>
>>>>>>> P calling H does not mean that P is recursive in nature, it
>>>>>>> means your decider is recursive in nature.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> A simulating halt decider always only simulates the behavior that
>>>>>> its input specifies.
>>>>>>
>>>>>
>>>>> Again: H calling P calling H calling P does NOT mean that P is
>>>>> recursive, it means H is recursive.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Because H merely simulates whatever behavior that its input
>>>> specifies then it is P and *NOT* H that is recursive.
>>>
>>> WRONG. H is recursive not P, P is oblivious to how H decides P's
>>> halting status,
>>
>> Because P calls H(P,P) that makes the simulated P the source of the
>> recursion.
>
> Nope, it is an implementation detail of H to recursively call P in the
> following sequence:
>
> H calls P calls H calls P
>
> Not all deciders are SHDs and it is for that reason that it is
> incorrect to say that P is the source of the recursion: your H is the
> source of the recursion.
>
>>
>>> it is an implementation detail of *your* decider to
>>
>> Always correctly simulate the behavior specified by its inputs.
>
> Which your H doesn't do if P is defined as:
>
> void P(ptr x)
> {
> int Halt_Status = H(x, x);
> (void)Halt_Status;
> return;
> }
>
> This P halts even though it references H.
>
> /Flibble
>

When H(P,P) correctly simulates its first argument it never stops
running unless and until H aborts its simulation.

The ALWAYS means that the first argument specifies a non-halting
sequence of instructions.

--
Copyright 2022 Pete Olcott

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

Re: Simulating Halt Deciders

<20220812223305.0000344b@reddwarf.jmc.corp>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=37442&group=comp.theory#37442

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx11.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Simulating Halt Deciders
Message-ID: <20220812223305.0000344b@reddwarf.jmc.corp>
References: <Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812172225.00007d90@reddwarf.jmc.corp>
<lsycnUVFCrw-FWv_nZ2dnZfqlJ9g4p2d@giganews.com>
<20220812181455.00003b76@reddwarf.jmc.corp>
<3NGdnZX7zN03E2v_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812184621.00006447@reddwarf.jmc.corp>
<q96dnSSGIqlOC2v_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812191252.00000f2b@reddwarf.jmc.corp>
<KLedndgHTqwGOGv_nZ2dnZfqlJxh4p2d@giganews.com>
<20220812202137.00007243@reddwarf.jmc.corp>
<t-ednQ2gQN2SN2v_nZ2dnZfqlJzNnZ2d@giganews.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 154
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 12 Aug 2022 21:33:06 UTC
Date: Fri, 12 Aug 2022 22:33:05 +0100
X-Received-Bytes: 6572

by: Mr Flibble - Fri, 12 Aug 2022 21:33 UTC

On Fri, 12 Aug 2022 14:29:34 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/12/2022 2:21 PM, Mr Flibble wrote:
> > On Fri, 12 Aug 2022 14:10:34 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/12/2022 1:12 PM, Mr Flibble wrote:
> >>> On Fri, 12 Aug 2022 13:07:30 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/12/2022 12:46 PM, Mr Flibble wrote:
> >>>>> On Fri, 12 Aug 2022 12:32:41 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/12/2022 12:14 PM, Mr Flibble wrote:
> >>>>>>> On Fri, 12 Aug 2022 12:07:03 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 8/12/2022 11:22 AM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 12 Aug 2022 10:45:34 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> A simulating halt decider simulates its input until it
> >>>>>>>>>> correctly proves that this simulation would never stop
> >>>>>>>>>> unless aborted.
> >>>>>>>>>>
> >>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>> int H(ptr p, ptr i); // simulating halt decider
> >>>>>>>>>>
> >>>>>>>>>> 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));
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> (a) I believe that most computer scientists would agree
> >>>>>>>>>> that a halt decider must compute the mapping from its
> >>>>>>>>>> inputs to an accept or reject state on the basis of the
> >>>>>>>>>> actual behavior specified by this input.
> >>>>>>>>>>
> >>>>>>>>>> (b) Furthermore ALL computer scientists would agree that
> >>>>>>>>>> the correct simulation of a machine description does
> >>>>>>>>>> derive the correct behavior specified by this machine
> >>>>>>>>>> description.
> >>>>>>>>>>
> >>>>>>>>>> This logically entails that when H(P,P) simulates its input
> >>>>>>>>>> until the behavior of this input essentially matches the
> >>>>>>>>>> infinite recursion behavior pattern, then H has correctly
> >>>>>>>>>> determined the halt status of P.
> >>>>>>>>>>
> >>>>>>>>>> (a) The invoked 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)... Until H aborts the simulation of its
> >>>>>>>>>> input
> >>>>>>>>>
> >>>>>>>>> Nope. I have shown that a simulating halt decider needn't be
> >>>>>>>>> recursive in nature and you are incorrect to map your
> >>>>>>>>> erroneous infinite recursion to non-halting if P actually
> >>>>>>>>> halts when run.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> A simulating halt decider is never recursive in nature unless
> >>>>>>>> its input is recursive:
> >>>>>>>>
> >>>>>>>> void Infinite_Recursion(int N)
> >>>>>>>> {
> >>>>>>>> Infinite_Recursion(N);
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H((u32)Infinite_Recursion,
> >>>>>>>> 0x777)); }
> >>>>>>>
> >>>>>>> P calling H does not mean that P is recursive in nature, it
> >>>>>>> means your decider is recursive in nature.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>>
> >>>>>>
> >>>>>> A simulating halt decider always only simulates the behavior
> >>>>>> that its input specifies.
> >>>>>>
> >>>>>
> >>>>> Again: H calling P calling H calling P does NOT mean that P is
> >>>>> recursive, it means H is recursive.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Because H merely simulates whatever behavior that its input
> >>>> specifies then it is P and *NOT* H that is recursive.
> >>>
> >>> WRONG. H is recursive not P, P is oblivious to how H decides P's
> >>> halting status,
> >>
> >> Because P calls H(P,P) that makes the simulated P the source of the
> >> recursion.
> >
> > Nope, it is an implementation detail of H to recursively call P in
> > the following sequence:
> >
> > H calls P calls H calls P
> >
> > Not all deciders are SHDs and it is for that reason that it is
> > incorrect to say that P is the source of the recursion: your H is
> > the source of the recursion.
> >
> >>
> >>> it is an implementation detail of *your* decider to
> >>
> >> Always correctly simulate the behavior specified by its inputs.
> >
> > Which your H doesn't do if P is defined as:
> >
> > void P(ptr x)
> > {
> > int Halt_Status = H(x, x);
> > (void)Halt_Status;
> > return;
> > }
> >
> > This P halts even though it references H.
> >
> > /Flibble
> >
>
> When H(P,P) correctly simulates its first argument it never stops
> running unless and until H aborts its simulation.

Except it isn't correctly simulating its first argument so cannot reach
a correct decision of halting or non-halting.

>
> The ALWAYS means that the first argument specifies a non-halting
> sequence of instructions.

Nope. Only your broken H suffers from infinite recursion which you
erroneously map to non-halting.

/Flibble

On 8/12/22 11:45 AM, olcott wrote:
> A simulating halt decider simulates its input until it correctly proves
> that this simulation would never stop unless aborted.

And you H fails to meet that definiton as it stop its simulation and
returns non-halting to the call of H(P,P) before it has actually proven
that answer.

>
> typedef void (*ptr)();
> int H(ptr p, ptr i); // simulating halt decider
>
> 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));
> }
>
> (a) I believe that most computer scientists would agree that a halt
> decider must compute the mapping from its inputs to an accept or reject
> state on the basis of the actual behavior specified by this input.

And the behavior of the input to H(P,P) is the behavior of P(P) BY
DEFINITION.

>
> (b) Furthermore ALL computer scientists would agree that the correct
> simulation of a machine description does derive the correct behavior
> specified by this machine description.

Right, the correct and COMPLET simulation of the input, using ALL the
behavior thus specifed.

>
> This logically entails that when H(P,P) simulates its input until the
> behavior of this input essentially matches the infinite recursion
> behavior pattern, then H has correctly determined the halt status of P.

No, because your "essentially" doesn't mean Correctly.

>
> (a) The invoked 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)...
> Until H aborts the simulation of its input

But that isn't the actual behavior that your defined H would do.

So you are caught in your lie.

>
> *Halting problem proofs refuted on the basis of software engineering* ?
> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>
>
>

On 8/12/2022 8:45 AM, olcott wrote:
> A simulating halt decider simulates its input until it correctly proves

Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again. Post
it again. Post it again. Post it again. Post it again. Post it again.
Post it again. Post it again. Post it again. Post it again. Post it
again. Post it again. Post it again. Post it again. Post it again.
Thanks!

On 2022-08-12 15:45:34 +0000, olcott said:

> A simulating halt decider simulates its input until it correctly proves
> that this simulation would never stop unless aborted.

Can you prove that a simulating halt decider does something useful?
Can you prove that a simulating halt decider does something interesting?
Can you prove that a simulating halt decider is a halt decider?
Can you prove that a simulating halt decider is a decider?
Can you prove that a simulating halt decider exists?

Mikko

Re: Simulating Halt Deciders

<HbudnZZUldl0ZmX_nZ2dnZfqlJxh4p2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=37603&group=comp.theory#37603

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 14 Aug 2022 13:43:05 +0000
Date: Sun, 14 Aug 2022 08:43:21 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Simulating Halt Deciders
Content-Language: en-US
Newsgroups: comp.theory
References: <Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>
<tdahi2$34bhv$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <tdahi2$34bhv$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <HbudnZZUldl0ZmX_nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 32
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-E0TqrUHiz5sYQALse7EW9W6SHlY1nCqoEfRRYpswu4fbSj8isCCdmyR6ZU/hmglWS2tztMIhN6fUSAL!1o1hQZwa3iP2qUw1WEwI/uyE/87FqZ/4Woa2e20u9pkjfNaGpX1qJiRW29eeWfhemaJdso4VAC71!xw==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40

by: olcott - Sun, 14 Aug 2022 13:43 UTC

On 8/14/2022 5:08 AM, Mikko wrote:
> On 2022-08-12 15:45:34 +0000, olcott said:
>
>> A simulating halt decider simulates its input until it correctly
>> proves that this simulation would never stop unless aborted.
>
> Can you prove that a simulating halt decider does something useful?
> Can you prove that a simulating halt decider does something interesting?
> Can you prove that a simulating halt decider is a halt decider?
> Can you prove that a simulating halt decider is a decider?
> Can you prove that a simulating halt decider exists?
>
> Mikko
>

See for yourself.

*I am working on getting this to compile under Linux Ubuntu 16.04*

https://www.liarparadox.org/2022_07_22.zip
This is the complete system that compiles under:

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

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

On 2022-08-14 13:43:21 +0000, olcott said:

> On 8/14/2022 5:08 AM, Mikko wrote:
>> On 2022-08-12 15:45:34 +0000, olcott said:
>>
>>> A simulating halt decider simulates its input until it correctly proves
>>> that this simulation would never stop unless aborted.
>>
>> Can you prove that a simulating halt decider does something useful?
>> Can you prove that a simulating halt decider does something interesting?
>> Can you prove that a simulating halt decider is a halt decider?
>> Can you prove that a simulating halt decider is a decider?
>> Can you prove that a simulating halt decider exists?
>>
>> Mikko
>>
>
> See for yourself.

I see. You can't.

Mikko

Re: Simulating Halt Deciders

<996dnYwJ0p7JwWf_nZ2dnZfqlJzNnZ2d@giganews.com>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=37711&group=comp.theory#37711

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 15 Aug 2022 14:46:44 +0000
Date: Mon, 15 Aug 2022 09:46:59 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Simulating Halt Deciders
Content-Language: en-US
Newsgroups: comp.theory
References: <Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>
<tdahi2$34bhv$1@dont-email.me>
<HbudnZZUldl0ZmX_nZ2dnZfqlJxh4p2d@giganews.com>
<tddfqg$3l6rq$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <tddfqg$3l6rq$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <996dnYwJ0p7JwWf_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 47
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-uGlvQ81evlwJYxQp4aGsp8x0vm2cTDPnD+m4Bc8JDetA3aDfguOdXYhGEa9s7M9cOxvUQl+AOoQQN/c!/MQpsSKJ3pB/CrWj3eNhn/nIYDCksxkRsSigmg8iLVS76VQvLLoq9JVQTsf7OGqxt5M0tAThC3A=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40

by: olcott - Mon, 15 Aug 2022 14:46 UTC

On 8/15/2022 7:56 AM, Mikko wrote:
> On 2022-08-14 13:43:21 +0000, olcott said:
>
>> On 8/14/2022 5:08 AM, Mikko wrote:
>>> On 2022-08-12 15:45:34 +0000, olcott said:
>>>
>>>> A simulating halt decider simulates its input until it correctly
>>>> proves that this simulation would never stop unless aborted.
>>>
>>> Can you prove that a simulating halt decider does something useful?
>>> Can you prove that a simulating halt decider does something interesting?
>>> Can you prove that a simulating halt decider is a halt decider?
>>> Can you prove that a simulating halt decider is a decider?
>>> Can you prove that a simulating halt decider exists?
>>>
>>> Mikko
>>>
>>
>> See for yourself.
>
> I see. You can't.
>
> Mikko
>

I am sick of people contradicting the verified facts.
I am not going to play that head game any more.
This code proves all those points.

https://www.liarparadox.org/2022_07_22.zip
This is the complete system that compiles under:

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

Here is the corresponding paper:
*Halting problem proofs refuted on the basis of software engineering* ?
https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering

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

Re: Simulating Halt Deciders

<edAKK.673364$vAW9.635714@fx10.iad>

copy mid

https://www.novabbs.com/devel/article-flat.php?id=37753&group=comp.theory#37753

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx10.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.12.0
Subject: Re: Simulating Halt Deciders
Content-Language: en-US
Newsgroups: comp.theory
References: <Ht6dnWojQ_8M6Gv_nZ2dnZfqlJxh4p2d@giganews.com>
<tdahi2$34bhv$1@dont-email.me>
<HbudnZZUldl0ZmX_nZ2dnZfqlJxh4p2d@giganews.com>
<tddfqg$3l6rq$1@dont-email.me>
<996dnYwJ0p7JwWf_nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <996dnYwJ0p7JwWf_nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 62
Message-ID: <edAKK.673364$vAW9.635714@fx10.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 15 Aug 2022 18:59:21 -0400
X-Received-Bytes: 2893

by: Richard Damon - Mon, 15 Aug 2022 22:59 UTC

On 8/15/22 10:46 AM, olcott wrote:
> On 8/15/2022 7:56 AM, Mikko wrote:
>> On 2022-08-14 13:43:21 +0000, olcott said:
>>
>>> On 8/14/2022 5:08 AM, Mikko wrote:
>>>> On 2022-08-12 15:45:34 +0000, olcott said:
>>>>
>>>>> A simulating halt decider simulates its input until it correctly
>>>>> proves that this simulation would never stop unless aborted.
>>>>
>>>> Can you prove that a simulating halt decider does something useful?
>>>> Can you prove that a simulating halt decider does something
>>>> interesting?
>>>> Can you prove that a simulating halt decider is a halt decider?
>>>> Can you prove that a simulating halt decider is a decider?
>>>> Can you prove that a simulating halt decider exists?
>>>>
>>>> Mikko
>>>>
>>>
>>> See for yourself.
>>
>> I see. You can't.
>>
>> Mikko
>>
>
> I am sick of people contradicting the verified facts.
> I am not going to play that head game any more.
> This code proves all those points.
>
> https://www.liarparadox.org/2022_07_22.zip
> This is the complete system that compiles under:
>
> Microsoft Visual Studio Community 2017
> https://visualstudio.microsoft.com/vs/older-downloads/
>
> Here is the corresponding paper:
> *Halting problem proofs refuted on the basis of software engineering* ?
> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>
>
>
>

And that H is incorrect as H(P,P) will return 0, saying its input, which
is the specification of P(P) will never halt, while P(P) Does Halt.

This is clear by your construction of P and its definition.

Non-halting is not Halting, so H is wrong.

PERIOD.

You are just shown to be a liar or an idiot,

Take your choice,

It is proven, by the plain meaning of the words, which you don't seem to
understand or are intentionally not looking at.

Subject	Author
Simulating Halt Deciders	olcott
Simulating Halt Deciders	Mr Flibble
Simulating Halt Deciders	olcott
Simulating Halt Deciders	Mr Flibble
Simulating Halt Deciders	olcott
Simulating Halt Deciders	Mr Flibble
Simulating Halt Deciders	olcott
Simulating Halt Deciders	Mr Flibble
Simulating Halt Deciders	olcott
Simulating Halt Deciders	Mr Flibble
Simulating Halt Deciders	olcott
Simulating Halt Deciders	Mr Flibble
Simulating Halt Deciders	Richard Damon
Simulating Halt Deciders	Pancho Valvejob
Simulating Halt Deciders	Mikko
Simulating Halt Deciders	olcott
Simulating Halt Deciders	Mikko
Simulating Halt Deciders	olcott
Simulating Halt Deciders	Richard Damon
Simulating Halt Deciders	Mikko