Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

This is now. Later is later.

devel / comp.theory / Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

SubjectAuthor
* Reviewers quit reviewing my work because it is now finallyolcott
+- Reviewers quit reviewing my work because it is now finallyRichard Damon
+* Reviewers quit reviewing my work because it is now finallywij
|`* Reviewers quit reviewing my work because it is now finallyolcott
| +* Reviewers quit reviewing my work because it is now finallywij
| |`* Reviewers quit reviewing my work because it is now finallyolcott
| | +* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | |`* Reviewers quit reviewing my work because it is now finallyolcott
| | | +* Reviewers quit reviewing my work because it is now finally irrefutable [V2]Mr Flibble
| | | |`* Reviewers quit reviewing my work because it is now finallyolcott
| | | | +* Reviewers quit reviewing my work because it is now finally irrefutable [V2]Mr Flibble
| | | | |`* Reviewers quit reviewing my work because it is now finallyolcott
| | | | | `* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | | | |  `* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |   `* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | | | |    `* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     +* Reviewers quit reviewing my work because it is now finally irrefutable [V2]Mr Flibble
| | | | |     |`* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     | +* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | | | |     | |`* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     | | `- Reviewers quit reviewing my work because it is now finallyRichard Damon
| | | | |     | `* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | | | |     |  `* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     |   +* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | | | |     |   |`* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     |   | +* Reviewers quit reviewing my work because it is now finally irrefutable [V2]Mr Flibble
| | | | |     |   | |+* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | | | |     |   | ||+* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | | | |     |   | |||`* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     |   | ||| `- Reviewers quit reviewing my work because it is now finallyRichard Damon
| | | | |     |   | ||`* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     |   | || `- Reviewers quit reviewing my work because it is now finallyRichard Damon
| | | | |     |   | |`* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     |   | | `* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | | | |     |   | |  `* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     |   | |   `* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | | | |     |   | |    `* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     |   | |     `* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | | | |     |   | |      `* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     |   | |       `* Reviewers quit reviewing my work because it is now finally irrefutable [V2]Mr Flibble
| | | | |     |   | |        `* Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     |   | |         `* Reviewers quit reviewing my work because it is now finallyMr Flibble
| | | | |     |   | |          `- Reviewers quit reviewing my work because it is now finallyolcott
| | | | |     |   | `- Reviewers quit reviewing my work because it is now finallyRichard Damon
| | | | |     |   `- Reviewers quit reviewing my work because it is now finallyRichard Damon
| | | | |     `- Reviewers quit reviewing my work because it is now finallyRichard Damon
| | | | `- Reviewers quit reviewing my work because it is now finallyRichard Damon
| | | `- Reviewers quit reviewing my work because it is now finallyRichard Damon
| | +* Reviewers quit reviewing my work because it is now finallywij
| | |`* Reviewers quit reviewing my work because it is now finallyolcott
| | | `- Reviewers quit reviewing my work because it is now finallyRichard Damon
| | +- Reviewers quit reviewing my work because it is now finallyRichard Damon
| | `- Reviewers quit reviewing my work because it is now finallyRichard Damon
| `- Reviewers quit reviewing my work because it is now finallyRichard Damon
+* Reviewers quit reviewing my work because it is now finallyMr Flibble
|`* Reviewers quit reviewing my work because it is now finallyolcott
| +* Reviewers quit reviewing my work because it is now finallyMr Flibble
| |`* Reviewers quit reviewing my work because it is now finallyolcott
| | `- Reviewers quit reviewing my work because it is now finallyMr Flibble
| `* Reviewers quit reviewing my work because it is now finally irrefutable [V2]Mikko
|  `- Reviewers quit reviewing my work because it is now finallyolcott
`* Reviewers quit reviewing my work because it is now finallyMalcolm McLean
 `* Reviewers quit reviewing my work because it is now finallyolcott
  +* Reviewers quit reviewing my work because it is now finallywij
  |`* Reviewers quit reviewing my work because it is now finallyolcott
  | +- Reviewers quit reviewing my work because it is now finallywij
  | `* Reviewers quit reviewing my work because it is now finallyRichard Damon
  |  `* _Reviewers_quit_reviewing_my_work_because_it_is_now_olcott
  |   `- _Reviewers_quit_reviewing_my_work_because_it_is_now_Richard Damon
  `- Reviewers quit reviewing my work because it is now finallyRichard Damon

Pages:123
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<20220617174139.000051dc@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx11.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Message-ID: <20220617174139.000051dc@reddwarf.jmc>
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<912de0f6-ed7e-432b-a66f-151b90a3165dn@googlegroups.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 301
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 17 Jun 2022 16:41:39 UTC
Date: Fri, 17 Jun 2022 17:41:39 +0100
X-Received-Bytes: 14311
 by: Mr Flibble - Fri, 17 Jun 2022 16:41 UTC

On Fri, 17 Jun 2022 11:38:29 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/17/2022 11:36 AM, Mr Flibble wrote:
> > On Fri, 17 Jun 2022 11:33:22 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/17/2022 11:22 AM, Mr Flibble wrote:
> >>> On Fri, 17 Jun 2022 11:16:15 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
> >>>>> On Fri, 17 Jun 2022 11:12:31 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
> >>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
> >>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
> >>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8, olcott
> >>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>> When a simulating halt decider rejects all inputs as
> >>>>>>>>>>>>>>>> non-halting whenever it correctly detects that its
> >>>>>>>>>>>>>>>> correct and complete simulation of its input would
> >>>>>>>>>>>>>>>> never reach the final state of this input then all
> >>>>>>>>>>>>>>>> [these] inputs (including pathological inputs) are
> >>>>>>>>>>>>>>>> decided correctly.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *computation that halts* … the Turing machine will
> >>>>>>>>>>>>>>>> halt whenever it enters a final state.
> >>>>>>>>>>>>>>>> (Linz:1990:234)
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal Languages
> >>>>>>>>>>>>>>>> and Automata. Lexington/Toronto: D. C. Heath and
> >>>>>>>>>>>>>>>> Company. (317-320)
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> #include <stdint.h>
> >>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we assume
> >>>>>>>>>>>>>>>> that H is only an x86 emulator that the correctly
> >>>>>>>>>>>>>>>> emulated P never reaches its "ret" instruction it
> >>>>>>>>>>>>>>>> remains stuck in repeated cycles of emulation.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has been
> >>>>>>>>>>>>>>>> adapted to correctly detect (in a finite number of
> >>>>>>>>>>>>>>>> steps) that the correct and complete x86 emulation of
> >>>>>>>>>>>>>>>> its input would never each its "ret" instruction that
> >>>>>>>>>>>>>>>> H could abort its emulation and return 0 to report
> >>>>>>>>>>>>>>>> this.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
> >>>>>>>>>>>>>>>> correctly determining whether or not an x86 emulated
> >>>>>>>>>>>>>>>> input would ever reach its "ret" instruction then it
> >>>>>>>>>>>>>>>> becomes an easily verified fact H(P,P) could
> >>>>>>>>>>>>>>>> correctly reject its input as non-halting.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Correct deductive inference proves that all of these
> >>>>>>>>>>>>>>>> things are true without any need what-so-ever to see
> >>>>>>>>>>>>>>>> either the source-code or the execution trace of H.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> The one thing that is not proved is whether or not an
> >>>>>>>>>>>>>>>> actual encoded H(P,P) does indeed correctly determine
> >>>>>>>>>>>>>>>> that its input would never reach its "ret"
> >>>>>>>>>>>>>>>> instruction as a pure function of its inputs. This
> >>>>>>>>>>>>>>>> aspect will be confirmed by fully operational
> >>>>>>>>>>>>>>>> source-code.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
> >>>>>>>>>>>>>>>> simulation (V5)
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> GUR already suggested such a halting decider H cannot
> >>>>>>>>>>>>>>> exist:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
> >>>>>>>>>>>>>> That is a misconception.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Halt deciders must compute the mapping from their
> >>>>>>>>>>>>>> inputs to an accept or reject state on the basis of
> >>>>>>>>>>>>>> the actual behavior actually specified by these inputs.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> It is an easily verified fact that the correct and
> >>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>> would never reach its "ret" instruction thus
> >>>>>>>>>>>>>> conclusively proving that it never halts.
> >>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
> >>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
> >>>>>>>>>>>>>>> (undecidable).
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> -----
> >>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts demonstrated
> >>>>>>>>>>>>>>> even himself a genius in 10000-years cannot refute my
> >>>>>>>>>>>>>>> GUR. ...
> >>>>>>>>>>>>>> --
> >>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> GUR suggests no halting decider can exist. You just
> >>>>>>>>>>>>> confirms it by not able to provide POOH to test/review.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> It took me six months to figure out how to transform
> >>>>>>>>>>>> H(P,P) into a pure function of its inputs. I did not
> >>>>>>>>>>>> release the code before because I knew that its use of
> >>>>>>>>>>>> static local data would have been rejected. With this
> >>>>>>>>>>>> update to H I will be able to publish the code.
> >>>>>>>>>>>>
> >>>>>>>>>>>> H recognizes that P is calling itself with its same
> >>>>>>>>>>>> arguments that it was called with and there are no
> >>>>>>>>>>>> instructions preceding this call that could possibly
> >>>>>>>>>>>> escape infinitely recursive emulation so H aborts its
> >>>>>>>>>>>> emulation of P before P even makes its first call to H.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Without even looking at the code competent software
> >>>>>>>>>>>> engineers will be able to verify that the above H would
> >>>>>>>>>>>> correctly determine that that is input is non-halting as
> >>>>>>>>>>>> a pure function of this input.
> >>>>>>>>>>>
> >>>>>>>>>>> So my other reply for why your H is not a pure function
> >>>>>>>>>>> for any accepted definition of the term.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> In computer programming, a pure function is a function that
> >>>>>>>>>> has the following properties:
> >>>>>>>>>>
> >>>>>>>>>> (1) the function return values are identical for identical
> >>>>>>>>>> arguments (no variation with local static variables,
> >>>>>>>>>> non-local variables, mutable reference arguments or input
> >>>>>>>>>> streams), and
> >>>>>>>>>>
> >>>>>>>>>> (2) the function application has no side effects (no
> >>>>>>>>>> mutation of local static variables, non-local variables,
> >>>>>>>>>> mutable reference arguments or input/output streams).
> >>>>>>>>>>
> >>>>>>>>>> Thus a pure function is a computational analogue of a
> >>>>>>>>>> mathematical function.
> >>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>
> >>>>>>>>>> The revised H has no:
> >>>>>>>>>> (a) local static variables
> >>>>>>>>>> (b) non-local variables
> >>>>>>>>>> (c) mutable reference arguments
> >>>>>>>>>> (d) input streams
> >>>>>>>>>
> >>>>>>>>> Aborting the simulation is a side effect; pure functions do
> >>>>>>>>> not have side effects.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>> You have a reading comprehension problem.
> >>>>>>>> If H does not have (a)(b)(c)(d) then
> >>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
> >>>>>>>
> >>>>>>> Not at all, but you do seem to have that problem.
> >>>>>>>
> >>>>>>> Again:
> >>>>>>>
> >>>>>>> Aborting the simulation is a side effect; pure functions do
> >>>>>>> not have side effects.
> >>>>>>>
> >>>>>>
> >>>>>> Whether or not it is construed as a side-effect does not matter
> >>>>>> it must be a mutation side-effect to (a)(b)(c)(d) or it does
> >>>>>> not count.
> >>>>>
> >>>>> It doesn't count according to who?
> >>>>
> >>>> The above definition of pure functions.
> >>>
> >>> "In computer science, an operation, function or expression is said
> >>> to have a side effect if it modifies some state variable value(s)
> >>> outside its local environment,
> >>
> >> The second part is an inaccurate paraphrase of the first part.
> >>
> >>> which is to say if it has any observable effect
> >>> other than its primary effect of returning a value to the invoker
> >>> of the operation." --
> >>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
> >>>
> >>> "any observable effect"
> >>>
> >>> Aborting the simulation instead of returning a value to the
> >>> invoker disqualifies it from being a pure function.
> >>>
> >>> /Flibble
> >>>
> >>
> >> void P(ptr x)
> >> {
> >> if (H(x, x))
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H(P, P));
> >> }
> >>
> >> _P()
> >> [00001352](01) 55 push ebp
> >> [00001353](02) 8bec mov ebp,esp
> >> [00001355](03) 8b4508 mov eax,[ebp+08]
> >> [00001358](01) 50 push eax // push P
> >> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >> [0000135c](01) 51 push ecx // push P
> >> [0000135d](05) e840feffff call 000011a2 // call H
> >> [00001362](03) 83c408 add esp,+08
> >> [00001365](02) 85c0 test eax,eax
> >> [00001367](02) 7402 jz 0000136b
> >> [00001369](02) ebfe jmp 00001369
> >> [0000136b](01) 5d pop ebp
> >> [0000136c](01) c3 ret
> >> Size in bytes:(0027) [0000136c]
> >>
> >> H aborts its x86 emulation of P as soon P reaches its machine
> >> address of [0000135d] the very first time before the code at this
> >> address is emulated. Then H returns 0 to its caller: main().
> >
> > Returning to main() is not returning to its invoker, P.
> >
> > Again:
> >
> > Aborting the simulation is a side effect; pure functions do not have
> > side effects.
> >
> > /Flibble
> >
>
> Do you have ADD?
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> }

Click here to read the complete article

Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<20220617175104.00001454@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx11.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Message-ID: <20220617175104.00001454@reddwarf.jmc>
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<912de0f6-ed7e-432b-a66f-151b90a3165dn@googlegroups.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 304
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 17 Jun 2022 16:51:04 UTC
Date: Fri, 17 Jun 2022 17:51:04 +0100
X-Received-Bytes: 14486
 by: Mr Flibble - Fri, 17 Jun 2022 16:51 UTC

On Fri, 17 Jun 2022 11:38:29 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/17/2022 11:36 AM, Mr Flibble wrote:
> > On Fri, 17 Jun 2022 11:33:22 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/17/2022 11:22 AM, Mr Flibble wrote:
> >>> On Fri, 17 Jun 2022 11:16:15 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
> >>>>> On Fri, 17 Jun 2022 11:12:31 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
> >>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
> >>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
> >>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8, olcott
> >>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>> When a simulating halt decider rejects all inputs as
> >>>>>>>>>>>>>>>> non-halting whenever it correctly detects that its
> >>>>>>>>>>>>>>>> correct and complete simulation of its input would
> >>>>>>>>>>>>>>>> never reach the final state of this input then all
> >>>>>>>>>>>>>>>> [these] inputs (including pathological inputs) are
> >>>>>>>>>>>>>>>> decided correctly.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *computation that halts* … the Turing machine will
> >>>>>>>>>>>>>>>> halt whenever it enters a final state.
> >>>>>>>>>>>>>>>> (Linz:1990:234)
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal Languages
> >>>>>>>>>>>>>>>> and Automata. Lexington/Toronto: D. C. Heath and
> >>>>>>>>>>>>>>>> Company. (317-320)
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> #include <stdint.h>
> >>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we assume
> >>>>>>>>>>>>>>>> that H is only an x86 emulator that the correctly
> >>>>>>>>>>>>>>>> emulated P never reaches its "ret" instruction it
> >>>>>>>>>>>>>>>> remains stuck in repeated cycles of emulation.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has been
> >>>>>>>>>>>>>>>> adapted to correctly detect (in a finite number of
> >>>>>>>>>>>>>>>> steps) that the correct and complete x86 emulation of
> >>>>>>>>>>>>>>>> its input would never each its "ret" instruction that
> >>>>>>>>>>>>>>>> H could abort its emulation and return 0 to report
> >>>>>>>>>>>>>>>> this.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
> >>>>>>>>>>>>>>>> correctly determining whether or not an x86 emulated
> >>>>>>>>>>>>>>>> input would ever reach its "ret" instruction then it
> >>>>>>>>>>>>>>>> becomes an easily verified fact H(P,P) could
> >>>>>>>>>>>>>>>> correctly reject its input as non-halting.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Correct deductive inference proves that all of these
> >>>>>>>>>>>>>>>> things are true without any need what-so-ever to see
> >>>>>>>>>>>>>>>> either the source-code or the execution trace of H.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> The one thing that is not proved is whether or not an
> >>>>>>>>>>>>>>>> actual encoded H(P,P) does indeed correctly determine
> >>>>>>>>>>>>>>>> that its input would never reach its "ret"
> >>>>>>>>>>>>>>>> instruction as a pure function of its inputs. This
> >>>>>>>>>>>>>>>> aspect will be confirmed by fully operational
> >>>>>>>>>>>>>>>> source-code.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
> >>>>>>>>>>>>>>>> simulation (V5)
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> GUR already suggested such a halting decider H cannot
> >>>>>>>>>>>>>>> exist:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
> >>>>>>>>>>>>>> That is a misconception.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Halt deciders must compute the mapping from their
> >>>>>>>>>>>>>> inputs to an accept or reject state on the basis of
> >>>>>>>>>>>>>> the actual behavior actually specified by these inputs.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> It is an easily verified fact that the correct and
> >>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>> would never reach its "ret" instruction thus
> >>>>>>>>>>>>>> conclusively proving that it never halts.
> >>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
> >>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
> >>>>>>>>>>>>>>> (undecidable).
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> -----
> >>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts demonstrated
> >>>>>>>>>>>>>>> even himself a genius in 10000-years cannot refute my
> >>>>>>>>>>>>>>> GUR. ...
> >>>>>>>>>>>>>> --
> >>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> GUR suggests no halting decider can exist. You just
> >>>>>>>>>>>>> confirms it by not able to provide POOH to test/review.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> It took me six months to figure out how to transform
> >>>>>>>>>>>> H(P,P) into a pure function of its inputs. I did not
> >>>>>>>>>>>> release the code before because I knew that its use of
> >>>>>>>>>>>> static local data would have been rejected. With this
> >>>>>>>>>>>> update to H I will be able to publish the code.
> >>>>>>>>>>>>
> >>>>>>>>>>>> H recognizes that P is calling itself with its same
> >>>>>>>>>>>> arguments that it was called with and there are no
> >>>>>>>>>>>> instructions preceding this call that could possibly
> >>>>>>>>>>>> escape infinitely recursive emulation so H aborts its
> >>>>>>>>>>>> emulation of P before P even makes its first call to H.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Without even looking at the code competent software
> >>>>>>>>>>>> engineers will be able to verify that the above H would
> >>>>>>>>>>>> correctly determine that that is input is non-halting as
> >>>>>>>>>>>> a pure function of this input.
> >>>>>>>>>>>
> >>>>>>>>>>> So my other reply for why your H is not a pure function
> >>>>>>>>>>> for any accepted definition of the term.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> In computer programming, a pure function is a function that
> >>>>>>>>>> has the following properties:
> >>>>>>>>>>
> >>>>>>>>>> (1) the function return values are identical for identical
> >>>>>>>>>> arguments (no variation with local static variables,
> >>>>>>>>>> non-local variables, mutable reference arguments or input
> >>>>>>>>>> streams), and
> >>>>>>>>>>
> >>>>>>>>>> (2) the function application has no side effects (no
> >>>>>>>>>> mutation of local static variables, non-local variables,
> >>>>>>>>>> mutable reference arguments or input/output streams).
> >>>>>>>>>>
> >>>>>>>>>> Thus a pure function is a computational analogue of a
> >>>>>>>>>> mathematical function.
> >>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>
> >>>>>>>>>> The revised H has no:
> >>>>>>>>>> (a) local static variables
> >>>>>>>>>> (b) non-local variables
> >>>>>>>>>> (c) mutable reference arguments
> >>>>>>>>>> (d) input streams
> >>>>>>>>>
> >>>>>>>>> Aborting the simulation is a side effect; pure functions do
> >>>>>>>>> not have side effects.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>> You have a reading comprehension problem.
> >>>>>>>> If H does not have (a)(b)(c)(d) then
> >>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
> >>>>>>>
> >>>>>>> Not at all, but you do seem to have that problem.
> >>>>>>>
> >>>>>>> Again:
> >>>>>>>
> >>>>>>> Aborting the simulation is a side effect; pure functions do
> >>>>>>> not have side effects.
> >>>>>>>
> >>>>>>
> >>>>>> Whether or not it is construed as a side-effect does not matter
> >>>>>> it must be a mutation side-effect to (a)(b)(c)(d) or it does
> >>>>>> not count.
> >>>>>
> >>>>> It doesn't count according to who?
> >>>>
> >>>> The above definition of pure functions.
> >>>
> >>> "In computer science, an operation, function or expression is said
> >>> to have a side effect if it modifies some state variable value(s)
> >>> outside its local environment,
> >>
> >> The second part is an inaccurate paraphrase of the first part.
> >>
> >>> which is to say if it has any observable effect
> >>> other than its primary effect of returning a value to the invoker
> >>> of the operation." --
> >>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
> >>>
> >>> "any observable effect"
> >>>
> >>> Aborting the simulation instead of returning a value to the
> >>> invoker disqualifies it from being a pure function.
> >>>
> >>> /Flibble
> >>>
> >>
> >> void P(ptr x)
> >> {
> >> if (H(x, x))
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H(P, P));
> >> }
> >>
> >> _P()
> >> [00001352](01) 55 push ebp
> >> [00001353](02) 8bec mov ebp,esp
> >> [00001355](03) 8b4508 mov eax,[ebp+08]
> >> [00001358](01) 50 push eax // push P
> >> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >> [0000135c](01) 51 push ecx // push P
> >> [0000135d](05) e840feffff call 000011a2 // call H
> >> [00001362](03) 83c408 add esp,+08
> >> [00001365](02) 85c0 test eax,eax
> >> [00001367](02) 7402 jz 0000136b
> >> [00001369](02) ebfe jmp 00001369
> >> [0000136b](01) 5d pop ebp
> >> [0000136c](01) c3 ret
> >> Size in bytes:(0027) [0000136c]
> >>
> >> H aborts its x86 emulation of P as soon P reaches its machine
> >> address of [0000135d] the very first time before the code at this
> >> address is emulated. Then H returns 0 to its caller: main().
> >
> > Returning to main() is not returning to its invoker, P.
> >
> > Again:
> >
> > Aborting the simulation is a side effect; pure functions do not have
> > side effects.
> >
> > /Flibble
> >
>
> Do you have ADD?
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> }

Click here to read the complete article

Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<jeWdnTnluoxnLTH_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 11:51:06 -0500
Date: Fri, 17 Jun 2022 11:51:05 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<912de0f6-ed7e-432b-a66f-151b90a3165dn@googlegroups.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617174139.000051dc@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220617174139.000051dc@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <jeWdnTnluoxnLTH_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 314
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-n5BmIz1CAXQVas8x+TFw1Wxvrw6/qh0PLR9EjbubEP35xuTxVyLsjdydpWXjIaP6pyhWO8GD5b4bE0A!4g59y0DV0RfFK5uuAznN+xqqnbTdl1dozplqj4oc+bKrcNEOgvLyioOsBgjCP8vj13BxFw2bozx0
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
X-Original-Bytes: 15068
 by: olcott - Fri, 17 Jun 2022 16:51 UTC

On 6/17/2022 11:41 AM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 11:38:29 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8, olcott
>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all inputs as
>>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects that its
>>>>>>>>>>>>>>>>>> correct and complete simulation of its input would
>>>>>>>>>>>>>>>>>> never reach the final state of this input then all
>>>>>>>>>>>>>>>>>> [these] inputs (including pathological inputs) are
>>>>>>>>>>>>>>>>>> decided correctly.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine will
>>>>>>>>>>>>>>>>>> halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal Languages
>>>>>>>>>>>>>>>>>> and Automata. Lexington/Toronto: D. C. Heath and
>>>>>>>>>>>>>>>>>> Company. (317-320)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we assume
>>>>>>>>>>>>>>>>>> that H is only an x86 emulator that the correctly
>>>>>>>>>>>>>>>>>> emulated P never reaches its "ret" instruction it
>>>>>>>>>>>>>>>>>> remains stuck in repeated cycles of emulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has been
>>>>>>>>>>>>>>>>>> adapted to correctly detect (in a finite number of
>>>>>>>>>>>>>>>>>> steps) that the correct and complete x86 emulation of
>>>>>>>>>>>>>>>>>> its input would never each its "ret" instruction that
>>>>>>>>>>>>>>>>>> H could abort its emulation and return 0 to report
>>>>>>>>>>>>>>>>>> this.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
>>>>>>>>>>>>>>>>>> correctly determining whether or not an x86 emulated
>>>>>>>>>>>>>>>>>> input would ever reach its "ret" instruction then it
>>>>>>>>>>>>>>>>>> becomes an easily verified fact H(P,P) could
>>>>>>>>>>>>>>>>>> correctly reject its input as non-halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all of these
>>>>>>>>>>>>>>>>>> things are true without any need what-so-ever to see
>>>>>>>>>>>>>>>>>> either the source-code or the execution trace of H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether or not an
>>>>>>>>>>>>>>>>>> actual encoded H(P,P) does indeed correctly determine
>>>>>>>>>>>>>>>>>> that its input would never reach its "ret"
>>>>>>>>>>>>>>>>>> instruction as a pure function of its inputs. This
>>>>>>>>>>>>>>>>>> aspect will be confirmed by fully operational
>>>>>>>>>>>>>>>>>> source-code.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>>>> simulation (V5)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H cannot
>>>>>>>>>>>>>>>>> exist:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from their
>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of
>>>>>>>>>>>>>>>> the actual behavior actually specified by these inputs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is an easily verified fact that the correct and
>>>>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>> would never reach its "ret" instruction thus
>>>>>>>>>>>>>>>> conclusively proving that it never halts.
>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
>>>>>>>>>>>>>>>>> (undecidable).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts demonstrated
>>>>>>>>>>>>>>>>> even himself a genius in 10000-years cannot refute my
>>>>>>>>>>>>>>>>> GUR. ...
>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You just
>>>>>>>>>>>>>>> confirms it by not able to provide POOH to test/review.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It took me six months to figure out how to transform
>>>>>>>>>>>>>> H(P,P) into a pure function of its inputs. I did not
>>>>>>>>>>>>>> release the code before because I knew that its use of
>>>>>>>>>>>>>> static local data would have been rejected. With this
>>>>>>>>>>>>>> update to H I will be able to publish the code.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H recognizes that P is calling itself with its same
>>>>>>>>>>>>>> arguments that it was called with and there are no
>>>>>>>>>>>>>> instructions preceding this call that could possibly
>>>>>>>>>>>>>> escape infinitely recursive emulation so H aborts its
>>>>>>>>>>>>>> emulation of P before P even makes its first call to H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Without even looking at the code competent software
>>>>>>>>>>>>>> engineers will be able to verify that the above H would
>>>>>>>>>>>>>> correctly determine that that is input is non-halting as
>>>>>>>>>>>>>> a pure function of this input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So my other reply for why your H is not a pure function
>>>>>>>>>>>>> for any accepted definition of the term.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> In computer programming, a pure function is a function that
>>>>>>>>>>>> has the following properties:
>>>>>>>>>>>>
>>>>>>>>>>>> (1) the function return values are identical for identical
>>>>>>>>>>>> arguments (no variation with local static variables,
>>>>>>>>>>>> non-local variables, mutable reference arguments or input
>>>>>>>>>>>> streams), and
>>>>>>>>>>>>
>>>>>>>>>>>> (2) the function application has no side effects (no
>>>>>>>>>>>> mutation of local static variables, non-local variables,
>>>>>>>>>>>> mutable reference arguments or input/output streams).
>>>>>>>>>>>>
>>>>>>>>>>>> Thus a pure function is a computational analogue of a
>>>>>>>>>>>> mathematical function.
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>
>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>
>>>>>>>>>>> Aborting the simulation is a side effect; pure functions do
>>>>>>>>>>> not have side effects.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>
>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>
>>>>>>>>> Again:
>>>>>>>>>
>>>>>>>>> Aborting the simulation is a side effect; pure functions do
>>>>>>>>> not have side effects.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Whether or not it is construed as a side-effect does not matter
>>>>>>>> it must be a mutation side-effect to (a)(b)(c)(d) or it does
>>>>>>>> not count.
>>>>>>>
>>>>>>> It doesn't count according to who?
>>>>>>
>>>>>> The above definition of pure functions.
>>>>>
>>>>> "In computer science, an operation, function or expression is said
>>>>> to have a side effect if it modifies some state variable value(s)
>>>>> outside its local environment,
>>>>
>>>> The second part is an inaccurate paraphrase of the first part.
>>>>
>>>>> which is to say if it has any observable effect
>>>>> other than its primary effect of returning a value to the invoker
>>>>> of the operation." --
>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>
>>>>> "any observable effect"
>>>>>
>>>>> Aborting the simulation instead of returning a value to the
>>>>> invoker disqualifies it from being a pure function.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> void P(ptr x)
>>>> {
>>>> if (H(x, x))
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(P, P));
>>>> }
>>>>
>>>> _P()
>>>> [00001352](01) 55 push ebp
>>>> [00001353](02) 8bec mov ebp,esp
>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>> [00001358](01) 50 push eax // push P
>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>> [0000135c](01) 51 push ecx // push P
>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>> [00001362](03) 83c408 add esp,+08
>>>> [00001365](02) 85c0 test eax,eax
>>>> [00001367](02) 7402 jz 0000136b
>>>> [00001369](02) ebfe jmp 00001369
>>>> [0000136b](01) 5d pop ebp
>>>> [0000136c](01) c3 ret
>>>> Size in bytes:(0027) [0000136c]
>>>>
>>>> H aborts its x86 emulation of P as soon P reaches its machine
>>>> address of [0000135d] the very first time before the code at this
>>>> address is emulated. Then H returns 0 to its caller: main().
>>>
>>> Returning to main() is not returning to its invoker, P.
>>>
>>> Again:
>>>
>>> Aborting the simulation is a side effect; pure functions do not have
>>> side effects.
>>>
>>> /Flibble
>>>
>>
>> Do you have ADD?
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(P, P));
>> }
>
> I might be on the spectrum; probably got Asperger's; whilst as far as
> the topic under discussion is concerned, you've got nothing.
>
> /Flibble
>


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 11:59:54 -0500
Date: Fri, 17 Jun 2022 11:59:53 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<912de0f6-ed7e-432b-a66f-151b90a3165dn@googlegroups.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220617175104.00001454@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 317
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Fknd23OPPxznVKNTNbHRnCxW1a6z72NE2MzmM1ejYwR0IFklxyBGNPp3yse6lGyRMI2l+/mLQOqBLah!N8H0w5A5e+Z50XoDndiK0klrz8Dpi88ik10lrAX08BmP0ve2z5Na2b0y+TRk7c8UhriM7sdDYnqh
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
X-Original-Bytes: 15350
 by: olcott - Fri, 17 Jun 2022 16:59 UTC

On 6/17/2022 11:51 AM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 11:38:29 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8, olcott
>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all inputs as
>>>>>>>>>>>>>>>>>> non-halting whenever it correctly detects that its
>>>>>>>>>>>>>>>>>> correct and complete simulation of its input would
>>>>>>>>>>>>>>>>>> never reach the final state of this input then all
>>>>>>>>>>>>>>>>>> [these] inputs (including pathological inputs) are
>>>>>>>>>>>>>>>>>> decided correctly.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine will
>>>>>>>>>>>>>>>>>> halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal Languages
>>>>>>>>>>>>>>>>>> and Automata. Lexington/Toronto: D. C. Heath and
>>>>>>>>>>>>>>>>>> Company. (317-320)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we assume
>>>>>>>>>>>>>>>>>> that H is only an x86 emulator that the correctly
>>>>>>>>>>>>>>>>>> emulated P never reaches its "ret" instruction it
>>>>>>>>>>>>>>>>>> remains stuck in repeated cycles of emulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has been
>>>>>>>>>>>>>>>>>> adapted to correctly detect (in a finite number of
>>>>>>>>>>>>>>>>>> steps) that the correct and complete x86 emulation of
>>>>>>>>>>>>>>>>>> its input would never each its "ret" instruction that
>>>>>>>>>>>>>>>>>> H could abort its emulation and return 0 to report
>>>>>>>>>>>>>>>>>> this.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
>>>>>>>>>>>>>>>>>> correctly determining whether or not an x86 emulated
>>>>>>>>>>>>>>>>>> input would ever reach its "ret" instruction then it
>>>>>>>>>>>>>>>>>> becomes an easily verified fact H(P,P) could
>>>>>>>>>>>>>>>>>> correctly reject its input as non-halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all of these
>>>>>>>>>>>>>>>>>> things are true without any need what-so-ever to see
>>>>>>>>>>>>>>>>>> either the source-code or the execution trace of H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether or not an
>>>>>>>>>>>>>>>>>> actual encoded H(P,P) does indeed correctly determine
>>>>>>>>>>>>>>>>>> that its input would never reach its "ret"
>>>>>>>>>>>>>>>>>> instruction as a pure function of its inputs. This
>>>>>>>>>>>>>>>>>> aspect will be confirmed by fully operational
>>>>>>>>>>>>>>>>>> source-code.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>>>> simulation (V5)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H cannot
>>>>>>>>>>>>>>>>> exist:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from their
>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of
>>>>>>>>>>>>>>>> the actual behavior actually specified by these inputs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is an easily verified fact that the correct and
>>>>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>> would never reach its "ret" instruction thus
>>>>>>>>>>>>>>>> conclusively proving that it never halts.
>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
>>>>>>>>>>>>>>>>> (undecidable).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts demonstrated
>>>>>>>>>>>>>>>>> even himself a genius in 10000-years cannot refute my
>>>>>>>>>>>>>>>>> GUR. ...
>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You just
>>>>>>>>>>>>>>> confirms it by not able to provide POOH to test/review.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It took me six months to figure out how to transform
>>>>>>>>>>>>>> H(P,P) into a pure function of its inputs. I did not
>>>>>>>>>>>>>> release the code before because I knew that its use of
>>>>>>>>>>>>>> static local data would have been rejected. With this
>>>>>>>>>>>>>> update to H I will be able to publish the code.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H recognizes that P is calling itself with its same
>>>>>>>>>>>>>> arguments that it was called with and there are no
>>>>>>>>>>>>>> instructions preceding this call that could possibly
>>>>>>>>>>>>>> escape infinitely recursive emulation so H aborts its
>>>>>>>>>>>>>> emulation of P before P even makes its first call to H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Without even looking at the code competent software
>>>>>>>>>>>>>> engineers will be able to verify that the above H would
>>>>>>>>>>>>>> correctly determine that that is input is non-halting as
>>>>>>>>>>>>>> a pure function of this input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So my other reply for why your H is not a pure function
>>>>>>>>>>>>> for any accepted definition of the term.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> In computer programming, a pure function is a function that
>>>>>>>>>>>> has the following properties:
>>>>>>>>>>>>
>>>>>>>>>>>> (1) the function return values are identical for identical
>>>>>>>>>>>> arguments (no variation with local static variables,
>>>>>>>>>>>> non-local variables, mutable reference arguments or input
>>>>>>>>>>>> streams), and
>>>>>>>>>>>>
>>>>>>>>>>>> (2) the function application has no side effects (no
>>>>>>>>>>>> mutation of local static variables, non-local variables,
>>>>>>>>>>>> mutable reference arguments or input/output streams).
>>>>>>>>>>>>
>>>>>>>>>>>> Thus a pure function is a computational analogue of a
>>>>>>>>>>>> mathematical function.
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>
>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>
>>>>>>>>>>> Aborting the simulation is a side effect; pure functions do
>>>>>>>>>>> not have side effects.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>
>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>
>>>>>>>>> Again:
>>>>>>>>>
>>>>>>>>> Aborting the simulation is a side effect; pure functions do
>>>>>>>>> not have side effects.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Whether or not it is construed as a side-effect does not matter
>>>>>>>> it must be a mutation side-effect to (a)(b)(c)(d) or it does
>>>>>>>> not count.
>>>>>>>
>>>>>>> It doesn't count according to who?
>>>>>>
>>>>>> The above definition of pure functions.
>>>>>
>>>>> "In computer science, an operation, function or expression is said
>>>>> to have a side effect if it modifies some state variable value(s)
>>>>> outside its local environment,
>>>>
>>>> The second part is an inaccurate paraphrase of the first part.
>>>>
>>>>> which is to say if it has any observable effect
>>>>> other than its primary effect of returning a value to the invoker
>>>>> of the operation." --
>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>
>>>>> "any observable effect"
>>>>>
>>>>> Aborting the simulation instead of returning a value to the
>>>>> invoker disqualifies it from being a pure function.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> void P(ptr x)
>>>> {
>>>> if (H(x, x))
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(P, P));
>>>> }
>>>>
>>>> _P()
>>>> [00001352](01) 55 push ebp
>>>> [00001353](02) 8bec mov ebp,esp
>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>> [00001358](01) 50 push eax // push P
>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>> [0000135c](01) 51 push ecx // push P
>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>> [00001362](03) 83c408 add esp,+08
>>>> [00001365](02) 85c0 test eax,eax
>>>> [00001367](02) 7402 jz 0000136b
>>>> [00001369](02) ebfe jmp 00001369
>>>> [0000136b](01) 5d pop ebp
>>>> [0000136c](01) c3 ret
>>>> Size in bytes:(0027) [0000136c]
>>>>
>>>> H aborts its x86 emulation of P as soon P reaches its machine
>>>> address of [0000135d] the very first time before the code at this
>>>> address is emulated. Then H returns 0 to its caller: main().
>>>
>>> Returning to main() is not returning to its invoker, P.
>>>
>>> Again:
>>>
>>> Aborting the simulation is a side effect; pure functions do not have
>>> side effects.
>>>
>>> /Flibble
>>>
>>
>> Do you have ADD?
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(P, P));
>> }
>
> If your claim is that H is only called once and the second time an
> *attempt* to call H is prevented than that is equivalent to calling H
> and having H do something different with side effects. This is just my
> opinion though as it requires more thought and I am currently getting
> drunk on gin and tonics.
>
> /Flibble
>


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<20220617180447.00003b49@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!ecngs!feeder2.ecngs.de!178.20.174.213.MISMATCH!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx11.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Message-ID: <20220617180447.00003b49@reddwarf.jmc>
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<912de0f6-ed7e-432b-a66f-151b90a3165dn@googlegroups.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 326
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 17 Jun 2022 17:04:47 UTC
Date: Fri, 17 Jun 2022 18:04:47 +0100
X-Received-Bytes: 15996
 by: Mr Flibble - Fri, 17 Jun 2022 17:04 UTC

On Fri, 17 Jun 2022 11:59:53 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/17/2022 11:51 AM, Mr Flibble wrote:
> > On Fri, 17 Jun 2022 11:38:29 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/17/2022 11:36 AM, Mr Flibble wrote:
> >>> On Fri, 17 Jun 2022 11:33:22 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
> >>>>> On Fri, 17 Jun 2022 11:16:15 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
> >>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
> >>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8, olcott
> >>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all inputs
> >>>>>>>>>>>>>>>>>> as non-halting whenever it correctly detects that
> >>>>>>>>>>>>>>>>>> its correct and complete simulation of its input
> >>>>>>>>>>>>>>>>>> would never reach the final state of this input
> >>>>>>>>>>>>>>>>>> then all [these] inputs (including pathological
> >>>>>>>>>>>>>>>>>> inputs) are decided correctly.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine will
> >>>>>>>>>>>>>>>>>> halt whenever it enters a final state.
> >>>>>>>>>>>>>>>>>> (Linz:1990:234)
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
> >>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D. C.
> >>>>>>>>>>>>>>>>>> Heath and Company. (317-320)
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> #include <stdint.h>
> >>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>>>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we
> >>>>>>>>>>>>>>>>>> assume that H is only an x86 emulator that the
> >>>>>>>>>>>>>>>>>> correctly emulated P never reaches its "ret"
> >>>>>>>>>>>>>>>>>> instruction it remains stuck in repeated cycles of
> >>>>>>>>>>>>>>>>>> emulation.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has
> >>>>>>>>>>>>>>>>>> been adapted to correctly detect (in a finite
> >>>>>>>>>>>>>>>>>> number of steps) that the correct and complete x86
> >>>>>>>>>>>>>>>>>> emulation of its input would never each its "ret"
> >>>>>>>>>>>>>>>>>> instruction that H could abort its emulation and
> >>>>>>>>>>>>>>>>>> return 0 to report this.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
> >>>>>>>>>>>>>>>>>> correctly determining whether or not an x86
> >>>>>>>>>>>>>>>>>> emulated input would ever reach its "ret"
> >>>>>>>>>>>>>>>>>> instruction then it becomes an easily verified
> >>>>>>>>>>>>>>>>>> fact H(P,P) could correctly reject its input as
> >>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Correct deductive inference proves that all of
> >>>>>>>>>>>>>>>>>> these things are true without any need
> >>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or the
> >>>>>>>>>>>>>>>>>> execution trace of H.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> The one thing that is not proved is whether or not
> >>>>>>>>>>>>>>>>>> an actual encoded H(P,P) does indeed correctly
> >>>>>>>>>>>>>>>>>> determine that its input would never reach its
> >>>>>>>>>>>>>>>>>> "ret" instruction as a pure function of its
> >>>>>>>>>>>>>>>>>> inputs. This aspect will be confirmed by fully
> >>>>>>>>>>>>>>>>>> operational source-code.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
> >>>>>>>>>>>>>>>>>> nested simulation (V5)
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
> >>>>>>>>>>>>>>>>> cannot exist:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
> >>>>>>>>>>>>>>>> That is a misconception.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Halt deciders must compute the mapping from their
> >>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of
> >>>>>>>>>>>>>>>> the actual behavior actually specified by these
> >>>>>>>>>>>>>>>> inputs.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> It is an easily verified fact that the correct and
> >>>>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>>>> would never reach its "ret" instruction thus
> >>>>>>>>>>>>>>>> conclusively proving that it never halts.
> >>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
> >>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
> >>>>>>>>>>>>>>>>> (undecidable).
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> -----
> >>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts demonstrated
> >>>>>>>>>>>>>>>>> even himself a genius in 10000-years cannot refute
> >>>>>>>>>>>>>>>>> my GUR. ...
> >>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You just
> >>>>>>>>>>>>>>> confirms it by not able to provide POOH to
> >>>>>>>>>>>>>>> test/review.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> It took me six months to figure out how to transform
> >>>>>>>>>>>>>> H(P,P) into a pure function of its inputs. I did not
> >>>>>>>>>>>>>> release the code before because I knew that its use of
> >>>>>>>>>>>>>> static local data would have been rejected. With this
> >>>>>>>>>>>>>> update to H I will be able to publish the code.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> H recognizes that P is calling itself with its same
> >>>>>>>>>>>>>> arguments that it was called with and there are no
> >>>>>>>>>>>>>> instructions preceding this call that could possibly
> >>>>>>>>>>>>>> escape infinitely recursive emulation so H aborts its
> >>>>>>>>>>>>>> emulation of P before P even makes its first call to H.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Without even looking at the code competent software
> >>>>>>>>>>>>>> engineers will be able to verify that the above H would
> >>>>>>>>>>>>>> correctly determine that that is input is non-halting
> >>>>>>>>>>>>>> as a pure function of this input.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> So my other reply for why your H is not a pure function
> >>>>>>>>>>>>> for any accepted definition of the term.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> In computer programming, a pure function is a function
> >>>>>>>>>>>> that has the following properties:
> >>>>>>>>>>>>
> >>>>>>>>>>>> (1) the function return values are identical for
> >>>>>>>>>>>> identical arguments (no variation with local static
> >>>>>>>>>>>> variables, non-local variables, mutable reference
> >>>>>>>>>>>> arguments or input streams), and
> >>>>>>>>>>>>
> >>>>>>>>>>>> (2) the function application has no side effects (no
> >>>>>>>>>>>> mutation of local static variables, non-local variables,
> >>>>>>>>>>>> mutable reference arguments or input/output streams).
> >>>>>>>>>>>>
> >>>>>>>>>>>> Thus a pure function is a computational analogue of a
> >>>>>>>>>>>> mathematical function.
> >>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>
> >>>>>>>>>>>> The revised H has no:
> >>>>>>>>>>>> (a) local static variables
> >>>>>>>>>>>> (b) non-local variables
> >>>>>>>>>>>> (c) mutable reference arguments
> >>>>>>>>>>>> (d) input streams
> >>>>>>>>>>>
> >>>>>>>>>>> Aborting the simulation is a side effect; pure functions
> >>>>>>>>>>> do not have side effects.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>
> >>>>>>>>>> You have a reading comprehension problem.
> >>>>>>>>>> If H does not have (a)(b)(c)(d) then
> >>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
> >>>>>>>>>
> >>>>>>>>> Not at all, but you do seem to have that problem.
> >>>>>>>>>
> >>>>>>>>> Again:
> >>>>>>>>>
> >>>>>>>>> Aborting the simulation is a side effect; pure functions do
> >>>>>>>>> not have side effects.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Whether or not it is construed as a side-effect does not
> >>>>>>>> matter it must be a mutation side-effect to (a)(b)(c)(d) or
> >>>>>>>> it does not count.
> >>>>>>>
> >>>>>>> It doesn't count according to who?
> >>>>>>
> >>>>>> The above definition of pure functions.
> >>>>>
> >>>>> "In computer science, an operation, function or expression is
> >>>>> said to have a side effect if it modifies some state variable
> >>>>> value(s) outside its local environment,
> >>>>
> >>>> The second part is an inaccurate paraphrase of the first part.
> >>>>
> >>>>> which is to say if it has any observable effect
> >>>>> other than its primary effect of returning a value to the
> >>>>> invoker of the operation." --
> >>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
> >>>>>
> >>>>> "any observable effect"
> >>>>>
> >>>>> Aborting the simulation instead of returning a value to the
> >>>>> invoker disqualifies it from being a pure function.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> void P(ptr x)
> >>>> {
> >>>> if (H(x, x))
> >>>> HERE: goto HERE;
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H(P, P));
> >>>> }
> >>>>
> >>>> _P()
> >>>> [00001352](01) 55 push ebp
> >>>> [00001353](02) 8bec mov ebp,esp
> >>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>> [00001358](01) 50 push eax // push P
> >>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>> [0000135c](01) 51 push ecx // push P
> >>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>> [00001362](03) 83c408 add esp,+08
> >>>> [00001365](02) 85c0 test eax,eax
> >>>> [00001367](02) 7402 jz 0000136b
> >>>> [00001369](02) ebfe jmp 00001369
> >>>> [0000136b](01) 5d pop ebp
> >>>> [0000136c](01) c3 ret
> >>>> Size in bytes:(0027) [0000136c]
> >>>>
> >>>> H aborts its x86 emulation of P as soon P reaches its machine
> >>>> address of [0000135d] the very first time before the code at this
> >>>> address is emulated. Then H returns 0 to its caller: main().
> >>>
> >>> Returning to main() is not returning to its invoker, P.
> >>>
> >>> Again:
> >>>
> >>> Aborting the simulation is a side effect; pure functions do not
> >>> have side effects.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Do you have ADD?
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H(P, P));
> >> }
> >
> > If your claim is that H is only called once and the second time an
> > *attempt* to call H is prevented than that is equivalent to calling
> > H and having H do something different with side effects. This is
> > just my opinion though as it requires more thought and I am
> > currently getting drunk on gin and tonics.
> >
> > /Flibble
> >
>
> It is obviously the exact same pattern as infinite recursion
> (a) calling the same function a second time with the same arguments
> and
>
> (b) there are no instructions preceding this call that could possibly
> escape the infinite recursion / infinitely recursive emulation.

Click here to read the complete article

Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 12:13:14 -0500
Date: Fri, 17 Jun 2022 12:13:13 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<912de0f6-ed7e-432b-a66f-151b90a3165dn@googlegroups.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220617180447.00003b49@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 340
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-adao5jL/2zrj0Cx7+TyFVsCz7+UEJRiMRCNO8dReKODAwe8UN9K3twe7T/Vw47tfeNqTLGDORnOYbW0!97ipHcqcedVJXfUvTP4bRbcxVaplwmuIGs20ES5l/jD7l9LTwa6Izd2+xDVDkXlT0OT4VAM2qo4F
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
X-Original-Bytes: 16876
 by: olcott - Fri, 17 Jun 2022 17:13 UTC

On 6/17/2022 12:04 PM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 11:59:53 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
>>> On Fri, 17 Jun 2022 11:38:29 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8, olcott
>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all inputs
>>>>>>>>>>>>>>>>>>>> as non-halting whenever it correctly detects that
>>>>>>>>>>>>>>>>>>>> its correct and complete simulation of its input
>>>>>>>>>>>>>>>>>>>> would never reach the final state of this input
>>>>>>>>>>>>>>>>>>>> then all [these] inputs (including pathological
>>>>>>>>>>>>>>>>>>>> inputs) are decided correctly.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine will
>>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D. C.
>>>>>>>>>>>>>>>>>>>> Heath and Company. (317-320)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we
>>>>>>>>>>>>>>>>>>>> assume that H is only an x86 emulator that the
>>>>>>>>>>>>>>>>>>>> correctly emulated P never reaches its "ret"
>>>>>>>>>>>>>>>>>>>> instruction it remains stuck in repeated cycles of
>>>>>>>>>>>>>>>>>>>> emulation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has
>>>>>>>>>>>>>>>>>>>> been adapted to correctly detect (in a finite
>>>>>>>>>>>>>>>>>>>> number of steps) that the correct and complete x86
>>>>>>>>>>>>>>>>>>>> emulation of its input would never each its "ret"
>>>>>>>>>>>>>>>>>>>> instruction that H could abort its emulation and
>>>>>>>>>>>>>>>>>>>> return 0 to report this.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
>>>>>>>>>>>>>>>>>>>> correctly determining whether or not an x86
>>>>>>>>>>>>>>>>>>>> emulated input would ever reach its "ret"
>>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily verified
>>>>>>>>>>>>>>>>>>>> fact H(P,P) could correctly reject its input as
>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all of
>>>>>>>>>>>>>>>>>>>> these things are true without any need
>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or the
>>>>>>>>>>>>>>>>>>>> execution trace of H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether or not
>>>>>>>>>>>>>>>>>>>> an actual encoded H(P,P) does indeed correctly
>>>>>>>>>>>>>>>>>>>> determine that its input would never reach its
>>>>>>>>>>>>>>>>>>>> "ret" instruction as a pure function of its
>>>>>>>>>>>>>>>>>>>> inputs. This aspect will be confirmed by fully
>>>>>>>>>>>>>>>>>>>> operational source-code.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>> nested simulation (V5)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
>>>>>>>>>>>>>>>>>>> cannot exist:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from their
>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of
>>>>>>>>>>>>>>>>>> the actual behavior actually specified by these
>>>>>>>>>>>>>>>>>> inputs.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct and
>>>>>>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>>>> would never reach its "ret" instruction thus
>>>>>>>>>>>>>>>>>> conclusively proving that it never halts.
>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
>>>>>>>>>>>>>>>>>>> (undecidable).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts demonstrated
>>>>>>>>>>>>>>>>>>> even himself a genius in 10000-years cannot refute
>>>>>>>>>>>>>>>>>>> my GUR. ...
>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You just
>>>>>>>>>>>>>>>>> confirms it by not able to provide POOH to
>>>>>>>>>>>>>>>>> test/review.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It took me six months to figure out how to transform
>>>>>>>>>>>>>>>> H(P,P) into a pure function of its inputs. I did not
>>>>>>>>>>>>>>>> release the code before because I knew that its use of
>>>>>>>>>>>>>>>> static local data would have been rejected. With this
>>>>>>>>>>>>>>>> update to H I will be able to publish the code.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its same
>>>>>>>>>>>>>>>> arguments that it was called with and there are no
>>>>>>>>>>>>>>>> instructions preceding this call that could possibly
>>>>>>>>>>>>>>>> escape infinitely recursive emulation so H aborts its
>>>>>>>>>>>>>>>> emulation of P before P even makes its first call to H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Without even looking at the code competent software
>>>>>>>>>>>>>>>> engineers will be able to verify that the above H would
>>>>>>>>>>>>>>>> correctly determine that that is input is non-halting
>>>>>>>>>>>>>>>> as a pure function of this input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So my other reply for why your H is not a pure function
>>>>>>>>>>>>>>> for any accepted definition of the term.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In computer programming, a pure function is a function
>>>>>>>>>>>>>> that has the following properties:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (1) the function return values are identical for
>>>>>>>>>>>>>> identical arguments (no variation with local static
>>>>>>>>>>>>>> variables, non-local variables, mutable reference
>>>>>>>>>>>>>> arguments or input streams), and
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (2) the function application has no side effects (no
>>>>>>>>>>>>>> mutation of local static variables, non-local variables,
>>>>>>>>>>>>>> mutable reference arguments or input/output streams).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus a pure function is a computational analogue of a
>>>>>>>>>>>>>> mathematical function.
>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>>>
>>>>>>>>>>>>> Aborting the simulation is a side effect; pure functions
>>>>>>>>>>>>> do not have side effects.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>>>
>>>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>>>
>>>>>>>>>>> Again:
>>>>>>>>>>>
>>>>>>>>>>> Aborting the simulation is a side effect; pure functions do
>>>>>>>>>>> not have side effects.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Whether or not it is construed as a side-effect does not
>>>>>>>>>> matter it must be a mutation side-effect to (a)(b)(c)(d) or
>>>>>>>>>> it does not count.
>>>>>>>>>
>>>>>>>>> It doesn't count according to who?
>>>>>>>>
>>>>>>>> The above definition of pure functions.
>>>>>>>
>>>>>>> "In computer science, an operation, function or expression is
>>>>>>> said to have a side effect if it modifies some state variable
>>>>>>> value(s) outside its local environment,
>>>>>>
>>>>>> The second part is an inaccurate paraphrase of the first part.
>>>>>>
>>>>>>> which is to say if it has any observable effect
>>>>>>> other than its primary effect of returning a value to the
>>>>>>> invoker of the operation." --
>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>>>
>>>>>>> "any observable effect"
>>>>>>>
>>>>>>> Aborting the simulation instead of returning a value to the
>>>>>>> invoker disqualifies it from being a pure function.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> void P(ptr x)
>>>>>> {
>>>>>> if (H(x, x))
>>>>>> HERE: goto HERE;
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>> }
>>>>>>
>>>>>> _P()
>>>>>> [00001352](01) 55 push ebp
>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00001358](01) 50 push eax // push P
>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>> [0000136b](01) 5d pop ebp
>>>>>> [0000136c](01) c3 ret
>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>
>>>>>> H aborts its x86 emulation of P as soon P reaches its machine
>>>>>> address of [0000135d] the very first time before the code at this
>>>>>> address is emulated. Then H returns 0 to its caller: main().
>>>>>
>>>>> Returning to main() is not returning to its invoker, P.
>>>>>
>>>>> Again:
>>>>>
>>>>> Aborting the simulation is a side effect; pure functions do not
>>>>> have side effects.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Do you have ADD?
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(P, P));
>>>> }
>>>
>>> If your claim is that H is only called once and the second time an
>>> *attempt* to call H is prevented than that is equivalent to calling
>>> H and having H do something different with side effects. This is
>>> just my opinion though as it requires more thought and I am
>>> currently getting drunk on gin and tonics.
>>>
>>> /Flibble
>>>
>>
>> It is obviously the exact same pattern as infinite recursion
>> (a) calling the same function a second time with the same arguments
>> and
>>
>> (b) there are no instructions preceding this call that could possibly
>> escape the infinite recursion / infinitely recursive emulation.
>
> Agree but refusing to analyse what P would have done if H wasn't a
> simulating decider still makes what you've got worthless as far as the
> Halting Problem is concerned.
>
> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
>


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<20220617181448.00005cdb@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder.usenetexpress.com!tr3.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx11.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]
Message-ID: <20220617181448.00005cdb@reddwarf.jmc>
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com> <912de0f6-ed7e-432b-a66f-151b90a3165dn@googlegroups.com> <3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com> <854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com> <-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com> <20220617155601.00005a04@reddwarf.jmc> <mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com> <20220617163707.00002d66@reddwarf.jmc> <6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com> <20220617165613.00006ff4@reddwarf.jmc> <19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com> <20220617171424.00006f1f@reddwarf.jmc> <19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com> <20220617172234.00000777@reddwarf.jmc> <5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com> <20220617173640.00006b94@reddwarf.jmc> <BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com> <20220617175104.00001454@reddwarf.jmc> <d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com> <20220617180447.00003b49@reddwarf.jmc> <-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 346
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 17 Jun 2022 17:14:49 UTC
Date: Fri, 17 Jun 2022 18:14:48 +0100
X-Received-Bytes: 17417
 by: Mr Flibble - Fri, 17 Jun 2022 17:14 UTC

On Fri, 17 Jun 2022 12:13:13 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/17/2022 12:04 PM, Mr Flibble wrote:
> > On Fri, 17 Jun 2022 11:59:53 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/17/2022 11:51 AM, Mr Flibble wrote:
> >>> On Fri, 17 Jun 2022 11:38:29 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
> >>>>> On Fri, 17 Jun 2022 11:33:22 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
> >>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8, olcott
> >>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all inputs
> >>>>>>>>>>>>>>>>>>>> as non-halting whenever it correctly detects that
> >>>>>>>>>>>>>>>>>>>> its correct and complete simulation of its input
> >>>>>>>>>>>>>>>>>>>> would never reach the final state of this input
> >>>>>>>>>>>>>>>>>>>> then all [these] inputs (including pathological
> >>>>>>>>>>>>>>>>>>>> inputs) are decided correctly.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
> >>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
> >>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
> >>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D. C.
> >>>>>>>>>>>>>>>>>>>> Heath and Company. (317-320)
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> #include <stdint.h>
> >>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>>>>>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we
> >>>>>>>>>>>>>>>>>>>> assume that H is only an x86 emulator that the
> >>>>>>>>>>>>>>>>>>>> correctly emulated P never reaches its "ret"
> >>>>>>>>>>>>>>>>>>>> instruction it remains stuck in repeated cycles
> >>>>>>>>>>>>>>>>>>>> of emulation.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has
> >>>>>>>>>>>>>>>>>>>> been adapted to correctly detect (in a finite
> >>>>>>>>>>>>>>>>>>>> number of steps) that the correct and complete
> >>>>>>>>>>>>>>>>>>>> x86 emulation of its input would never each its
> >>>>>>>>>>>>>>>>>>>> "ret" instruction that H could abort its
> >>>>>>>>>>>>>>>>>>>> emulation and return 0 to report this.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
> >>>>>>>>>>>>>>>>>>>> correctly determining whether or not an x86
> >>>>>>>>>>>>>>>>>>>> emulated input would ever reach its "ret"
> >>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily verified
> >>>>>>>>>>>>>>>>>>>> fact H(P,P) could correctly reject its input as
> >>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all of
> >>>>>>>>>>>>>>>>>>>> these things are true without any need
> >>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or the
> >>>>>>>>>>>>>>>>>>>> execution trace of H.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether or
> >>>>>>>>>>>>>>>>>>>> not an actual encoded H(P,P) does indeed
> >>>>>>>>>>>>>>>>>>>> correctly determine that its input would never
> >>>>>>>>>>>>>>>>>>>> reach its "ret" instruction as a pure function
> >>>>>>>>>>>>>>>>>>>> of its inputs. This aspect will be confirmed by
> >>>>>>>>>>>>>>>>>>>> fully operational source-code.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
> >>>>>>>>>>>>>>>>>>>> nested simulation (V5)
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
> >>>>>>>>>>>>>>>>>>> cannot exist:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
> >>>>>>>>>>>>>>>>>> That is a misconception.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from their
> >>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of
> >>>>>>>>>>>>>>>>>> the actual behavior actually specified by these
> >>>>>>>>>>>>>>>>>> inputs.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct and
> >>>>>>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>>>>>> would never reach its "ret" instruction thus
> >>>>>>>>>>>>>>>>>> conclusively proving that it never halts.
> >>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
> >>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
> >>>>>>>>>>>>>>>>>>> (undecidable).
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> -----
> >>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
> >>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in 10000-years
> >>>>>>>>>>>>>>>>>>> cannot refute my GUR. ...
> >>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You just
> >>>>>>>>>>>>>>>>> confirms it by not able to provide POOH to
> >>>>>>>>>>>>>>>>> test/review.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> It took me six months to figure out how to transform
> >>>>>>>>>>>>>>>> H(P,P) into a pure function of its inputs. I did not
> >>>>>>>>>>>>>>>> release the code before because I knew that its use
> >>>>>>>>>>>>>>>> of static local data would have been rejected. With
> >>>>>>>>>>>>>>>> this update to H I will be able to publish the code.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H recognizes that P is calling itself with its same
> >>>>>>>>>>>>>>>> arguments that it was called with and there are no
> >>>>>>>>>>>>>>>> instructions preceding this call that could possibly
> >>>>>>>>>>>>>>>> escape infinitely recursive emulation so H aborts its
> >>>>>>>>>>>>>>>> emulation of P before P even makes its first call to
> >>>>>>>>>>>>>>>> H.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Without even looking at the code competent software
> >>>>>>>>>>>>>>>> engineers will be able to verify that the above H
> >>>>>>>>>>>>>>>> would correctly determine that that is input is
> >>>>>>>>>>>>>>>> non-halting as a pure function of this input.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> So my other reply for why your H is not a pure
> >>>>>>>>>>>>>>> function for any accepted definition of the term.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> In computer programming, a pure function is a function
> >>>>>>>>>>>>>> that has the following properties:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> (1) the function return values are identical for
> >>>>>>>>>>>>>> identical arguments (no variation with local static
> >>>>>>>>>>>>>> variables, non-local variables, mutable reference
> >>>>>>>>>>>>>> arguments or input streams), and
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> (2) the function application has no side effects (no
> >>>>>>>>>>>>>> mutation of local static variables, non-local
> >>>>>>>>>>>>>> variables, mutable reference arguments or input/output
> >>>>>>>>>>>>>> streams).
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Thus a pure function is a computational analogue of a
> >>>>>>>>>>>>>> mathematical function.
> >>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> The revised H has no:
> >>>>>>>>>>>>>> (a) local static variables
> >>>>>>>>>>>>>> (b) non-local variables
> >>>>>>>>>>>>>> (c) mutable reference arguments
> >>>>>>>>>>>>>> (d) input streams
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Aborting the simulation is a side effect; pure functions
> >>>>>>>>>>>>> do not have side effects.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>>> You have a reading comprehension problem.
> >>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
> >>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
> >>>>>>>>>>>
> >>>>>>>>>>> Not at all, but you do seem to have that problem.
> >>>>>>>>>>>
> >>>>>>>>>>> Again:
> >>>>>>>>>>>
> >>>>>>>>>>> Aborting the simulation is a side effect; pure functions
> >>>>>>>>>>> do not have side effects.
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Whether or not it is construed as a side-effect does not
> >>>>>>>>>> matter it must be a mutation side-effect to (a)(b)(c)(d) or
> >>>>>>>>>> it does not count.
> >>>>>>>>>
> >>>>>>>>> It doesn't count according to who?
> >>>>>>>>
> >>>>>>>> The above definition of pure functions.
> >>>>>>>
> >>>>>>> "In computer science, an operation, function or expression is
> >>>>>>> said to have a side effect if it modifies some state variable
> >>>>>>> value(s) outside its local environment,
> >>>>>>
> >>>>>> The second part is an inaccurate paraphrase of the first part.
> >>>>>>
> >>>>>>> which is to say if it has any observable effect
> >>>>>>> other than its primary effect of returning a value to the
> >>>>>>> invoker of the operation." --
> >>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
> >>>>>>>
> >>>>>>> "any observable effect"
> >>>>>>>
> >>>>>>> Aborting the simulation instead of returning a value to the
> >>>>>>> invoker disqualifies it from being a pure function.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> void P(ptr x)
> >>>>>> {
> >>>>>> if (H(x, x))
> >>>>>> HERE: goto HERE;
> >>>>>> return;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>> }
> >>>>>>
> >>>>>> _P()
> >>>>>> [00001352](01) 55 push ebp
> >>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>> [00001358](01) 50 push eax // push P
> >>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>>>> [00001362](03) 83c408 add esp,+08
> >>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>> [0000136b](01) 5d pop ebp
> >>>>>> [0000136c](01) c3 ret
> >>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>
> >>>>>> H aborts its x86 emulation of P as soon P reaches its machine
> >>>>>> address of [0000135d] the very first time before the code at
> >>>>>> this address is emulated. Then H returns 0 to its caller:
> >>>>>> main().
> >>>>>
> >>>>> Returning to main() is not returning to its invoker, P.
> >>>>>
> >>>>> Again:
> >>>>>
> >>>>> Aborting the simulation is a side effect; pure functions do not
> >>>>> have side effects.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Do you have ADD?
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H(P, P));
> >>>> }
> >>>
> >>> If your claim is that H is only called once and the second time an
> >>> *attempt* to call H is prevented than that is equivalent to
> >>> calling H and having H do something different with side effects.
> >>> This is just my opinion though as it requires more thought and I
> >>> am currently getting drunk on gin and tonics.
> >>>
> >>> /Flibble
> >>>
> >>
> >> It is obviously the exact same pattern as infinite recursion
> >> (a) calling the same function a second time with the same arguments
> >> and
> >>
> >> (b) there are no instructions preceding this call that could
> >> possibly escape the infinite recursion / infinitely recursive
> >> emulation.
> >
> > Agree but refusing to analyse what P would have done if H wasn't a
> > simulating decider still makes what you've got worthless as far as
> > the Halting Problem is concerned.
> >
> > /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
> >
>
> It is dead obvious to everyone (even Richard) that what P would have
> done if H was merely an x86 emulator and not a halt deciding emulator.
>
> The correct and complete x86 emulation of H(P,P) would never reach
> its "ret" instruction thus making H a correct "not reach ret" / halt
> decider for P.


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<20220617190451.00003626@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx11.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Message-ID: <20220617190451.00003626@reddwarf.jmc>
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 360
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 17 Jun 2022 18:04:52 UTC
Date: Fri, 17 Jun 2022 19:04:51 +0100
X-Received-Bytes: 18629
 by: Mr Flibble - Fri, 17 Jun 2022 18:04 UTC

On Fri, 17 Jun 2022 18:14:48 +0100
Mr Flibble <flibble@reddwarf.jmc> wrote:

> On Fri, 17 Jun 2022 12:13:13 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
> > On 6/17/2022 12:04 PM, Mr Flibble wrote:
> > > On Fri, 17 Jun 2022 11:59:53 -0500
> > > olcott <NoOne@NoWhere.com> wrote:
> > >
> > >> On 6/17/2022 11:51 AM, Mr Flibble wrote:
> > >>> On Fri, 17 Jun 2022 11:38:29 -0500
> > >>> olcott <NoOne@NoWhere.com> wrote:
> > >>>
> > >>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
> > >>>>> On Fri, 17 Jun 2022 11:33:22 -0500
> > >>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>
> > >>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
> > >>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
> > >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>>>
> > >>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
> > >>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
> > >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>>>>>
> > >>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
> > >>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
> > >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>>>>>>>
> > >>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
> > >>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
> > >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
> > >>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
> > >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
> > >>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
> > >>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
> > >>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
> > >>>>>>>>>>>>>>>>>>> olcott wrote:
> > >>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
> > >>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
> > >>>>>>>>>>>>>>>>>>>> detects that its correct and complete
> > >>>>>>>>>>>>>>>>>>>> simulation of its input would never reach the
> > >>>>>>>>>>>>>>>>>>>> final state of this input then all [these]
> > >>>>>>>>>>>>>>>>>>>> inputs (including pathological inputs) are
> > >>>>>>>>>>>>>>>>>>>> decided correctly.
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
> > >>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
> > >>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
> > >>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D.
> > >>>>>>>>>>>>>>>>>>>> C. Heath and Company. (317-320)
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> #include <stdint.h>
> > >>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> void P(ptr x)
> > >>>>>>>>>>>>>>>>>>>> {
> > >>>>>>>>>>>>>>>>>>>> if (H(x, x))
> > >>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> > >>>>>>>>>>>>>>>>>>>> return;
> > >>>>>>>>>>>>>>>>>>>> }
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> int main()
> > >>>>>>>>>>>>>>>>>>>> {
> > >>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> > >>>>>>>>>>>>>>>>>>>> }
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> _P()
> > >>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> > >>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> > >>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> > >>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> > >>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> > >>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> > >>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
> > >>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
> > >>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
> > >>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> > >>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> > >>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> > >>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> > >>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we
> > >>>>>>>>>>>>>>>>>>>> assume that H is only an x86 emulator that the
> > >>>>>>>>>>>>>>>>>>>> correctly emulated P never reaches its "ret"
> > >>>>>>>>>>>>>>>>>>>> instruction it remains stuck in repeated cycles
> > >>>>>>>>>>>>>>>>>>>> of emulation.
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has
> > >>>>>>>>>>>>>>>>>>>> been adapted to correctly detect (in a finite
> > >>>>>>>>>>>>>>>>>>>> number of steps) that the correct and complete
> > >>>>>>>>>>>>>>>>>>>> x86 emulation of its input would never each its
> > >>>>>>>>>>>>>>>>>>>> "ret" instruction that H could abort its
> > >>>>>>>>>>>>>>>>>>>> emulation and return 0 to report this.
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
> > >>>>>>>>>>>>>>>>>>>> correctly determining whether or not an x86
> > >>>>>>>>>>>>>>>>>>>> emulated input would ever reach its "ret"
> > >>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily verified
> > >>>>>>>>>>>>>>>>>>>> fact H(P,P) could correctly reject its input as
> > >>>>>>>>>>>>>>>>>>>> non-halting.
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all of
> > >>>>>>>>>>>>>>>>>>>> these things are true without any need
> > >>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or
> > >>>>>>>>>>>>>>>>>>>> the execution trace of H.
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether or
> > >>>>>>>>>>>>>>>>>>>> not an actual encoded H(P,P) does indeed
> > >>>>>>>>>>>>>>>>>>>> correctly determine that its input would never
> > >>>>>>>>>>>>>>>>>>>> reach its "ret" instruction as a pure function
> > >>>>>>>>>>>>>>>>>>>> of its inputs. This aspect will be confirmed by
> > >>>>>>>>>>>>>>>>>>>> fully operational source-code.
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
> > >>>>>>>>>>>>>>>>>>>> nested simulation (V5)
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> --
> > >>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> > >>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> > >>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
> > >>>>>>>>>>>>>>>>>>> cannot exist:
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
> > >>>>>>>>>>>>>>>>>> That is a misconception.
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from their
> > >>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis
> > >>>>>>>>>>>>>>>>>> of the actual behavior actually specified by
> > >>>>>>>>>>>>>>>>>> these inputs.
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct
> > >>>>>>>>>>>>>>>>>> and complete x86 emulation of the input to
> > >>>>>>>>>>>>>>>>>> H(P,P) by H would never reach its "ret"
> > >>>>>>>>>>>>>>>>>> instruction thus conclusively proving that it
> > >>>>>>>>>>>>>>>>>> never halts.
> > >>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
> > >>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
> > >>>>>>>>>>>>>>>>>>> (undecidable).
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> -----
> > >>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
> > >>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
> > >>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
> > >>>>>>>>>>>>>>>>>> --
> > >>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> > >>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> > >>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
> > >>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH to
> > >>>>>>>>>>>>>>>>> test/review.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> It took me six months to figure out how to
> > >>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
> > >>>>>>>>>>>>>>>> inputs. I did not release the code before because
> > >>>>>>>>>>>>>>>> I knew that its use of static local data would
> > >>>>>>>>>>>>>>>> have been rejected. With this update to H I will
> > >>>>>>>>>>>>>>>> be able to publish the code.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> H recognizes that P is calling itself with its same
> > >>>>>>>>>>>>>>>> arguments that it was called with and there are no
> > >>>>>>>>>>>>>>>> instructions preceding this call that could
> > >>>>>>>>>>>>>>>> possibly escape infinitely recursive emulation so
> > >>>>>>>>>>>>>>>> H aborts its emulation of P before P even makes
> > >>>>>>>>>>>>>>>> its first call to H.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Without even looking at the code competent software
> > >>>>>>>>>>>>>>>> engineers will be able to verify that the above H
> > >>>>>>>>>>>>>>>> would correctly determine that that is input is
> > >>>>>>>>>>>>>>>> non-halting as a pure function of this input.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> So my other reply for why your H is not a pure
> > >>>>>>>>>>>>>>> function for any accepted definition of the term.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> /Flibble
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> In computer programming, a pure function is a
> > >>>>>>>>>>>>>> function that has the following properties:
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> (1) the function return values are identical for
> > >>>>>>>>>>>>>> identical arguments (no variation with local static
> > >>>>>>>>>>>>>> variables, non-local variables, mutable reference
> > >>>>>>>>>>>>>> arguments or input streams), and
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> (2) the function application has no side effects (no
> > >>>>>>>>>>>>>> mutation of local static variables, non-local
> > >>>>>>>>>>>>>> variables, mutable reference arguments or
> > >>>>>>>>>>>>>> input/output streams).
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Thus a pure function is a computational analogue of a
> > >>>>>>>>>>>>>> mathematical function.
> > >>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> The revised H has no:
> > >>>>>>>>>>>>>> (a) local static variables
> > >>>>>>>>>>>>>> (b) non-local variables
> > >>>>>>>>>>>>>> (c) mutable reference arguments
> > >>>>>>>>>>>>>> (d) input streams
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> > >>>>>>>>>>>>> functions do not have side effects.
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> /Flibble
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> You have a reading comprehension problem.
> > >>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
> > >>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
> > >>>>>>>>>>>
> > >>>>>>>>>>> Not at all, but you do seem to have that problem.
> > >>>>>>>>>>>
> > >>>>>>>>>>> Again:
> > >>>>>>>>>>>
> > >>>>>>>>>>> Aborting the simulation is a side effect; pure functions
> > >>>>>>>>>>> do not have side effects.
> > >>>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>>> Whether or not it is construed as a side-effect does not
> > >>>>>>>>>> matter it must be a mutation side-effect to (a)(b)(c)(d)
> > >>>>>>>>>> or it does not count.
> > >>>>>>>>>
> > >>>>>>>>> It doesn't count according to who?
> > >>>>>>>>
> > >>>>>>>> The above definition of pure functions.
> > >>>>>>>
> > >>>>>>> "In computer science, an operation, function or expression
> > >>>>>>> is said to have a side effect if it modifies some state
> > >>>>>>> variable value(s) outside its local environment,
> > >>>>>>
> > >>>>>> The second part is an inaccurate paraphrase of the first
> > >>>>>> part.
> > >>>>>>> which is to say if it has any observable effect
> > >>>>>>> other than its primary effect of returning a value to the
> > >>>>>>> invoker of the operation." --
> > >>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
> > >>>>>>>
> > >>>>>>> "any observable effect"
> > >>>>>>>
> > >>>>>>> Aborting the simulation instead of returning a value to the
> > >>>>>>> invoker disqualifies it from being a pure function.
> > >>>>>>>
> > >>>>>>> /Flibble
> > >>>>>>>
> > >>>>>>
> > >>>>>> void P(ptr x)
> > >>>>>> {
> > >>>>>> if (H(x, x))
> > >>>>>> HERE: goto HERE;
> > >>>>>> return;
> > >>>>>> }
> > >>>>>>
> > >>>>>> int main()
> > >>>>>> {
> > >>>>>> Output("Input_Halts = ", H(P, P));
> > >>>>>> }
> > >>>>>>
> > >>>>>> _P()
> > >>>>>> [00001352](01) 55 push ebp
> > >>>>>> [00001353](02) 8bec mov ebp,esp
> > >>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> > >>>>>> [00001358](01) 50 push eax // push P
> > >>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> > >>>>>> [0000135c](01) 51 push ecx // push P
> > >>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> > >>>>>> [00001362](03) 83c408 add esp,+08
> > >>>>>> [00001365](02) 85c0 test eax,eax
> > >>>>>> [00001367](02) 7402 jz 0000136b
> > >>>>>> [00001369](02) ebfe jmp 00001369
> > >>>>>> [0000136b](01) 5d pop ebp
> > >>>>>> [0000136c](01) c3 ret
> > >>>>>> Size in bytes:(0027) [0000136c]
> > >>>>>>
> > >>>>>> H aborts its x86 emulation of P as soon P reaches its machine
> > >>>>>> address of [0000135d] the very first time before the code at
> > >>>>>> this address is emulated. Then H returns 0 to its caller:
> > >>>>>> main().
> > >>>>>
> > >>>>> Returning to main() is not returning to its invoker, P.
> > >>>>>
> > >>>>> Again:
> > >>>>>
> > >>>>> Aborting the simulation is a side effect; pure functions do
> > >>>>> not have side effects.
> > >>>>>
> > >>>>> /Flibble
> > >>>>>
> > >>>>
> > >>>> Do you have ADD?
> > >>>>
> > >>>> int main()
> > >>>> {
> > >>>> Output("Input_Halts = ", H(P, P));
> > >>>> }
> > >>>
> > >>> If your claim is that H is only called once and the second time
> > >>> an *attempt* to call H is prevented than that is equivalent to
> > >>> calling H and having H do something different with side effects.
> > >>> This is just my opinion though as it requires more thought and I
> > >>> am currently getting drunk on gin and tonics.
> > >>>
> > >>> /Flibble
> > >>>
> > >>
> > >> It is obviously the exact same pattern as infinite recursion
> > >> (a) calling the same function a second time with the same
> > >> arguments and
> > >>
> > >> (b) there are no instructions preceding this call that could
> > >> possibly escape the infinite recursion / infinitely recursive
> > >> emulation.
> > >
> > > Agree but refusing to analyse what P would have done if H wasn't a
> > > simulating decider still makes what you've got worthless as far as
> > > the Halting Problem is concerned.
> > >
> > > /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
> > >
> >
> > It is dead obvious to everyone (even Richard) that what P would
> > have done if H was merely an x86 emulator and not a halt deciding
> > emulator.
> >
> > The correct and complete x86 emulation of H(P,P) would never reach
> > its "ret" instruction thus making H a correct "not reach ret" / halt
> > decider for P.
>
> You need to think about a P that calls H but is non-pathological
> halting (no infinite loop).


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<20220617190826.000032b6@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx11.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Message-ID: <20220617190826.000032b6@reddwarf.jmc>
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
<20220617190451.00003626@reddwarf.jmc>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 371
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 17 Jun 2022 18:08:26 UTC
Date: Fri, 17 Jun 2022 19:08:26 +0100
X-Received-Bytes: 19803
 by: Mr Flibble - Fri, 17 Jun 2022 18:08 UTC

On Fri, 17 Jun 2022 19:04:51 +0100
Mr Flibble <flibble@reddwarf.jmc> wrote:

> On Fri, 17 Jun 2022 18:14:48 +0100
> Mr Flibble <flibble@reddwarf.jmc> wrote:
>
> > On Fri, 17 Jun 2022 12:13:13 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> > > On 6/17/2022 12:04 PM, Mr Flibble wrote:
> > > > On Fri, 17 Jun 2022 11:59:53 -0500
> > > > olcott <NoOne@NoWhere.com> wrote:
> > > >
> > > >> On 6/17/2022 11:51 AM, Mr Flibble wrote:
> > > >>> On Fri, 17 Jun 2022 11:38:29 -0500
> > > >>> olcott <NoOne@NoWhere.com> wrote:
> > > >>>
> > > >>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
> > > >>>>> On Fri, 17 Jun 2022 11:33:22 -0500
> > > >>>>> olcott <NoOne@NoWhere.com> wrote:
> > > >>>>>
> > > >>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
> > > >>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
> > > >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > > >>>>>>>
> > > >>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
> > > >>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
> > > >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > > >>>>>>>>>
> > > >>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
> > > >>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
> > > >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > > >>>>>>>>>>>
> > > >>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
> > > >>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
> > > >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > > >>>>>>>>>>>>>
> > > >>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
> > > >>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
> > > >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> > > >>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
> > > >>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8,
> > > >>>>>>>>>>>>>>>>> olcott wrote:
> > > >>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
> > > >>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
> > > >>>>>>>>>>>>>>>>>>> olcott wrote:
> > > >>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
> > > >>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
> > > >>>>>>>>>>>>>>>>>>>> detects that its correct and complete
> > > >>>>>>>>>>>>>>>>>>>> simulation of its input would never reach the
> > > >>>>>>>>>>>>>>>>>>>> final state of this input then all [these]
> > > >>>>>>>>>>>>>>>>>>>> inputs (including pathological inputs) are
> > > >>>>>>>>>>>>>>>>>>>> decided correctly.
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
> > > >>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
> > > >>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
> > > >>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D.
> > > >>>>>>>>>>>>>>>>>>>> C. Heath and Company. (317-320)
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> #include <stdint.h>
> > > >>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> void P(ptr x)
> > > >>>>>>>>>>>>>>>>>>>> {
> > > >>>>>>>>>>>>>>>>>>>> if (H(x, x))
> > > >>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> > > >>>>>>>>>>>>>>>>>>>> return;
> > > >>>>>>>>>>>>>>>>>>>> }
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> int main()
> > > >>>>>>>>>>>>>>>>>>>> {
> > > >>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> > > >>>>>>>>>>>>>>>>>>>> }
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> _P()
> > > >>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> > > >>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> > > >>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> > > >>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> > > >>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> > > >>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> > > >>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
> > > >>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
> > > >>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
> > > >>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> > > >>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> > > >>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> > > >>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> > > >>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when
> > > >>>>>>>>>>>>>>>>>>>> we assume that H is only an x86 emulator
> > > >>>>>>>>>>>>>>>>>>>> that the correctly emulated P never reaches
> > > >>>>>>>>>>>>>>>>>>>> its "ret" instruction it remains stuck in
> > > >>>>>>>>>>>>>>>>>>>> repeated cycles of emulation.
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H
> > > >>>>>>>>>>>>>>>>>>>> has been adapted to correctly detect (in a
> > > >>>>>>>>>>>>>>>>>>>> finite number of steps) that the correct and
> > > >>>>>>>>>>>>>>>>>>>> complete x86 emulation of its input would
> > > >>>>>>>>>>>>>>>>>>>> never each its "ret" instruction that H
> > > >>>>>>>>>>>>>>>>>>>> could abort its emulation and return 0 to
> > > >>>>>>>>>>>>>>>>>>>> report this.
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined
> > > >>>>>>>>>>>>>>>>>>>> as correctly determining whether or not an
> > > >>>>>>>>>>>>>>>>>>>> x86 emulated input would ever reach its "ret"
> > > >>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily
> > > >>>>>>>>>>>>>>>>>>>> verified fact H(P,P) could correctly reject
> > > >>>>>>>>>>>>>>>>>>>> its input as non-halting.
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all
> > > >>>>>>>>>>>>>>>>>>>> of these things are true without any need
> > > >>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or
> > > >>>>>>>>>>>>>>>>>>>> the execution trace of H.
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether
> > > >>>>>>>>>>>>>>>>>>>> or not an actual encoded H(P,P) does indeed
> > > >>>>>>>>>>>>>>>>>>>> correctly determine that its input would
> > > >>>>>>>>>>>>>>>>>>>> never reach its "ret" instruction as a pure
> > > >>>>>>>>>>>>>>>>>>>> function of its inputs. This aspect will be
> > > >>>>>>>>>>>>>>>>>>>> confirmed by fully operational source-code.
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
> > > >>>>>>>>>>>>>>>>>>>> nested simulation (V5)
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> --
> > > >>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> > > >>>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> > > >>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> > > >>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> > > >>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
> > > >>>>>>>>>>>>>>>>>>> cannot exist:
> > > >>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
> > > >>>>>>>>>>>>>>>>>> That is a misconception.
> > > >>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from
> > > >>>>>>>>>>>>>>>>>> their inputs to an accept or reject state on
> > > >>>>>>>>>>>>>>>>>> the basis of the actual behavior actually
> > > >>>>>>>>>>>>>>>>>> specified by these inputs.
> > > >>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct
> > > >>>>>>>>>>>>>>>>>> and complete x86 emulation of the input to
> > > >>>>>>>>>>>>>>>>>> H(P,P) by H would never reach its "ret"
> > > >>>>>>>>>>>>>>>>>> instruction thus conclusively proving that it
> > > >>>>>>>>>>>>>>>>>> never halts.
> > > >>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
> > > >>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
> > > >>>>>>>>>>>>>>>>>>> (undecidable).
> > > >>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>> -----
> > > >>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
> > > >>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
> > > >>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
> > > >>>>>>>>>>>>>>>>>> --
> > > >>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> > > >>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> > > >>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> > > >>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> > > >>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
> > > >>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH to
> > > >>>>>>>>>>>>>>>>> test/review.
> > > >>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>> It took me six months to figure out how to
> > > >>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
> > > >>>>>>>>>>>>>>>> inputs. I did not release the code before because
> > > >>>>>>>>>>>>>>>> I knew that its use of static local data would
> > > >>>>>>>>>>>>>>>> have been rejected. With this update to H I will
> > > >>>>>>>>>>>>>>>> be able to publish the code.
> > > >>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>> H recognizes that P is calling itself with its
> > > >>>>>>>>>>>>>>>> same arguments that it was called with and there
> > > >>>>>>>>>>>>>>>> are no instructions preceding this call that
> > > >>>>>>>>>>>>>>>> could possibly escape infinitely recursive
> > > >>>>>>>>>>>>>>>> emulation so H aborts its emulation of P before
> > > >>>>>>>>>>>>>>>> P even makes its first call to H.
> > > >>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>> Without even looking at the code competent
> > > >>>>>>>>>>>>>>>> software engineers will be able to verify that
> > > >>>>>>>>>>>>>>>> the above H would correctly determine that that
> > > >>>>>>>>>>>>>>>> is input is non-halting as a pure function of
> > > >>>>>>>>>>>>>>>> this input.
> > > >>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>> So my other reply for why your H is not a pure
> > > >>>>>>>>>>>>>>> function for any accepted definition of the term.
> > > >>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>> /Flibble
> > > >>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>> In computer programming, a pure function is a
> > > >>>>>>>>>>>>>> function that has the following properties:
> > > >>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>> (1) the function return values are identical for
> > > >>>>>>>>>>>>>> identical arguments (no variation with local static
> > > >>>>>>>>>>>>>> variables, non-local variables, mutable reference
> > > >>>>>>>>>>>>>> arguments or input streams), and
> > > >>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>> (2) the function application has no side effects
> > > >>>>>>>>>>>>>> (no mutation of local static variables, non-local
> > > >>>>>>>>>>>>>> variables, mutable reference arguments or
> > > >>>>>>>>>>>>>> input/output streams).
> > > >>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>> Thus a pure function is a computational analogue
> > > >>>>>>>>>>>>>> of a mathematical function.
> > > >>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> > > >>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>> The revised H has no:
> > > >>>>>>>>>>>>>> (a) local static variables
> > > >>>>>>>>>>>>>> (b) non-local variables
> > > >>>>>>>>>>>>>> (c) mutable reference arguments
> > > >>>>>>>>>>>>>> (d) input streams
> > > >>>>>>>>>>>>>
> > > >>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> > > >>>>>>>>>>>>> functions do not have side effects.
> > > >>>>>>>>>>>>>
> > > >>>>>>>>>>>>> /Flibble
> > > >>>>>>>>>>>>
> > > >>>>>>>>>>>> You have a reading comprehension problem.
> > > >>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
> > > >>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
> > > >>>>>>>>>>>
> > > >>>>>>>>>>> Not at all, but you do seem to have that problem.
> > > >>>>>>>>>>>
> > > >>>>>>>>>>> Again:
> > > >>>>>>>>>>>
> > > >>>>>>>>>>> Aborting the simulation is a side effect; pure
> > > >>>>>>>>>>> functions do not have side effects.
> > > >>>>>>>>>>>
> > > >>>>>>>>>>
> > > >>>>>>>>>> Whether or not it is construed as a side-effect does
> > > >>>>>>>>>> not matter it must be a mutation side-effect to
> > > >>>>>>>>>> (a)(b)(c)(d) or it does not count.
> > > >>>>>>>>>
> > > >>>>>>>>> It doesn't count according to who?
> > > >>>>>>>>
> > > >>>>>>>> The above definition of pure functions.
> > > >>>>>>>
> > > >>>>>>> "In computer science, an operation, function or expression
> > > >>>>>>> is said to have a side effect if it modifies some state
> > > >>>>>>> variable value(s) outside its local environment,
> > > >>>>>>
> > > >>>>>> The second part is an inaccurate paraphrase of the first
> > > >>>>>> part.
> > > >>>>>>> which is to say if it has any observable effect
> > > >>>>>>> other than its primary effect of returning a value to the
> > > >>>>>>> invoker of the operation." --
> > > >>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
> > > >>>>>>>
> > > >>>>>>> "any observable effect"
> > > >>>>>>>
> > > >>>>>>> Aborting the simulation instead of returning a value to
> > > >>>>>>> the invoker disqualifies it from being a pure function.
> > > >>>>>>>
> > > >>>>>>> /Flibble
> > > >>>>>>>
> > > >>>>>>
> > > >>>>>> void P(ptr x)
> > > >>>>>> {
> > > >>>>>> if (H(x, x))
> > > >>>>>> HERE: goto HERE;
> > > >>>>>> return;
> > > >>>>>> }
> > > >>>>>>
> > > >>>>>> int main()
> > > >>>>>> {
> > > >>>>>> Output("Input_Halts = ", H(P, P));
> > > >>>>>> }
> > > >>>>>>
> > > >>>>>> _P()
> > > >>>>>> [00001352](01) 55 push ebp
> > > >>>>>> [00001353](02) 8bec mov ebp,esp
> > > >>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> > > >>>>>> [00001358](01) 50 push eax // push P
> > > >>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> > > >>>>>> [0000135c](01) 51 push ecx // push P
> > > >>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> > > >>>>>> [00001362](03) 83c408 add esp,+08
> > > >>>>>> [00001365](02) 85c0 test eax,eax
> > > >>>>>> [00001367](02) 7402 jz 0000136b
> > > >>>>>> [00001369](02) ebfe jmp 00001369
> > > >>>>>> [0000136b](01) 5d pop ebp
> > > >>>>>> [0000136c](01) c3 ret
> > > >>>>>> Size in bytes:(0027) [0000136c]
> > > >>>>>>
> > > >>>>>> H aborts its x86 emulation of P as soon P reaches its
> > > >>>>>> machine address of [0000135d] the very first time before
> > > >>>>>> the code at this address is emulated. Then H returns 0 to
> > > >>>>>> its caller: main().
> > > >>>>>
> > > >>>>> Returning to main() is not returning to its invoker, P.
> > > >>>>>
> > > >>>>> Again:
> > > >>>>>
> > > >>>>> Aborting the simulation is a side effect; pure functions do
> > > >>>>> not have side effects.
> > > >>>>>
> > > >>>>> /Flibble
> > > >>>>>
> > > >>>>
> > > >>>> Do you have ADD?
> > > >>>>
> > > >>>> int main()
> > > >>>> {
> > > >>>> Output("Input_Halts = ", H(P, P));
> > > >>>> }
> > > >>>
> > > >>> If your claim is that H is only called once and the second
> > > >>> time an *attempt* to call H is prevented than that is
> > > >>> equivalent to calling H and having H do something different
> > > >>> with side effects. This is just my opinion though as it
> > > >>> requires more thought and I am currently getting drunk on gin
> > > >>> and tonics.
> > > >>>
> > > >>> /Flibble
> > > >>>
> > > >>
> > > >> It is obviously the exact same pattern as infinite recursion
> > > >> (a) calling the same function a second time with the same
> > > >> arguments and
> > > >>
> > > >> (b) there are no instructions preceding this call that could
> > > >> possibly escape the infinite recursion / infinitely recursive
> > > >> emulation.
> > > >
> > > > Agree but refusing to analyse what P would have done if H
> > > > wasn't a simulating decider still makes what you've got
> > > > worthless as far as the Halting Problem is concerned.
> > > >
> > > > /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
> > > >
> > >
> > > It is dead obvious to everyone (even Richard) that what P would
> > > have done if H was merely an x86 emulator and not a halt deciding
> > > emulator.
> > >
> > > The correct and complete x86 emulation of H(P,P) would never reach
> > > its "ret" instruction thus making H a correct "not reach ret" /
> > > halt decider for P.
> >
> > You need to think about a P that calls H but is non-pathological
> > halting (no infinite loop).
>
> Your assumption that any program that calls H is also pathological is
> a flawed one. I have said before that all you have is a simulation
> detector and not a halt decider: simulating halt deciders cannot
> decide non-pathological non-halting programs in finite time so are not
> actually deciders.


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 13:42:06 -0500
Date: Fri, 17 Jun 2022 13:42:05 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220617181448.00005cdb@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 372
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-6MW5wps8SQu8+vKsrXjAs2agqDM3zz2uo2xFn72IQ6G6mu+R3gr5VMTMGgys2cZcoON5wAR7oVp+Dra!j822/EMs3+u6WQOhaQZF+5xceGvYDEsl4oWkGEY6xDZ1mfBrq3rAIPeSDS+z8qnVS4nARD+rzLer
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
X-Original-Bytes: 18297
 by: olcott - Fri, 17 Jun 2022 18:42 UTC

On 6/17/2022 12:14 PM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 12:13:13 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
>>> On Fri, 17 Jun 2022 11:59:53 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8, olcott
>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all inputs
>>>>>>>>>>>>>>>>>>>>>> as non-halting whenever it correctly detects that
>>>>>>>>>>>>>>>>>>>>>> its correct and complete simulation of its input
>>>>>>>>>>>>>>>>>>>>>> would never reach the final state of this input
>>>>>>>>>>>>>>>>>>>>>> then all [these] inputs (including pathological
>>>>>>>>>>>>>>>>>>>>>> inputs) are decided correctly.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
>>>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D. C.
>>>>>>>>>>>>>>>>>>>>>> Heath and Company. (317-320)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we
>>>>>>>>>>>>>>>>>>>>>> assume that H is only an x86 emulator that the
>>>>>>>>>>>>>>>>>>>>>> correctly emulated P never reaches its "ret"
>>>>>>>>>>>>>>>>>>>>>> instruction it remains stuck in repeated cycles
>>>>>>>>>>>>>>>>>>>>>> of emulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has
>>>>>>>>>>>>>>>>>>>>>> been adapted to correctly detect (in a finite
>>>>>>>>>>>>>>>>>>>>>> number of steps) that the correct and complete
>>>>>>>>>>>>>>>>>>>>>> x86 emulation of its input would never each its
>>>>>>>>>>>>>>>>>>>>>> "ret" instruction that H could abort its
>>>>>>>>>>>>>>>>>>>>>> emulation and return 0 to report this.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
>>>>>>>>>>>>>>>>>>>>>> correctly determining whether or not an x86
>>>>>>>>>>>>>>>>>>>>>> emulated input would ever reach its "ret"
>>>>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily verified
>>>>>>>>>>>>>>>>>>>>>> fact H(P,P) could correctly reject its input as
>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all of
>>>>>>>>>>>>>>>>>>>>>> these things are true without any need
>>>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or the
>>>>>>>>>>>>>>>>>>>>>> execution trace of H.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether or
>>>>>>>>>>>>>>>>>>>>>> not an actual encoded H(P,P) does indeed
>>>>>>>>>>>>>>>>>>>>>> correctly determine that its input would never
>>>>>>>>>>>>>>>>>>>>>> reach its "ret" instruction as a pure function
>>>>>>>>>>>>>>>>>>>>>> of its inputs. This aspect will be confirmed by
>>>>>>>>>>>>>>>>>>>>>> fully operational source-code.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>> nested simulation (V5)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
>>>>>>>>>>>>>>>>>>>>> cannot exist:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from their
>>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis of
>>>>>>>>>>>>>>>>>>>> the actual behavior actually specified by these
>>>>>>>>>>>>>>>>>>>> inputs.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct and
>>>>>>>>>>>>>>>>>>>> complete x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>>>>>> would never reach its "ret" instruction thus
>>>>>>>>>>>>>>>>>>>> conclusively proving that it never halts.
>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
>>>>>>>>>>>>>>>>>>>>> (undecidable).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in 10000-years
>>>>>>>>>>>>>>>>>>>>> cannot refute my GUR. ...
>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You just
>>>>>>>>>>>>>>>>>>> confirms it by not able to provide POOH to
>>>>>>>>>>>>>>>>>>> test/review.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It took me six months to figure out how to transform
>>>>>>>>>>>>>>>>>> H(P,P) into a pure function of its inputs. I did not
>>>>>>>>>>>>>>>>>> release the code before because I knew that its use
>>>>>>>>>>>>>>>>>> of static local data would have been rejected. With
>>>>>>>>>>>>>>>>>> this update to H I will be able to publish the code.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its same
>>>>>>>>>>>>>>>>>> arguments that it was called with and there are no
>>>>>>>>>>>>>>>>>> instructions preceding this call that could possibly
>>>>>>>>>>>>>>>>>> escape infinitely recursive emulation so H aborts its
>>>>>>>>>>>>>>>>>> emulation of P before P even makes its first call to
>>>>>>>>>>>>>>>>>> H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Without even looking at the code competent software
>>>>>>>>>>>>>>>>>> engineers will be able to verify that the above H
>>>>>>>>>>>>>>>>>> would correctly determine that that is input is
>>>>>>>>>>>>>>>>>> non-halting as a pure function of this input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
>>>>>>>>>>>>>>>>> function for any accepted definition of the term.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In computer programming, a pure function is a function
>>>>>>>>>>>>>>>> that has the following properties:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (1) the function return values are identical for
>>>>>>>>>>>>>>>> identical arguments (no variation with local static
>>>>>>>>>>>>>>>> variables, non-local variables, mutable reference
>>>>>>>>>>>>>>>> arguments or input streams), and
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (2) the function application has no side effects (no
>>>>>>>>>>>>>>>> mutation of local static variables, non-local
>>>>>>>>>>>>>>>> variables, mutable reference arguments or input/output
>>>>>>>>>>>>>>>> streams).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus a pure function is a computational analogue of a
>>>>>>>>>>>>>>>> mathematical function.
>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure functions
>>>>>>>>>>>>>>> do not have side effects.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Aborting the simulation is a side effect; pure functions
>>>>>>>>>>>>> do not have side effects.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Whether or not it is construed as a side-effect does not
>>>>>>>>>>>> matter it must be a mutation side-effect to (a)(b)(c)(d) or
>>>>>>>>>>>> it does not count.
>>>>>>>>>>>
>>>>>>>>>>> It doesn't count according to who?
>>>>>>>>>>
>>>>>>>>>> The above definition of pure functions.
>>>>>>>>>
>>>>>>>>> "In computer science, an operation, function or expression is
>>>>>>>>> said to have a side effect if it modifies some state variable
>>>>>>>>> value(s) outside its local environment,
>>>>>>>>
>>>>>>>> The second part is an inaccurate paraphrase of the first part.
>>>>>>>>
>>>>>>>>> which is to say if it has any observable effect
>>>>>>>>> other than its primary effect of returning a value to the
>>>>>>>>> invoker of the operation." --
>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>>>>>
>>>>>>>>> "any observable effect"
>>>>>>>>>
>>>>>>>>> Aborting the simulation instead of returning a value to the
>>>>>>>>> invoker disqualifies it from being a pure function.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>> if (H(x, x))
>>>>>>>> HERE: goto HERE;
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>> }
>>>>>>>>
>>>>>>>> _P()
>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>> [0000136c](01) c3 ret
>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>
>>>>>>>> H aborts its x86 emulation of P as soon P reaches its machine
>>>>>>>> address of [0000135d] the very first time before the code at
>>>>>>>> this address is emulated. Then H returns 0 to its caller:
>>>>>>>> main().
>>>>>>>
>>>>>>> Returning to main() is not returning to its invoker, P.
>>>>>>>
>>>>>>> Again:
>>>>>>>
>>>>>>> Aborting the simulation is a side effect; pure functions do not
>>>>>>> have side effects.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Do you have ADD?
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>> }
>>>>>
>>>>> If your claim is that H is only called once and the second time an
>>>>> *attempt* to call H is prevented than that is equivalent to
>>>>> calling H and having H do something different with side effects.
>>>>> This is just my opinion though as it requires more thought and I
>>>>> am currently getting drunk on gin and tonics.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> It is obviously the exact same pattern as infinite recursion
>>>> (a) calling the same function a second time with the same arguments
>>>> and
>>>>
>>>> (b) there are no instructions preceding this call that could
>>>> possibly escape the infinite recursion / infinitely recursive
>>>> emulation.
>>>
>>> Agree but refusing to analyse what P would have done if H wasn't a
>>> simulating decider still makes what you've got worthless as far as
>>> the Halting Problem is concerned.
>>>
>>> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
>>>
>>
>> It is dead obvious to everyone (even Richard) that what P would have
>> done if H was merely an x86 emulator and not a halt deciding emulator.
>>
>> The correct and complete x86 emulation of H(P,P) would never reach
>> its "ret" instruction thus making H a correct "not reach ret" / halt
>> decider for P.
>
> You need to think about a P that calls H but is non-pathological halting
> (no infinite loop).
>
> /Flibble
>


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<QY2dnTo8IPAuVjH_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 13:45:07 -0500
Date: Fri, 17 Jun 2022 13:45:06 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc> <20220617190451.00003626@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220617190451.00003626@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <QY2dnTo8IPAuVjH_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 373
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-bBUbgdgQ3HwFFpRd4SuDBmN2zzhzicrYorUdPFHYWU8LTaKKhQXo1Kf9hIzjnmuMJLx9wwME5YM1Hw8!/GwBVmR6ZzrxfcHn8wfx/8DQ+GZADQoWCY26BEFlIDYRCkrZRl8wtH3yoH2iv57hsJVqMQ0ceS/B
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
X-Original-Bytes: 19023
 by: olcott - Fri, 17 Jun 2022 18:45 UTC

On 6/17/2022 1:04 PM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 18:14:48 +0100
> Mr Flibble <flibble@reddwarf.jmc> wrote:
>
>> On Fri, 17 Jun 2022 12:13:13 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
>>>> On Fri, 17 Jun 2022 11:59:53 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>
>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>
>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>
>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
>>>>>>>>>>>>>>>>>>>>>>> detects that its correct and complete
>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach the
>>>>>>>>>>>>>>>>>>>>>>> final state of this input then all [these]
>>>>>>>>>>>>>>>>>>>>>>> inputs (including pathological inputs) are
>>>>>>>>>>>>>>>>>>>>>>> decided correctly.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
>>>>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D.
>>>>>>>>>>>>>>>>>>>>>>> C. Heath and Company. (317-320)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we
>>>>>>>>>>>>>>>>>>>>>>> assume that H is only an x86 emulator that the
>>>>>>>>>>>>>>>>>>>>>>> correctly emulated P never reaches its "ret"
>>>>>>>>>>>>>>>>>>>>>>> instruction it remains stuck in repeated cycles
>>>>>>>>>>>>>>>>>>>>>>> of emulation.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has
>>>>>>>>>>>>>>>>>>>>>>> been adapted to correctly detect (in a finite
>>>>>>>>>>>>>>>>>>>>>>> number of steps) that the correct and complete
>>>>>>>>>>>>>>>>>>>>>>> x86 emulation of its input would never each its
>>>>>>>>>>>>>>>>>>>>>>> "ret" instruction that H could abort its
>>>>>>>>>>>>>>>>>>>>>>> emulation and return 0 to report this.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
>>>>>>>>>>>>>>>>>>>>>>> correctly determining whether or not an x86
>>>>>>>>>>>>>>>>>>>>>>> emulated input would ever reach its "ret"
>>>>>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily verified
>>>>>>>>>>>>>>>>>>>>>>> fact H(P,P) could correctly reject its input as
>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all of
>>>>>>>>>>>>>>>>>>>>>>> these things are true without any need
>>>>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or
>>>>>>>>>>>>>>>>>>>>>>> the execution trace of H.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether or
>>>>>>>>>>>>>>>>>>>>>>> not an actual encoded H(P,P) does indeed
>>>>>>>>>>>>>>>>>>>>>>> correctly determine that its input would never
>>>>>>>>>>>>>>>>>>>>>>> reach its "ret" instruction as a pure function
>>>>>>>>>>>>>>>>>>>>>>> of its inputs. This aspect will be confirmed by
>>>>>>>>>>>>>>>>>>>>>>> fully operational source-code.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V5)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
>>>>>>>>>>>>>>>>>>>>>> cannot exist:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from their
>>>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis
>>>>>>>>>>>>>>>>>>>>> of the actual behavior actually specified by
>>>>>>>>>>>>>>>>>>>>> these inputs.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct
>>>>>>>>>>>>>>>>>>>>> and complete x86 emulation of the input to
>>>>>>>>>>>>>>>>>>>>> H(P,P) by H would never reach its "ret"
>>>>>>>>>>>>>>>>>>>>> instruction thus conclusively proving that it
>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
>>>>>>>>>>>>>>>>>>>>>> (undecidable).
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
>>>>>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH to
>>>>>>>>>>>>>>>>>>>> test/review.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
>>>>>>>>>>>>>>>>>>> inputs. I did not release the code before because
>>>>>>>>>>>>>>>>>>> I knew that its use of static local data would
>>>>>>>>>>>>>>>>>>> have been rejected. With this update to H I will
>>>>>>>>>>>>>>>>>>> be able to publish the code.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its same
>>>>>>>>>>>>>>>>>>> arguments that it was called with and there are no
>>>>>>>>>>>>>>>>>>> instructions preceding this call that could
>>>>>>>>>>>>>>>>>>> possibly escape infinitely recursive emulation so
>>>>>>>>>>>>>>>>>>> H aborts its emulation of P before P even makes
>>>>>>>>>>>>>>>>>>> its first call to H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Without even looking at the code competent software
>>>>>>>>>>>>>>>>>>> engineers will be able to verify that the above H
>>>>>>>>>>>>>>>>>>> would correctly determine that that is input is
>>>>>>>>>>>>>>>>>>> non-halting as a pure function of this input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
>>>>>>>>>>>>>>>>>> function for any accepted definition of the term.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
>>>>>>>>>>>>>>>>> function that has the following properties:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (1) the function return values are identical for
>>>>>>>>>>>>>>>>> identical arguments (no variation with local static
>>>>>>>>>>>>>>>>> variables, non-local variables, mutable reference
>>>>>>>>>>>>>>>>> arguments or input streams), and
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (2) the function application has no side effects (no
>>>>>>>>>>>>>>>>> mutation of local static variables, non-local
>>>>>>>>>>>>>>>>> variables, mutable reference arguments or
>>>>>>>>>>>>>>>>> input/output streams).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus a pure function is a computational analogue of a
>>>>>>>>>>>>>>>>> mathematical function.
>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure functions
>>>>>>>>>>>>>> do not have side effects.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Whether or not it is construed as a side-effect does not
>>>>>>>>>>>>> matter it must be a mutation side-effect to (a)(b)(c)(d)
>>>>>>>>>>>>> or it does not count.
>>>>>>>>>>>>
>>>>>>>>>>>> It doesn't count according to who?
>>>>>>>>>>>
>>>>>>>>>>> The above definition of pure functions.
>>>>>>>>>>
>>>>>>>>>> "In computer science, an operation, function or expression
>>>>>>>>>> is said to have a side effect if it modifies some state
>>>>>>>>>> variable value(s) outside its local environment,
>>>>>>>>>
>>>>>>>>> The second part is an inaccurate paraphrase of the first
>>>>>>>>> part.
>>>>>>>>>> which is to say if it has any observable effect
>>>>>>>>>> other than its primary effect of returning a value to the
>>>>>>>>>> invoker of the operation." --
>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>>>>>>
>>>>>>>>>> "any observable effect"
>>>>>>>>>>
>>>>>>>>>> Aborting the simulation instead of returning a value to the
>>>>>>>>>> invoker disqualifies it from being a pure function.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> void P(ptr x)
>>>>>>>>> {
>>>>>>>>> if (H(x, x))
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>
>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its machine
>>>>>>>>> address of [0000135d] the very first time before the code at
>>>>>>>>> this address is emulated. Then H returns 0 to its caller:
>>>>>>>>> main().
>>>>>>>>
>>>>>>>> Returning to main() is not returning to its invoker, P.
>>>>>>>>
>>>>>>>> Again:
>>>>>>>>
>>>>>>>> Aborting the simulation is a side effect; pure functions do
>>>>>>>> not have side effects.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> Do you have ADD?
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>> }
>>>>>>
>>>>>> If your claim is that H is only called once and the second time
>>>>>> an *attempt* to call H is prevented than that is equivalent to
>>>>>> calling H and having H do something different with side effects.
>>>>>> This is just my opinion though as it requires more thought and I
>>>>>> am currently getting drunk on gin and tonics.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> It is obviously the exact same pattern as infinite recursion
>>>>> (a) calling the same function a second time with the same
>>>>> arguments and
>>>>>
>>>>> (b) there are no instructions preceding this call that could
>>>>> possibly escape the infinite recursion / infinitely recursive
>>>>> emulation.
>>>>
>>>> Agree but refusing to analyse what P would have done if H wasn't a
>>>> simulating decider still makes what you've got worthless as far as
>>>> the Halting Problem is concerned.
>>>>
>>>> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
>>>>
>>>
>>> It is dead obvious to everyone (even Richard) that what P would
>>> have done if H was merely an x86 emulator and not a halt deciding
>>> emulator.
>>>
>>> The correct and complete x86 emulation of H(P,P) would never reach
>>> its "ret" instruction thus making H a correct "not reach ret" / halt
>>> decider for P.
>>
>> You need to think about a P that calls H but is non-pathological
>> halting (no infinite loop).
>
> Your assumption that any program that calls H is also pathological is


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<20220617194532.00006384@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.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 (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Message-ID: <20220617194532.00006384@reddwarf.jmc>
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
<spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 387
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 17 Jun 2022 18:45:33 UTC
Date: Fri, 17 Jun 2022 19:45:32 +0100
X-Received-Bytes: 18949
 by: Mr Flibble - Fri, 17 Jun 2022 18:45 UTC

On Fri, 17 Jun 2022 13:42:05 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/17/2022 12:14 PM, Mr Flibble wrote:
> > On Fri, 17 Jun 2022 12:13:13 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/17/2022 12:04 PM, Mr Flibble wrote:
> >>> On Fri, 17 Jun 2022 11:59:53 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
> >>>>> On Fri, 17 Jun 2022 11:38:29 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
> >>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
> >>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
> >>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
> >>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
> >>>>>>>>>>>>>>>>>>>>>> detects that its correct and complete
> >>>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach the
> >>>>>>>>>>>>>>>>>>>>>> final state of this input then all [these]
> >>>>>>>>>>>>>>>>>>>>>> inputs (including pathological inputs) are
> >>>>>>>>>>>>>>>>>>>>>> decided correctly.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
> >>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
> >>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
> >>>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D.
> >>>>>>>>>>>>>>>>>>>>>> C. Heath and Company. (317-320)
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
> >>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
> >>>>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we
> >>>>>>>>>>>>>>>>>>>>>> assume that H is only an x86 emulator that the
> >>>>>>>>>>>>>>>>>>>>>> correctly emulated P never reaches its "ret"
> >>>>>>>>>>>>>>>>>>>>>> instruction it remains stuck in repeated cycles
> >>>>>>>>>>>>>>>>>>>>>> of emulation.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has
> >>>>>>>>>>>>>>>>>>>>>> been adapted to correctly detect (in a finite
> >>>>>>>>>>>>>>>>>>>>>> number of steps) that the correct and complete
> >>>>>>>>>>>>>>>>>>>>>> x86 emulation of its input would never each its
> >>>>>>>>>>>>>>>>>>>>>> "ret" instruction that H could abort its
> >>>>>>>>>>>>>>>>>>>>>> emulation and return 0 to report this.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
> >>>>>>>>>>>>>>>>>>>>>> correctly determining whether or not an x86
> >>>>>>>>>>>>>>>>>>>>>> emulated input would ever reach its "ret"
> >>>>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily verified
> >>>>>>>>>>>>>>>>>>>>>> fact H(P,P) could correctly reject its input as
> >>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all of
> >>>>>>>>>>>>>>>>>>>>>> these things are true without any need
> >>>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or
> >>>>>>>>>>>>>>>>>>>>>> the execution trace of H.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether or
> >>>>>>>>>>>>>>>>>>>>>> not an actual encoded H(P,P) does indeed
> >>>>>>>>>>>>>>>>>>>>>> correctly determine that its input would never
> >>>>>>>>>>>>>>>>>>>>>> reach its "ret" instruction as a pure function
> >>>>>>>>>>>>>>>>>>>>>> of its inputs. This aspect will be confirmed by
> >>>>>>>>>>>>>>>>>>>>>> fully operational source-code.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
> >>>>>>>>>>>>>>>>>>>>>> nested simulation (V5)
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
> >>>>>>>>>>>>>>>>>>>>> cannot exist:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
> >>>>>>>>>>>>>>>>>>>> That is a misconception.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from their
> >>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis
> >>>>>>>>>>>>>>>>>>>> of the actual behavior actually specified by
> >>>>>>>>>>>>>>>>>>>> these inputs.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct
> >>>>>>>>>>>>>>>>>>>> and complete x86 emulation of the input to
> >>>>>>>>>>>>>>>>>>>> H(P,P) by H would never reach its "ret"
> >>>>>>>>>>>>>>>>>>>> instruction thus conclusively proving that it
> >>>>>>>>>>>>>>>>>>>> never halts.
> >>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
> >>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
> >>>>>>>>>>>>>>>>>>>>> (undecidable).
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> -----
> >>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
> >>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
> >>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
> >>>>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
> >>>>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH to
> >>>>>>>>>>>>>>>>>>> test/review.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> It took me six months to figure out how to
> >>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
> >>>>>>>>>>>>>>>>>> inputs. I did not release the code before because
> >>>>>>>>>>>>>>>>>> I knew that its use of static local data would
> >>>>>>>>>>>>>>>>>> have been rejected. With this update to H I will
> >>>>>>>>>>>>>>>>>> be able to publish the code.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its same
> >>>>>>>>>>>>>>>>>> arguments that it was called with and there are no
> >>>>>>>>>>>>>>>>>> instructions preceding this call that could
> >>>>>>>>>>>>>>>>>> possibly escape infinitely recursive emulation so
> >>>>>>>>>>>>>>>>>> H aborts its emulation of P before P even makes
> >>>>>>>>>>>>>>>>>> its first call to H.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Without even looking at the code competent software
> >>>>>>>>>>>>>>>>>> engineers will be able to verify that the above H
> >>>>>>>>>>>>>>>>>> would correctly determine that that is input is
> >>>>>>>>>>>>>>>>>> non-halting as a pure function of this input.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
> >>>>>>>>>>>>>>>>> function for any accepted definition of the term.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> In computer programming, a pure function is a
> >>>>>>>>>>>>>>>> function that has the following properties:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (1) the function return values are identical for
> >>>>>>>>>>>>>>>> identical arguments (no variation with local static
> >>>>>>>>>>>>>>>> variables, non-local variables, mutable reference
> >>>>>>>>>>>>>>>> arguments or input streams), and
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> (2) the function application has no side effects (no
> >>>>>>>>>>>>>>>> mutation of local static variables, non-local
> >>>>>>>>>>>>>>>> variables, mutable reference arguments or
> >>>>>>>>>>>>>>>> input/output streams).
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Thus a pure function is a computational analogue of a
> >>>>>>>>>>>>>>>> mathematical function.
> >>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> The revised H has no:
> >>>>>>>>>>>>>>>> (a) local static variables
> >>>>>>>>>>>>>>>> (b) non-local variables
> >>>>>>>>>>>>>>>> (c) mutable reference arguments
> >>>>>>>>>>>>>>>> (d) input streams
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> >>>>>>>>>>>>>>> functions do not have side effects.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> You have a reading comprehension problem.
> >>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
> >>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Not at all, but you do seem to have that problem.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Again:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Aborting the simulation is a side effect; pure functions
> >>>>>>>>>>>>> do not have side effects.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Whether or not it is construed as a side-effect does not
> >>>>>>>>>>>> matter it must be a mutation side-effect to (a)(b)(c)(d)
> >>>>>>>>>>>> or it does not count.
> >>>>>>>>>>>
> >>>>>>>>>>> It doesn't count according to who?
> >>>>>>>>>>
> >>>>>>>>>> The above definition of pure functions.
> >>>>>>>>>
> >>>>>>>>> "In computer science, an operation, function or expression
> >>>>>>>>> is said to have a side effect if it modifies some state
> >>>>>>>>> variable value(s) outside its local environment,
> >>>>>>>>
> >>>>>>>> The second part is an inaccurate paraphrase of the first
> >>>>>>>> part.
> >>>>>>>>> which is to say if it has any observable effect
> >>>>>>>>> other than its primary effect of returning a value to the
> >>>>>>>>> invoker of the operation." --
> >>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
> >>>>>>>>>
> >>>>>>>>> "any observable effect"
> >>>>>>>>>
> >>>>>>>>> Aborting the simulation instead of returning a value to the
> >>>>>>>>> invoker disqualifies it from being a pure function.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> void P(ptr x)
> >>>>>>>> {
> >>>>>>>> if (H(x, x))
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> return;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> _P()
> >>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>>>>>> [00001362](03) 83c408 add esp,+08
> >>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>> [0000136c](01) c3 ret
> >>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>
> >>>>>>>> H aborts its x86 emulation of P as soon P reaches its machine
> >>>>>>>> address of [0000135d] the very first time before the code at
> >>>>>>>> this address is emulated. Then H returns 0 to its caller:
> >>>>>>>> main().
> >>>>>>>
> >>>>>>> Returning to main() is not returning to its invoker, P.
> >>>>>>>
> >>>>>>> Again:
> >>>>>>>
> >>>>>>> Aborting the simulation is a side effect; pure functions do
> >>>>>>> not have side effects.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> Do you have ADD?
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>> }
> >>>>>
> >>>>> If your claim is that H is only called once and the second time
> >>>>> an *attempt* to call H is prevented than that is equivalent to
> >>>>> calling H and having H do something different with side effects.
> >>>>> This is just my opinion though as it requires more thought and I
> >>>>> am currently getting drunk on gin and tonics.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> It is obviously the exact same pattern as infinite recursion
> >>>> (a) calling the same function a second time with the same
> >>>> arguments and
> >>>>
> >>>> (b) there are no instructions preceding this call that could
> >>>> possibly escape the infinite recursion / infinitely recursive
> >>>> emulation.
> >>>
> >>> Agree but refusing to analyse what P would have done if H wasn't a
> >>> simulating decider still makes what you've got worthless as far as
> >>> the Halting Problem is concerned.
> >>>
> >>> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
> >>>
> >>
> >> It is dead obvious to everyone (even Richard) that what P would
> >> have done if H was merely an x86 emulator and not a halt deciding
> >> emulator.
> >>
> >> The correct and complete x86 emulation of H(P,P) would never reach
> >> its "ret" instruction thus making H a correct "not reach ret" /
> >> halt decider for P.
> >
> > You need to think about a P that calls H but is non-pathological
> > halting (no infinite loop).
> >
> > /Flibble
> >
>
> I have already done that and posted all of the details here about
> three dozen times.
>
> void P(ptr x)
> {
> if (H(x, x))
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H1(P, P));
> }
>
> It remains true that the correct and complete x86 emulation of the
> input to H(P,P) by H never reaches its "ret" instruction thus never
> halts.

Click here to read the complete article

Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<yLidnc32p8yLUjH_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 13:59:34 -0500
Date: Fri, 17 Jun 2022 13:59:33 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc> <20220617190451.00003626@reddwarf.jmc>
<20220617190826.000032b6@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220617190826.000032b6@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <yLidnc32p8yLUjH_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 451
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-rgzO9fazgUkSIH1lbZaD4OVj7AuSqDCXvbGQJxEqzDO+DqOc2FK0kwPe3kSIvn24H9ibpANmqZARQOV!m0Z928FJbd11yecKqqCPOYB9PD00b4GmS1MNAdvKG0JVaA7hSjb6+xeIteAz+Tjh7KfO3oGtL0sy
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
X-Original-Bytes: 22474
 by: olcott - Fri, 17 Jun 2022 18:59 UTC

On 6/17/2022 1:08 PM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 19:04:51 +0100
> Mr Flibble <flibble@reddwarf.jmc> wrote:
>
>> On Fri, 17 Jun 2022 18:14:48 +0100
>> Mr Flibble <flibble@reddwarf.jmc> wrote:
>>
>>> On Fri, 17 Jun 2022 12:13:13 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
>>>>> On Fri, 17 Jun 2022 11:59:53 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
>>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
>>>>>>>>>>>>>>>>>>>>>>>> detects that its correct and complete
>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach the
>>>>>>>>>>>>>>>>>>>>>>>> final state of this input then all [these]
>>>>>>>>>>>>>>>>>>>>>>>> inputs (including pathological inputs) are
>>>>>>>>>>>>>>>>>>>>>>>> decided correctly.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
>>>>>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D.
>>>>>>>>>>>>>>>>>>>>>>>> C. Heath and Company. (317-320)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
>>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when
>>>>>>>>>>>>>>>>>>>>>>>> we assume that H is only an x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>> that the correctly emulated P never reaches
>>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction it remains stuck in
>>>>>>>>>>>>>>>>>>>>>>>> repeated cycles of emulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H
>>>>>>>>>>>>>>>>>>>>>>>> has been adapted to correctly detect (in a
>>>>>>>>>>>>>>>>>>>>>>>> finite number of steps) that the correct and
>>>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation of its input would
>>>>>>>>>>>>>>>>>>>>>>>> never each its "ret" instruction that H
>>>>>>>>>>>>>>>>>>>>>>>> could abort its emulation and return 0 to
>>>>>>>>>>>>>>>>>>>>>>>> report this.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined
>>>>>>>>>>>>>>>>>>>>>>>> as correctly determining whether or not an
>>>>>>>>>>>>>>>>>>>>>>>> x86 emulated input would ever reach its "ret"
>>>>>>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily
>>>>>>>>>>>>>>>>>>>>>>>> verified fact H(P,P) could correctly reject
>>>>>>>>>>>>>>>>>>>>>>>> its input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all
>>>>>>>>>>>>>>>>>>>>>>>> of these things are true without any need
>>>>>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or
>>>>>>>>>>>>>>>>>>>>>>>> the execution trace of H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether
>>>>>>>>>>>>>>>>>>>>>>>> or not an actual encoded H(P,P) does indeed
>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that its input would
>>>>>>>>>>>>>>>>>>>>>>>> never reach its "ret" instruction as a pure
>>>>>>>>>>>>>>>>>>>>>>>> function of its inputs. This aspect will be
>>>>>>>>>>>>>>>>>>>>>>>> confirmed by fully operational source-code.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V5)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
>>>>>>>>>>>>>>>>>>>>>>> cannot exist:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from
>>>>>>>>>>>>>>>>>>>>>> their inputs to an accept or reject state on
>>>>>>>>>>>>>>>>>>>>>> the basis of the actual behavior actually
>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct
>>>>>>>>>>>>>>>>>>>>>> and complete x86 emulation of the input to
>>>>>>>>>>>>>>>>>>>>>> H(P,P) by H would never reach its "ret"
>>>>>>>>>>>>>>>>>>>>>> instruction thus conclusively proving that it
>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
>>>>>>>>>>>>>>>>>>>>>>> (undecidable).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
>>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
>>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
>>>>>>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH to
>>>>>>>>>>>>>>>>>>>>> test/review.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
>>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
>>>>>>>>>>>>>>>>>>>> inputs. I did not release the code before because
>>>>>>>>>>>>>>>>>>>> I knew that its use of static local data would
>>>>>>>>>>>>>>>>>>>> have been rejected. With this update to H I will
>>>>>>>>>>>>>>>>>>>> be able to publish the code.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its
>>>>>>>>>>>>>>>>>>>> same arguments that it was called with and there
>>>>>>>>>>>>>>>>>>>> are no instructions preceding this call that
>>>>>>>>>>>>>>>>>>>> could possibly escape infinitely recursive
>>>>>>>>>>>>>>>>>>>> emulation so H aborts its emulation of P before
>>>>>>>>>>>>>>>>>>>> P even makes its first call to H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Without even looking at the code competent
>>>>>>>>>>>>>>>>>>>> software engineers will be able to verify that
>>>>>>>>>>>>>>>>>>>> the above H would correctly determine that that
>>>>>>>>>>>>>>>>>>>> is input is non-halting as a pure function of
>>>>>>>>>>>>>>>>>>>> this input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
>>>>>>>>>>>>>>>>>>> function for any accepted definition of the term.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
>>>>>>>>>>>>>>>>>> function that has the following properties:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (1) the function return values are identical for
>>>>>>>>>>>>>>>>>> identical arguments (no variation with local static
>>>>>>>>>>>>>>>>>> variables, non-local variables, mutable reference
>>>>>>>>>>>>>>>>>> arguments or input streams), and
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (2) the function application has no side effects
>>>>>>>>>>>>>>>>>> (no mutation of local static variables, non-local
>>>>>>>>>>>>>>>>>> variables, mutable reference arguments or
>>>>>>>>>>>>>>>>>> input/output streams).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus a pure function is a computational analogue
>>>>>>>>>>>>>>>>>> of a mathematical function.
>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Whether or not it is construed as a side-effect does
>>>>>>>>>>>>>> not matter it must be a mutation side-effect to
>>>>>>>>>>>>>> (a)(b)(c)(d) or it does not count.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It doesn't count according to who?
>>>>>>>>>>>>
>>>>>>>>>>>> The above definition of pure functions.
>>>>>>>>>>>
>>>>>>>>>>> "In computer science, an operation, function or expression
>>>>>>>>>>> is said to have a side effect if it modifies some state
>>>>>>>>>>> variable value(s) outside its local environment,
>>>>>>>>>>
>>>>>>>>>> The second part is an inaccurate paraphrase of the first
>>>>>>>>>> part.
>>>>>>>>>>> which is to say if it has any observable effect
>>>>>>>>>>> other than its primary effect of returning a value to the
>>>>>>>>>>> invoker of the operation." --
>>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>>>>>>>
>>>>>>>>>>> "any observable effect"
>>>>>>>>>>>
>>>>>>>>>>> Aborting the simulation instead of returning a value to
>>>>>>>>>>> the invoker disqualifies it from being a pure function.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>> if (H(x, x))
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> _P()
>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>
>>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its
>>>>>>>>>> machine address of [0000135d] the very first time before
>>>>>>>>>> the code at this address is emulated. Then H returns 0 to
>>>>>>>>>> its caller: main().
>>>>>>>>>
>>>>>>>>> Returning to main() is not returning to its invoker, P.
>>>>>>>>>
>>>>>>>>> Again:
>>>>>>>>>
>>>>>>>>> Aborting the simulation is a side effect; pure functions do
>>>>>>>>> not have side effects.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Do you have ADD?
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>> }
>>>>>>>
>>>>>>> If your claim is that H is only called once and the second
>>>>>>> time an *attempt* to call H is prevented than that is
>>>>>>> equivalent to calling H and having H do something different
>>>>>>> with side effects. This is just my opinion though as it
>>>>>>> requires more thought and I am currently getting drunk on gin
>>>>>>> and tonics.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> It is obviously the exact same pattern as infinite recursion
>>>>>> (a) calling the same function a second time with the same
>>>>>> arguments and
>>>>>>
>>>>>> (b) there are no instructions preceding this call that could
>>>>>> possibly escape the infinite recursion / infinitely recursive
>>>>>> emulation.
>>>>>
>>>>> Agree but refusing to analyse what P would have done if H
>>>>> wasn't a simulating decider still makes what you've got
>>>>> worthless as far as the Halting Problem is concerned.
>>>>>
>>>>> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
>>>>>
>>>>
>>>> It is dead obvious to everyone (even Richard) that what P would
>>>> have done if H was merely an x86 emulator and not a halt deciding
>>>> emulator.
>>>>
>>>> The correct and complete x86 emulation of H(P,P) would never reach
>>>> its "ret" instruction thus making H a correct "not reach ret" /
>>>> halt decider for P.
>>>
>>> You need to think about a P that calls H but is non-pathological
>>> halting (no infinite loop).
>>
>> Your assumption that any program that calls H is also pathological is
>> a flawed one. I have said before that all you have is a simulation
>> detector and not a halt decider: simulating halt deciders cannot
>> decide non-pathological non-halting programs in finite time so are not
>> actually deciders.
>
> The question then becomes is a simulation detector (rather than a halt
> decider) sufficient to refute proofs based on the [Strachey 1965]
> impossible program? I cannot answer that question as I am unfamiliar
> with the proofs.
>
> /Flibble
>


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<VNWdnT4AepokTzH_nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 14:15:05 -0500
Date: Fri, 17 Jun 2022 14:15:04 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
<spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617194532.00006384@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220617194532.00006384@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <VNWdnT4AepokTzH_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 475
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-uv1f2w/GkxBELu07ns0vZo5s2iNjufih8bILVlpoT5HwcBQa44MDJinweW5sJ7vwJ2kuzQBrTihigZS!vVvv/UDv3QSwpA64bouTyDwY9RLI5jWrXOgo++/NdAj1jUz3ZxTAqTGR8kU/rVV3IdoJr0zd9+2W
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
X-Original-Bytes: 22971
 by: olcott - Fri, 17 Jun 2022 19:15 UTC

On 6/17/2022 1:45 PM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 13:42:05 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/17/2022 12:14 PM, Mr Flibble wrote:
>>> On Fri, 17 Jun 2022 12:13:13 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
>>>>> On Fri, 17 Jun 2022 11:59:53 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
>>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
>>>>>>>>>>>>>>>>>>>>>>>> detects that its correct and complete
>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach the
>>>>>>>>>>>>>>>>>>>>>>>> final state of this input then all [these]
>>>>>>>>>>>>>>>>>>>>>>>> inputs (including pathological inputs) are
>>>>>>>>>>>>>>>>>>>>>>>> decided correctly.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
>>>>>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D.
>>>>>>>>>>>>>>>>>>>>>>>> C. Heath and Company. (317-320)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
>>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we
>>>>>>>>>>>>>>>>>>>>>>>> assume that H is only an x86 emulator that the
>>>>>>>>>>>>>>>>>>>>>>>> correctly emulated P never reaches its "ret"
>>>>>>>>>>>>>>>>>>>>>>>> instruction it remains stuck in repeated cycles
>>>>>>>>>>>>>>>>>>>>>>>> of emulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has
>>>>>>>>>>>>>>>>>>>>>>>> been adapted to correctly detect (in a finite
>>>>>>>>>>>>>>>>>>>>>>>> number of steps) that the correct and complete
>>>>>>>>>>>>>>>>>>>>>>>> x86 emulation of its input would never each its
>>>>>>>>>>>>>>>>>>>>>>>> "ret" instruction that H could abort its
>>>>>>>>>>>>>>>>>>>>>>>> emulation and return 0 to report this.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
>>>>>>>>>>>>>>>>>>>>>>>> correctly determining whether or not an x86
>>>>>>>>>>>>>>>>>>>>>>>> emulated input would ever reach its "ret"
>>>>>>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily verified
>>>>>>>>>>>>>>>>>>>>>>>> fact H(P,P) could correctly reject its input as
>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all of
>>>>>>>>>>>>>>>>>>>>>>>> these things are true without any need
>>>>>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or
>>>>>>>>>>>>>>>>>>>>>>>> the execution trace of H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether or
>>>>>>>>>>>>>>>>>>>>>>>> not an actual encoded H(P,P) does indeed
>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that its input would never
>>>>>>>>>>>>>>>>>>>>>>>> reach its "ret" instruction as a pure function
>>>>>>>>>>>>>>>>>>>>>>>> of its inputs. This aspect will be confirmed by
>>>>>>>>>>>>>>>>>>>>>>>> fully operational source-code.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V5)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
>>>>>>>>>>>>>>>>>>>>>>> cannot exist:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from their
>>>>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis
>>>>>>>>>>>>>>>>>>>>>> of the actual behavior actually specified by
>>>>>>>>>>>>>>>>>>>>>> these inputs.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct
>>>>>>>>>>>>>>>>>>>>>> and complete x86 emulation of the input to
>>>>>>>>>>>>>>>>>>>>>> H(P,P) by H would never reach its "ret"
>>>>>>>>>>>>>>>>>>>>>> instruction thus conclusively proving that it
>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
>>>>>>>>>>>>>>>>>>>>>>> (undecidable).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
>>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
>>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
>>>>>>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH to
>>>>>>>>>>>>>>>>>>>>> test/review.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
>>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
>>>>>>>>>>>>>>>>>>>> inputs. I did not release the code before because
>>>>>>>>>>>>>>>>>>>> I knew that its use of static local data would
>>>>>>>>>>>>>>>>>>>> have been rejected. With this update to H I will
>>>>>>>>>>>>>>>>>>>> be able to publish the code.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its same
>>>>>>>>>>>>>>>>>>>> arguments that it was called with and there are no
>>>>>>>>>>>>>>>>>>>> instructions preceding this call that could
>>>>>>>>>>>>>>>>>>>> possibly escape infinitely recursive emulation so
>>>>>>>>>>>>>>>>>>>> H aborts its emulation of P before P even makes
>>>>>>>>>>>>>>>>>>>> its first call to H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Without even looking at the code competent software
>>>>>>>>>>>>>>>>>>>> engineers will be able to verify that the above H
>>>>>>>>>>>>>>>>>>>> would correctly determine that that is input is
>>>>>>>>>>>>>>>>>>>> non-halting as a pure function of this input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
>>>>>>>>>>>>>>>>>>> function for any accepted definition of the term.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
>>>>>>>>>>>>>>>>>> function that has the following properties:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (1) the function return values are identical for
>>>>>>>>>>>>>>>>>> identical arguments (no variation with local static
>>>>>>>>>>>>>>>>>> variables, non-local variables, mutable reference
>>>>>>>>>>>>>>>>>> arguments or input streams), and
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (2) the function application has no side effects (no
>>>>>>>>>>>>>>>>>> mutation of local static variables, non-local
>>>>>>>>>>>>>>>>>> variables, mutable reference arguments or
>>>>>>>>>>>>>>>>>> input/output streams).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus a pure function is a computational analogue of a
>>>>>>>>>>>>>>>>>> mathematical function.
>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure functions
>>>>>>>>>>>>>>> do not have side effects.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Whether or not it is construed as a side-effect does not
>>>>>>>>>>>>>> matter it must be a mutation side-effect to (a)(b)(c)(d)
>>>>>>>>>>>>>> or it does not count.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It doesn't count according to who?
>>>>>>>>>>>>
>>>>>>>>>>>> The above definition of pure functions.
>>>>>>>>>>>
>>>>>>>>>>> "In computer science, an operation, function or expression
>>>>>>>>>>> is said to have a side effect if it modifies some state
>>>>>>>>>>> variable value(s) outside its local environment,
>>>>>>>>>>
>>>>>>>>>> The second part is an inaccurate paraphrase of the first
>>>>>>>>>> part.
>>>>>>>>>>> which is to say if it has any observable effect
>>>>>>>>>>> other than its primary effect of returning a value to the
>>>>>>>>>>> invoker of the operation." --
>>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>>>>>>>
>>>>>>>>>>> "any observable effect"
>>>>>>>>>>>
>>>>>>>>>>> Aborting the simulation instead of returning a value to the
>>>>>>>>>>> invoker disqualifies it from being a pure function.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>> if (H(x, x))
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> _P()
>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>
>>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its machine
>>>>>>>>>> address of [0000135d] the very first time before the code at
>>>>>>>>>> this address is emulated. Then H returns 0 to its caller:
>>>>>>>>>> main().
>>>>>>>>>
>>>>>>>>> Returning to main() is not returning to its invoker, P.
>>>>>>>>>
>>>>>>>>> Again:
>>>>>>>>>
>>>>>>>>> Aborting the simulation is a side effect; pure functions do
>>>>>>>>> not have side effects.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Do you have ADD?
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>> }
>>>>>>>
>>>>>>> If your claim is that H is only called once and the second time
>>>>>>> an *attempt* to call H is prevented than that is equivalent to
>>>>>>> calling H and having H do something different with side effects.
>>>>>>> This is just my opinion though as it requires more thought and I
>>>>>>> am currently getting drunk on gin and tonics.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> It is obviously the exact same pattern as infinite recursion
>>>>>> (a) calling the same function a second time with the same
>>>>>> arguments and
>>>>>>
>>>>>> (b) there are no instructions preceding this call that could
>>>>>> possibly escape the infinite recursion / infinitely recursive
>>>>>> emulation.
>>>>>
>>>>> Agree but refusing to analyse what P would have done if H wasn't a
>>>>> simulating decider still makes what you've got worthless as far as
>>>>> the Halting Problem is concerned.
>>>>>
>>>>> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
>>>>>
>>>>
>>>> It is dead obvious to everyone (even Richard) that what P would
>>>> have done if H was merely an x86 emulator and not a halt deciding
>>>> emulator.
>>>>
>>>> The correct and complete x86 emulation of H(P,P) would never reach
>>>> its "ret" instruction thus making H a correct "not reach ret" /
>>>> halt decider for P.
>>>
>>> You need to think about a P that calls H but is non-pathological
>>> halting (no infinite loop).
>>>
>>> /Flibble
>>>
>>
>> I have already done that and posted all of the details here about
>> three dozen times.
>>
>> void P(ptr x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H1(P, P));
>> }
>>
>> It remains true that the correct and complete x86 emulation of the
>> input to H(P,P) by H never reaches its "ret" instruction thus never
>> halts.
>
> Try reading what I actually wrote:
>
> void P(ptr x)
> {
> H(x, x); // ignore result
> return; // halt
> }
>
> How does your "decider" handle that P?
>
> /Flibble
>


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<20220617201738.000021c4@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx13.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Message-ID: <20220617201738.000021c4@reddwarf.jmc>
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
<spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617194532.00006384@reddwarf.jmc>
<VNWdnT4AepokTzH_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 482
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 17 Jun 2022 19:17:38 UTC
Date: Fri, 17 Jun 2022 20:17:38 +0100
X-Received-Bytes: 23669
 by: Mr Flibble - Fri, 17 Jun 2022 19:17 UTC

On Fri, 17 Jun 2022 14:15:04 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/17/2022 1:45 PM, Mr Flibble wrote:
> > On Fri, 17 Jun 2022 13:42:05 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/17/2022 12:14 PM, Mr Flibble wrote:
> >>> On Fri, 17 Jun 2022 12:13:13 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
> >>>>> On Fri, 17 Jun 2022 11:59:53 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
> >>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
> >>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8,
> >>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
> >>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
> >>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
> >>>>>>>>>>>>>>>>>>>>>>>> detects that its correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach the
> >>>>>>>>>>>>>>>>>>>>>>>> final state of this input then all [these]
> >>>>>>>>>>>>>>>>>>>>>>>> inputs (including pathological inputs) are
> >>>>>>>>>>>>>>>>>>>>>>>> decided correctly.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
> >>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
> >>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
> >>>>>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D.
> >>>>>>>>>>>>>>>>>>>>>>>> C. Heath and Company. (317-320)
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
> >>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
> >>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when
> >>>>>>>>>>>>>>>>>>>>>>>> we assume that H is only an x86 emulator
> >>>>>>>>>>>>>>>>>>>>>>>> that the correctly emulated P never reaches
> >>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction it remains stuck in
> >>>>>>>>>>>>>>>>>>>>>>>> repeated cycles of emulation.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H
> >>>>>>>>>>>>>>>>>>>>>>>> has been adapted to correctly detect (in a
> >>>>>>>>>>>>>>>>>>>>>>>> finite number of steps) that the correct and
> >>>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation of its input would
> >>>>>>>>>>>>>>>>>>>>>>>> never each its "ret" instruction that H
> >>>>>>>>>>>>>>>>>>>>>>>> could abort its emulation and return 0 to
> >>>>>>>>>>>>>>>>>>>>>>>> report this.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined
> >>>>>>>>>>>>>>>>>>>>>>>> as correctly determining whether or not an
> >>>>>>>>>>>>>>>>>>>>>>>> x86 emulated input would ever reach its "ret"
> >>>>>>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily
> >>>>>>>>>>>>>>>>>>>>>>>> verified fact H(P,P) could correctly reject
> >>>>>>>>>>>>>>>>>>>>>>>> its input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all
> >>>>>>>>>>>>>>>>>>>>>>>> of these things are true without any need
> >>>>>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or
> >>>>>>>>>>>>>>>>>>>>>>>> the execution trace of H.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether
> >>>>>>>>>>>>>>>>>>>>>>>> or not an actual encoded H(P,P) does indeed
> >>>>>>>>>>>>>>>>>>>>>>>> correctly determine that its input would
> >>>>>>>>>>>>>>>>>>>>>>>> never reach its "ret" instruction as a pure
> >>>>>>>>>>>>>>>>>>>>>>>> function of its inputs. This aspect will be
> >>>>>>>>>>>>>>>>>>>>>>>> confirmed by fully operational source-code.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
> >>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V5)
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
> >>>>>>>>>>>>>>>>>>>>>>> cannot exist:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
> >>>>>>>>>>>>>>>>>>>>>> That is a misconception.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from
> >>>>>>>>>>>>>>>>>>>>>> their inputs to an accept or reject state on
> >>>>>>>>>>>>>>>>>>>>>> the basis of the actual behavior actually
> >>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct
> >>>>>>>>>>>>>>>>>>>>>> and complete x86 emulation of the input to
> >>>>>>>>>>>>>>>>>>>>>> H(P,P) by H would never reach its "ret"
> >>>>>>>>>>>>>>>>>>>>>> instruction thus conclusively proving that it
> >>>>>>>>>>>>>>>>>>>>>> never halts.
> >>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
> >>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
> >>>>>>>>>>>>>>>>>>>>>>> (undecidable).
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> -----
> >>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
> >>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
> >>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
> >>>>>>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
> >>>>>>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH to
> >>>>>>>>>>>>>>>>>>>>> test/review.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
> >>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
> >>>>>>>>>>>>>>>>>>>> inputs. I did not release the code before because
> >>>>>>>>>>>>>>>>>>>> I knew that its use of static local data would
> >>>>>>>>>>>>>>>>>>>> have been rejected. With this update to H I will
> >>>>>>>>>>>>>>>>>>>> be able to publish the code.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its
> >>>>>>>>>>>>>>>>>>>> same arguments that it was called with and there
> >>>>>>>>>>>>>>>>>>>> are no instructions preceding this call that
> >>>>>>>>>>>>>>>>>>>> could possibly escape infinitely recursive
> >>>>>>>>>>>>>>>>>>>> emulation so H aborts its emulation of P before
> >>>>>>>>>>>>>>>>>>>> P even makes its first call to H.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Without even looking at the code competent
> >>>>>>>>>>>>>>>>>>>> software engineers will be able to verify that
> >>>>>>>>>>>>>>>>>>>> the above H would correctly determine that that
> >>>>>>>>>>>>>>>>>>>> is input is non-halting as a pure function of
> >>>>>>>>>>>>>>>>>>>> this input.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
> >>>>>>>>>>>>>>>>>>> function for any accepted definition of the term.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
> >>>>>>>>>>>>>>>>>> function that has the following properties:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> (1) the function return values are identical for
> >>>>>>>>>>>>>>>>>> identical arguments (no variation with local static
> >>>>>>>>>>>>>>>>>> variables, non-local variables, mutable reference
> >>>>>>>>>>>>>>>>>> arguments or input streams), and
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> (2) the function application has no side effects
> >>>>>>>>>>>>>>>>>> (no mutation of local static variables, non-local
> >>>>>>>>>>>>>>>>>> variables, mutable reference arguments or
> >>>>>>>>>>>>>>>>>> input/output streams).
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Thus a pure function is a computational analogue
> >>>>>>>>>>>>>>>>>> of a mathematical function.
> >>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> The revised H has no:
> >>>>>>>>>>>>>>>>>> (a) local static variables
> >>>>>>>>>>>>>>>>>> (b) non-local variables
> >>>>>>>>>>>>>>>>>> (c) mutable reference arguments
> >>>>>>>>>>>>>>>>>> (d) input streams
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> >>>>>>>>>>>>>>>>> functions do not have side effects.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> You have a reading comprehension problem.
> >>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
> >>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Again:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> >>>>>>>>>>>>>>> functions do not have side effects.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Whether or not it is construed as a side-effect does
> >>>>>>>>>>>>>> not matter it must be a mutation side-effect to
> >>>>>>>>>>>>>> (a)(b)(c)(d) or it does not count.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> It doesn't count according to who?
> >>>>>>>>>>>>
> >>>>>>>>>>>> The above definition of pure functions.
> >>>>>>>>>>>
> >>>>>>>>>>> "In computer science, an operation, function or expression
> >>>>>>>>>>> is said to have a side effect if it modifies some state
> >>>>>>>>>>> variable value(s) outside its local environment,
> >>>>>>>>>>
> >>>>>>>>>> The second part is an inaccurate paraphrase of the first
> >>>>>>>>>> part.
> >>>>>>>>>>> which is to say if it has any observable effect
> >>>>>>>>>>> other than its primary effect of returning a value to the
> >>>>>>>>>>> invoker of the operation." --
> >>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
> >>>>>>>>>>>
> >>>>>>>>>>> "any observable effect"
> >>>>>>>>>>>
> >>>>>>>>>>> Aborting the simulation instead of returning a value to
> >>>>>>>>>>> the invoker disqualifies it from being a pure function.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> void P(ptr x)
> >>>>>>>>>> {
> >>>>>>>>>> if (H(x, x))
> >>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>> return;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> int main()
> >>>>>>>>>> {
> >>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> _P()
> >>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>>>>>>>> [00001362](03) 83c408 add esp,+08
> >>>>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>
> >>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its
> >>>>>>>>>> machine address of [0000135d] the very first time before
> >>>>>>>>>> the code at this address is emulated. Then H returns 0 to
> >>>>>>>>>> its caller: main().
> >>>>>>>>>
> >>>>>>>>> Returning to main() is not returning to its invoker, P.
> >>>>>>>>>
> >>>>>>>>> Again:
> >>>>>>>>>
> >>>>>>>>> Aborting the simulation is a side effect; pure functions do
> >>>>>>>>> not have side effects.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Do you have ADD?
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>> }
> >>>>>>>
> >>>>>>> If your claim is that H is only called once and the second
> >>>>>>> time an *attempt* to call H is prevented than that is
> >>>>>>> equivalent to calling H and having H do something different
> >>>>>>> with side effects. This is just my opinion though as it
> >>>>>>> requires more thought and I am currently getting drunk on gin
> >>>>>>> and tonics.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> It is obviously the exact same pattern as infinite recursion
> >>>>>> (a) calling the same function a second time with the same
> >>>>>> arguments and
> >>>>>>
> >>>>>> (b) there are no instructions preceding this call that could
> >>>>>> possibly escape the infinite recursion / infinitely recursive
> >>>>>> emulation.
> >>>>>
> >>>>> Agree but refusing to analyse what P would have done if H
> >>>>> wasn't a simulating decider still makes what you've got
> >>>>> worthless as far as the Halting Problem is concerned.
> >>>>>
> >>>>> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
> >>>>>
> >>>>
> >>>> It is dead obvious to everyone (even Richard) that what P would
> >>>> have done if H was merely an x86 emulator and not a halt deciding
> >>>> emulator.
> >>>>
> >>>> The correct and complete x86 emulation of H(P,P) would never
> >>>> reach its "ret" instruction thus making H a correct "not reach
> >>>> ret" / halt decider for P.
> >>>
> >>> You need to think about a P that calls H but is non-pathological
> >>> halting (no infinite loop).
> >>>
> >>> /Flibble
> >>>
> >>
> >> I have already done that and posted all of the details here about
> >> three dozen times.
> >>
> >> void P(ptr x)
> >> {
> >> if (H(x, x))
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H1(P, P));
> >> }
> >>
> >> It remains true that the correct and complete x86 emulation of the
> >> input to H(P,P) by H never reaches its "ret" instruction thus never
> >> halts.
> >
> > Try reading what I actually wrote:
> >
> > void P(ptr x)
> > {
> > H(x, x); // ignore result
> > return; // halt
> > }
> >
> > How does your "decider" handle that P?
> >
> > /Flibble
> >
>
> Removing the infinite loop does not make it non pathological.
> As I have said donzens of times the infinite loop is unreachable.
>
> void Px(u32 x)
> {
> H(x, x);
> return;
> }
>
>
> int main()
> {
> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> }
>
> _Px()
> [000013b6](01) 55 push ebp
> [000013b7](02) 8bec mov ebp,esp
> [000013b9](03) 8b4508 mov eax,[ebp+08]
> [000013bc](01) 50 push eax
> [000013bd](03) 8b4d08 mov ecx,[ebp+08]
> [000013c0](01) 51 push ecx
> [000013c1](05) e8e0fdffff call 000011a6
> [000013c6](03) 83c408 add esp,+08
> [000013c9](01) 5d pop ebp
> [000013ca](01) c3 ret
> Size in bytes:(0021) [000013ca]
>
> _main()
> [000013d6](01) 55 push ebp
> [000013d7](02) 8bec mov ebp,esp
> [000013d9](05) 68b6130000 push 000013b6
> [000013de](05) 68b6130000 push 000013b6
> [000013e3](05) e8befdffff call 000011a6
> [000013e8](03) 83c408 add esp,+08
> [000013eb](01) 50 push eax
> [000013ec](05) 6827040000 push 00000427
> [000013f1](05) e880f0ffff call 00000476
> [000013f6](03) 83c408 add esp,+08
> [000013f9](02) 33c0 xor eax,eax
> [000013fb](01) 5d pop ebp
> [000013fc](01) c3 ret
> Size in bytes:(0039) [000013fc]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= ============> ...[000013d6][00102357][00000000] 55 push ebp
> ...[000013d7][00102357][00000000] 8bec mov ebp,esp
> ...[000013d9][00102353][000013b6] 68b6130000 push 000013b6
> ...[000013de][0010234f][000013b6] 68b6130000 push 000013b6
> ...[000013e3][0010234b][000013e8] e8befdffff call 000011a6
>
> Begin Local Halt Decider Simulation Execution Trace Stored at:21240b
> ...[000013b6][002123f7][002123fb] 55 push ebp
> ...[000013b7][002123f7][002123fb] 8bec mov ebp,esp
> ...[000013b9][002123f7][002123fb] 8b4508 mov eax,[ebp+08]
> ...[000013bc][002123f3][000013b6] 50 push eax
> ...[000013bd][002123f3][000013b6] 8b4d08 mov ecx,[ebp+08]
> ...[000013c0][002123ef][000013b6] 51 push ecx
> ...[000013c1][002123eb][000013c6] e8e0fdffff call 000011a6
> ...[000013b6][0025ce1f][0025ce23] 55 push ebp
> ...[000013b7][0025ce1f][0025ce23] 8bec mov ebp,esp
> ...[000013b9][0025ce1f][0025ce23] 8b4508 mov eax,[ebp+08]
> ...[000013bc][0025ce1b][000013b6] 50 push eax
> ...[000013bd][0025ce1b][000013b6] 8b4d08 mov ecx,[ebp+08]
> ...[000013c0][0025ce17][000013b6] 51 push ecx
> ...[000013c1][0025ce13][000013c6] e8e0fdffff call 000011a6
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> ...[000013eb][00102353][00000000] 50 push eax
> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> Input_Halts = 0
> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> ...[000013fb][0010235b][00100000] 5d pop ebp
> ...[000013fc][0010235f][00000004] c3 ret
> Number of Instructions Executed(16120)

Click here to read the complete article

Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<C6KdndXRT62oSjH_nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 14:34:13 -0500
Date: Fri, 17 Jun 2022 14:34:12 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617155601.00005a04@reddwarf.jmc>
<mP6dnRFqDvZ1AzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
<spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617194532.00006384@reddwarf.jmc>
<VNWdnT4AepokTzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617201738.000021c4@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220617201738.000021c4@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <C6KdndXRT62oSjH_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 501
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-cmfQQdEi16wrvTOexFkxdkbSdZw3t2F+/bTqOvsirzeYzPru/eyJHK00ufpr2gFcuRQajGILSx+c9aa!339TuY0Cq6CaOdKbtL1KRBX4HHt1YQtUJL341KKwF2UwVkbCkhrX5JABFbAfGgGqd3RO0kNMC1LN
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
X-Original-Bytes: 24865
 by: olcott - Fri, 17 Jun 2022 19:34 UTC

On 6/17/2022 2:17 PM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 14:15:04 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/17/2022 1:45 PM, Mr Flibble wrote:
>>> On Fri, 17 Jun 2022 13:42:05 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/17/2022 12:14 PM, Mr Flibble wrote:
>>>>> On Fri, 17 Jun 2022 12:13:13 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
>>>>>>> On Fri, 17 Jun 2022 11:59:53 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8,
>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
>>>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> detects that its correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach the
>>>>>>>>>>>>>>>>>>>>>>>>>> final state of this input then all [these]
>>>>>>>>>>>>>>>>>>>>>>>>>> inputs (including pathological inputs) are
>>>>>>>>>>>>>>>>>>>>>>>>>> decided correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
>>>>>>>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D.
>>>>>>>>>>>>>>>>>>>>>>>>>> C. Heath and Company. (317-320)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
>>>>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when
>>>>>>>>>>>>>>>>>>>>>>>>>> we assume that H is only an x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>> that the correctly emulated P never reaches
>>>>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction it remains stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>> repeated cycles of emulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H
>>>>>>>>>>>>>>>>>>>>>>>>>> has been adapted to correctly detect (in a
>>>>>>>>>>>>>>>>>>>>>>>>>> finite number of steps) that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation of its input would
>>>>>>>>>>>>>>>>>>>>>>>>>> never each its "ret" instruction that H
>>>>>>>>>>>>>>>>>>>>>>>>>> could abort its emulation and return 0 to
>>>>>>>>>>>>>>>>>>>>>>>>>> report this.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined
>>>>>>>>>>>>>>>>>>>>>>>>>> as correctly determining whether or not an
>>>>>>>>>>>>>>>>>>>>>>>>>> x86 emulated input would ever reach its "ret"
>>>>>>>>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily
>>>>>>>>>>>>>>>>>>>>>>>>>> verified fact H(P,P) could correctly reject
>>>>>>>>>>>>>>>>>>>>>>>>>> its input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all
>>>>>>>>>>>>>>>>>>>>>>>>>> of these things are true without any need
>>>>>>>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or
>>>>>>>>>>>>>>>>>>>>>>>>>> the execution trace of H.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether
>>>>>>>>>>>>>>>>>>>>>>>>>> or not an actual encoded H(P,P) does indeed
>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that its input would
>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its "ret" instruction as a pure
>>>>>>>>>>>>>>>>>>>>>>>>>> function of its inputs. This aspect will be
>>>>>>>>>>>>>>>>>>>>>>>>>> confirmed by fully operational source-code.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V5)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
>>>>>>>>>>>>>>>>>>>>>>>>> cannot exist:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from
>>>>>>>>>>>>>>>>>>>>>>>> their inputs to an accept or reject state on
>>>>>>>>>>>>>>>>>>>>>>>> the basis of the actual behavior actually
>>>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct
>>>>>>>>>>>>>>>>>>>>>>>> and complete x86 emulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) by H would never reach its "ret"
>>>>>>>>>>>>>>>>>>>>>>>> instruction thus conclusively proving that it
>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
>>>>>>>>>>>>>>>>>>>>>>>>> (undecidable).
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
>>>>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
>>>>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
>>>>>>>>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH to
>>>>>>>>>>>>>>>>>>>>>>> test/review.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
>>>>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
>>>>>>>>>>>>>>>>>>>>>> inputs. I did not release the code before because
>>>>>>>>>>>>>>>>>>>>>> I knew that its use of static local data would
>>>>>>>>>>>>>>>>>>>>>> have been rejected. With this update to H I will
>>>>>>>>>>>>>>>>>>>>>> be able to publish the code.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its
>>>>>>>>>>>>>>>>>>>>>> same arguments that it was called with and there
>>>>>>>>>>>>>>>>>>>>>> are no instructions preceding this call that
>>>>>>>>>>>>>>>>>>>>>> could possibly escape infinitely recursive
>>>>>>>>>>>>>>>>>>>>>> emulation so H aborts its emulation of P before
>>>>>>>>>>>>>>>>>>>>>> P even makes its first call to H.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Without even looking at the code competent
>>>>>>>>>>>>>>>>>>>>>> software engineers will be able to verify that
>>>>>>>>>>>>>>>>>>>>>> the above H would correctly determine that that
>>>>>>>>>>>>>>>>>>>>>> is input is non-halting as a pure function of
>>>>>>>>>>>>>>>>>>>>>> this input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
>>>>>>>>>>>>>>>>>>>>> function for any accepted definition of the term.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
>>>>>>>>>>>>>>>>>>>> function that has the following properties:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (1) the function return values are identical for
>>>>>>>>>>>>>>>>>>>> identical arguments (no variation with local static
>>>>>>>>>>>>>>>>>>>> variables, non-local variables, mutable reference
>>>>>>>>>>>>>>>>>>>> arguments or input streams), and
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (2) the function application has no side effects
>>>>>>>>>>>>>>>>>>>> (no mutation of local static variables, non-local
>>>>>>>>>>>>>>>>>>>> variables, mutable reference arguments or
>>>>>>>>>>>>>>>>>>>> input/output streams).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Thus a pure function is a computational analogue
>>>>>>>>>>>>>>>>>>>> of a mathematical function.
>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Whether or not it is construed as a side-effect does
>>>>>>>>>>>>>>>> not matter it must be a mutation side-effect to
>>>>>>>>>>>>>>>> (a)(b)(c)(d) or it does not count.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It doesn't count according to who?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The above definition of pure functions.
>>>>>>>>>>>>>
>>>>>>>>>>>>> "In computer science, an operation, function or expression
>>>>>>>>>>>>> is said to have a side effect if it modifies some state
>>>>>>>>>>>>> variable value(s) outside its local environment,
>>>>>>>>>>>>
>>>>>>>>>>>> The second part is an inaccurate paraphrase of the first
>>>>>>>>>>>> part.
>>>>>>>>>>>>> which is to say if it has any observable effect
>>>>>>>>>>>>> other than its primary effect of returning a value to the
>>>>>>>>>>>>> invoker of the operation." --
>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>>>>>>>>>
>>>>>>>>>>>>> "any observable effect"
>>>>>>>>>>>>>
>>>>>>>>>>>>> Aborting the simulation instead of returning a value to
>>>>>>>>>>>>> the invoker disqualifies it from being a pure function.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> _P()
>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>
>>>>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its
>>>>>>>>>>>> machine address of [0000135d] the very first time before
>>>>>>>>>>>> the code at this address is emulated. Then H returns 0 to
>>>>>>>>>>>> its caller: main().
>>>>>>>>>>>
>>>>>>>>>>> Returning to main() is not returning to its invoker, P.
>>>>>>>>>>>
>>>>>>>>>>> Again:
>>>>>>>>>>>
>>>>>>>>>>> Aborting the simulation is a side effect; pure functions do
>>>>>>>>>>> not have side effects.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Do you have ADD?
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> If your claim is that H is only called once and the second
>>>>>>>>> time an *attempt* to call H is prevented than that is
>>>>>>>>> equivalent to calling H and having H do something different
>>>>>>>>> with side effects. This is just my opinion though as it
>>>>>>>>> requires more thought and I am currently getting drunk on gin
>>>>>>>>> and tonics.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is obviously the exact same pattern as infinite recursion
>>>>>>>> (a) calling the same function a second time with the same
>>>>>>>> arguments and
>>>>>>>>
>>>>>>>> (b) there are no instructions preceding this call that could
>>>>>>>> possibly escape the infinite recursion / infinitely recursive
>>>>>>>> emulation.
>>>>>>>
>>>>>>> Agree but refusing to analyse what P would have done if H
>>>>>>> wasn't a simulating decider still makes what you've got
>>>>>>> worthless as far as the Halting Problem is concerned.
>>>>>>>
>>>>>>> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
>>>>>>>
>>>>>>
>>>>>> It is dead obvious to everyone (even Richard) that what P would
>>>>>> have done if H was merely an x86 emulator and not a halt deciding
>>>>>> emulator.
>>>>>>
>>>>>> The correct and complete x86 emulation of H(P,P) would never
>>>>>> reach its "ret" instruction thus making H a correct "not reach
>>>>>> ret" / halt decider for P.
>>>>>
>>>>> You need to think about a P that calls H but is non-pathological
>>>>> halting (no infinite loop).
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> I have already done that and posted all of the details here about
>>>> three dozen times.
>>>>
>>>> void P(ptr x)
>>>> {
>>>> if (H(x, x))
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H1(P, P));
>>>> }
>>>>
>>>> It remains true that the correct and complete x86 emulation of the
>>>> input to H(P,P) by H never reaches its "ret" instruction thus never
>>>> halts.
>>>
>>> Try reading what I actually wrote:
>>>
>>> void P(ptr x)
>>> {
>>> H(x, x); // ignore result
>>> return; // halt
>>> }
>>>
>>> How does your "decider" handle that P?
>>>
>>> /Flibble
>>>
>>
>> Removing the infinite loop does not make it non pathological.
>> As I have said donzens of times the infinite loop is unreachable.
>>
>> void Px(u32 x)
>> {
>> H(x, x);
>> return;
>> }
>>
>>
>> int main()
>> {
>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>> }
>>
>> _Px()
>> [000013b6](01) 55 push ebp
>> [000013b7](02) 8bec mov ebp,esp
>> [000013b9](03) 8b4508 mov eax,[ebp+08]
>> [000013bc](01) 50 push eax
>> [000013bd](03) 8b4d08 mov ecx,[ebp+08]
>> [000013c0](01) 51 push ecx
>> [000013c1](05) e8e0fdffff call 000011a6
>> [000013c6](03) 83c408 add esp,+08
>> [000013c9](01) 5d pop ebp
>> [000013ca](01) c3 ret
>> Size in bytes:(0021) [000013ca]
>>
>> _main()
>> [000013d6](01) 55 push ebp
>> [000013d7](02) 8bec mov ebp,esp
>> [000013d9](05) 68b6130000 push 000013b6
>> [000013de](05) 68b6130000 push 000013b6
>> [000013e3](05) e8befdffff call 000011a6
>> [000013e8](03) 83c408 add esp,+08
>> [000013eb](01) 50 push eax
>> [000013ec](05) 6827040000 push 00000427
>> [000013f1](05) e880f0ffff call 00000476
>> [000013f6](03) 83c408 add esp,+08
>> [000013f9](02) 33c0 xor eax,eax
>> [000013fb](01) 5d pop ebp
>> [000013fc](01) c3 ret
>> Size in bytes:(0039) [000013fc]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> ...[000013d6][00102357][00000000] 55 push ebp
>> ...[000013d7][00102357][00000000] 8bec mov ebp,esp
>> ...[000013d9][00102353][000013b6] 68b6130000 push 000013b6
>> ...[000013de][0010234f][000013b6] 68b6130000 push 000013b6
>> ...[000013e3][0010234b][000013e8] e8befdffff call 000011a6
>>
>> Begin Local Halt Decider Simulation Execution Trace Stored at:21240b
>> ...[000013b6][002123f7][002123fb] 55 push ebp
>> ...[000013b7][002123f7][002123fb] 8bec mov ebp,esp
>> ...[000013b9][002123f7][002123fb] 8b4508 mov eax,[ebp+08]
>> ...[000013bc][002123f3][000013b6] 50 push eax
>> ...[000013bd][002123f3][000013b6] 8b4d08 mov ecx,[ebp+08]
>> ...[000013c0][002123ef][000013b6] 51 push ecx
>> ...[000013c1][002123eb][000013c6] e8e0fdffff call 000011a6
>> ...[000013b6][0025ce1f][0025ce23] 55 push ebp
>> ...[000013b7][0025ce1f][0025ce23] 8bec mov ebp,esp
>> ...[000013b9][0025ce1f][0025ce23] 8b4508 mov eax,[ebp+08]
>> ...[000013bc][0025ce1b][000013b6] 50 push eax
>> ...[000013bd][0025ce1b][000013b6] 8b4d08 mov ecx,[ebp+08]
>> ...[000013c0][0025ce17][000013b6] 51 push ecx
>> ...[000013c1][0025ce13][000013c6] e8e0fdffff call 000011a6
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
>> ...[000013eb][00102353][00000000] 50 push eax
>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
>> Input_Halts = 0
>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
>> ...[000013fb][0010235b][00100000] 5d pop ebp
>> ...[000013fc][0010235f][00000004] c3 ret
>> Number of Instructions Executed(16120)
>
> So it gets the answer wrong. QED.
>
> /Flibble
>
>


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<20220617203634.00000d49@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx13.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Message-ID: <20220617203634.00000d49@reddwarf.jmc>
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
<spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617194532.00006384@reddwarf.jmc>
<VNWdnT4AepokTzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617201738.000021c4@reddwarf.jmc>
<C6KdndXRT62oSjH_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 509
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 17 Jun 2022 19:36:34 UTC
Date: Fri, 17 Jun 2022 20:36:34 +0100
X-Received-Bytes: 25665
 by: Mr Flibble - Fri, 17 Jun 2022 19:36 UTC

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

> On 6/17/2022 2:17 PM, Mr Flibble wrote:
> > On Fri, 17 Jun 2022 14:15:04 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/17/2022 1:45 PM, Mr Flibble wrote:
> >>> On Fri, 17 Jun 2022 13:42:05 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/17/2022 12:14 PM, Mr Flibble wrote:
> >>>>> On Fri, 17 Jun 2022 12:13:13 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
> >>>>>>> On Fri, 17 Jun 2022 11:59:53 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
> >>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
> >>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
> >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8,
> >>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
> >>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
> >>>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>> detects that its correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach
> >>>>>>>>>>>>>>>>>>>>>>>>>> the final state of this input then all
> >>>>>>>>>>>>>>>>>>>>>>>>>> [these] inputs (including pathological
> >>>>>>>>>>>>>>>>>>>>>>>>>> inputs) are decided correctly.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing
> >>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a
> >>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234)
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
> >>>>>>>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto:
> >>>>>>>>>>>>>>>>>>>>>>>>>> D. C. Heath and Company. (317-320)
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
> >>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
> >>>>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when
> >>>>>>>>>>>>>>>>>>>>>>>>>> we assume that H is only an x86 emulator
> >>>>>>>>>>>>>>>>>>>>>>>>>> that the correctly emulated P never reaches
> >>>>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction it remains stuck in
> >>>>>>>>>>>>>>>>>>>>>>>>>> repeated cycles of emulation.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H
> >>>>>>>>>>>>>>>>>>>>>>>>>> has been adapted to correctly detect (in a
> >>>>>>>>>>>>>>>>>>>>>>>>>> finite number of steps) that the correct
> >>>>>>>>>>>>>>>>>>>>>>>>>> and complete x86 emulation of its input
> >>>>>>>>>>>>>>>>>>>>>>>>>> would never each its "ret" instruction
> >>>>>>>>>>>>>>>>>>>>>>>>>> that H could abort its emulation and
> >>>>>>>>>>>>>>>>>>>>>>>>>> return 0 to report this.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is
> >>>>>>>>>>>>>>>>>>>>>>>>>> defined as correctly determining whether
> >>>>>>>>>>>>>>>>>>>>>>>>>> or not an x86 emulated input would ever
> >>>>>>>>>>>>>>>>>>>>>>>>>> reach its "ret" instruction then it
> >>>>>>>>>>>>>>>>>>>>>>>>>> becomes an easily verified fact H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>> could correctly reject its input as
> >>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all
> >>>>>>>>>>>>>>>>>>>>>>>>>> of these things are true without any need
> >>>>>>>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code
> >>>>>>>>>>>>>>>>>>>>>>>>>> or the execution trace of H.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether
> >>>>>>>>>>>>>>>>>>>>>>>>>> or not an actual encoded H(P,P) does indeed
> >>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that its input would
> >>>>>>>>>>>>>>>>>>>>>>>>>> never reach its "ret" instruction as a pure
> >>>>>>>>>>>>>>>>>>>>>>>>>> function of its inputs. This aspect will be
> >>>>>>>>>>>>>>>>>>>>>>>>>> confirmed by fully operational source-code.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and
> >>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation (V5)
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting
> >>>>>>>>>>>>>>>>>>>>>>>>> decider H cannot exist:
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
> >>>>>>>>>>>>>>>>>>>>>>>> That is a misconception.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from
> >>>>>>>>>>>>>>>>>>>>>>>> their inputs to an accept or reject state on
> >>>>>>>>>>>>>>>>>>>>>>>> the basis of the actual behavior actually
> >>>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the
> >>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the
> >>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) by H would never reach its
> >>>>>>>>>>>>>>>>>>>>>>>> "ret" instruction thus conclusively proving
> >>>>>>>>>>>>>>>>>>>>>>>> that it never halts.
> >>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
> >>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
> >>>>>>>>>>>>>>>>>>>>>>>>> (undecidable).
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> -----
> >>>>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
> >>>>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
> >>>>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
> >>>>>>>>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
> >>>>>>>>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH
> >>>>>>>>>>>>>>>>>>>>>>> to test/review.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
> >>>>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
> >>>>>>>>>>>>>>>>>>>>>> inputs. I did not release the code before
> >>>>>>>>>>>>>>>>>>>>>> because I knew that its use of static local
> >>>>>>>>>>>>>>>>>>>>>> data would have been rejected. With this
> >>>>>>>>>>>>>>>>>>>>>> update to H I will be able to publish the code.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its
> >>>>>>>>>>>>>>>>>>>>>> same arguments that it was called with and
> >>>>>>>>>>>>>>>>>>>>>> there are no instructions preceding this call
> >>>>>>>>>>>>>>>>>>>>>> that could possibly escape infinitely recursive
> >>>>>>>>>>>>>>>>>>>>>> emulation so H aborts its emulation of P before
> >>>>>>>>>>>>>>>>>>>>>> P even makes its first call to H.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Without even looking at the code competent
> >>>>>>>>>>>>>>>>>>>>>> software engineers will be able to verify that
> >>>>>>>>>>>>>>>>>>>>>> the above H would correctly determine that that
> >>>>>>>>>>>>>>>>>>>>>> is input is non-halting as a pure function of
> >>>>>>>>>>>>>>>>>>>>>> this input.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
> >>>>>>>>>>>>>>>>>>>>> function for any accepted definition of the
> >>>>>>>>>>>>>>>>>>>>> term.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
> >>>>>>>>>>>>>>>>>>>> function that has the following properties:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> (1) the function return values are identical for
> >>>>>>>>>>>>>>>>>>>> identical arguments (no variation with local
> >>>>>>>>>>>>>>>>>>>> static variables, non-local variables, mutable
> >>>>>>>>>>>>>>>>>>>> reference arguments or input streams), and
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> (2) the function application has no side effects
> >>>>>>>>>>>>>>>>>>>> (no mutation of local static variables, non-local
> >>>>>>>>>>>>>>>>>>>> variables, mutable reference arguments or
> >>>>>>>>>>>>>>>>>>>> input/output streams).
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Thus a pure function is a computational analogue
> >>>>>>>>>>>>>>>>>>>> of a mathematical function.
> >>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> The revised H has no:
> >>>>>>>>>>>>>>>>>>>> (a) local static variables
> >>>>>>>>>>>>>>>>>>>> (b) non-local variables
> >>>>>>>>>>>>>>>>>>>> (c) mutable reference arguments
> >>>>>>>>>>>>>>>>>>>> (d) input streams
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> >>>>>>>>>>>>>>>>>>> functions do not have side effects.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You have a reading comprehension problem.
> >>>>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
> >>>>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Again:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> >>>>>>>>>>>>>>>>> functions do not have side effects.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Whether or not it is construed as a side-effect does
> >>>>>>>>>>>>>>>> not matter it must be a mutation side-effect to
> >>>>>>>>>>>>>>>> (a)(b)(c)(d) or it does not count.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> It doesn't count according to who?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> The above definition of pure functions.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> "In computer science, an operation, function or
> >>>>>>>>>>>>> expression is said to have a side effect if it modifies
> >>>>>>>>>>>>> some state variable value(s) outside its local
> >>>>>>>>>>>>> environment,
> >>>>>>>>>>>>
> >>>>>>>>>>>> The second part is an inaccurate paraphrase of the first
> >>>>>>>>>>>> part.
> >>>>>>>>>>>>> which is to say if it has any observable effect
> >>>>>>>>>>>>> other than its primary effect of returning a value to
> >>>>>>>>>>>>> the invoker of the operation." --
> >>>>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> "any observable effect"
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Aborting the simulation instead of returning a value to
> >>>>>>>>>>>>> the invoker disqualifies it from being a pure function.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>> return;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> int main()
> >>>>>>>>>>>> {
> >>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> _P()
> >>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
> >>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>
> >>>>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its
> >>>>>>>>>>>> machine address of [0000135d] the very first time before
> >>>>>>>>>>>> the code at this address is emulated. Then H returns 0 to
> >>>>>>>>>>>> its caller: main().
> >>>>>>>>>>>
> >>>>>>>>>>> Returning to main() is not returning to its invoker, P.
> >>>>>>>>>>>
> >>>>>>>>>>> Again:
> >>>>>>>>>>>
> >>>>>>>>>>> Aborting the simulation is a side effect; pure functions
> >>>>>>>>>>> do not have side effects.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Do you have ADD?
> >>>>>>>>>>
> >>>>>>>>>> int main()
> >>>>>>>>>> {
> >>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> If your claim is that H is only called once and the second
> >>>>>>>>> time an *attempt* to call H is prevented than that is
> >>>>>>>>> equivalent to calling H and having H do something different
> >>>>>>>>> with side effects. This is just my opinion though as it
> >>>>>>>>> requires more thought and I am currently getting drunk on
> >>>>>>>>> gin and tonics.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> It is obviously the exact same pattern as infinite recursion
> >>>>>>>> (a) calling the same function a second time with the same
> >>>>>>>> arguments and
> >>>>>>>>
> >>>>>>>> (b) there are no instructions preceding this call that could
> >>>>>>>> possibly escape the infinite recursion / infinitely recursive
> >>>>>>>> emulation.
> >>>>>>>
> >>>>>>> Agree but refusing to analyse what P would have done if H
> >>>>>>> wasn't a simulating decider still makes what you've got
> >>>>>>> worthless as far as the Halting Problem is concerned.
> >>>>>>>
> >>>>>>> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
> >>>>>>>
> >>>>>>
> >>>>>> It is dead obvious to everyone (even Richard) that what P would
> >>>>>> have done if H was merely an x86 emulator and not a halt
> >>>>>> deciding emulator.
> >>>>>>
> >>>>>> The correct and complete x86 emulation of H(P,P) would never
> >>>>>> reach its "ret" instruction thus making H a correct "not reach
> >>>>>> ret" / halt decider for P.
> >>>>>
> >>>>> You need to think about a P that calls H but is non-pathological
> >>>>> halting (no infinite loop).
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> I have already done that and posted all of the details here about
> >>>> three dozen times.
> >>>>
> >>>> void P(ptr x)
> >>>> {
> >>>> if (H(x, x))
> >>>> HERE: goto HERE;
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H1(P, P));
> >>>> }
> >>>>
> >>>> It remains true that the correct and complete x86 emulation of
> >>>> the input to H(P,P) by H never reaches its "ret" instruction
> >>>> thus never halts.
> >>>
> >>> Try reading what I actually wrote:
> >>>
> >>> void P(ptr x)
> >>> {
> >>> H(x, x); // ignore result
> >>> return; // halt
> >>> }
> >>>
> >>> How does your "decider" handle that P?
> >>>
> >>> /Flibble
> >>>
> >>
> >> Removing the infinite loop does not make it non pathological.
> >> As I have said donzens of times the infinite loop is unreachable.
> >>
> >> void Px(u32 x)
> >> {
> >> H(x, x);
> >> return;
> >> }
> >>
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >> }
> >>
> >> _Px()
> >> [000013b6](01) 55 push ebp
> >> [000013b7](02) 8bec mov ebp,esp
> >> [000013b9](03) 8b4508 mov eax,[ebp+08]
> >> [000013bc](01) 50 push eax
> >> [000013bd](03) 8b4d08 mov ecx,[ebp+08]
> >> [000013c0](01) 51 push ecx
> >> [000013c1](05) e8e0fdffff call 000011a6
> >> [000013c6](03) 83c408 add esp,+08
> >> [000013c9](01) 5d pop ebp
> >> [000013ca](01) c3 ret
> >> Size in bytes:(0021) [000013ca]
> >>
> >> _main()
> >> [000013d6](01) 55 push ebp
> >> [000013d7](02) 8bec mov ebp,esp
> >> [000013d9](05) 68b6130000 push 000013b6
> >> [000013de](05) 68b6130000 push 000013b6
> >> [000013e3](05) e8befdffff call 000011a6
> >> [000013e8](03) 83c408 add esp,+08
> >> [000013eb](01) 50 push eax
> >> [000013ec](05) 6827040000 push 00000427
> >> [000013f1](05) e880f0ffff call 00000476
> >> [000013f6](03) 83c408 add esp,+08
> >> [000013f9](02) 33c0 xor eax,eax
> >> [000013fb](01) 5d pop ebp
> >> [000013fc](01) c3 ret
> >> Size in bytes:(0039) [000013fc]
> >>
> >> machine stack stack machine assembly
> >> address address data code language
> >> ======== ======== ======== ========= ============> >> ...[000013d6][00102357][00000000] 55 push ebp
> >> ...[000013d7][00102357][00000000] 8bec mov ebp,esp
> >> ...[000013d9][00102353][000013b6] 68b6130000 push 000013b6
> >> ...[000013de][0010234f][000013b6] 68b6130000 push 000013b6
> >> ...[000013e3][0010234b][000013e8] e8befdffff call 000011a6
> >>
> >> Begin Local Halt Decider Simulation Execution Trace Stored
> >> at:21240b ...[000013b6][002123f7][002123fb] 55 push
> >> ebp ...[000013b7][002123f7][002123fb] 8bec mov ebp,esp
> >> ...[000013b9][002123f7][002123fb] 8b4508 mov eax,[ebp+08]
> >> ...[000013bc][002123f3][000013b6] 50 push eax
> >> ...[000013bd][002123f3][000013b6] 8b4d08 mov ecx,[ebp+08]
> >> ...[000013c0][002123ef][000013b6] 51 push ecx
> >> ...[000013c1][002123eb][000013c6] e8e0fdffff call 000011a6
> >> ...[000013b6][0025ce1f][0025ce23] 55 push ebp
> >> ...[000013b7][0025ce1f][0025ce23] 8bec mov ebp,esp
> >> ...[000013b9][0025ce1f][0025ce23] 8b4508 mov eax,[ebp+08]
> >> ...[000013bc][0025ce1b][000013b6] 50 push eax
> >> ...[000013bd][0025ce1b][000013b6] 8b4d08 mov ecx,[ebp+08]
> >> ...[000013c0][0025ce17][000013b6] 51 push ecx
> >> ...[000013c1][0025ce13][000013c6] e8e0fdffff call 000011a6
> >> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> >>
> >> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> >> ...[000013eb][00102353][00000000] 50 push eax
> >> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> >> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> >> Input_Halts = 0
> >> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> >> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> >> ...[000013fb][0010235b][00100000] 5d pop ebp
> >> ...[000013fc][0010235f][00000004] c3 ret
> >> Number of Instructions Executed(16120)
> >
> > So it gets the answer wrong. QED.
> >
> > /Flibble
> >
> >
>
> comp.theory:
> [Solution to one instance of the Halting Problem]
> On 3/14/2017 9:05 AM, peteolcott wrote:
>
> This is the culmination of the essence of more than five years worth
> of full time work when I first discovered that a simulating halt
> decider could correctly determine the halt status of the "impossible"
> input:
>
> When a simulating halt decider rejects all inputs as non-halting
> whenever it correctly detects that its correct and complete
> simulation of its input would never reach the final state of this
> input that all [these] inputs (including pathological inputs) are
> decided correctly.


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<wPydnRxSR-SoRDH_nZ2dnUU7_81g4p2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 14:42:45 -0500
Date: Fri, 17 Jun 2022 14:42:45 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617163707.00002d66@reddwarf.jmc>
<6LydnXGCDLXoPzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
<spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617194532.00006384@reddwarf.jmc>
<VNWdnT4AepokTzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617201738.000021c4@reddwarf.jmc>
<C6KdndXRT62oSjH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617203634.00000d49@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220617203634.00000d49@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <wPydnRxSR-SoRDH_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 518
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jezSwjO1Nf6HMNM1ShfVfMwjzg/M4UocmEH+QATnGyDMAnP8rBuKYdtKwF6F4RMrxwj9Y9q5mVAUVP6!UBviYnJxz1sVJP+SFgXwYBmZ08/kNSAs0Qo6XOtagMq9E/mvPdGUc1B/89hkzgiAwBlgI5D+Gwxe
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
X-Original-Bytes: 26369
 by: olcott - Fri, 17 Jun 2022 19:42 UTC

On 6/17/2022 2:36 PM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 14:34:12 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/17/2022 2:17 PM, Mr Flibble wrote:
>>> On Fri, 17 Jun 2022 14:15:04 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/17/2022 1:45 PM, Mr Flibble wrote:
>>>>> On Fri, 17 Jun 2022 13:42:05 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/17/2022 12:14 PM, Mr Flibble wrote:
>>>>>>> On Fri, 17 Jun 2022 12:13:13 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 17 Jun 2022 11:59:53 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8,
>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> detects that its correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the final state of this input then all
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [these] inputs (including pathological
>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs) are decided correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> D. C. Heath and Company. (317-320)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
>>>>>>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when
>>>>>>>>>>>>>>>>>>>>>>>>>>>> we assume that H is only an x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correctly emulated P never reaches
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction it remains stuck in
>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeated cycles of emulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> has been adapted to correctly detect (in a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite number of steps) that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> and complete x86 emulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never each its "ret" instruction
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H could abort its emulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0 to report this.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined as correctly determining whether
>>>>>>>>>>>>>>>>>>>>>>>>>>>> or not an x86 emulated input would ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its "ret" instruction then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>> becomes an easily verified fact H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> could correctly reject its input as
>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of these things are true without any need
>>>>>>>>>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code
>>>>>>>>>>>>>>>>>>>>>>>>>>>> or the execution trace of H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether
>>>>>>>>>>>>>>>>>>>>>>>>>>>> or not an actual encoded H(P,P) does indeed
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that its input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its "ret" instruction as a pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>> function of its inputs. This aspect will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>> confirmed by fully operational source-code.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation (V5)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting
>>>>>>>>>>>>>>>>>>>>>>>>>>> decider H cannot exist:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from
>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs to an accept or reject state on
>>>>>>>>>>>>>>>>>>>>>>>>>> the basis of the actual behavior actually
>>>>>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the
>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) by H would never reach its
>>>>>>>>>>>>>>>>>>>>>>>>>> "ret" instruction thus conclusively proving
>>>>>>>>>>>>>>>>>>>>>>>>>> that it never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
>>>>>>>>>>>>>>>>>>>>>>>>>>> (undecidable).
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
>>>>>>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
>>>>>>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
>>>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
>>>>>>>>>>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH
>>>>>>>>>>>>>>>>>>>>>>>>> to test/review.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
>>>>>>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
>>>>>>>>>>>>>>>>>>>>>>>> inputs. I did not release the code before
>>>>>>>>>>>>>>>>>>>>>>>> because I knew that its use of static local
>>>>>>>>>>>>>>>>>>>>>>>> data would have been rejected. With this
>>>>>>>>>>>>>>>>>>>>>>>> update to H I will be able to publish the code.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its
>>>>>>>>>>>>>>>>>>>>>>>> same arguments that it was called with and
>>>>>>>>>>>>>>>>>>>>>>>> there are no instructions preceding this call
>>>>>>>>>>>>>>>>>>>>>>>> that could possibly escape infinitely recursive
>>>>>>>>>>>>>>>>>>>>>>>> emulation so H aborts its emulation of P before
>>>>>>>>>>>>>>>>>>>>>>>> P even makes its first call to H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Without even looking at the code competent
>>>>>>>>>>>>>>>>>>>>>>>> software engineers will be able to verify that
>>>>>>>>>>>>>>>>>>>>>>>> the above H would correctly determine that that
>>>>>>>>>>>>>>>>>>>>>>>> is input is non-halting as a pure function of
>>>>>>>>>>>>>>>>>>>>>>>> this input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
>>>>>>>>>>>>>>>>>>>>>>> function for any accepted definition of the
>>>>>>>>>>>>>>>>>>>>>>> term.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
>>>>>>>>>>>>>>>>>>>>>> function that has the following properties:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (1) the function return values are identical for
>>>>>>>>>>>>>>>>>>>>>> identical arguments (no variation with local
>>>>>>>>>>>>>>>>>>>>>> static variables, non-local variables, mutable
>>>>>>>>>>>>>>>>>>>>>> reference arguments or input streams), and
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (2) the function application has no side effects
>>>>>>>>>>>>>>>>>>>>>> (no mutation of local static variables, non-local
>>>>>>>>>>>>>>>>>>>>>> variables, mutable reference arguments or
>>>>>>>>>>>>>>>>>>>>>> input/output streams).
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Thus a pure function is a computational analogue
>>>>>>>>>>>>>>>>>>>>>> of a mathematical function.
>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Whether or not it is construed as a side-effect does
>>>>>>>>>>>>>>>>>> not matter it must be a mutation side-effect to
>>>>>>>>>>>>>>>>>> (a)(b)(c)(d) or it does not count.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It doesn't count according to who?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The above definition of pure functions.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> "In computer science, an operation, function or
>>>>>>>>>>>>>>> expression is said to have a side effect if it modifies
>>>>>>>>>>>>>>> some state variable value(s) outside its local
>>>>>>>>>>>>>>> environment,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The second part is an inaccurate paraphrase of the first
>>>>>>>>>>>>>> part.
>>>>>>>>>>>>>>> which is to say if it has any observable effect
>>>>>>>>>>>>>>> other than its primary effect of returning a value to
>>>>>>>>>>>>>>> the invoker of the operation." --
>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> "any observable effect"
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Aborting the simulation instead of returning a value to
>>>>>>>>>>>>>>> the invoker disqualifies it from being a pure function.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its
>>>>>>>>>>>>>> machine address of [0000135d] the very first time before
>>>>>>>>>>>>>> the code at this address is emulated. Then H returns 0 to
>>>>>>>>>>>>>> its caller: main().
>>>>>>>>>>>>>
>>>>>>>>>>>>> Returning to main() is not returning to its invoker, P.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Aborting the simulation is a side effect; pure functions
>>>>>>>>>>>>> do not have side effects.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Do you have ADD?
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> If your claim is that H is only called once and the second
>>>>>>>>>>> time an *attempt* to call H is prevented than that is
>>>>>>>>>>> equivalent to calling H and having H do something different
>>>>>>>>>>> with side effects. This is just my opinion though as it
>>>>>>>>>>> requires more thought and I am currently getting drunk on
>>>>>>>>>>> gin and tonics.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is obviously the exact same pattern as infinite recursion
>>>>>>>>>> (a) calling the same function a second time with the same
>>>>>>>>>> arguments and
>>>>>>>>>>
>>>>>>>>>> (b) there are no instructions preceding this call that could
>>>>>>>>>> possibly escape the infinite recursion / infinitely recursive
>>>>>>>>>> emulation.
>>>>>>>>>
>>>>>>>>> Agree but refusing to analyse what P would have done if H
>>>>>>>>> wasn't a simulating decider still makes what you've got
>>>>>>>>> worthless as far as the Halting Problem is concerned.
>>>>>>>>>
>>>>>>>>> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is dead obvious to everyone (even Richard) that what P would
>>>>>>>> have done if H was merely an x86 emulator and not a halt
>>>>>>>> deciding emulator.
>>>>>>>>
>>>>>>>> The correct and complete x86 emulation of H(P,P) would never
>>>>>>>> reach its "ret" instruction thus making H a correct "not reach
>>>>>>>> ret" / halt decider for P.
>>>>>>>
>>>>>>> You need to think about a P that calls H but is non-pathological
>>>>>>> halting (no infinite loop).
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> I have already done that and posted all of the details here about
>>>>>> three dozen times.
>>>>>>
>>>>>> void P(ptr x)
>>>>>> {
>>>>>> if (H(x, x))
>>>>>> HERE: goto HERE;
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H1(P, P));
>>>>>> }
>>>>>>
>>>>>> It remains true that the correct and complete x86 emulation of
>>>>>> the input to H(P,P) by H never reaches its "ret" instruction
>>>>>> thus never halts.
>>>>>
>>>>> Try reading what I actually wrote:
>>>>>
>>>>> void P(ptr x)
>>>>> {
>>>>> H(x, x); // ignore result
>>>>> return; // halt
>>>>> }
>>>>>
>>>>> How does your "decider" handle that P?
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Removing the infinite loop does not make it non pathological.
>>>> As I have said donzens of times the infinite loop is unreachable.
>>>>
>>>> void Px(u32 x)
>>>> {
>>>> H(x, x);
>>>> return;
>>>> }
>>>>
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>> }
>>>>
>>>> _Px()
>>>> [000013b6](01) 55 push ebp
>>>> [000013b7](02) 8bec mov ebp,esp
>>>> [000013b9](03) 8b4508 mov eax,[ebp+08]
>>>> [000013bc](01) 50 push eax
>>>> [000013bd](03) 8b4d08 mov ecx,[ebp+08]
>>>> [000013c0](01) 51 push ecx
>>>> [000013c1](05) e8e0fdffff call 000011a6
>>>> [000013c6](03) 83c408 add esp,+08
>>>> [000013c9](01) 5d pop ebp
>>>> [000013ca](01) c3 ret
>>>> Size in bytes:(0021) [000013ca]
>>>>
>>>> _main()
>>>> [000013d6](01) 55 push ebp
>>>> [000013d7](02) 8bec mov ebp,esp
>>>> [000013d9](05) 68b6130000 push 000013b6
>>>> [000013de](05) 68b6130000 push 000013b6
>>>> [000013e3](05) e8befdffff call 000011a6
>>>> [000013e8](03) 83c408 add esp,+08
>>>> [000013eb](01) 50 push eax
>>>> [000013ec](05) 6827040000 push 00000427
>>>> [000013f1](05) e880f0ffff call 00000476
>>>> [000013f6](03) 83c408 add esp,+08
>>>> [000013f9](02) 33c0 xor eax,eax
>>>> [000013fb](01) 5d pop ebp
>>>> [000013fc](01) c3 ret
>>>> Size in bytes:(0039) [000013fc]
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> ...[000013d6][00102357][00000000] 55 push ebp
>>>> ...[000013d7][00102357][00000000] 8bec mov ebp,esp
>>>> ...[000013d9][00102353][000013b6] 68b6130000 push 000013b6
>>>> ...[000013de][0010234f][000013b6] 68b6130000 push 000013b6
>>>> ...[000013e3][0010234b][000013e8] e8befdffff call 000011a6
>>>>
>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>> at:21240b ...[000013b6][002123f7][002123fb] 55 push
>>>> ebp ...[000013b7][002123f7][002123fb] 8bec mov ebp,esp
>>>> ...[000013b9][002123f7][002123fb] 8b4508 mov eax,[ebp+08]
>>>> ...[000013bc][002123f3][000013b6] 50 push eax
>>>> ...[000013bd][002123f3][000013b6] 8b4d08 mov ecx,[ebp+08]
>>>> ...[000013c0][002123ef][000013b6] 51 push ecx
>>>> ...[000013c1][002123eb][000013c6] e8e0fdffff call 000011a6
>>>> ...[000013b6][0025ce1f][0025ce23] 55 push ebp
>>>> ...[000013b7][0025ce1f][0025ce23] 8bec mov ebp,esp
>>>> ...[000013b9][0025ce1f][0025ce23] 8b4508 mov eax,[ebp+08]
>>>> ...[000013bc][0025ce1b][000013b6] 50 push eax
>>>> ...[000013bd][0025ce1b][000013b6] 8b4d08 mov ecx,[ebp+08]
>>>> ...[000013c0][0025ce17][000013b6] 51 push ecx
>>>> ...[000013c1][0025ce13][000013c6] e8e0fdffff call 000011a6
>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>
>>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
>>>> ...[000013eb][00102353][00000000] 50 push eax
>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
>>>> Input_Halts = 0
>>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
>>>> ...[000013fc][0010235f][00000004] c3 ret
>>>> Number of Instructions Executed(16120)
>>>
>>> So it gets the answer wrong. QED.
>>>
>>> /Flibble
>>>
>>>
>>
>> comp.theory:
>> [Solution to one instance of the Halting Problem]
>> On 3/14/2017 9:05 AM, peteolcott wrote:
>>
>> This is the culmination of the essence of more than five years worth
>> of full time work when I first discovered that a simulating halt
>> decider could correctly determine the halt status of the "impossible"
>> input:
>>
>> When a simulating halt decider rejects all inputs as non-halting
>> whenever it correctly detects that its correct and complete
>> simulation of its input would never reach the final state of this
>> input that all [these] inputs (including pathological inputs) are
>> decided correctly.
>
> It gets the answer wrong. QED.
>
> /Flibble
>


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<20220617204356.000070a0@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!feeder.usenetexpress.com!tr2.eu1.usenetexpress.com!81.171.65.13.MISMATCH!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx13.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]
Message-ID: <20220617204356.000070a0@reddwarf.jmc>
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com> <20220617165613.00006ff4@reddwarf.jmc> <19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com> <20220617171424.00006f1f@reddwarf.jmc> <19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com> <20220617172234.00000777@reddwarf.jmc> <5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com> <20220617173640.00006b94@reddwarf.jmc> <BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com> <20220617175104.00001454@reddwarf.jmc> <d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com> <20220617180447.00003b49@reddwarf.jmc> <-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com> <20220617181448.00005cdb@reddwarf.jmc> <spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com> <20220617194532.00006384@reddwarf.jmc> <VNWdnT4AepokTzH_nZ2dnUU7_83NnZ2d@giganews.com> <20220617201738.000021c4@reddwarf.jmc> <C6KdndXRT62oSjH_nZ2dnUU7_83NnZ2d@giganews.com> <20220617203634.00000d49@reddwarf.jmc> <wPydnRxSR-SoRDH_nZ2dnUU7_81g4p2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 534
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 17 Jun 2022 19:43:57 UTC
Date: Fri, 17 Jun 2022 20:43:56 +0100
X-Received-Bytes: 27394
 by: Mr Flibble - Fri, 17 Jun 2022 19:43 UTC

On Fri, 17 Jun 2022 14:42:45 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/17/2022 2:36 PM, Mr Flibble wrote:
> > On Fri, 17 Jun 2022 14:34:12 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/17/2022 2:17 PM, Mr Flibble wrote:
> >>> On Fri, 17 Jun 2022 14:15:04 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/17/2022 1:45 PM, Mr Flibble wrote:
> >>>>> On Fri, 17 Jun 2022 13:42:05 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/17/2022 12:14 PM, Mr Flibble wrote:
> >>>>>>> On Fri, 17 Jun 2022 12:13:13 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 17 Jun 2022 11:59:53 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
> >>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
> >>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
> >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
> >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8,
> >>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
> >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> all inputs as non-halting whenever it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly detects that its correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of its input would
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach the final state of this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> input then all [these] inputs (including
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> pathological inputs) are decided
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Formal Languages and Automata.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Lexington/Toronto: D. C. Heath and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Company. (317-320)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> // call H [00001362](03) 83c408 add
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [00001365](02) 85c0 test eax,eax
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> when we assume that H is only an x86
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator that the correctly emulated P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> never reaches its "ret" instruction it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> remains stuck in repeated cycles of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> if H has been adapted to correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> detect (in a finite number of steps)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct and complete x86
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never each
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction that H could abort
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> its emulation and return 0 to report
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> this.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> defined as correctly determining whether
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> or not an x86 emulated input would ever
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its "ret" instruction then it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> becomes an easily verified fact H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> could correctly reject its input as
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> all of these things are true without any
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> need what-so-ever to see either the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> source-code or the execution trace of H.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not an actual encoded H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> does indeed correctly determine that its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach its "ret"
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction as a pure function of its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs. This aspect will be confirmed by
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> fully operational source-code.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation (V5)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> hit; Genius hits a target no one else
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> can see." Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting
> >>>>>>>>>>>>>>>>>>>>>>>>>>> decider H cannot exist:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
> >>>>>>>>>>>>>>>>>>>>>>>>>> That is a misconception.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from
> >>>>>>>>>>>>>>>>>>>>>>>>>> their inputs to an accept or reject state
> >>>>>>>>>>>>>>>>>>>>>>>>>> on the basis of the actual behavior
> >>>>>>>>>>>>>>>>>>>>>>>>>> actually specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the
> >>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) by H would never reach its
> >>>>>>>>>>>>>>>>>>>>>>>>>> "ret" instruction thus conclusively proving
> >>>>>>>>>>>>>>>>>>>>>>>>>> that it never halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a
> >>>>>>>>>>>>>>>>>>>>>>>>>>> decider (undecidable).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> -----
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
> >>>>>>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
> >>>>>>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
> >>>>>>>>>>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
> >>>>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
> >>>>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist.
> >>>>>>>>>>>>>>>>>>>>>>>>> You just confirms it by not able to provide
> >>>>>>>>>>>>>>>>>>>>>>>>> POOH to test/review.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
> >>>>>>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
> >>>>>>>>>>>>>>>>>>>>>>>> inputs. I did not release the code before
> >>>>>>>>>>>>>>>>>>>>>>>> because I knew that its use of static local
> >>>>>>>>>>>>>>>>>>>>>>>> data would have been rejected. With this
> >>>>>>>>>>>>>>>>>>>>>>>> update to H I will be able to publish the
> >>>>>>>>>>>>>>>>>>>>>>>> code.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with
> >>>>>>>>>>>>>>>>>>>>>>>> its same arguments that it was called with
> >>>>>>>>>>>>>>>>>>>>>>>> and there are no instructions preceding this
> >>>>>>>>>>>>>>>>>>>>>>>> call that could possibly escape infinitely
> >>>>>>>>>>>>>>>>>>>>>>>> recursive emulation so H aborts its
> >>>>>>>>>>>>>>>>>>>>>>>> emulation of P before P even makes its first
> >>>>>>>>>>>>>>>>>>>>>>>> call to H.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Without even looking at the code competent
> >>>>>>>>>>>>>>>>>>>>>>>> software engineers will be able to verify
> >>>>>>>>>>>>>>>>>>>>>>>> that the above H would correctly determine
> >>>>>>>>>>>>>>>>>>>>>>>> that that is input is non-halting as a pure
> >>>>>>>>>>>>>>>>>>>>>>>> function of this input.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
> >>>>>>>>>>>>>>>>>>>>>>> function for any accepted definition of the
> >>>>>>>>>>>>>>>>>>>>>>> term.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
> >>>>>>>>>>>>>>>>>>>>>> function that has the following properties:
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> (1) the function return values are identical
> >>>>>>>>>>>>>>>>>>>>>> for identical arguments (no variation with
> >>>>>>>>>>>>>>>>>>>>>> local static variables, non-local variables,
> >>>>>>>>>>>>>>>>>>>>>> mutable reference arguments or input streams),
> >>>>>>>>>>>>>>>>>>>>>> and
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> (2) the function application has no side
> >>>>>>>>>>>>>>>>>>>>>> effects (no mutation of local static
> >>>>>>>>>>>>>>>>>>>>>> variables, non-local variables, mutable
> >>>>>>>>>>>>>>>>>>>>>> reference arguments or input/output streams).
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Thus a pure function is a computational
> >>>>>>>>>>>>>>>>>>>>>> analogue of a mathematical function.
> >>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> The revised H has no:
> >>>>>>>>>>>>>>>>>>>>>> (a) local static variables
> >>>>>>>>>>>>>>>>>>>>>> (b) non-local variables
> >>>>>>>>>>>>>>>>>>>>>> (c) mutable reference arguments
> >>>>>>>>>>>>>>>>>>>>>> (d) input streams
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> >>>>>>>>>>>>>>>>>>>>> functions do not have side effects.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> You have a reading comprehension problem.
> >>>>>>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
> >>>>>>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Again:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> >>>>>>>>>>>>>>>>>>> functions do not have side effects.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Whether or not it is construed as a side-effect
> >>>>>>>>>>>>>>>>>> does not matter it must be a mutation side-effect
> >>>>>>>>>>>>>>>>>> to (a)(b)(c)(d) or it does not count.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> It doesn't count according to who?
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> The above definition of pure functions.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> "In computer science, an operation, function or
> >>>>>>>>>>>>>>> expression is said to have a side effect if it
> >>>>>>>>>>>>>>> modifies some state variable value(s) outside its
> >>>>>>>>>>>>>>> local environment,
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> The second part is an inaccurate paraphrase of the
> >>>>>>>>>>>>>> first part.
> >>>>>>>>>>>>>>> which is to say if it has any observable effect
> >>>>>>>>>>>>>>> other than its primary effect of returning a value to
> >>>>>>>>>>>>>>> the invoker of the operation." --
> >>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> "any observable effect"
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Aborting the simulation instead of returning a value
> >>>>>>>>>>>>>>> to the invoker disqualifies it from being a pure
> >>>>>>>>>>>>>>> function.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
> >>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
> >>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
> >>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its
> >>>>>>>>>>>>>> machine address of [0000135d] the very first time
> >>>>>>>>>>>>>> before the code at this address is emulated. Then H
> >>>>>>>>>>>>>> returns 0 to its caller: main().
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Returning to main() is not returning to its invoker, P.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Again:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Aborting the simulation is a side effect; pure functions
> >>>>>>>>>>>>> do not have side effects.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Do you have ADD?
> >>>>>>>>>>>>
> >>>>>>>>>>>> int main()
> >>>>>>>>>>>> {
> >>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> If your claim is that H is only called once and the second
> >>>>>>>>>>> time an *attempt* to call H is prevented than that is
> >>>>>>>>>>> equivalent to calling H and having H do something
> >>>>>>>>>>> different with side effects. This is just my opinion
> >>>>>>>>>>> though as it requires more thought and I am currently
> >>>>>>>>>>> getting drunk on gin and tonics.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> It is obviously the exact same pattern as infinite
> >>>>>>>>>> recursion (a) calling the same function a second time with
> >>>>>>>>>> the same arguments and
> >>>>>>>>>>
> >>>>>>>>>> (b) there are no instructions preceding this call that
> >>>>>>>>>> could possibly escape the infinite recursion / infinitely
> >>>>>>>>>> recursive emulation.
> >>>>>>>>>
> >>>>>>>>> Agree but refusing to analyse what P would have done if H
> >>>>>>>>> wasn't a simulating decider still makes what you've got
> >>>>>>>>> worthless as far as the Halting Problem is concerned.
> >>>>>>>>>
> >>>>>>>>> /Flibble (getting drunk, possibly not quite at Ballmer's
> >>>>>>>>> Peak)
> >>>>>>>>
> >>>>>>>> It is dead obvious to everyone (even Richard) that what P
> >>>>>>>> would have done if H was merely an x86 emulator and not a
> >>>>>>>> halt deciding emulator.
> >>>>>>>>
> >>>>>>>> The correct and complete x86 emulation of H(P,P) would never
> >>>>>>>> reach its "ret" instruction thus making H a correct "not
> >>>>>>>> reach ret" / halt decider for P.
> >>>>>>>
> >>>>>>> You need to think about a P that calls H but is
> >>>>>>> non-pathological halting (no infinite loop).
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> I have already done that and posted all of the details here
> >>>>>> about three dozen times.
> >>>>>>
> >>>>>> void P(ptr x)
> >>>>>> {
> >>>>>> if (H(x, x))
> >>>>>> HERE: goto HERE;
> >>>>>> return;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H1(P, P));
> >>>>>> }
> >>>>>>
> >>>>>> It remains true that the correct and complete x86 emulation of
> >>>>>> the input to H(P,P) by H never reaches its "ret" instruction
> >>>>>> thus never halts.
> >>>>>
> >>>>> Try reading what I actually wrote:
> >>>>>
> >>>>> void P(ptr x)
> >>>>> {
> >>>>> H(x, x); // ignore result
> >>>>> return; // halt
> >>>>> }
> >>>>>
> >>>>> How does your "decider" handle that P?
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Removing the infinite loop does not make it non pathological.
> >>>> As I have said donzens of times the infinite loop is unreachable.
> >>>>
> >>>> void Px(u32 x)
> >>>> {
> >>>> H(x, x);
> >>>> return;
> >>>> }
> >>>>
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>> }
> >>>>
> >>>> _Px()
> >>>> [000013b6](01) 55 push ebp
> >>>> [000013b7](02) 8bec mov ebp,esp
> >>>> [000013b9](03) 8b4508 mov eax,[ebp+08]
> >>>> [000013bc](01) 50 push eax
> >>>> [000013bd](03) 8b4d08 mov ecx,[ebp+08]
> >>>> [000013c0](01) 51 push ecx
> >>>> [000013c1](05) e8e0fdffff call 000011a6
> >>>> [000013c6](03) 83c408 add esp,+08
> >>>> [000013c9](01) 5d pop ebp
> >>>> [000013ca](01) c3 ret
> >>>> Size in bytes:(0021) [000013ca]
> >>>>
> >>>> _main()
> >>>> [000013d6](01) 55 push ebp
> >>>> [000013d7](02) 8bec mov ebp,esp
> >>>> [000013d9](05) 68b6130000 push 000013b6
> >>>> [000013de](05) 68b6130000 push 000013b6
> >>>> [000013e3](05) e8befdffff call 000011a6
> >>>> [000013e8](03) 83c408 add esp,+08
> >>>> [000013eb](01) 50 push eax
> >>>> [000013ec](05) 6827040000 push 00000427
> >>>> [000013f1](05) e880f0ffff call 00000476
> >>>> [000013f6](03) 83c408 add esp,+08
> >>>> [000013f9](02) 33c0 xor eax,eax
> >>>> [000013fb](01) 5d pop ebp
> >>>> [000013fc](01) c3 ret
> >>>> Size in bytes:(0039) [000013fc]
> >>>>
> >>>> machine stack stack machine assembly
> >>>> address address data code language
> >>>> ======== ======== ======== ========= ============> >>>> ...[000013d6][00102357][00000000] 55 push ebp
> >>>> ...[000013d7][00102357][00000000] 8bec mov ebp,esp
> >>>> ...[000013d9][00102353][000013b6] 68b6130000 push 000013b6
> >>>> ...[000013de][0010234f][000013b6] 68b6130000 push 000013b6
> >>>> ...[000013e3][0010234b][000013e8] e8befdffff call 000011a6
> >>>>
> >>>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>>> at:21240b ...[000013b6][002123f7][002123fb] 55 push
> >>>> ebp ...[000013b7][002123f7][002123fb] 8bec mov ebp,esp
> >>>> ...[000013b9][002123f7][002123fb] 8b4508 mov
> >>>> eax,[ebp+08] ...[000013bc][002123f3][000013b6] 50
> >>>> push eax ...[000013bd][002123f3][000013b6] 8b4d08 mov
> >>>> ecx,[ebp+08] ...[000013c0][002123ef][000013b6] 51
> >>>> push ecx ...[000013c1][002123eb][000013c6] e8e0fdffff call
> >>>> 000011a6 ...[000013b6][0025ce1f][0025ce23] 55 push
> >>>> ebp ...[000013b7][0025ce1f][0025ce23] 8bec mov ebp,esp
> >>>> ...[000013b9][0025ce1f][0025ce23] 8b4508 mov
> >>>> eax,[ebp+08] ...[000013bc][0025ce1b][000013b6] 50
> >>>> push eax ...[000013bd][0025ce1b][000013b6] 8b4d08 mov
> >>>> ecx,[ebp+08] ...[000013c0][0025ce17][000013b6] 51
> >>>> push ecx ...[000013c1][0025ce13][000013c6] e8e0fdffff call
> >>>> 000011a6 Local Halt Decider: Infinite Recursion Detected
> >>>> Simulation Stopped
> >>>>
> >>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> >>>> ...[000013eb][00102353][00000000] 50 push eax
> >>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> >>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> >>>> Input_Halts = 0
> >>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> >>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> >>>> ...[000013fb][0010235b][00100000] 5d pop ebp
> >>>> ...[000013fc][0010235f][00000004] c3 ret
> >>>> Number of Instructions Executed(16120)
> >>>
> >>> So it gets the answer wrong. QED.
> >>>
> >>> /Flibble
> >>>
> >>>
> >>
> >> comp.theory:
> >> [Solution to one instance of the Halting Problem]
> >> On 3/14/2017 9:05 AM, peteolcott wrote:
> >>
> >> This is the culmination of the essence of more than five years
> >> worth of full time work when I first discovered that a simulating
> >> halt decider could correctly determine the halt status of the
> >> "impossible" input:
> >>
> >> When a simulating halt decider rejects all inputs as non-halting
> >> whenever it correctly detects that its correct and complete
> >> simulation of its input would never reach the final state of this
> >> input that all [these] inputs (including pathological inputs) are
> >> decided correctly.
> >
> > It gets the answer wrong. QED.
> >
> > /Flibble
> >
>
> It takes an actual competent software engineer to understand that the
> complete and correct x86 emulation of the input to H(Px, Px) would
> never reach is "ret" instruction.


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<ovKdnZjUXabEQTH_nZ2dnUU7_8xh4p2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 14:56:09 -0500
Date: Fri, 17 Jun 2022 14:56:08 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617165613.00006ff4@reddwarf.jmc>
<19ednd06ecVtOjH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
<spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617194532.00006384@reddwarf.jmc>
<VNWdnT4AepokTzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617201738.000021c4@reddwarf.jmc>
<C6KdndXRT62oSjH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617203634.00000d49@reddwarf.jmc>
<wPydnRxSR-SoRDH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617204356.000070a0@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220617204356.000070a0@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ovKdnZjUXabEQTH_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 542
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ZORLzPk5tp0sAufK7a8Yl3cCpGQ+odp33NxmA1vmA+TxZbB6T4JAOZdCCPA2aL1T3iqUr/DVvZaO+fU!qzD89OW86agPemAPAJat1vtLQit3MSaUYMjIXN3FnxogrvO/QmnJRdqszH1TeDJNoMNSDa+7YupH
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
X-Original-Bytes: 28062
 by: olcott - Fri, 17 Jun 2022 19:56 UTC

On 6/17/2022 2:43 PM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 14:42:45 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/17/2022 2:36 PM, Mr Flibble wrote:
>>> On Fri, 17 Jun 2022 14:34:12 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/17/2022 2:17 PM, Mr Flibble wrote:
>>>>> On Fri, 17 Jun 2022 14:15:04 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/17/2022 1:45 PM, Mr Flibble wrote:
>>>>>>> On Fri, 17 Jun 2022 13:42:05 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/17/2022 12:14 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 17 Jun 2022 12:13:13 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 17 Jun 2022 11:59:53 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8,
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all inputs as non-halting whenever it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly detects that its correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of its input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach the final state of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then all [these] inputs (including
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pathological inputs) are decided
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Formal Languages and Automata.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Lexington/Toronto: D. C. Heath and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Company. (317-320)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call H [00001362](03) 83c408 add
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when we assume that H is only an x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator that the correctly emulated P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reaches its "ret" instruction it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> remains stuck in repeated cycles of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if H has been adapted to correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> detect (in a finite number of steps)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct and complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never each
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction that H could abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its emulation and return 0 to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined as correctly determining whether
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or not an x86 emulated input would ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its "ret" instruction then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> becomes an easily verified fact H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could correctly reject its input as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all of these things are true without any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> need what-so-ever to see either the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> source-code or the execution trace of H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not an actual encoded H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does indeed correctly determine that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach its "ret"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction as a pure function of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs. This aspect will be confirmed by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fully operational source-code.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation (V5)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hit; Genius hits a target no one else
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can see." Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider H cannot exist:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from
>>>>>>>>>>>>>>>>>>>>>>>>>>>> their inputs to an accept or reject state
>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the basis of the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) by H would never reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> "ret" instruction thus conclusively proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider (undecidable).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
>>>>>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist.
>>>>>>>>>>>>>>>>>>>>>>>>>>> You just confirms it by not able to provide
>>>>>>>>>>>>>>>>>>>>>>>>>>> POOH to test/review.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
>>>>>>>>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
>>>>>>>>>>>>>>>>>>>>>>>>>> inputs. I did not release the code before
>>>>>>>>>>>>>>>>>>>>>>>>>> because I knew that its use of static local
>>>>>>>>>>>>>>>>>>>>>>>>>> data would have been rejected. With this
>>>>>>>>>>>>>>>>>>>>>>>>>> update to H I will be able to publish the
>>>>>>>>>>>>>>>>>>>>>>>>>> code.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with
>>>>>>>>>>>>>>>>>>>>>>>>>> its same arguments that it was called with
>>>>>>>>>>>>>>>>>>>>>>>>>> and there are no instructions preceding this
>>>>>>>>>>>>>>>>>>>>>>>>>> call that could possibly escape infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>> recursive emulation so H aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P before P even makes its first
>>>>>>>>>>>>>>>>>>>>>>>>>> call to H.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Without even looking at the code competent
>>>>>>>>>>>>>>>>>>>>>>>>>> software engineers will be able to verify
>>>>>>>>>>>>>>>>>>>>>>>>>> that the above H would correctly determine
>>>>>>>>>>>>>>>>>>>>>>>>>> that that is input is non-halting as a pure
>>>>>>>>>>>>>>>>>>>>>>>>>> function of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
>>>>>>>>>>>>>>>>>>>>>>>>> function for any accepted definition of the
>>>>>>>>>>>>>>>>>>>>>>>>> term.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
>>>>>>>>>>>>>>>>>>>>>>>> function that has the following properties:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (1) the function return values are identical
>>>>>>>>>>>>>>>>>>>>>>>> for identical arguments (no variation with
>>>>>>>>>>>>>>>>>>>>>>>> local static variables, non-local variables,
>>>>>>>>>>>>>>>>>>>>>>>> mutable reference arguments or input streams),
>>>>>>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (2) the function application has no side
>>>>>>>>>>>>>>>>>>>>>>>> effects (no mutation of local static
>>>>>>>>>>>>>>>>>>>>>>>> variables, non-local variables, mutable
>>>>>>>>>>>>>>>>>>>>>>>> reference arguments or input/output streams).
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Thus a pure function is a computational
>>>>>>>>>>>>>>>>>>>>>>>> analogue of a mathematical function.
>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>>>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>>>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>>>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>>>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Whether or not it is construed as a side-effect
>>>>>>>>>>>>>>>>>>>> does not matter it must be a mutation side-effect
>>>>>>>>>>>>>>>>>>>> to (a)(b)(c)(d) or it does not count.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It doesn't count according to who?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The above definition of pure functions.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> "In computer science, an operation, function or
>>>>>>>>>>>>>>>>> expression is said to have a side effect if it
>>>>>>>>>>>>>>>>> modifies some state variable value(s) outside its
>>>>>>>>>>>>>>>>> local environment,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The second part is an inaccurate paraphrase of the
>>>>>>>>>>>>>>>> first part.
>>>>>>>>>>>>>>>>> which is to say if it has any observable effect
>>>>>>>>>>>>>>>>> other than its primary effect of returning a value to
>>>>>>>>>>>>>>>>> the invoker of the operation." --
>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> "any observable effect"
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Aborting the simulation instead of returning a value
>>>>>>>>>>>>>>>>> to the invoker disqualifies it from being a pure
>>>>>>>>>>>>>>>>> function.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its
>>>>>>>>>>>>>>>> machine address of [0000135d] the very first time
>>>>>>>>>>>>>>>> before the code at this address is emulated. Then H
>>>>>>>>>>>>>>>> returns 0 to its caller: main().
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Returning to main() is not returning to its invoker, P.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure functions
>>>>>>>>>>>>>>> do not have side effects.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do you have ADD?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> If your claim is that H is only called once and the second
>>>>>>>>>>>>> time an *attempt* to call H is prevented than that is
>>>>>>>>>>>>> equivalent to calling H and having H do something
>>>>>>>>>>>>> different with side effects. This is just my opinion
>>>>>>>>>>>>> though as it requires more thought and I am currently
>>>>>>>>>>>>> getting drunk on gin and tonics.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It is obviously the exact same pattern as infinite
>>>>>>>>>>>> recursion (a) calling the same function a second time with
>>>>>>>>>>>> the same arguments and
>>>>>>>>>>>>
>>>>>>>>>>>> (b) there are no instructions preceding this call that
>>>>>>>>>>>> could possibly escape the infinite recursion / infinitely
>>>>>>>>>>>> recursive emulation.
>>>>>>>>>>>
>>>>>>>>>>> Agree but refusing to analyse what P would have done if H
>>>>>>>>>>> wasn't a simulating decider still makes what you've got
>>>>>>>>>>> worthless as far as the Halting Problem is concerned.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble (getting drunk, possibly not quite at Ballmer's
>>>>>>>>>>> Peak)
>>>>>>>>>>
>>>>>>>>>> It is dead obvious to everyone (even Richard) that what P
>>>>>>>>>> would have done if H was merely an x86 emulator and not a
>>>>>>>>>> halt deciding emulator.
>>>>>>>>>>
>>>>>>>>>> The correct and complete x86 emulation of H(P,P) would never
>>>>>>>>>> reach its "ret" instruction thus making H a correct "not
>>>>>>>>>> reach ret" / halt decider for P.
>>>>>>>>>
>>>>>>>>> You need to think about a P that calls H but is
>>>>>>>>> non-pathological halting (no infinite loop).
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> I have already done that and posted all of the details here
>>>>>>>> about three dozen times.
>>>>>>>>
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>> if (H(x, x))
>>>>>>>> HERE: goto HERE;
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H1(P, P));
>>>>>>>> }
>>>>>>>>
>>>>>>>> It remains true that the correct and complete x86 emulation of
>>>>>>>> the input to H(P,P) by H never reaches its "ret" instruction
>>>>>>>> thus never halts.
>>>>>>>
>>>>>>> Try reading what I actually wrote:
>>>>>>>
>>>>>>> void P(ptr x)
>>>>>>> {
>>>>>>> H(x, x); // ignore result
>>>>>>> return; // halt
>>>>>>> }
>>>>>>>
>>>>>>> How does your "decider" handle that P?
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Removing the infinite loop does not make it non pathological.
>>>>>> As I have said donzens of times the infinite loop is unreachable.
>>>>>>
>>>>>> void Px(u32 x)
>>>>>> {
>>>>>> H(x, x);
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>> }
>>>>>>
>>>>>> _Px()
>>>>>> [000013b6](01) 55 push ebp
>>>>>> [000013b7](02) 8bec mov ebp,esp
>>>>>> [000013b9](03) 8b4508 mov eax,[ebp+08]
>>>>>> [000013bc](01) 50 push eax
>>>>>> [000013bd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [000013c0](01) 51 push ecx
>>>>>> [000013c1](05) e8e0fdffff call 000011a6
>>>>>> [000013c6](03) 83c408 add esp,+08
>>>>>> [000013c9](01) 5d pop ebp
>>>>>> [000013ca](01) c3 ret
>>>>>> Size in bytes:(0021) [000013ca]
>>>>>>
>>>>>> _main()
>>>>>> [000013d6](01) 55 push ebp
>>>>>> [000013d7](02) 8bec mov ebp,esp
>>>>>> [000013d9](05) 68b6130000 push 000013b6
>>>>>> [000013de](05) 68b6130000 push 000013b6
>>>>>> [000013e3](05) e8befdffff call 000011a6
>>>>>> [000013e8](03) 83c408 add esp,+08
>>>>>> [000013eb](01) 50 push eax
>>>>>> [000013ec](05) 6827040000 push 00000427
>>>>>> [000013f1](05) e880f0ffff call 00000476
>>>>>> [000013f6](03) 83c408 add esp,+08
>>>>>> [000013f9](02) 33c0 xor eax,eax
>>>>>> [000013fb](01) 5d pop ebp
>>>>>> [000013fc](01) c3 ret
>>>>>> Size in bytes:(0039) [000013fc]
>>>>>>
>>>>>> machine stack stack machine assembly
>>>>>> address address data code language
>>>>>> ======== ======== ======== ========= =============
>>>>>> ...[000013d6][00102357][00000000] 55 push ebp
>>>>>> ...[000013d7][00102357][00000000] 8bec mov ebp,esp
>>>>>> ...[000013d9][00102353][000013b6] 68b6130000 push 000013b6
>>>>>> ...[000013de][0010234f][000013b6] 68b6130000 push 000013b6
>>>>>> ...[000013e3][0010234b][000013e8] e8befdffff call 000011a6
>>>>>>
>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>>>> at:21240b ...[000013b6][002123f7][002123fb] 55 push
>>>>>> ebp ...[000013b7][002123f7][002123fb] 8bec mov ebp,esp
>>>>>> ...[000013b9][002123f7][002123fb] 8b4508 mov
>>>>>> eax,[ebp+08] ...[000013bc][002123f3][000013b6] 50
>>>>>> push eax ...[000013bd][002123f3][000013b6] 8b4d08 mov
>>>>>> ecx,[ebp+08] ...[000013c0][002123ef][000013b6] 51
>>>>>> push ecx ...[000013c1][002123eb][000013c6] e8e0fdffff call
>>>>>> 000011a6 ...[000013b6][0025ce1f][0025ce23] 55 push
>>>>>> ebp ...[000013b7][0025ce1f][0025ce23] 8bec mov ebp,esp
>>>>>> ...[000013b9][0025ce1f][0025ce23] 8b4508 mov
>>>>>> eax,[ebp+08] ...[000013bc][0025ce1b][000013b6] 50
>>>>>> push eax ...[000013bd][0025ce1b][000013b6] 8b4d08 mov
>>>>>> ecx,[ebp+08] ...[000013c0][0025ce17][000013b6] 51
>>>>>> push ecx ...[000013c1][0025ce13][000013c6] e8e0fdffff call
>>>>>> 000011a6 Local Halt Decider: Infinite Recursion Detected
>>>>>> Simulation Stopped
>>>>>>
>>>>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
>>>>>> ...[000013eb][00102353][00000000] 50 push eax
>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
>>>>>> Input_Halts = 0
>>>>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
>>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
>>>>>> ...[000013fc][0010235f][00000004] c3 ret
>>>>>> Number of Instructions Executed(16120)
>>>>>
>>>>> So it gets the answer wrong. QED.
>>>>>
>>>>> /Flibble
>>>>>
>>>>>
>>>>
>>>> comp.theory:
>>>> [Solution to one instance of the Halting Problem]
>>>> On 3/14/2017 9:05 AM, peteolcott wrote:
>>>>
>>>> This is the culmination of the essence of more than five years
>>>> worth of full time work when I first discovered that a simulating
>>>> halt decider could correctly determine the halt status of the
>>>> "impossible" input:
>>>>
>>>> When a simulating halt decider rejects all inputs as non-halting
>>>> whenever it correctly detects that its correct and complete
>>>> simulation of its input would never reach the final state of this
>>>> input that all [these] inputs (including pathological inputs) are
>>>> decided correctly.
>>>
>>> It gets the answer wrong. QED.
>>>
>>> /Flibble
>>>
>>
>> It takes an actual competent software engineer to understand that the
>> complete and correct x86 emulation of the input to H(Px, Px) would
>> never reach is "ret" instruction.
>
> It gets the answer wrong, i.e. input has not been decided correctly.
> QED.
>
> /Flibble
>


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<20220617210553.00001f51@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx12.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Message-ID: <20220617210553.00001f51@reddwarf.jmc>
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
<spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617194532.00006384@reddwarf.jmc>
<VNWdnT4AepokTzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617201738.000021c4@reddwarf.jmc>
<C6KdndXRT62oSjH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617203634.00000d49@reddwarf.jmc>
<wPydnRxSR-SoRDH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617204356.000070a0@reddwarf.jmc>
<ovKdnZjUXabEQTH_nZ2dnUU7_8xh4p2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 553
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 17 Jun 2022 20:05:53 UTC
Date: Fri, 17 Jun 2022 21:05:53 +0100
X-Received-Bytes: 29075
 by: Mr Flibble - Fri, 17 Jun 2022 20:05 UTC

On Fri, 17 Jun 2022 14:56:08 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/17/2022 2:43 PM, Mr Flibble wrote:
> > On Fri, 17 Jun 2022 14:42:45 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/17/2022 2:36 PM, Mr Flibble wrote:
> >>> On Fri, 17 Jun 2022 14:34:12 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/17/2022 2:17 PM, Mr Flibble wrote:
> >>>>> On Fri, 17 Jun 2022 14:15:04 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/17/2022 1:45 PM, Mr Flibble wrote:
> >>>>>>> On Fri, 17 Jun 2022 13:42:05 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/17/2022 12:14 PM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 17 Jun 2022 12:13:13 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 17 Jun 2022 11:59:53 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
> >>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
> >>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
> >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
> >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
> >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8,
> >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+8, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all inputs as non-halting whenever it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly detects that its correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of its input would
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach the final state of this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then all [these] inputs
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decided correctly.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Formal Languages and Automata.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Lexington/Toronto: D. C. Heath and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Company. (317-320)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call H [00001362](03) 83c408 add
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [00001365](02) 85c0 test
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when we assume that H is only an x86
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator that the correctly emulated P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reaches its "ret" instruction it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> remains stuck in repeated cycles of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if H has been adapted to correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> detect (in a finite number of steps)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct and complete x86
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never each
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction that H could
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its emulation and return 0 to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report this.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined as correctly determining
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not an x86 emulated input
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would ever reach its "ret" instruction
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it becomes an easily verified
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fact H(P,P) could correctly reject its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all of these things are true without
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any need what-so-ever to see either the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> source-code or the execution trace of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not an actual encoded H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does indeed correctly determine that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input would never reach its "ret"
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction as a pure function of its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs. This aspect will be confirmed
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by fully operational source-code.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation (V5)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hit; Genius hits a target no one else
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can see." Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider H cannot exist:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> That is a misconception.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> from their inputs to an accept or reject
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> actually specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) by H would never reach
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction thus conclusively
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> proving that it never halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider (undecidable).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> -----
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> --
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> hit; Genius hits a target no one else
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> can see." Arthur Schopenhauer
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> You just confirms it by not able to
> >>>>>>>>>>>>>>>>>>>>>>>>>>> provide POOH to test/review.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
> >>>>>>>>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of
> >>>>>>>>>>>>>>>>>>>>>>>>>> its inputs. I did not release the code
> >>>>>>>>>>>>>>>>>>>>>>>>>> before because I knew that its use of
> >>>>>>>>>>>>>>>>>>>>>>>>>> static local data would have been
> >>>>>>>>>>>>>>>>>>>>>>>>>> rejected. With this update to H I will be
> >>>>>>>>>>>>>>>>>>>>>>>>>> able to publish the code.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with
> >>>>>>>>>>>>>>>>>>>>>>>>>> its same arguments that it was called with
> >>>>>>>>>>>>>>>>>>>>>>>>>> and there are no instructions preceding
> >>>>>>>>>>>>>>>>>>>>>>>>>> this call that could possibly escape
> >>>>>>>>>>>>>>>>>>>>>>>>>> infinitely recursive emulation so H aborts
> >>>>>>>>>>>>>>>>>>>>>>>>>> its emulation of P before P even makes its
> >>>>>>>>>>>>>>>>>>>>>>>>>> first call to H.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Without even looking at the code competent
> >>>>>>>>>>>>>>>>>>>>>>>>>> software engineers will be able to verify
> >>>>>>>>>>>>>>>>>>>>>>>>>> that the above H would correctly determine
> >>>>>>>>>>>>>>>>>>>>>>>>>> that that is input is non-halting as a pure
> >>>>>>>>>>>>>>>>>>>>>>>>>> function of this input.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a
> >>>>>>>>>>>>>>>>>>>>>>>>> pure function for any accepted definition
> >>>>>>>>>>>>>>>>>>>>>>>>> of the term.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
> >>>>>>>>>>>>>>>>>>>>>>>> function that has the following properties:
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> (1) the function return values are identical
> >>>>>>>>>>>>>>>>>>>>>>>> for identical arguments (no variation with
> >>>>>>>>>>>>>>>>>>>>>>>> local static variables, non-local variables,
> >>>>>>>>>>>>>>>>>>>>>>>> mutable reference arguments or input
> >>>>>>>>>>>>>>>>>>>>>>>> streams), and
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> (2) the function application has no side
> >>>>>>>>>>>>>>>>>>>>>>>> effects (no mutation of local static
> >>>>>>>>>>>>>>>>>>>>>>>> variables, non-local variables, mutable
> >>>>>>>>>>>>>>>>>>>>>>>> reference arguments or input/output streams).
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Thus a pure function is a computational
> >>>>>>>>>>>>>>>>>>>>>>>> analogue of a mathematical function.
> >>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> The revised H has no:
> >>>>>>>>>>>>>>>>>>>>>>>> (a) local static variables
> >>>>>>>>>>>>>>>>>>>>>>>> (b) non-local variables
> >>>>>>>>>>>>>>>>>>>>>>>> (c) mutable reference arguments
> >>>>>>>>>>>>>>>>>>>>>>>> (d) input streams
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> >>>>>>>>>>>>>>>>>>>>>>> functions do not have side effects.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> You have a reading comprehension problem.
> >>>>>>>>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
> >>>>>>>>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Not at all, but you do seem to have that
> >>>>>>>>>>>>>>>>>>>>> problem.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Again:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> >>>>>>>>>>>>>>>>>>>>> functions do not have side effects.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Whether or not it is construed as a side-effect
> >>>>>>>>>>>>>>>>>>>> does not matter it must be a mutation side-effect
> >>>>>>>>>>>>>>>>>>>> to (a)(b)(c)(d) or it does not count.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> It doesn't count according to who?
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> The above definition of pure functions.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> "In computer science, an operation, function or
> >>>>>>>>>>>>>>>>> expression is said to have a side effect if it
> >>>>>>>>>>>>>>>>> modifies some state variable value(s) outside its
> >>>>>>>>>>>>>>>>> local environment,
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> The second part is an inaccurate paraphrase of the
> >>>>>>>>>>>>>>>> first part.
> >>>>>>>>>>>>>>>>> which is to say if it has any observable effect
> >>>>>>>>>>>>>>>>> other than its primary effect of returning a value
> >>>>>>>>>>>>>>>>> to the invoker of the operation." --
> >>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> "any observable effect"
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Aborting the simulation instead of returning a value
> >>>>>>>>>>>>>>>>> to the invoker disqualifies it from being a pure
> >>>>>>>>>>>>>>>>> function.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> if (H(x, x))
> >>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
> >>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>> [00001358](01) 50 push eax //
> >>>>>>>>>>>>>>>> push P [00001359](03) 8b4d08 mov
> >>>>>>>>>>>>>>>> ecx,[ebp+08] [0000135c](01) 51 push
> >>>>>>>>>>>>>>>> ecx // push P [0000135d](05) e840feffff
> >>>>>>>>>>>>>>>> call 000011a2 // call H [00001362](03) 83c408
> >>>>>>>>>>>>>>>> add esp,+08 [00001365](02) 85c0 test
> >>>>>>>>>>>>>>>> eax,eax [00001367](02) 7402 jz 0000136b
> >>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
> >>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
> >>>>>>>>>>>>>>>> [0000136c](01) c3 ret
> >>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its
> >>>>>>>>>>>>>>>> machine address of [0000135d] the very first time
> >>>>>>>>>>>>>>>> before the code at this address is emulated. Then H
> >>>>>>>>>>>>>>>> returns 0 to its caller: main().
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Returning to main() is not returning to its invoker,
> >>>>>>>>>>>>>>> P.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Again:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
> >>>>>>>>>>>>>>> functions do not have side effects.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Do you have ADD?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If your claim is that H is only called once and the
> >>>>>>>>>>>>> second time an *attempt* to call H is prevented than
> >>>>>>>>>>>>> that is equivalent to calling H and having H do
> >>>>>>>>>>>>> something different with side effects. This is just my
> >>>>>>>>>>>>> opinion though as it requires more thought and I am
> >>>>>>>>>>>>> currently getting drunk on gin and tonics.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> It is obviously the exact same pattern as infinite
> >>>>>>>>>>>> recursion (a) calling the same function a second time
> >>>>>>>>>>>> with the same arguments and
> >>>>>>>>>>>>
> >>>>>>>>>>>> (b) there are no instructions preceding this call that
> >>>>>>>>>>>> could possibly escape the infinite recursion / infinitely
> >>>>>>>>>>>> recursive emulation.
> >>>>>>>>>>>
> >>>>>>>>>>> Agree but refusing to analyse what P would have done if H
> >>>>>>>>>>> wasn't a simulating decider still makes what you've got
> >>>>>>>>>>> worthless as far as the Halting Problem is concerned.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble (getting drunk, possibly not quite at Ballmer's
> >>>>>>>>>>> Peak)
> >>>>>>>>>>
> >>>>>>>>>> It is dead obvious to everyone (even Richard) that what P
> >>>>>>>>>> would have done if H was merely an x86 emulator and not a
> >>>>>>>>>> halt deciding emulator.
> >>>>>>>>>>
> >>>>>>>>>> The correct and complete x86 emulation of H(P,P) would
> >>>>>>>>>> never reach its "ret" instruction thus making H a correct
> >>>>>>>>>> "not reach ret" / halt decider for P.
> >>>>>>>>>
> >>>>>>>>> You need to think about a P that calls H but is
> >>>>>>>>> non-pathological halting (no infinite loop).
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> I have already done that and posted all of the details here
> >>>>>>>> about three dozen times.
> >>>>>>>>
> >>>>>>>> void P(ptr x)
> >>>>>>>> {
> >>>>>>>> if (H(x, x))
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> return;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> int main()
> >>>>>>>> {
> >>>>>>>> Output("Input_Halts = ", H1(P, P));
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> It remains true that the correct and complete x86 emulation
> >>>>>>>> of the input to H(P,P) by H never reaches its "ret"
> >>>>>>>> instruction thus never halts.
> >>>>>>>
> >>>>>>> Try reading what I actually wrote:
> >>>>>>>
> >>>>>>> void P(ptr x)
> >>>>>>> {
> >>>>>>> H(x, x); // ignore result
> >>>>>>> return; // halt
> >>>>>>> }
> >>>>>>>
> >>>>>>> How does your "decider" handle that P?
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> Removing the infinite loop does not make it non pathological.
> >>>>>> As I have said donzens of times the infinite loop is
> >>>>>> unreachable.
> >>>>>>
> >>>>>> void Px(u32 x)
> >>>>>> {
> >>>>>> H(x, x);
> >>>>>> return;
> >>>>>> }
> >>>>>>
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>> }
> >>>>>>
> >>>>>> _Px()
> >>>>>> [000013b6](01) 55 push ebp
> >>>>>> [000013b7](02) 8bec mov ebp,esp
> >>>>>> [000013b9](03) 8b4508 mov eax,[ebp+08]
> >>>>>> [000013bc](01) 50 push eax
> >>>>>> [000013bd](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>> [000013c0](01) 51 push ecx
> >>>>>> [000013c1](05) e8e0fdffff call 000011a6
> >>>>>> [000013c6](03) 83c408 add esp,+08
> >>>>>> [000013c9](01) 5d pop ebp
> >>>>>> [000013ca](01) c3 ret
> >>>>>> Size in bytes:(0021) [000013ca]
> >>>>>>
> >>>>>> _main()
> >>>>>> [000013d6](01) 55 push ebp
> >>>>>> [000013d7](02) 8bec mov ebp,esp
> >>>>>> [000013d9](05) 68b6130000 push 000013b6
> >>>>>> [000013de](05) 68b6130000 push 000013b6
> >>>>>> [000013e3](05) e8befdffff call 000011a6
> >>>>>> [000013e8](03) 83c408 add esp,+08
> >>>>>> [000013eb](01) 50 push eax
> >>>>>> [000013ec](05) 6827040000 push 00000427
> >>>>>> [000013f1](05) e880f0ffff call 00000476
> >>>>>> [000013f6](03) 83c408 add esp,+08
> >>>>>> [000013f9](02) 33c0 xor eax,eax
> >>>>>> [000013fb](01) 5d pop ebp
> >>>>>> [000013fc](01) c3 ret
> >>>>>> Size in bytes:(0039) [000013fc]
> >>>>>>
> >>>>>> machine stack stack machine assembly
> >>>>>> address address data code language
> >>>>>> ======== ======== ======== ========= ============> >>>>>> ...[000013d6][00102357][00000000] 55 push ebp
> >>>>>> ...[000013d7][00102357][00000000] 8bec mov ebp,esp
> >>>>>> ...[000013d9][00102353][000013b6] 68b6130000 push 000013b6
> >>>>>> ...[000013de][0010234f][000013b6] 68b6130000 push 000013b6
> >>>>>> ...[000013e3][0010234b][000013e8] e8befdffff call 000011a6
> >>>>>>
> >>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
> >>>>>> at:21240b ...[000013b6][002123f7][002123fb] 55
> >>>>>> push ebp ...[000013b7][002123f7][002123fb] 8bec mov
> >>>>>> ebp,esp ...[000013b9][002123f7][002123fb] 8b4508 mov
> >>>>>> eax,[ebp+08] ...[000013bc][002123f3][000013b6] 50
> >>>>>> push eax ...[000013bd][002123f3][000013b6] 8b4d08 mov
> >>>>>> ecx,[ebp+08] ...[000013c0][002123ef][000013b6] 51
> >>>>>> push ecx ...[000013c1][002123eb][000013c6] e8e0fdffff call
> >>>>>> 000011a6 ...[000013b6][0025ce1f][0025ce23] 55 push
> >>>>>> ebp ...[000013b7][0025ce1f][0025ce23] 8bec mov
> >>>>>> ebp,esp ...[000013b9][0025ce1f][0025ce23] 8b4508 mov
> >>>>>> eax,[ebp+08] ...[000013bc][0025ce1b][000013b6] 50
> >>>>>> push eax ...[000013bd][0025ce1b][000013b6] 8b4d08 mov
> >>>>>> ecx,[ebp+08] ...[000013c0][0025ce17][000013b6] 51
> >>>>>> push ecx ...[000013c1][0025ce13][000013c6] e8e0fdffff call
> >>>>>> 000011a6 Local Halt Decider: Infinite Recursion Detected
> >>>>>> Simulation Stopped
> >>>>>>
> >>>>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> >>>>>> ...[000013eb][00102353][00000000] 50 push eax
> >>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> >>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> >>>>>> Input_Halts = 0
> >>>>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> >>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> >>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
> >>>>>> ...[000013fc][0010235f][00000004] c3 ret
> >>>>>> Number of Instructions Executed(16120)
> >>>>>
> >>>>> So it gets the answer wrong. QED.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>>
> >>>>
> >>>> comp.theory:
> >>>> [Solution to one instance of the Halting Problem]
> >>>> On 3/14/2017 9:05 AM, peteolcott wrote:
> >>>>
> >>>> This is the culmination of the essence of more than five years
> >>>> worth of full time work when I first discovered that a simulating
> >>>> halt decider could correctly determine the halt status of the
> >>>> "impossible" input:
> >>>>
> >>>> When a simulating halt decider rejects all inputs as non-halting
> >>>> whenever it correctly detects that its correct and complete
> >>>> simulation of its input would never reach the final state of this
> >>>> input that all [these] inputs (including pathological inputs) are
> >>>> decided correctly.
> >>>
> >>> It gets the answer wrong. QED.
> >>>
> >>> /Flibble
> >>>
> >>
> >> It takes an actual competent software engineer to understand that
> >> the complete and correct x86 emulation of the input to H(Px, Px)
> >> would never reach is "ret" instruction.
> >
> > It gets the answer wrong, i.e. input has not been decided correctly.
> > QED.
> >
> > /Flibble
> >
>
> In other words when I told you that the actual issued is infinitely
> recursive emulation 150 times you made sure to always ignore
> everything that I said.

Click here to read the complete article

Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<srudnRoUE9E_eTH_nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 17 Jun 2022 15:31:30 -0500
Date: Fri, 17 Jun 2022 15:31:29 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617171424.00006f1f@reddwarf.jmc>
<19edndw6ecVNNTH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617172234.00000777@reddwarf.jmc>
<5_2dnT82vrNOMTH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617173640.00006b94@reddwarf.jmc>
<BfidnQwGbdqbMzH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617175104.00001454@reddwarf.jmc>
<d56dnQTwFZOXLjH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617180447.00003b49@reddwarf.jmc>
<-M-dnYc6NqG3KzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617181448.00005cdb@reddwarf.jmc>
<spCdna12j9BjVzH_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220617194532.00006384@reddwarf.jmc>
<VNWdnT4AepokTzH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617201738.000021c4@reddwarf.jmc>
<C6KdndXRT62oSjH_nZ2dnUU7_83NnZ2d@giganews.com>
<20220617203634.00000d49@reddwarf.jmc>
<wPydnRxSR-SoRDH_nZ2dnUU7_81g4p2d@giganews.com>
<20220617204356.000070a0@reddwarf.jmc>
<ovKdnZjUXabEQTH_nZ2dnUU7_8xh4p2d@giganews.com>
<20220617210553.00001f51@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220617210553.00001f51@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <srudnRoUE9E_eTH_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 574
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-u63+i1XQvWk9J3ijgwxeELJwltg4j2l3rJjjgQyHDEzq0FFLnmI5VF1VE+IBvDiD0c5GpK+OUhac7Yt!abIDM9kZ3lo617gYM2nAkAA9niJoZxF2XLQY6OiaxTXTq8vyiqNdDFOBGw8tdY8dr4pLCjJAVB0f
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
X-Original-Bytes: 30331
 by: olcott - Fri, 17 Jun 2022 20:31 UTC

On 6/17/2022 3:05 PM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 14:56:08 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/17/2022 2:43 PM, Mr Flibble wrote:
>>> On Fri, 17 Jun 2022 14:42:45 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/17/2022 2:36 PM, Mr Flibble wrote:
>>>>> On Fri, 17 Jun 2022 14:34:12 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/17/2022 2:17 PM, Mr Flibble wrote:
>>>>>>> On Fri, 17 Jun 2022 14:15:04 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/17/2022 1:45 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 17 Jun 2022 13:42:05 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/17/2022 12:14 PM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 17 Jun 2022 12:13:13 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:59:53 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+8, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all inputs as non-halting whenever it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly detects that its correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of its input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach the final state of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then all [these] inputs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (including pathological inputs) are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decided correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Formal Languages and Automata.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Lexington/Toronto: D. C. Heath and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Company. (317-320)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // call H [00001362](03) 83c408 add
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [00001365](02) 85c0 test
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when we assume that H is only an x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulator that the correctly emulated P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reaches its "ret" instruction it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> remains stuck in repeated cycles of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if H has been adapted to correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> detect (in a finite number of steps)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the correct and complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never each
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction that H could
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its emulation and return 0 to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report this.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined as correctly determining
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not an x86 emulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would ever reach its "ret" instruction
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then it becomes an easily verified
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fact H(P,P) could correctly reject its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all of these things are true without
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any need what-so-ever to see either the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> source-code or the execution trace of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not an actual encoded H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does indeed correctly determine that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input would never reach its "ret"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction as a pure function of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs. This aspect will be confirmed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by fully operational source-code.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested simulation (V5)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hit; Genius hits a target no one else
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can see." Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider H cannot exist:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from their inputs to an accept or reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) by H would never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction thus conclusively
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proving that it never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider (undecidable).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hit; Genius hits a target no one else
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can see." Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just confirms it by not able to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provide POOH to test/review.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its inputs. I did not release the code
>>>>>>>>>>>>>>>>>>>>>>>>>>>> before because I knew that its use of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> static local data would have been
>>>>>>>>>>>>>>>>>>>>>>>>>>>> rejected. With this update to H I will be
>>>>>>>>>>>>>>>>>>>>>>>>>>>> able to publish the code.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its same arguments that it was called with
>>>>>>>>>>>>>>>>>>>>>>>>>>>> and there are no instructions preceding
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this call that could possibly escape
>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely recursive emulation so H aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its emulation of P before P even makes its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> first call to H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Without even looking at the code competent
>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineers will be able to verify
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the above H would correctly determine
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that that is input is non-halting as a pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>> function of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>> pure function for any accepted definition
>>>>>>>>>>>>>>>>>>>>>>>>>>> of the term.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
>>>>>>>>>>>>>>>>>>>>>>>>>> function that has the following properties:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (1) the function return values are identical
>>>>>>>>>>>>>>>>>>>>>>>>>> for identical arguments (no variation with
>>>>>>>>>>>>>>>>>>>>>>>>>> local static variables, non-local variables,
>>>>>>>>>>>>>>>>>>>>>>>>>> mutable reference arguments or input
>>>>>>>>>>>>>>>>>>>>>>>>>> streams), and
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (2) the function application has no side
>>>>>>>>>>>>>>>>>>>>>>>>>> effects (no mutation of local static
>>>>>>>>>>>>>>>>>>>>>>>>>> variables, non-local variables, mutable
>>>>>>>>>>>>>>>>>>>>>>>>>> reference arguments or input/output streams).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Thus a pure function is a computational
>>>>>>>>>>>>>>>>>>>>>>>>>> analogue of a mathematical function.
>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>>>>>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>>>>>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>>>>>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>>>>>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Not at all, but you do seem to have that
>>>>>>>>>>>>>>>>>>>>>>> problem.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Whether or not it is construed as a side-effect
>>>>>>>>>>>>>>>>>>>>>> does not matter it must be a mutation side-effect
>>>>>>>>>>>>>>>>>>>>>> to (a)(b)(c)(d) or it does not count.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It doesn't count according to who?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The above definition of pure functions.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> "In computer science, an operation, function or
>>>>>>>>>>>>>>>>>>> expression is said to have a side effect if it
>>>>>>>>>>>>>>>>>>> modifies some state variable value(s) outside its
>>>>>>>>>>>>>>>>>>> local environment,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The second part is an inaccurate paraphrase of the
>>>>>>>>>>>>>>>>>> first part.
>>>>>>>>>>>>>>>>>>> which is to say if it has any observable effect
>>>>>>>>>>>>>>>>>>> other than its primary effect of returning a value
>>>>>>>>>>>>>>>>>>> to the invoker of the operation." --
>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> "any observable effect"
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Aborting the simulation instead of returning a value
>>>>>>>>>>>>>>>>>>> to the invoker disqualifies it from being a pure
>>>>>>>>>>>>>>>>>>> function.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax //
>>>>>>>>>>>>>>>>>> push P [00001359](03) 8b4d08 mov
>>>>>>>>>>>>>>>>>> ecx,[ebp+08] [0000135c](01) 51 push
>>>>>>>>>>>>>>>>>> ecx // push P [0000135d](05) e840feffff
>>>>>>>>>>>>>>>>>> call 000011a2 // call H [00001362](03) 83c408
>>>>>>>>>>>>>>>>>> add esp,+08 [00001365](02) 85c0 test
>>>>>>>>>>>>>>>>>> eax,eax [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its
>>>>>>>>>>>>>>>>>> machine address of [0000135d] the very first time
>>>>>>>>>>>>>>>>>> before the code at this address is emulated. Then H
>>>>>>>>>>>>>>>>>> returns 0 to its caller: main().
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Returning to main() is not returning to its invoker,
>>>>>>>>>>>>>>>>> P.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do you have ADD?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If your claim is that H is only called once and the
>>>>>>>>>>>>>>> second time an *attempt* to call H is prevented than
>>>>>>>>>>>>>>> that is equivalent to calling H and having H do
>>>>>>>>>>>>>>> something different with side effects. This is just my
>>>>>>>>>>>>>>> opinion though as it requires more thought and I am
>>>>>>>>>>>>>>> currently getting drunk on gin and tonics.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is obviously the exact same pattern as infinite
>>>>>>>>>>>>>> recursion (a) calling the same function a second time
>>>>>>>>>>>>>> with the same arguments and
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (b) there are no instructions preceding this call that
>>>>>>>>>>>>>> could possibly escape the infinite recursion / infinitely
>>>>>>>>>>>>>> recursive emulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Agree but refusing to analyse what P would have done if H
>>>>>>>>>>>>> wasn't a simulating decider still makes what you've got
>>>>>>>>>>>>> worthless as far as the Halting Problem is concerned.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble (getting drunk, possibly not quite at Ballmer's
>>>>>>>>>>>>> Peak)
>>>>>>>>>>>>
>>>>>>>>>>>> It is dead obvious to everyone (even Richard) that what P
>>>>>>>>>>>> would have done if H was merely an x86 emulator and not a
>>>>>>>>>>>> halt deciding emulator.
>>>>>>>>>>>>
>>>>>>>>>>>> The correct and complete x86 emulation of H(P,P) would
>>>>>>>>>>>> never reach its "ret" instruction thus making H a correct
>>>>>>>>>>>> "not reach ret" / halt decider for P.
>>>>>>>>>>>
>>>>>>>>>>> You need to think about a P that calls H but is
>>>>>>>>>>> non-pathological halting (no infinite loop).
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I have already done that and posted all of the details here
>>>>>>>>>> about three dozen times.
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>> if (H(x, x))
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H1(P, P));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> It remains true that the correct and complete x86 emulation
>>>>>>>>>> of the input to H(P,P) by H never reaches its "ret"
>>>>>>>>>> instruction thus never halts.
>>>>>>>>>
>>>>>>>>> Try reading what I actually wrote:
>>>>>>>>>
>>>>>>>>> void P(ptr x)
>>>>>>>>> {
>>>>>>>>> H(x, x); // ignore result
>>>>>>>>> return; // halt
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> How does your "decider" handle that P?
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Removing the infinite loop does not make it non pathological.
>>>>>>>> As I have said donzens of times the infinite loop is
>>>>>>>> unreachable.
>>>>>>>>
>>>>>>>> void Px(u32 x)
>>>>>>>> {
>>>>>>>> H(x, x);
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>> }
>>>>>>>>
>>>>>>>> _Px()
>>>>>>>> [000013b6](01) 55 push ebp
>>>>>>>> [000013b7](02) 8bec mov ebp,esp
>>>>>>>> [000013b9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>> [000013bc](01) 50 push eax
>>>>>>>> [000013bd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [000013c0](01) 51 push ecx
>>>>>>>> [000013c1](05) e8e0fdffff call 000011a6
>>>>>>>> [000013c6](03) 83c408 add esp,+08
>>>>>>>> [000013c9](01) 5d pop ebp
>>>>>>>> [000013ca](01) c3 ret
>>>>>>>> Size in bytes:(0021) [000013ca]
>>>>>>>>
>>>>>>>> _main()
>>>>>>>> [000013d6](01) 55 push ebp
>>>>>>>> [000013d7](02) 8bec mov ebp,esp
>>>>>>>> [000013d9](05) 68b6130000 push 000013b6
>>>>>>>> [000013de](05) 68b6130000 push 000013b6
>>>>>>>> [000013e3](05) e8befdffff call 000011a6
>>>>>>>> [000013e8](03) 83c408 add esp,+08
>>>>>>>> [000013eb](01) 50 push eax
>>>>>>>> [000013ec](05) 6827040000 push 00000427
>>>>>>>> [000013f1](05) e880f0ffff call 00000476
>>>>>>>> [000013f6](03) 83c408 add esp,+08
>>>>>>>> [000013f9](02) 33c0 xor eax,eax
>>>>>>>> [000013fb](01) 5d pop ebp
>>>>>>>> [000013fc](01) c3 ret
>>>>>>>> Size in bytes:(0039) [000013fc]
>>>>>>>>
>>>>>>>> machine stack stack machine assembly
>>>>>>>> address address data code language
>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>> ...[000013d6][00102357][00000000] 55 push ebp
>>>>>>>> ...[000013d7][00102357][00000000] 8bec mov ebp,esp
>>>>>>>> ...[000013d9][00102353][000013b6] 68b6130000 push 000013b6
>>>>>>>> ...[000013de][0010234f][000013b6] 68b6130000 push 000013b6
>>>>>>>> ...[000013e3][0010234b][000013e8] e8befdffff call 000011a6
>>>>>>>>
>>>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored
>>>>>>>> at:21240b ...[000013b6][002123f7][002123fb] 55
>>>>>>>> push ebp ...[000013b7][002123f7][002123fb] 8bec mov
>>>>>>>> ebp,esp ...[000013b9][002123f7][002123fb] 8b4508 mov
>>>>>>>> eax,[ebp+08] ...[000013bc][002123f3][000013b6] 50
>>>>>>>> push eax ...[000013bd][002123f3][000013b6] 8b4d08 mov
>>>>>>>> ecx,[ebp+08] ...[000013c0][002123ef][000013b6] 51
>>>>>>>> push ecx ...[000013c1][002123eb][000013c6] e8e0fdffff call
>>>>>>>> 000011a6 ...[000013b6][0025ce1f][0025ce23] 55 push
>>>>>>>> ebp ...[000013b7][0025ce1f][0025ce23] 8bec mov
>>>>>>>> ebp,esp ...[000013b9][0025ce1f][0025ce23] 8b4508 mov
>>>>>>>> eax,[ebp+08] ...[000013bc][0025ce1b][000013b6] 50
>>>>>>>> push eax ...[000013bd][0025ce1b][000013b6] 8b4d08 mov
>>>>>>>> ecx,[ebp+08] ...[000013c0][0025ce17][000013b6] 51
>>>>>>>> push ecx ...[000013c1][0025ce13][000013c6] e8e0fdffff call
>>>>>>>> 000011a6 Local Halt Decider: Infinite Recursion Detected
>>>>>>>> Simulation Stopped
>>>>>>>>
>>>>>>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
>>>>>>>> ...[000013eb][00102353][00000000] 50 push eax
>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
>>>>>>>> Input_Halts = 0
>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
>>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
>>>>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret
>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>
>>>>>>> So it gets the answer wrong. QED.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> comp.theory:
>>>>>> [Solution to one instance of the Halting Problem]
>>>>>> On 3/14/2017 9:05 AM, peteolcott wrote:
>>>>>>
>>>>>> This is the culmination of the essence of more than five years
>>>>>> worth of full time work when I first discovered that a simulating
>>>>>> halt decider could correctly determine the halt status of the
>>>>>> "impossible" input:
>>>>>>
>>>>>> When a simulating halt decider rejects all inputs as non-halting
>>>>>> whenever it correctly detects that its correct and complete
>>>>>> simulation of its input would never reach the final state of this
>>>>>> input that all [these] inputs (including pathological inputs) are
>>>>>> decided correctly.
>>>>>
>>>>> It gets the answer wrong. QED.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> It takes an actual competent software engineer to understand that
>>>> the complete and correct x86 emulation of the input to H(Px, Px)
>>>> would never reach is "ret" instruction.
>>>
>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>> QED.
>>>
>>> /Flibble
>>>
>>
>> In other words when I told you that the actual issued is infinitely
>> recursive emulation 150 times you made sure to always ignore
>> everything that I said.
>
> Px will always halt with a non-simulating "decider"; your "simulating
> decider" behaves differently, getting the answer wrong. QED.
>
> /Flibble
>


Click here to read the complete article
Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<wl9rK.179137$70j.81241@fx16.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx16.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.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<912de0f6-ed7e-432b-a66f-151b90a3165dn@googlegroups.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 117
Message-ID: <wl9rK.179137$70j.81241@fx16.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: Fri, 17 Jun 2022 20:52:44 -0400
X-Received-Bytes: 5240
 by: Richard Damon - Sat, 18 Jun 2022 00:52 UTC

On 6/17/22 10:19 AM, olcott wrote:
> On 6/17/2022 8:39 AM, wij wrote:
>> On Friday, 17 June 2022 at 19:29:37 UTC+8, olcott wrote:
>>> When a simulating halt decider rejects all inputs as non-halting
>>> whenever it correctly detects that its correct and complete simulation
>>> of its input would never reach the final state of this input then all
>>> [these] inputs (including pathological inputs) are decided correctly.
>>>
>>> *computation that halts* … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>>
>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>>
>>> #include <stdint.h>
>>> typedef void (*ptr)();
>>>
>>> void P(ptr x)
>>> {
>>> if (H(x, x))
>>> HERE: goto HERE;
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H(P, P));
>>> }
>>>
>>> _P()
>>> [00001352](01) 55 push ebp
>>> [00001353](02) 8bec mov ebp,esp
>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>> [00001358](01) 50 push eax // push P
>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>> [0000135c](01) 51 push ecx // push P
>>> [0000135d](05) e840feffff call 000011a2 // call H
>>> [00001362](03) 83c408 add esp,+08
>>> [00001365](02) 85c0 test eax,eax
>>> [00001367](02) 7402 jz 0000136b
>>> [00001369](02) ebfe jmp 00001369
>>> [0000136b](01) 5d pop ebp
>>> [0000136c](01) c3 ret
>>> Size in bytes:(0027) [0000136c]
>>>
>>> (1) It is an easily verified fact that when we assume that H is only an
>>> x86 emulator that the correctly emulated P never reaches its "ret"
>>> instruction it remains stuck in repeated cycles of emulation.
>>>
>>> (2) It is an easily verified fact that if H has been adapted to
>>> correctly detect (in a finite number of steps) that the correct and
>>> complete x86 emulation of its input would never each its "ret"
>>> instruction that H could abort its emulation and return 0 to report
>>> this.
>>>
>>> (3) When the halt status criteria is defined as correctly determining
>>> whether or not an x86 emulated input would ever reach its "ret"
>>> instruction then it becomes an easily verified fact H(P,P) could
>>> correctly reject its input as non-halting.
>>>
>>> Correct deductive inference proves that all of these things are true
>>> without any need what-so-ever to see either the source-code or the
>>> execution trace of H.
>>>
>>> The one thing that is not proved is whether or not an actual encoded
>>> H(P,P) does indeed correctly determine that its input would never reach
>>> its "ret" instruction as a pure function of its inputs. This aspect will
>>> be confirmed by fully operational source-code.
>>>
>>>
>>>
>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>
>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>
>>>
>>>
>>> --
>>> Copyright 2022 Pete Olcott
>>>
>>> "Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see."
>>> Arthur Schopenhauer
>>
>> GUR already suggested such a halting decider H cannot exist:
>>
>> H(P,P)==0 means P(P) does not halt.
>
> That is a misconception.
>
> Halt deciders must compute the mapping from their inputs to an accept or
> reject state on the basis of the actual behavior actually specified by
> these inputs.
>
> It is an easily verified fact that the correct and complete x86
> emulation of the input to H(P,P) by H would never reach its "ret"
> instruction thus conclusively proving that it never halts.
>

What was the first instruction where it differed? Since the DEFINITION
is they are the same, you need to show some real proof that they differ.

Note, your "hand-waving" about assuming what H does is just incorrect
and NOT an actual emulation of the input, and shows that you are just lying.

>
>> H(P,P)==1 means P(P) halts.
>> H(P,P)==Otherwise means H fails as a decider (undecidable).
>>
>> -----
>> Thanks to PO's years' tireless efforts demonstrated even himself a
>> genius in 10000-years
>> cannot refute my GUR. ...
>
>

Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<_l9rK.179138$70j.122393@fx16.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx16.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.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<912de0f6-ed7e-432b-a66f-151b90a3165dn@googlegroups.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 135
Message-ID: <_l9rK.179138$70j.122393@fx16.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: Fri, 17 Jun 2022 20:53:13 -0400
X-Received-Bytes: 6422
 by: Richard Damon - Sat, 18 Jun 2022 00:53 UTC

On 6/17/22 10:51 AM, olcott wrote:
> On 6/17/2022 9:39 AM, wij wrote:
>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott wrote:
>>> On 6/17/2022 8:39 AM, wij wrote:
>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8, olcott wrote:
>>>>> When a simulating halt decider rejects all inputs as non-halting
>>>>> whenever it correctly detects that its correct and complete simulation
>>>>> of its input would never reach the final state of this input then all
>>>>> [these] inputs (including pathological inputs) are decided correctly.
>>>>>
>>>>> *computation that halts* … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>>>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>>>>
>>>>> #include <stdint.h>
>>>>> typedef void (*ptr)();
>>>>>
>>>>> void P(ptr x)
>>>>> {
>>>>> if (H(x, x))
>>>>> HERE: goto HERE;
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H(P, P));
>>>>> }
>>>>>
>>>>> _P()
>>>>> [00001352](01) 55 push ebp
>>>>> [00001353](02) 8bec mov ebp,esp
>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>> [00001358](01) 50 push eax // push P
>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>> [0000135c](01) 51 push ecx // push P
>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>> [00001362](03) 83c408 add esp,+08
>>>>> [00001365](02) 85c0 test eax,eax
>>>>> [00001367](02) 7402 jz 0000136b
>>>>> [00001369](02) ebfe jmp 00001369
>>>>> [0000136b](01) 5d pop ebp
>>>>> [0000136c](01) c3 ret
>>>>> Size in bytes:(0027) [0000136c]
>>>>>
>>>>> (1) It is an easily verified fact that when we assume that H is
>>>>> only an
>>>>> x86 emulator that the correctly emulated P never reaches its "ret"
>>>>> instruction it remains stuck in repeated cycles of emulation.
>>>>>
>>>>> (2) It is an easily verified fact that if H has been adapted to
>>>>> correctly detect (in a finite number of steps) that the correct and
>>>>> complete x86 emulation of its input would never each its "ret"
>>>>> instruction that H could abort its emulation and return 0 to report
>>>>> this.
>>>>>
>>>>> (3) When the halt status criteria is defined as correctly determining
>>>>> whether or not an x86 emulated input would ever reach its "ret"
>>>>> instruction then it becomes an easily verified fact H(P,P) could
>>>>> correctly reject its input as non-halting.
>>>>>
>>>>> Correct deductive inference proves that all of these things are true
>>>>> without any need what-so-ever to see either the source-code or the
>>>>> execution trace of H.
>>>>>
>>>>> The one thing that is not proved is whether or not an actual encoded
>>>>> H(P,P) does indeed correctly determine that its input would never
>>>>> reach
>>>>> its "ret" instruction as a pure function of its inputs. This aspect
>>>>> will
>>>>> be confirmed by fully operational source-code.
>>>>>
>>>>>
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>>
>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> Copyright 2022 Pete Olcott
>>>>>
>>>>> "Talent hits a target no one else can hit;
>>>>> Genius hits a target no one else can see."
>>>>> Arthur Schopenhauer
>>>>
>>>> GUR already suggested such a halting decider H cannot exist:
>>>>
>>>> H(P,P)==0 means P(P) does not halt.
>>> That is a misconception.
>>>
>>> Halt deciders must compute the mapping from their inputs to an accept or
>>> reject state on the basis of the actual behavior actually specified by
>>> these inputs.
>>>
>>> It is an easily verified fact that the correct and complete x86
>>> emulation of the input to H(P,P) by H would never reach its "ret"
>>> instruction thus conclusively proving that it never halts.
>>>> H(P,P)==1 means P(P) halts.
>>>> H(P,P)==Otherwise means H fails as a decider (undecidable).
>>>>
>>>> -----
>>>> Thanks to PO's years' tireless efforts demonstrated even himself a
>>>> genius in 10000-years
>>>> cannot refute my GUR. ...
>>> --
>>> Copyright 2022 Pete Olcott
>>>
>>> "Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see."
>>> Arthur Schopenhauer
>>
>> GUR suggests no halting decider can exist. You just confirms it by not
>> able to
>> provide POOH to test/review.
>
> It took me six months to figure out how to transform H(P,P) into a pure
> function of its inputs. I did not release the code before because I knew
> that its use of static local data would have been rejected. With this
> update to H I will be able to publish the code.
>
> H recognizes that P is calling itself with its same arguments that it
> was called with and there are no instructions preceding this call that
> could possibly escape infinitely recursive emulation so H aborts its
> emulation of P before P even makes its first call to H.
>
> Without even looking at the code competent software engineers will be
> able to verify that the above H would correctly determine that that is
> input is non-halting as a pure function of this input.
>
>

Re: Reviewers quit reviewing my work because it is now finally irrefutable [V2]

<ln9rK.179139$70j.92861@fx16.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx16.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.10.0
Subject: Re: Reviewers quit reviewing my work because it is now finally
irrefutable [V2]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <MLOdnV3rR7YH-DH_nZ2dnUU7_81g4p2d@giganews.com>
<912de0f6-ed7e-432b-a66f-151b90a3165dn@googlegroups.com>
<3L-dnSLRg-HIEDH_nZ2dnUU7_8zNnZ2d@giganews.com>
<854a74fd-bde3-4027-a0af-879ab7cc4827n@googlegroups.com>
<-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <-c6dnZtIP_BBCTH_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 142
Message-ID: <ln9rK.179139$70j.92861@fx16.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: Fri, 17 Jun 2022 20:54:41 -0400
X-Received-Bytes: 6741
 by: Richard Damon - Sat, 18 Jun 2022 00:54 UTC

On 6/17/22 10:51 AM, olcott wrote:
> On 6/17/2022 9:39 AM, wij wrote:
>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott wrote:
>>> On 6/17/2022 8:39 AM, wij wrote:
>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8, olcott wrote:
>>>>> When a simulating halt decider rejects all inputs as non-halting
>>>>> whenever it correctly detects that its correct and complete simulation
>>>>> of its input would never reach the final state of this input then all
>>>>> [these] inputs (including pathological inputs) are decided correctly.
>>>>>
>>>>> *computation that halts* … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>>>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>>>>
>>>>> #include <stdint.h>
>>>>> typedef void (*ptr)();
>>>>>
>>>>> void P(ptr x)
>>>>> {
>>>>> if (H(x, x))
>>>>> HERE: goto HERE;
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H(P, P));
>>>>> }
>>>>>
>>>>> _P()
>>>>> [00001352](01) 55 push ebp
>>>>> [00001353](02) 8bec mov ebp,esp
>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>> [00001358](01) 50 push eax // push P
>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>> [0000135c](01) 51 push ecx // push P
>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>> [00001362](03) 83c408 add esp,+08
>>>>> [00001365](02) 85c0 test eax,eax
>>>>> [00001367](02) 7402 jz 0000136b
>>>>> [00001369](02) ebfe jmp 00001369
>>>>> [0000136b](01) 5d pop ebp
>>>>> [0000136c](01) c3 ret
>>>>> Size in bytes:(0027) [0000136c]
>>>>>
>>>>> (1) It is an easily verified fact that when we assume that H is
>>>>> only an
>>>>> x86 emulator that the correctly emulated P never reaches its "ret"
>>>>> instruction it remains stuck in repeated cycles of emulation.
>>>>>
>>>>> (2) It is an easily verified fact that if H has been adapted to
>>>>> correctly detect (in a finite number of steps) that the correct and
>>>>> complete x86 emulation of its input would never each its "ret"
>>>>> instruction that H could abort its emulation and return 0 to report
>>>>> this.
>>>>>
>>>>> (3) When the halt status criteria is defined as correctly determining
>>>>> whether or not an x86 emulated input would ever reach its "ret"
>>>>> instruction then it becomes an easily verified fact H(P,P) could
>>>>> correctly reject its input as non-halting.
>>>>>
>>>>> Correct deductive inference proves that all of these things are true
>>>>> without any need what-so-ever to see either the source-code or the
>>>>> execution trace of H.
>>>>>
>>>>> The one thing that is not proved is whether or not an actual encoded
>>>>> H(P,P) does indeed correctly determine that its input would never
>>>>> reach
>>>>> its "ret" instruction as a pure function of its inputs. This aspect
>>>>> will
>>>>> be confirmed by fully operational source-code.
>>>>>
>>>>>
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>>
>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> Copyright 2022 Pete Olcott
>>>>>
>>>>> "Talent hits a target no one else can hit;
>>>>> Genius hits a target no one else can see."
>>>>> Arthur Schopenhauer
>>>>
>>>> GUR already suggested such a halting decider H cannot exist:
>>>>
>>>> H(P,P)==0 means P(P) does not halt.
>>> That is a misconception.
>>>
>>> Halt deciders must compute the mapping from their inputs to an accept or
>>> reject state on the basis of the actual behavior actually specified by
>>> these inputs.
>>>
>>> It is an easily verified fact that the correct and complete x86
>>> emulation of the input to H(P,P) by H would never reach its "ret"
>>> instruction thus conclusively proving that it never halts.
>>>> H(P,P)==1 means P(P) halts.
>>>> H(P,P)==Otherwise means H fails as a decider (undecidable).
>>>>
>>>> -----
>>>> Thanks to PO's years' tireless efforts demonstrated even himself a
>>>> genius in 10000-years
>>>> cannot refute my GUR. ...
>>> --
>>> Copyright 2022 Pete Olcott
>>>
>>> "Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see."
>>> Arthur Schopenhauer
>>
>> GUR suggests no halting decider can exist. You just confirms it by not
>> able to
>> provide POOH to test/review.
>
> It took me six months to figure out how to transform H(P,P) into a pure
> function of its inputs. I did not release the code before because I knew
> that its use of static local data would have been rejected. With this
> update to H I will be able to publish the code.
>
> H recognizes that P is calling itself with its same arguments that it
> was called with and there are no instructions preceding this call that
> could possibly escape infinitely recursive emulation so H aborts its
> emulation of P before P even makes its first call to H.
>
> Without even looking at the code competent software engineers will be
> able to verify that the above H would correctly determine that that is
> input is non-halting as a pure function of this input.
>
>

But P calling H(P,P) is NOT a "proof" of non-halting, as since H(P,P)
has been shown to return 0 elsewhere, so must this until you can
actually prove that a "pure function" doesn't need to always behave the
same way for each call, dispite that being part of the definition of a
Pure Function.

You just fail.

Pages:123
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor