On 6/27/2022 2:19 PM, Mr Flibble wrote:
> On Mon, 27 Jun 2022 14:06:42 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/27/2022 1:53 PM, Mr Flibble wrote:
>>> On Mon, 27 Jun 2022 13:44:49 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/27/2022 1:20 PM, Mr Flibble wrote:
>>>>> On Mon, 27 Jun 2022 07:05:46 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> *This is the outline of the complete refutation*
>>>>>> *of the only rebuttal that anyone has left*
>>>>>>
>>>>>> (a) The complete and correct x86 emulation of the input to H(P,P)
>>>>>> by H never reaches the "ret" instruction of P.
>>>>>>
>>>>>> (b) The direct execution of P(P) does reach its "ret"
>>>>>> instruction.
>>>>>>
>>>>>> The above two are proven to be verified facts entirely on the
>>>>>> basis of the semantics of the x86 language.
>>>>>>
>>>>>> A halt decider must compute the mapping from its inputs to an
>>>>>> accept or reject state on the basis of the actual behavior that
>>>>>> is actually specified by these inputs.
>>>>>>
>>>>>> P(P) is provably not the actual behavior of the actual input.
>>>>>>
>>>>>>
>>>>>>
>>>>>> void P(u32 x)
>>>>>> {
>>>>>> if (H(x, x))
>>>>>> HERE: goto HERE;
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H1((u32)P, (u32)P));
>>>>>> }
>>>>>>
>>>>>> _P()
>>>>>> [0000163a](01) 55 push ebp
>>>>>> [0000163b](02) 8bec mov ebp,esp
>>>>>> [0000163d](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00001640](01) 50 push eax
>>>>>> [00001641](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [00001644](01) 51 push ecx
>>>>>> [00001645](05) e8f0fdffff call 0000143a // call H
>>>>>> [0000164a](03) 83c408 add esp,+08
>>>>>> [0000164d](02) 85c0 test eax,eax
>>>>>> [0000164f](02) 7402 jz 00001653
>>>>>> [00001651](02) ebfe jmp 00001651
>>>>>> [00001653](01) 5d pop ebp
>>>>>> [00001654](01) c3 ret
>>>>>> Size in bytes:(0027) [00001654]
>>>>>>
>>>>>> _main()
>>>>>> [0000165a](01) 55 push ebp
>>>>>> [0000165b](02) 8bec mov ebp,esp
>>>>>> [0000165d](05) 683a160000 push 0000163a // push P
>>>>>> [00001662](05) 683a160000 push 0000163a // push P
>>>>>> [00001667](05) e8cef9ffff call 0000103a // call H1
>>>>>> [0000166c](03) 83c408 add esp,+08
>>>>>> [0000166f](01) 50 push eax // push return
>>>>>> value [00001670](05) 689b040000 push 0000049b //
>>>>>> "Input_Halts = " [00001675](05) e870eeffff call 000004ea
>>>>>> // call Output [0000167a](03) 83c408 add esp,+08
>>>>>> [0000167d](02) 33c0 xor eax,eax
>>>>>> [0000167f](01) 5d pop ebp
>>>>>> [00001680](01) c3 ret
>>>>>> Size in bytes:(0039) [00001680]
>>>>>>
>>>>>> machine stack stack machine assembly
>>>>>> address address data code language
>>>>>> ======== ======== ======== ========= =============
>>>>>> [0000165a][001026a9][00000000] 55 push ebp
>>>>>> [0000165b][001026a9][00000000] 8bec mov ebp,esp
>>>>>> [0000165d][001026a5][0000163a] 683a160000 push 0000163a // push P
>>>>>> [00001662][001026a1][0000163a] 683a160000 push 0000163a // push P
>>>>>> [00001667][0010269d][0000166c] e8cef9ffff call 0000103a // call
>>>>>> H1
>>>>>>
>>>>>> H1: Begin Simulation Execution Trace Stored at:21275d
>>>>>> Address_of_H1:103a
>>>>>> [0000163a][00212749][0021274d] 55 push ebp
>>>>>> [0000163b][00212749][0021274d] 8bec mov ebp,esp
>>>>>> [0000163d][00212749][0021274d] 8b4508 mov eax,[ebp+08]
>>>>>> [00001640][00212745][0000163a] 50 push eax // push P
>>>>>> [00001641][00212745][0000163a] 8b4d08 mov ecx,[ebp+08]
>>>>>> [00001644][00212741][0000163a] 51 push ecx // push P
>>>>>> [00001645][0021273d][0000164a] e8f0fdffff call 0000143a // call H
>>>>>>
>>>>>> H: Begin Simulation Execution Trace Stored at:2285c5
>>>>>> Address_of_H:143a
>>>>>> [0000163a][002285b1][002285b5] 55 push ebp
>>>>>> [0000163b][002285b1][002285b5] 8bec mov ebp,esp
>>>>>> [0000163d][002285b1][002285b5] 8b4508 mov eax,[ebp+08]
>>>>>> [00001640][002285ad][0000163a] 50 push eax // push P
>>>>>> [00001641][002285ad][0000163a] 8b4d08 mov ecx,[ebp+08]
>>>>>> [00001644][002285a9][0000163a] 51 push ecx // push P
>>>>>> [00001645][002285a5][0000164a] e8f0fdffff call 0000143a // call H
>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>
>>>>>> [0000164a][00212749][0021274d] 83c408 add esp,+08
>>>>>> [0000164d][00212749][0021274d] 85c0 test eax,eax
>>>>>> [0000164f][00212749][0021274d] 7402 jz 00001653
>>>>>> [00001653][0021274d][0000111e] 5d pop ebp
>>>>>> [00001654][00212751][0000163a] c3 ret
>>>>>> H1: End Simulation Input Terminated Normally
>>>>>>
>>>>>> [0000166c][001026a9][00000000] 83c408 add esp,+08
>>>>>> [0000166f][001026a5][00000001] 50 push eax // return
>>>>>> value [00001670][001026a1][0000049b] 689b040000 push 0000049b //
>>>>>> "Input_Halts = " [00001675][001026a1][0000049b] e870eeffff call
>>>>>> 000004ea // call Output Input_Halts = 1
>>>>>> [0000167a][001026a9][00000000] 83c408 add esp,+08
>>>>>> [0000167d][001026a9][00000000] 33c0 xor eax,eax
>>>>>> [0000167f][001026ad][00100000] 5d pop ebp
>>>>>> [00001680][001026b1][00000004] c3 ret
>>>>>> Number of Instructions Executed(409590) == 6113 Pages
>>>>>
>>>>> Why the new H/H1 dichotomy? Are you finally admitting that the
>>>>> decider that main() calls is different to the decider that P would
>>>>> call if you weren't erroneously aborting the simulation?
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> The above example proves the following:
>>>>
>>>> (a) The complete and correct x86 emulation of the input to H(P,P)
>>>> by H never reaches the "ret" instruction of P.
>>>>
>>>> (b) The direct execution of P(P) does reach its "ret" instruction.
>>>>
>>>
>>> Then H returned the wrong answer. See [Strachey, 1965].
>>>
>>> /Flibble
>>>
>>
>> So your rebuttals simply ignore that I proved you are wrong?
>>
>> // rec routine P
>> // §L :if T[P] go to L
>> // Return §
>> // https://academic.oup.com/comjnl/article/7/4/313/354243
>> void Strachey_P()
>> {
>> L:if (T(Strachey_P))
>> goto L;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", T(Strachey_P));
>> }
>>
>> _Strachey_P()
>> [000015b2](01) 55 push ebp
>> [000015b3](02) 8bec mov ebp,esp
>> [000015b5](05) 68b2150000 push 000015b2 // push Strachey_P
>> [000015ba](05) e813fdffff call 000012d2 // call T
>> [000015bf](03) 83c404 add esp,+04
>> [000015c2](02) 85c0 test eax,eax
>> [000015c4](02) 7402 jz 000015c8
>> [000015c6](02) ebed jmp 000015b5
>> [000015c8](01) 5d pop ebp
>> [000015c9](01) c3 ret
>> Size in bytes:(0024) [000015c9]
>>
>> _main()
>> [000015d2](01) 55 push ebp
>> [000015d3](02) 8bec mov ebp,esp
>> [000015d5](05) 68b2150000 push 000015b2 // push Strachey_P
>> [000015da](05) e8f3fcffff call 000012d2 // call T
>> [000015df](03) 83c404 add esp,+04
>> [000015e2](01) 50 push eax
>> [000015e3](05) 6833040000 push 00000433
>> [000015e8](05) e895eeffff call 00000482
>> [000015ed](03) 83c408 add esp,+08
>> [000015f0](02) 33c0 xor eax,eax
>> [000015f2](01) 5d pop ebp
>> [000015f3](01) c3 ret
>> Size in bytes:(0034) [000015f3]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> [000015d2][001025c6][00000000] 55 push ebp
>> [000015d3][001025c6][00000000] 8bec mov ebp,esp
>> [000015d5][001025c2][000015b2] 68b2150000 push 000015b2 // push
>> Strachey_P [000015da][001025be][000015df] e8f3fcffff call 000012d2 //
>> call T
>>
>> Begin Simulation Execution Trace Stored at:21267a
>> Address_of_T:12d2
>> [000015b2][0021266a][0021266e] 55 push ebp
>> [000015b3][0021266a][0021266e] 8bec mov ebp,esp
>> [000015b5][00212666][000015b2] 68b2150000 push 000015b2 // push
>> Strachey_P [000015ba][00212662][000015bf] e813fdffff call 000012d2 //
>> call T Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> T knows its own machine address and on this basis it can easily
>> examine its stored execution_trace of Strachey_P (see above) to
>> determine: (a) Strachey_P is calling T with the same arguments that T
>> was called with. (b) No instructions in Strachey_P could possibly
>> escape this otherwise infinitely recursive emulation.
>> (c) T aborts its emulation of Strachey_P before its call to T is
>> emulated.
>>
>> [000015df][001025c6][00000000] 83c404 add esp,+04
>> [000015e2][001025c2][00000000] 50 push eax
>> [000015e3][001025be][00000433] 6833040000 push 00000433
>> [000015e8][001025be][00000433] e895eeffff call 00000482
>> Input_Halts = 0
>> [000015ed][001025c6][00000000] 83c408 add esp,+08
>> [000015f0][001025c6][00000000] 33c0 xor eax,eax
>> [000015f2][001025ca][00100000] 5d pop ebp
>> [000015f3][001025ce][00000004] c3 ret
>> Number of Instructions Executed(528) == 8 Pages
>
> There is no recursion in [Strachey, 1965]; a mistake you keep making
> again and again and again.
>
> /Flibble
>
>

A simulating halt decider correctly simulates its input until it
correctly determines that this simulated input would never reach its
final state.

T correctly predicts/determines that Strachey_P would never reach its
[000015c9] machine address: final state.

--
Copyright 2022 Pete Olcott

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