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

On 9/16/24 11:13 PM, olcott wrote:

On 9/16/2024 9:42 PM, Richard Damon wrote:

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.
>

 x86utm is a multi-taking operating system that requires
operating system functions knucklehead.
 

So?
I guess you are just admitting that you aren't doing what you say you are doing.
Sorry, but that just makes you a LIAR.
IF you can't actually produce the full instruction trace of what the input program would do at the actual x86 instruction level, then don't say that is what you are doing.
That *IS* what is meant when you say "by the semantics of the x86 langauge".
I guess you are just admitting that you never knew what you were talking about and were just using "buzz-words" to try to sound like you actually knew something.