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

--
Copyright 2022 Pete Olcott

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