On Wed, 29 Jun 2022 16:27:24 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/29/2022 4:15 PM, Mr Flibble wrote:
> > On Wed, 29 Jun 2022 22:09:53 +0100
> > Mr Flibble <flibble@reddwarf.jmc> wrote:
> >
> >> On Wed, 29 Jun 2022 16:06:19 -0500
> >> olcott <NoOne@NoWhere.com> wrote:
> >>
> >>> On 6/29/2022 3:47 PM, Mr Flibble wrote:
> >>>> On Wed, 29 Jun 2022 15:41:07 -0500
> >>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>
> >>>>> On 6/29/2022 2:18 PM, Mr Flibble wrote:
> >>>>>> On Wed, 29 Jun 2022 14:12:34 -0500
> >>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>
> >>>>>>> On 6/29/2022 1:25 PM, Mr Flibble wrote:
> >>>>>>>> Hi!
> >>>>>>>>
> >>>>>>>> If we put to one side the fact that a simulation-based
> >>>>>>>> halting decider is invalid* it is a FACT that such a
> >>>>>>>> decider, to be considered valid, should decide on the
> >>>>>>>> behaviour of P(P) calling H(P,P).
> >>>>>>>
> >>>>>>> It does do that yet the details of this seem to be beyond your
> >>>>>>> technical knowledge of the semantics of the x986 language.
> >>>>>>
> >>>>>> I fully understand 80x86 assembly; I was programming in it in
> >>>>>> the 1990s.
> >>>>>>
> >>>>>> Your simulation halting decider is no such thing as it gets the
> >>>>>> answer to the following wrong:
> >>>>>>
> >>>>>> void Px(u32 x)
> >>>>>> {
> >>>>>> H(x, x);
> >>>>>> return;
> >>>>>> }
> >>>>>>
> >>>>>> int main()
> >>>>>> {
> >>>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>> }
> >>>>>>
> >>>>>> ...[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)
> >>>>>>
> >>>>>> As can be seen above Olcott's H decides that Px does not halt
> >>>>>> but it is obvious that Px should always halt if H is a valid
> >>>>>> halt decider that always returns a decision to its caller (Px).
> >>>>>> Olcott's H does not return a decision to its caller (Px) and is
> >>>>>> thus invalid.
> >>>>>>
> >>>>>> /Flibble
> >>>>>>
> >>>>>>
> >>>>>
> >>>>> In other words you are insufficiently technically competent on
> >>>>> the semantics of the x86 language to correctly evalate this:
> >>>>>
> >>>>> void Px(u32 x)
> >>>>> {
> >>>>> H(x, x);
> >>>>> return;
> >>>>> }
> >>>>>
> >>>>> int main()
> >>>>> {
> >>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>> }
> >>>>>
> >>>>> _Px()
> >>>>> [00001152](01) 55 push ebp
> >>>>> [00001153](02) 8bec mov ebp,esp
> >>>>> [00001155](03) 8b4508 mov eax,[ebp+08]
> >>>>> [00001158](01) 50 push eax
> >>>>> [00001159](03) 8b4d08 mov ecx,[ebp+08]
> >>>>> [0000115c](01) 51 push ecx
> >>>>> [0000115d](05) e810feffff call 00000f72
> >>>>> [00001162](03) 83c408 add esp,+08
> >>>>> [00001165](01) 5d pop ebp
> >>>>> [00001166](01) c3 ret
> >>>>> Size in bytes:(0021) [00001166]
> >>>>>
> >>>>> _main()
> >>>>> [000011b2](01) 55 push ebp
> >>>>> [000011b3](02) 8bec mov ebp,esp
> >>>>> [000011b5](05) 6852110000 push 00001152
> >>>>> [000011ba](05) 6852110000 push 00001152
> >>>>> [000011bf](05) e8aefdffff call 00000f72
> >>>>> [000011c4](03) 83c408 add esp,+08
> >>>>> [000011c7](01) 50 push eax
> >>>>> [000011c8](05) 68a3040000 push 000004a3
> >>>>> [000011cd](05) e820f3ffff call 000004f2
> >>>>> [000011d2](03) 83c408 add esp,+08
> >>>>> [000011d5](02) 33c0 xor eax,eax
> >>>>> [000011d7](01) 5d pop ebp
> >>>>> [000011d8](01) c3 ret
> >>>>> Size in bytes:(0039) [000011d8]
> >>>>>
> >>>>> machine stack stack machine assembly
> >>>>> address address data code language
> >>>>> ======== ======== ======== ========= =============
> >>>>> [000011b2][00101f43][00000000] 55 push ebp
> >>>>> [000011b3][00101f43][00000000] 8bec mov ebp,esp
> >>>>> [000011b5][00101f3f][00001152] 6852110000 push 00001152
> >>>>> [000011ba][00101f3b][00001152] 6852110000 push 00001152
> >>>>> [000011bf][00101f37][000011c4] e8aefdffff call 00000f72
> >>>>>
> >>>>> H: Begin Simulation Execution Trace Stored at:111fef
> >>>>> Address_of_H:f72
> >>>>> [00001152][00111fdb][00111fdf] 55 push ebp
> >>>>> [00001153][00111fdb][00111fdf] 8bec mov ebp,esp
> >>>>> [00001155][00111fdb][00111fdf] 8b4508 mov eax,[ebp+08]
> >>>>> [00001158][00111fd7][00001152] 50 push eax
> >>>>> [00001159][00111fd7][00001152] 8b4d08 mov ecx,[ebp+08]
> >>>>> [0000115c][00111fd3][00001152] 51 push ecx
> >>>>> [0000115d][00111fcf][00001162] e810feffff call 00000f72
> >>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
> >>>>>
> >>>>> H knows its own machine address and on this basis it can easily
> >>>>> examine its stored execution_trace of P (see above) to
> >>>>> determine: (a) P is calling H with the same arguments that H
> >>>>> was called with. (b) No instructions in P could possibly escape
> >>>>> this otherwise infinitely recursive emulation.
> >>>>> (c) H aborts its emulation of P before its call to H is
> >>>>> emulated.
> >>>>>
> >>>>> [000011c4][00101f43][00000000] 83c408 add esp,+08
> >>>>> [000011c7][00101f3f][00000000] 50 push eax
> >>>>> [000011c8][00101f3b][000004a3] 68a3040000 push 000004a3
> >>>>> [000011cd][00101f3b][000004a3] e820f3ffff call 000004f2
> >>>>> Input_Halts = 0
> >>>>> [000011d2][00101f43][00000000] 83c408 add esp,+08
> >>>>> [000011d5][00101f43][00000000] 33c0 xor eax,eax
> >>>>> [000011d7][00101f47][00000018] 5d pop ebp
> >>>>> [000011d8][00101f4b][00000000] c3 ret
> >>>>> Number of Instructions Executed(881) == 13 Pages
> >>>>
> >>>> I fully understand 80x86 assembly: there is no infinite recursion
> >>>> when using a valid halting decider, your H isn't a valid halting
> >>>> decider.
> >>>>
> >>>> /Flibble
> >>>>
> >>>
> >>> You continue to use the strawman deception:
> >>>
> >>> straw man
> >>> An intentionally misrepresented proposition that is set up because
> >>> it is easier to defeat than an opponent's real argument.
> >>> https://www.lexico.com/en/definition/straw_man
> >>>
> >>> I am not saying that the input to H(P,P) is infinitely recursive
> >>> emulation. It is clear that this recursion stops as soon as it is
> >>> aborted. If stopped running (because simulation was aborted) was
> >>> the same thing as halting then I would be wrong. It is NOT the
> >>> same thing.
> >>
> >> There is no aborting of a simulation when using a valid halting
> >> decider, your H isn't a valid halting decider.
> >
> > Or more accurately:
> >
> > There is no aborting of a simulation without also returning a
> > decision to the caller of the decider (Px in this case). If you
> > insist on aborting the simulation then you must do it in such a way
> > that you can also return a value to the caller;
>
> Again your lack of technical skill. There is never a case when any
> function called in infinite recursion ever returns to its caller.

The lack of technical skill lies with yourself not me. The infinite
recursion is something H is doing, not what Px is doing, Px assumes
that H DOES NOT infinitely recurse otherwise it wouldn't be calling H. A
valid H does not infinitely recurse. If you are unable to re-write
your H to take account of this then you've got nothing.

/Flibble