Re: Rebutting the Sipser Halting Problem Proof --- damned liar

Op 16.sep.2024 om 14:09 schreef olcott:

On 9/16/2024 6:21 AM, Fred. Zwarts wrote:

Op 15.sep.2024 om 16:23 schreef olcott:

>
Rebutting the Sipser Halting Problem Proof
D(D) correctly reports its own halt status
>
https://www.researchgate.net/ publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>

>

We can see that the first seven instructions of D emulated by H precisely match the first seven instructions of the x86 source-code of D. This conclusively proves that these instructions were emulated correctly.

>
Yes H makes a good start, but fails to complete the simulation, because of a bug in the code to recognise an infinite 'recursion'.
>

Then if you are not a damned liar you can see this
next part that you dishonestly erased.
 D()
[0000218e] 55             push ebp         ; begin D
[0000218f] 8bec           mov ebp,esp
[00002191] 8b4508         mov eax,[ebp+08]
[00002194] 50             push eax         ; push param
[00002195] 8b4d08         mov ecx,[ebp+08]
[00002198] 51             push ecx         ; push param
[00002199] e8a0f2ffff     call 0000143e    ; call H
 After D calls H(D,  D) we can see that H correctly emulates itself emulating D because again we see that the first seven instructions of D emulated by the emulated H precisely match the first seven instructions of the x86 source-code of D. This conclusively proves that these instructions were emulated correctly.
 

Yes, nobody denies that H made a good start, but it failed with the seventh instruction, where it did not correctly simulate the call instruction, which should be followed by the simulation of instructions within H. Therefore, it misses many conditional branch instructions. Then, because of a bug in the recognition of an infinite recursion, it stops the simulation after two cycles. That makes that it also misses that in the next cycle the simulated H would also (incorrectly) see the 'special condition', after which it would also abort and return to DDD, which would halt.
In conclusion, after a good start, H failed to reach the end of the simulation of a halting program.
That the semantics of the x86 language of the string w describes a halting program, is proved beyond any doubt, by overwhelming evidence by direct execution and many correct simulations. These semantics allow only one behaviour for the program described by this string. But H fails to show this behaviour.
H cannot possibly simulate itself correctly up to the end.