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

> On 6/29/2022 4:09 PM, Mr Flibble 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.
> >
> > /Flibble
> >
>
> So basically you reject the whole idea of a simulating halt decider
> that most always abort every simulation that would never otherwise
> stop running. So even though the following conclusively proves that a
> simulating halt decider is a correct idea you reject it anyway.
>
> void Infinite_Loop()
> {
> HERE: goto HERE;
> }
>
> int main()
> {
> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> }
>
> _Infinite_Loop()
> [00001102](01) 55 push ebp
> [00001103](02) 8bec mov ebp,esp
> [00001105](02) ebfe jmp 00001105
> [00001107](01) 5d pop ebp
> [00001108](01) c3 ret
> Size in bytes:(0007) [00001108]
>
> _main()
> [00001192](01) 55 push ebp
> [00001193](02) 8bec mov ebp,esp
> [00001195](05) 6802110000 push 00001102
> [0000119a](05) e8d3fbffff call 00000d72
> [0000119f](03) 83c404 add esp,+04
> [000011a2](01) 50 push eax
> [000011a3](05) 68a3040000 push 000004a3
> [000011a8](05) e845f3ffff call 000004f2
> [000011ad](03) 83c408 add esp,+08
> [000011b0](02) 33c0 xor eax,eax
> [000011b2](01) 5d pop ebp
> [000011b3](01) c3 ret
> Size in bytes:(0034) [000011b3]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> [00001192][00101ef8][00000000] 55 push ebp
> [00001193][00101ef8][00000000] 8bec mov ebp,esp
> [00001195][00101ef4][00001102] 6802110000 push 00001102
> [0000119a][00101ef0][0000119f] e8d3fbffff call 00000d72
>
> H0: Begin Simulation Execution Trace Stored at:211fac
> Address_of_H0:d72
> [00001102][00211f9c][00211fa0] 55 push ebp
> [00001103][00211f9c][00211fa0] 8bec mov ebp,esp
> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
> [00001105][00211f9c][00211fa0] ebfe jmp 00001105
> H0: Infinite Loop Detected Simulation Stopped
>
> [0000119f][00101ef8][00000000] 83c404 add esp,+04
> [000011a2][00101ef4][00000000] 50 push eax
> [000011a3][00101ef0][000004a3] 68a3040000 push 000004a3
> [000011a8][00101ef0][000004a3] e845f3ffff call 000004f2
> Input_Halts = 0
> [000011ad][00101ef8][00000000] 83c408 add esp,+08
> [000011b0][00101ef8][00000000] 33c0 xor eax,eax
> [000011b2][00101efc][00100000] 5d pop ebp
> [000011b3][00101f00][00000004] c3 ret
> Number of Instructions Executed(554) == 8 Pages

See my other reply.

/Flibble