Re: Rebutting the Sipser Halting Problem Proof --- H emulating H emulating D

On 9/16/24 7:15 PM, olcott wrote:

On 9/16/2024 5:52 PM, Richard Damon wrote:

On 9/16/24 11:58 AM, olcott wrote:

On 9/16/2024 8:36 AM, Fred. Zwarts wrote:

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.

>
Examining emulations of emulations is very confusing
in the 260 page execution trace. Here it is:
>
first line of H [0000143e]
page  38 executed H
page  48 emulated H
page 249 emulated emulated H
>
first line of D [0000218e]
page  38 executed D
page  41 emulated D
page 132 emulated emulated D
>
We can tell that a line is emulated when it is
preceded by: "call 000007be" call _DebugStep()
>
https://www.liarparadox.org/D(D)_Sipser_Full.pdf
>
page 38 executed D invokes executed H
[000021be][00103868][00000000] 55 push ebp
[000021bf][00103868][00000000] 8bec mov ebp,esp
[000021c1][00103864][0000218e] 688e210000 push 0000218e
[000021c6][00103860][000021cb] e8c3ffffff call 0000218e
[0000218e][0010385c][00103868] 55 push ebp
[0000218f][0010385c][00103868] 8bec mov ebp,esp
[00002191][0010385c][00103868] 8b4508 mov eax,[ebp+08]
[00002194][00103858][0000218e] 50 push eax
[00002195][00103858][0000218e] 8b4d08 mov ecx,[ebp+08]
[00002198][00103854][0000218e] 51 push ecx
[00002199][00103850][0000219e] e8a0f2ffff call 0000143e
>
page 40-41 executed H is calling the emulator to emulate D
[00001208][001037dc][00103894] e8b1f5ffff call 000007be
[0000218e][00113900][00113904] 55 push ebp
>
page 48 executed H is calling the emulator to emulate H
[00001208][001037dc][00103894] e8b1f5ffff call 000007be
[00002199][001138f4][0000219e] e8a0f2ffff call 0000143e
>
page 132 emulated H is calling the emulator to emulate D
[00001208][001037dc][00103894] e8b1f5ffff call 000007be
[00001208][00113880][0014e2bc] e8b1f5ffff call 000007be
[0000218e][0015e328][0015e32c] 55 push ebp
>
page 249 emulated H is calling the emulator to emulate H
[00001208][001037dc][00103894] e8b1f5ffff call 000007be
[00001208][00113880][0014e2bc] e8b1f5ffff call 000007be
[00002199][0015e31c][0000219e] e8a0f2ffff call 0000143e
>

>
So?
>
That just shows you have worked out a way to LIE about what happens.
>
The results of a emulated call to debug step are NOT correctly part of the emulation of D.

>
DebugStep() calls the libx86emu library you freaking doofus.
When D calls H(D,D) H mus emulate itself emulating D you
freaking doofus.
>
>
>

 So?
 That just proves that you have lied that you have done an actual x86 emulation of the input, as, that means that *ALL* instructions need to be shown as to the actual steps the x86 does to exectute it.
 There is not x86 instruction "DebugStep" so that isn't an x86 operation, just a call instruction.