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.

/Flibble