On 6/17/22 12:33 PM, olcott 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
> ize 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().
>
>

Or to P when called by P when we test the results. Showing H was wrong.

Remember, since H aborted its emulation, we need to do an actual pure
emulation of the input to H(P,P) to see what the actual answer is.

That emulation will emulate through H, see H abort its emulation and
return 0 to P and P return (i.e. Halt), thus showing that H was incorrect.

All you are showing is you don't understand the requrements that you state.