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.

--
Copyright 2022 Pete Olcott

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