On 6/17/22 12:51 PM, olcott wrote:
> 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
>>
>
> Then that may explain why you didn't notice that main calls H(P,P);
> When H returns to its caller it must return to main().
>
> main() and not P is the invoker of H(P,P).
>
>
>

But if H is a pure function, it returns the same answer to ALL envokers,
and thus when we test H's answer by looking at the correct emulation of
its input, we see that H(P,P) returns 0 to P(P) letting P(P) halt.