1. Forum
  2. Usenet
  3. COMP.THEORY

  • Re: Rebutting the Sipser Halting Problem Proof --- H emulating H emulat

    From Richard Damon@21:1/5 to olcott on Mon Sep 16 18:52:07 2024
    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. and your including them just proves you just don't understand what you are talking about, but are just a pathological liar
    that just doesn't understand what TRUTH is, so you just ignore itl

    Sorry, you are just proving that you are just logically incompetent, as
    you keep repeating your errors after they have been pointed out,

    That means either you are incapable of learning due to mental defect, or
    are just a pathological liar.

    Either way, everyone with any smarts now knows to ignore EVERYTHING you
    say, as there is likely no real logic behind it.

    Sorry, those are the facts.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Mon Sep 16 22:42:24 2024
    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.

    There is no reason you can not actually trace the steps that "DebugStep"
    uses to trace an instruction.

    You are just proving you don't understand the meaning of the words.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Tue Sep 17 06:59:52 2024
    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.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)